xhs-mp-pack 1.1.0-beta.0

package/dist/plugins/optimize/LimitChunkCountPlugin.d.ts

@@ -0,0 +1,6 @@
+declare class LimitChunkCountPlugin {
+    options: any;
+    constructor(options: any);
+    apply(compiler: any): void;
+}
+export default LimitChunkCountPlugin;

package/dist/plugins/optimize/LimitChunkCountPlugin.js

@@ -0,0 +1,200 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const OptimizationStages_1 = require("@/plugins/optimize/OptimizationStages");
+const LazyBucketSortedSet_1 = __importDefault(require("@/base/LazyBucketSortedSet"));
+const comparators_1 = require("@/base/comparators");
+/**
+ * @typedef {Object} ChunkCombination
+ * @property {boolean} deleted this is set to true when combination was removed
+ * @property {number} sizeDiff
+ * @property {number} integratedSize
+ * @property {Chunk} a
+ * @property {Chunk} b
+ * @property {number} aIdx
+ * @property {number} bIdx
+ * @property {number} aSize
+ * @property {number} bSize
+ */
+const addToSetMap = (map, key, value) => {
+    const set = map.get(key);
+    if (set === undefined) {
+        map.set(key, new Set([value]));
+    }
+    else {
+        set.add(value);
+    }
+};
+class LimitChunkCountPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    apply(compiler) {
+        const options = this.options;
+        compiler.hooks.compilation.tap('LimitChunkCountPlugin', compilation => {
+            compilation.hooks.optimizeChunks.tap({
+                name: 'LimitChunkCountPlugin',
+                stage: OptimizationStages_1.STAGE_ADVANCED,
+            }, chunks => {
+                const chunkGraph = compilation.chunkGraph;
+                const maxChunks = options.maxChunks;
+                if (!maxChunks)
+                    return;
+                if (maxChunks < 1)
+                    return;
+                if (compilation.chunks.size <= maxChunks)
+                    return;
+                let remainingChunksToMerge = compilation.chunks.size - maxChunks;
+                // order chunks in a deterministic way
+                const compareChunksWithGraph = (0, comparators_1.compareChunks)(chunkGraph);
+                const orderedChunks = Array.from(chunks).sort(compareChunksWithGraph);
+                // create a lazy sorted data structure to keep all combinations
+                // this is large. Size = chunks * (chunks - 1) / 2
+                // It uses a multi layer bucket sort plus normal sort in the last layer
+                // It's also lazy so only accessed buckets are sorted
+                const combinations = new LazyBucketSortedSet_1.default(
+                // Layer 1: ordered by largest size benefit
+                c => c.sizeDiff, (a, b) => b - a, 
+                // Layer 2: ordered by smallest combined size
+                c => c.integratedSize, (a, b) => a - b, 
+                // Layer 3: ordered by position difference in orderedChunk (-> to be deterministic)
+                c => c.bIdx - c.aIdx, (a, b) => a - b, 
+                // Layer 4: ordered by position in orderedChunk (-> to be deterministic)
+                (a, b) => a.bIdx - b.bIdx);
+                // we keep a mapping from chunk to all combinations
+                // but this mapping is not kept up-to-date with deletions
+                // so `deleted` flag need to be considered when iterating this
+                const combinationsByChunk = new Map();
+                orderedChunks.forEach((b, bIdx) => {
+                    // create combination pairs with size and integrated size
+                    for (let aIdx = 0; aIdx < bIdx; aIdx++) {
+                        const a = orderedChunks[aIdx];
+                        // filter pairs that can not be integrated!
+                        if (!chunkGraph.canChunksBeIntegrated(a, b))
+                            continue;
+                        const integratedSize = chunkGraph.getIntegratedChunksSize(a, b, options);
+                        const aSize = chunkGraph.getChunkSize(a, options);
+                        const bSize = chunkGraph.getChunkSize(b, options);
+                        const c = {
+                            deleted: false,
+                            sizeDiff: aSize + bSize - integratedSize,
+                            integratedSize,
+                            a,
+                            b,
+                            aIdx,
+                            bIdx,
+                            aSize,
+                            bSize,
+                        };
+                        combinations.add(c);
+                        addToSetMap(combinationsByChunk, a, c);
+                        addToSetMap(combinationsByChunk, b, c);
+                    }
+                    return combinations;
+                });
+                // list of modified chunks during this run
+                // combinations affected by this change are skipped to allow
+                // further optimizations
+                const modifiedChunks = new Set();
+                let changed = false;
+                // eslint-disable-next-line no-constant-condition
+                loop: while (true) {
+                    const combination = combinations.popFirst();
+                    if (combination === undefined)
+                        break;
+                    combination.deleted = true;
+                    const { a, b, integratedSize } = combination;
+                    // skip over pair when
+                    // one of the already merged chunks is a parent of one of the chunks
+                    if (modifiedChunks.size > 0) {
+                        const queue = new Set(a.groupsIterable);
+                        for (const group of b.groupsIterable) {
+                            queue.add(group);
+                        }
+                        for (const group of queue) {
+                            for (const mChunk of modifiedChunks) {
+                                if (mChunk !== a && mChunk !== b && mChunk.isInGroup(group)) {
+                                    // This is a potential pair which needs recalculation
+                                    // We can't do that now, but it merge before following pairs
+                                    // so we leave space for it, and consider chunks as modified
+                                    // just for the worse case
+                                    remainingChunksToMerge--;
+                                    if (remainingChunksToMerge <= 0)
+                                        break loop;
+                                    modifiedChunks.add(a);
+                                    modifiedChunks.add(b);
+                                    continue loop;
+                                }
+                            }
+                            for (const parent of group.parentsIterable) {
+                                queue.add(parent);
+                            }
+                        }
+                    }
+                    // merge the chunks
+                    if (chunkGraph.canChunksBeIntegrated(a, b)) {
+                        chunkGraph.integrateChunks(a, b);
+                        compilation.chunks.delete(b);
+                        // flag chunk a as modified as further optimization are possible for all children here
+                        modifiedChunks.add(a);
+                        changed = true;
+                        remainingChunksToMerge--;
+                        if (remainingChunksToMerge <= 0)
+                            break;
+                        // Update all affected combinations
+                        // delete all combination with the removed chunk
+                        // we will use combinations with the kept chunk instead
+                        for (const combination of combinationsByChunk.get(a)) {
+                            if (combination.deleted)
+                                continue;
+                            combination.deleted = true;
+                            combinations.delete(combination);
+                        }
+                        // Update combinations with the kept chunk with new sizes
+                        for (const combination of combinationsByChunk.get(b)) {
+                            if (combination.deleted)
+                                continue;
+                            if (combination.a === b) {
+                                if (!chunkGraph.canChunksBeIntegrated(a, combination.b)) {
+                                    combination.deleted = true;
+                                    combinations.delete(combination);
+                                    continue;
+                                }
+                                // Update size
+                                const newIntegratedSize = chunkGraph.getIntegratedChunksSize(a, combination.b, options);
+                                const finishUpdate = combinations.startUpdate(combination);
+                                combination.a = a;
+                                combination.integratedSize = newIntegratedSize;
+                                combination.aSize = integratedSize;
+                                combination.sizeDiff = combination.bSize + integratedSize - newIntegratedSize;
+                                finishUpdate();
+                            }
+                            else if (combination.b === b) {
+                                if (!chunkGraph.canChunksBeIntegrated(combination.a, a)) {
+                                    combination.deleted = true;
+                                    combinations.delete(combination);
+                                    continue;
+                                }
+                                // Update size
+                                const newIntegratedSize = chunkGraph.getIntegratedChunksSize(combination.a, a, options);
+                                const finishUpdate = combinations.startUpdate(combination);
+                                combination.b = a;
+                                combination.integratedSize = newIntegratedSize;
+                                combination.bSize = integratedSize;
+                                combination.sizeDiff = integratedSize + combination.aSize - newIntegratedSize;
+                                finishUpdate();
+                            }
+                        }
+                        combinationsByChunk.set(a, combinationsByChunk.get(b));
+                        combinationsByChunk.delete(b);
+                    }
+                }
+                if (changed)
+                    return true;
+            });
+        });
+    }
+}
+exports.default = LimitChunkCountPlugin;

