xhs-mp-pack 1.1.0-beta.0

package/dist/MultiCompiler.js

@@ -0,0 +1,387 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const neo_async_1 = __importDefault(require("neo-async"));
+const tapable_1 = require("tapable");
+const ConcurrentCompilationError_1 = __importDefault(require("@/base/errors/ConcurrentCompilationError"));
+const MultiStats_1 = __importDefault(require("@/base/stats/MultiStats"));
+const ArrayQueue_1 = __importDefault(require("@/base/ArrayQueue"));
+const MultiWatching_1 = __importDefault(require("./MultiWatching"));
+class MultiCompiler {
+    constructor(compilers, options) {
+        if (!Array.isArray(compilers)) {
+            compilers = Object.keys(compilers).map(name => {
+                compilers[name].name = name;
+                return compilers[name];
+            });
+        }
+        this.hooks = Object.freeze({
+            done: new tapable_1.SyncHook(['stats']),
+            invalid: new tapable_1.MultiHook(compilers.map(c => c.hooks.invalid)),
+            run: new tapable_1.MultiHook(compilers.map(c => c.hooks.run)),
+            watchClose: new tapable_1.SyncHook([]),
+            watchRun: new tapable_1.MultiHook(compilers.map(c => c.hooks.watchRun)),
+            infrastructureLog: new tapable_1.MultiHook(compilers.map(c => c.hooks.infrastructureLog)),
+        });
+        this.compilers = compilers;
+        this._options = {
+            parallelism: options.parallelism || Infinity,
+        };
+        this.dependencies = new WeakMap();
+        this.running = false;
+        const compilerStats = this.compilers.map(() => null);
+        let doneCompilers = 0;
+        for (let index = 0; index < this.compilers.length; index++) {
+            const compiler = this.compilers[index];
+            const compilerIndex = index;
+            let compilerDone = false;
+            // eslint-disable-next-line no-loop-func
+            compiler.hooks.done.tap('MultiCompiler', stats => {
+                if (!compilerDone) {
+                    compilerDone = true;
+                    doneCompilers++;
+                }
+                compilerStats[compilerIndex] = stats;
+                if (doneCompilers === this.compilers.length) {
+                    this.hooks.done.call(new MultiStats_1.default(compilerStats));
+                }
+            });
+            // eslint-disable-next-line no-loop-func
+            compiler.hooks.invalid.tap('MultiCompiler', () => {
+                if (compilerDone) {
+                    compilerDone = false;
+                    doneCompilers--;
+                }
+            });
+        }
+    }
+    get options() {
+        return Object.assign(this.compilers.map(c => c.options), this._options);
+    }
+    get outputPath() {
+        let commonPath = this.compilers[0].outputPath;
+        for (const compiler of this.compilers) {
+            while (compiler.outputPath.indexOf(commonPath) !== 0 && /[/\\]/.test(commonPath)) {
+                commonPath = commonPath.replace(/[/\\][^/\\]*$/, '');
+            }
+        }
+        if (!commonPath && this.compilers[0].outputPath[0] === '/')
+            return '/';
+        return commonPath;
+    }
+    set inputFileSystem(value) {
+        for (const compiler of this.compilers) {
+            compiler.inputFileSystem = value;
+        }
+    }
+    set outputFileSystem(value) {
+        for (const compiler of this.compilers) {
+            compiler.outputFileSystem = value;
+        }
+    }
+    set watchFileSystem(value) {
+        for (const compiler of this.compilers) {
+            compiler.watchFileSystem = value;
+        }
+    }
+    set intermediateFileSystem(value) {
+        for (const compiler of this.compilers) {
+            compiler.intermediateFileSystem = value;
+        }
+    }
+    getInfrastructureLogger(name) {
+        return this.compilers[0].getInfrastructureLogger(name);
+    }
+    setDependencies(compiler, dependencies) {
+        this.dependencies.set(compiler, dependencies);
+    }
+    validateDependencies(callback) {
+        const edges = new Set();
+        const missing = [];
+        const targetFound = compiler => {
+            for (const edge of edges) {
+                if (edge.target === compiler) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        const sortEdges = (e1, e2) => (e1.source.name.localeCompare(e2.source.name) || e1.target.name.localeCompare(e2.target.name));
+        for (const source of this.compilers) {
+            const dependencies = this.dependencies.get(source);
+            if (dependencies) {
+                for (const dep of dependencies) {
+                    const target = this.compilers.find(c => c.name === dep);
+                    if (!target) {
+                        missing.push(dep);
+                    }
+                    else {
+                        edges.add({
+                            source,
+                            target,
+                        });
+                    }
+                }
+            }
+        }
+        const errors = missing.map(m => `Compiler dependency \`${m}\` not found.`);
+        const stack = this.compilers.filter(c => !targetFound(c));
+        while (stack.length > 0) {
+            const current = stack.pop();
+            for (const edge of edges) {
+                if (edge.source === current) {
+                    edges.delete(edge);
+                    const target = edge.target;
+                    if (!targetFound(target)) {
+                        stack.push(target);
+                    }
+                }
+            }
+        }
+        if (edges.size > 0) {
+            const lines = Array.from(edges)
+                .sort(sortEdges)
+                .map((edge) => `${edge.source.name} -> ${edge.target.name}`);
+            lines.unshift('Circular dependency found in compiler dependencies.');
+            errors.unshift(lines.join('\n'));
+        }
+        if (errors.length > 0) {
+            const message = errors.join('\n');
+            callback(new Error(message));
+            return false;
+        }
+        return true;
+    }
+    runWithDependencies(compilers, fn, callback) {
+        const fulfilledNames = new Set();
+        let remainingCompilers = compilers;
+        const isDependencyFulfilled = d => fulfilledNames.has(d);
+        const getReadyCompilers = () => {
+            const readyCompilers = [];
+            const list = remainingCompilers;
+            remainingCompilers = [];
+            for (const c of list) {
+                const dependencies = this.dependencies.get(c);
+                const ready = !dependencies || dependencies.every(isDependencyFulfilled);
+                if (ready) {
+                    readyCompilers.push(c);
+                }
+                else {
+                    remainingCompilers.push(c);
+                }
+            }
+            return readyCompilers;
+        };
+        const runCompilers = callback => {
+            if (remainingCompilers.length === 0)
+                return callback();
+            neo_async_1.default.map(getReadyCompilers(), (compiler, callback) => {
+                fn(compiler, err => {
+                    if (err)
+                        return callback(err);
+                    fulfilledNames.add(compiler.name);
+                    runCompilers(callback);
+                });
+            }, callback);
+        };
+        runCompilers(callback);
+    }
+    _runGraph(setup, run, callback) {
+        // State transitions for nodes:
+        // -> blocked (initial)
+        // blocked -> starting [running++] (when all parents done)
+        // queued -> starting [running++] (when processing the queue)
+        // starting -> running (when run has been called)
+        // running -> done [running--] (when compilation is done)
+        // done -> pending (when invalidated from file change)
+        // pending -> blocked [add to queue] (when invalidated from aggregated changes)
+        // done -> blocked [add to queue] (when invalidated, from parent invalidation)
+        // running -> running-outdated (when invalidated, either from change or parent invalidation)
+        // running-outdated -> blocked [running--] (when compilation is done)
+        const nodes = this.compilers.map(compiler => ({
+            compiler,
+            setupResult: undefined,
+            result: undefined,
+            state: 'blocked',
+            children: [],
+            parents: [],
+        }));
+        const compilerToNode = new Map();
+        for (const node of nodes)
+            compilerToNode.set(node.compiler.name, node);
+        for (const node of nodes) {
+            const dependencies = this.dependencies.get(node.compiler);
+            if (!dependencies)
+                continue;
+            for (const dep of dependencies) {
+                const parent = compilerToNode.get(dep);
+                node.parents.push(parent);
+                parent.children.push(node);
+            }
+        }
+        const queue = new ArrayQueue_1.default();
+        for (const node of nodes) {
+            if (node.parents.length === 0) {
+                node.state = 'queued';
+                queue.enqueue(node);
+            }
+        }
+        let errored = false;
+        let running = 0;
+        const parallelism = this._options.parallelism;
+        const nodeDone = (node, err, stats) => {
+            if (errored)
+                return;
+            if (err) {
+                errored = true;
+                return neo_async_1.default.each(nodes, (node, callback) => {
+                    if (node.compiler.watching) {
+                        node.compiler.watching.close(callback);
+                    }
+                    else {
+                        callback(null, null);
+                    }
+                }, () => callback(err, null));
+            }
+            node.result = stats;
+            running--;
+            if (node.state === 'running') {
+                node.state = 'done';
+                for (const child of node.children) {
+                    if (child.state === 'blocked')
+                        queue.enqueue(child);
+                }
+            }
+            else if (node.state === 'running-outdated') {
+                node.state = 'blocked';
+                queue.enqueue(node);
+            }
+            processQueue();
+        };
+        const nodeInvalidFromParent = node => {
+            if (node.state === 'done') {
+                node.state = 'blocked';
+            }
+            else if (node.state === 'running') {
+                node.state = 'running-outdated';
+            }
+            for (const child of node.children) {
+                nodeInvalidFromParent(child);
+            }
+        };
+        const nodeInvalid = node => {
+            if (node.state === 'done') {
+                node.state = 'pending';
+            }
+            else if (node.state === 'running') {
+                node.state = 'running-outdated';
+            }
+            for (const child of node.children) {
+                nodeInvalidFromParent(child);
+            }
+        };
+        const nodeChange = node => {
+            nodeInvalid(node);
+            if (node.state === 'pending') {
+                node.state = 'blocked';
+            }
+            if (node.state === 'blocked') {
+                queue.enqueue(node);
+                processQueue();
+            }
+        };
+        const setupResults = [];
+        nodes.forEach((node, i) => {
+            setupResults.push((node.setupResult = setup(node.compiler, i, nodeDone.bind(null, node), () => node.state !== 'starting' && node.state !== 'running', () => nodeChange(node), () => nodeInvalid(node))));
+        });
+        let processing = true;
+        const processQueue = () => {
+            if (processing)
+                return;
+            processing = true;
+            process.nextTick(processQueueWorker);
+        };
+        const processQueueWorker = () => {
+            while (running < parallelism && queue.length > 0 && !errored) {
+                const node = queue.dequeue();
+                if (node.state === 'queued' ||
+                    (node.state === 'blocked' && node.parents.every(p => p.state === 'done'))) {
+                    running++;
+                    node.state = 'starting';
+                    run(node.compiler, node.setupResult, nodeDone.bind(null, node));
+                    node.state = 'running';
+                }
+            }
+            processing = false;
+            if (!errored && running === 0 && nodes.every(node => node.state === 'done')) {
+                const stats = [];
+                for (const node of nodes) {
+                    const result = node.result;
+                    if (result) {
+                        node.result = undefined;
+                        stats.push(result);
+                    }
+                }
+                if (stats.length > 0) {
+                    callback(null, new MultiStats_1.default(stats));
+                }
+            }
+        };
+        processQueueWorker();
+        return setupResults;
+    }
+    watch(watchOptions, handler) {
+        if (this.running) {
+            return handler(new ConcurrentCompilationError_1.default());
+        }
+        this.running = true;
+        if (this.validateDependencies(handler)) {
+            const watchings = this._runGraph((compiler, idx, callback, isBlocked, setChanged, setInvalid) => {
+                const watching = compiler.watch(Array.isArray(watchOptions) ? watchOptions[idx] : watchOptions, callback);
+                if (watching) {
+                    watching._onInvalid = setInvalid;
+                    watching._onChange = setChanged;
+                    watching._isBlocked = isBlocked;
+                }
+                return watching;
+            }, (compiler, watching, callback) => {
+                if (compiler.watching !== watching)
+                    return;
+                if (!watching.running)
+                    watching.invalidate();
+            }, handler);
+            return new MultiWatching_1.default(watchings, this);
+        }
+        return new MultiWatching_1.default([], this);
+    }
+    run(callback) {
+        if (this.running) {
+            return callback(new ConcurrentCompilationError_1.default());
+        }
+        this.running = true;
+        if (this.validateDependencies(callback)) {
+            this._runGraph(() => { }, (compiler, setupResult, callback) => compiler.run(callback), (err, stats) => {
+                this.running = false;
+                if (callback !== undefined) {
+                    return callback(err, stats);
+                }
+            });
+        }
+    }
+    purgeInputFileSystem() {
+        var _a;
+        for (const compiler of this.compilers) {
+            if ((_a = compiler.inputFileSystem) === null || _a === void 0 ? void 0 : _a.purge) {
+                compiler.inputFileSystem.purge();
+            }
+        }
+    }
+    close(callback) {
+        neo_async_1.default.each(this.compilers, (compiler, callback) => {
+            compiler.close(callback);
+        }, callback);
+    }
+}
+exports.default = MultiCompiler;

package/dist/MultiWatching.d.ts

@@ -0,0 +1,11 @@
+declare class MultiWatching {
+    watchings: any;
+    compiler: any;
+    constructor(watchings: any, compiler: any);
+    invalidateWithReason(reason: any, callback: any): void;
+    invalidate(callback: any): void;
+    suspend(): void;
+    resume(): void;
+    close(callback: any): void;
+}
+export default MultiWatching;

package/dist/MultiWatching.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const neo_async_1 = __importDefault(require("neo-async"));
+class MultiWatching {
+    constructor(watchings, compiler) {
+        this.watchings = watchings;
+        this.compiler = compiler;
+    }
+    invalidateWithReason(reason, callback) {
+        if (callback) {
+            neo_async_1.default.each(this.watchings, (watching, callback) => watching.invalidateWithReason(reason, callback), callback);
+        }
+        else {
+            for (const watching of this.watchings) {
+                watching.invalidate();
+            }
+        }
+    }
+    invalidate(callback) {
+        if (callback) {
+            neo_async_1.default.each(this.watchings, (watching, callback) => watching.invalidate(callback), callback);
+        }
+        else {
+            for (const watching of this.watchings) {
+                watching.invalidate();
+            }
+        }
+    }
+    suspend() {
+        for (const watching of this.watchings) {
+            watching.suspend();
+        }
+    }
+    resume() {
+        for (const watching of this.watchings) {
+            watching.resume();
+        }
+    }
+    close(callback) {
+        neo_async_1.default.forEach(this.watchings, (watching, finishedCallback) => {
+            watching.close(finishedCallback);
+        }, err => {
+            this.compiler.hooks.watchClose.call();
+            if (typeof callback === 'function') {
+                this.compiler.running = false;
+                callback(err);
+            }
+        });
+    }
+}
+exports.default = MultiWatching;

package/dist/PluginManager.d.ts

@@ -0,0 +1,9 @@
+declare class PluginManager {
+    setup(options: any, compiler: any): any;
+    setupIdPlugins(compiler: any, options: any): void;
+    setupCachePlugins(compiler: any, options: any): void;
+    setupSourceMap(compiler: any, options: any): void;
+    setupEntryPlugins(compiler: any, options: any): void;
+    setupOptimizePlugins(compiler: any, options: any): void;
+}
+export default PluginManager;