mcler / webpack-concat-plugin Goto Github PK

import { readFile } from 'fs/promises';
import { relative } from 'upath';
import { ConcatSource, OriginalSource, SourceMapSource } from 'webpack-sources'
import { Compilation, Compiler } from 'webpack';
import type { RawSourceMap } from 'source-map';

import ConcatPlugin = require('@mcler/webpack-concat-plugin');

class FileWithMap {
    constructor(private readonly _content: string, private readonly _sourceMap: RawSourceMap) {
    }

    public get sourceMap() {
        return this._sourceMap;
    }

    public toString() {
        return this._content;
    }
}

const originalResolve = ConcatPlugin.prototype.resolveReadFiles;
ConcatPlugin.prototype.resolveReadFiles = function (compiler: Compiler): void {
    originalResolve.call(this, compiler);

    let readFilePromise: ReturnType<typeof createSourcesPromise>;

    this.getReadFilePromise = (createNew: boolean) => {
        if (!readFilePromise || createNew) {
            readFilePromise = createSourcesPromise.call(this);
        }

        return readFilePromise;
    };

    async function getSourceAndMap(filePath: string) {
        const path = `webpack:///${relative(compiler.options.context, filePath)}`;
        const source = await readFile(filePath);
        const sourceMap = await readSourceMap(filePath);

        return {
            [path]: new FileWithMap(source.toString(), sourceMap)
        };
    }

    async function readSourceMap(filePath: string) {
        try {
            const sourceMapText = await readFile(filePath + '.map');
            return JSON.parse(sourceMapText.toString()) as RawSourceMap;
        } catch (error) {
            console.debug(`Skip reading source map for '${filePath}'. Details: ${error.message}`);
            return undefined;
        }
    }

    async function createSourcesPromise() {
        this.needCreateNewFile = true;
        const filePathArray: string[] = await this.filesToConcatAbsolutePromise;

        return await Promise.all(filePathArray.map((path) => getSourceAndMap(path)));
    };
}

ConcatPlugin.prototype.resolveConcatAndUglify = function (compilation: Compilation, files: { [x: string]: FileWithMap }[]): void {
    const allFiles = files.reduce((file1, file2) => Object.assign(file1, file2), {});
    this.finalFileName = this.getFileName(allFiles);
    const concatSource = new ConcatSource();
    Object.entries(allFiles).forEach(([name, file]) => {
        const fileContent = file.toString();
        const source = file.sourceMap
            ? new SourceMapSource(fileContent, name, file.sourceMap)
            : new OriginalSource(fileContent, name);
        concatSource.add(source);
        concatSource.add('\n');
    });
    compilation.emitAsset(this.finalFileName, concatSource);
    this.needCreateNewFile = false;
}

export = ConcatPlugin;