package/dist/plugins/optimize/MangleExportsPlugin.d.ts

@@ -0,0 +1,6 @@
+declare class MangleExportsPlugin {
+    _deterministic: boolean;
+    constructor(deterministic: boolean);
+    apply(compiler: any): void;
+}
+export default MangleExportsPlugin;

package/dist/plugins/optimize/MangleExportsPlugin.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ExportsInfo_1 = require("@/module/ExportsInfo");
+const Template_1 = require("@/template/Template");
+const comparators_1 = require("@/base/comparators");
+const IdHelpers_1 = require("../../ids/IdHelpers");
+const canMangle = exportsInfo => {
+    if (exportsInfo.otherExportsInfo.getUsed(undefined) !== ExportsInfo_1.UsageState.Unused)
+        return false;
+    let hasSomethingToMangle = false;
+    for (const exportInfo of exportsInfo.exports) {
+        if (exportInfo.canMangle === true) {
+            hasSomethingToMangle = true;
+        }
+    }
+    return hasSomethingToMangle;
+};
+// Sort by name
+const comparator = (0, comparators_1.compareSelect)(e => e.name, comparators_1.compareStringsNumeric);
+const mangleExportsInfo = (deterministic, exportsInfo, isNamespace) => {
+    if (!canMangle(exportsInfo))
+        return;
+    const usedNames = new Set();
+    const mangleableExports = [];
+    // Avoid to renamed exports that are not provided when
+    // 1. it's not a namespace export: non-provided exports can be found in prototype chain
+    // 2. there are other provided exports and deterministic mode is chosen:
+    //    non-provided exports would break the determinism
+    let avoidMangleNonProvided = !isNamespace;
+    if (!avoidMangleNonProvided && deterministic) {
+        for (const exportInfo of exportsInfo.ownedExports) {
+            if (exportInfo.provided !== false) {
+                avoidMangleNonProvided = true;
+                break;
+            }
+        }
+    }
+    for (const exportInfo of exportsInfo.ownedExports) {
+        const name = exportInfo.name;
+        if (!exportInfo.hasUsedName()) {
+            if (
+            // Can the export be mangled?
+            exportInfo.canMangle !== true ||
+                // Never rename 1 char exports
+                (name.length === 1 && /^[a-zA-Z0-9_$]/.test(name)) ||
+                // Don't rename 2 char exports in deterministic mode
+                (deterministic && name.length === 2 && /^[a-zA-Z_$][a-zA-Z0-9_$]|^[1-9][0-9]/.test(name)) ||
+                // Don't rename exports that are not provided
+                (avoidMangleNonProvided && exportInfo.provided !== true)) {
+                exportInfo.setUsedName(name);
+                usedNames.add(name);
+            }
+            else {
+                mangleableExports.push(exportInfo);
+            }
+        }
+        if (exportInfo.exportsInfoOwned) {
+            const used = exportInfo.getUsed(undefined);
+            if (used === ExportsInfo_1.UsageState.OnlyPropertiesUsed || used === ExportsInfo_1.UsageState.Unused) {
+                mangleExportsInfo(deterministic, exportInfo.exportsInfo, false);
+            }
+        }
+    }
+    if (deterministic) {
+        (0, IdHelpers_1.assignDeterministicIds)(mangleableExports, e => e.name, comparator, (e, id) => {
+            const name = Template_1.Template.numberToIdentifier(id);
+            const size = usedNames.size;
+            usedNames.add(name);
+            if (size === usedNames.size)
+                return false;
+            e.setUsedName(name);
+            return true;
+        }, [
+            Template_1.NUMBER_OF_IDENTIFIER_START_CHARS,
+            Template_1.NUMBER_OF_IDENTIFIER_START_CHARS * Template_1.NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS,
+        ], Template_1.NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS, usedNames.size);
+    }
+    else {
+        const usedExports = [];
+        const unusedExports = [];
+        for (const exportInfo of mangleableExports) {
+            if (exportInfo.getUsed(undefined) === ExportsInfo_1.UsageState.Unused) {
+                unusedExports.push(exportInfo);
+            }
+            else {
+                usedExports.push(exportInfo);
+            }
+        }
+        usedExports.sort(comparator);
+        unusedExports.sort(comparator);
+        let i = 0;
+        for (const list of [usedExports, unusedExports]) {
+            for (const exportInfo of list) {
+                let name;
+                do {
+                    name = Template_1.Template.numberToIdentifier(i++);
+                } while (usedNames.has(name));
+                exportInfo.setUsedName(name);
+            }
+        }
+    }
+};
+class MangleExportsPlugin {
+    constructor(deterministic) {
+        this._deterministic = deterministic;
+    }
+    apply(compiler) {
+        const { _deterministic: deterministic } = this;
+        compiler.hooks.compilation.tap('MangleExportsPlugin', compilation => {
+            const moduleGraph = compilation.moduleGraph;
+            compilation.hooks.optimizeCodeGeneration.tap('MangleExportsPlugin', modules => {
+                if (compilation.moduleMemCaches) {
+                    throw new Error("optimization.mangleExports can't be used with cacheUnaffected as export mangling is a global effect");
+                }
+                for (const module of modules) {
+                    const isNamespace = module.buildMeta && module.buildMeta.exportsType === 'namespace';
+                    const exportsInfo = moduleGraph.getExportsInfo(module);
+                    mangleExportsInfo(deterministic, exportsInfo, isNamespace);
+                }
+            });
+        });
+    }
+}
+exports.default = MangleExportsPlugin;

package/dist/plugins/optimize/MergeDuplicateChunksPlugin.d.ts

@@ -0,0 +1,4 @@
+declare class MergeDuplicateChunksPlugin {
+    apply(compiler: any): void;
+}
+export default MergeDuplicateChunksPlugin;

package/dist/plugins/optimize/MergeDuplicateChunksPlugin.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const OptimizationStages_1 = require("@/plugins/optimize/OptimizationStages");
+const RuntimeHelpers_1 = require("@/module/RuntimeHelpers");
+class MergeDuplicateChunksPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap('MergeDuplicateChunksPlugin', compilation => {
+            compilation.hooks.optimizeChunks.tap({
+                name: 'MergeDuplicateChunksPlugin',
+                stage: OptimizationStages_1.STAGE_BASIC,
+            }, chunks => {
+                const { chunkGraph, moduleGraph } = compilation;
+                // remember already tested chunks for performance
+                const notDuplicates = new Set();
+                // for each chunk
+                for (const chunk of chunks) {
+                    // track a Set of all chunk that could be duplicates
+                    let possibleDuplicates;
+                    for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+                        if (possibleDuplicates === undefined) {
+                            // when possibleDuplicates is not yet set,
+                            // create a new Set from chunks of the current module
+                            // including only chunks with the same number of modules
+                            for (const dup of chunkGraph.getModuleChunksIterable(module)) {
+                                if (dup !== chunk &&
+                                    chunkGraph.getNumberOfChunkModules(chunk) ===
+                                        chunkGraph.getNumberOfChunkModules(dup) &&
+                                    !notDuplicates.has(dup)) {
+                                    // delay allocating the new Set until here, reduce memory pressure
+                                    if (possibleDuplicates === undefined) {
+                                        possibleDuplicates = new Set();
+                                    }
+                                    possibleDuplicates.add(dup);
+                                }
+                            }
+                            // when no chunk is possible we can break here
+                            if (possibleDuplicates === undefined)
+                                break;
+                        }
+                        else {
+                            // validate existing possible duplicates
+                            for (const dup of possibleDuplicates) {
+                                // remove possible duplicate when module is not contained
+                                if (!chunkGraph.isModuleInChunk(module, dup)) {
+                                    possibleDuplicates.delete(dup);
+                                }
+                            }
+                            // when all chunks has been removed we can break here
+                            if (possibleDuplicates.size === 0)
+                                break;
+                        }
+                    }
+                    // when we found duplicates
+                    if (possibleDuplicates !== undefined && possibleDuplicates.size > 0) {
+                        outer: for (const otherChunk of possibleDuplicates) {
+                            if (otherChunk.hasRuntime() !== chunk.hasRuntime())
+                                continue;
+                            if (chunkGraph.getNumberOfEntryModules(chunk) > 0)
+                                continue;
+                            if (chunkGraph.getNumberOfEntryModules(otherChunk) > 0)
+                                continue;
+                            if (!(0, RuntimeHelpers_1.runtimeEqual)(chunk.runtime, otherChunk.runtime)) {
+                                for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+                                    const exportsInfo = moduleGraph.getExportsInfo(module);
+                                    if (!exportsInfo.isEquallyUsed(chunk.runtime, otherChunk.runtime)) {
+                                        continue outer;
+                                    }
+                                }
+                            }
+                            // merge them
+                            if (chunkGraph.canChunksBeIntegrated(chunk, otherChunk)) {
+                                chunkGraph.integrateChunks(chunk, otherChunk);
+                                compilation.chunks.delete(otherChunk);
+                            }
+                        }
+                    }
+                    // don't check already processed chunks twice
+                    notDuplicates.add(chunk);
+                }
+            });
+        });
+    }
+}
+exports.default = MergeDuplicateChunksPlugin;

package/dist/plugins/optimize/MinChunkSizePlugin.d.ts

@@ -0,0 +1,6 @@
+declare class MinChunkSizePlugin {
+    options: any;
+    constructor(options: any);
+    apply(compiler: any): void;
+}
+export default MinChunkSizePlugin;

package/dist/plugins/optimize/MinChunkSizePlugin.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const OptimizationStages_1 = require("@/plugins/optimize/OptimizationStages");
+class MinChunkSizePlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    apply(compiler) {
+        const options = this.options;
+        const minChunkSize = options.minChunkSize;
+        compiler.hooks.compilation.tap('MinChunkSizePlugin', compilation => {
+            compilation.hooks.optimizeChunks.tap({
+                name: 'MinChunkSizePlugin',
+                stage: OptimizationStages_1.STAGE_ADVANCED,
+            }, chunks => {
+                const chunkGraph = compilation.chunkGraph;
+                const equalOptions = {
+                    chunkOverhead: 1,
+                    entryChunkMultiplicator: 1,
+                };
+                const chunkSizesMap = new Map();
+                const combinations = [];
+                const smallChunks = [];
+                const visitedChunks = [];
+                for (const a of chunks) {
+                    // check if one of the chunks sizes is smaller than the minChunkSize
+                    // and filter pairs that can NOT be integrated!
+                    if (chunkGraph.getChunkSize(a, equalOptions) < minChunkSize) {
+                        smallChunks.push(a);
+                        for (const b of visitedChunks) {
+                            if (chunkGraph.canChunksBeIntegrated(b, a))
+                                combinations.push([b, a]);
+                        }
+                    }
+                    else {
+                        for (const b of smallChunks) {
+                            if (chunkGraph.canChunksBeIntegrated(b, a))
+                                combinations.push([b, a]);
+                        }
+                    }
+                    chunkSizesMap.set(a, chunkGraph.getChunkSize(a, options));
+                    visitedChunks.push(a);
+                }
+                const sortedSizeFilteredExtendedPairCombinations = combinations
+                    .map(pair => {
+                    // extend combination pairs with size and integrated size
+                    const a = chunkSizesMap.get(pair[0]);
+                    const b = chunkSizesMap.get(pair[1]);
+                    const ab = chunkGraph.getIntegratedChunksSize(pair[0], pair[1], options);
+                    const extendedPair = [a + b - ab, ab, pair[0], pair[1]];
+                    return extendedPair;
+                })
+                    .sort((a, b) => {
+                    // sadly javascript does an in place sort here
+                    // sort by size
+                    const diff = b[0] - a[0];
+                    if (diff !== 0)
+                        return diff;
+                    return a[1] - b[1];
+                });
+                if (sortedSizeFilteredExtendedPairCombinations.length === 0)
+                    return;
+                const pair = sortedSizeFilteredExtendedPairCombinations[0];
+                chunkGraph.integrateChunks(pair[2], pair[3]);
+                compilation.chunks.delete(pair[3]);
+                return true;
+            });
+        });
+    }
+}
+exports.default = MinChunkSizePlugin;

package/dist/plugins/optimize/ModuleConcatenationPlugin.d.ts

@@ -0,0 +1,8 @@
+declare class ModuleConcatenationPlugin {
+    options: any;
+    constructor(options?: any);
+    apply(compiler: any): void;
+    _getImports(compilation: any, module: any, runtime: any): Set<unknown>;
+    _tryToAdd(compilation: any, config: any, module: any, runtime: any, activeRuntime: any, possibleModules: any, candidates: any, failureCache: any, chunkGraph: any, avoidMutateOnFailure: any, statistics: any): any;
+}
+export default ModuleConcatenationPlugin;