xhs-mp-pack 1.1.0-beta.0

package/dist/chunk/ChunkGroup.d.ts

@@ -0,0 +1,62 @@
+import SortableSet from '@/base/SortableSet';
+declare class ChunkGroup {
+    groupDebugId: number;
+    options: any;
+    _children: SortableSet;
+    _parents: SortableSet;
+    _asyncEntrypoints: SortableSet;
+    _blocks: SortableSet;
+    chunks: any[];
+    origins: any[];
+    _modulePreOrderIndices: Map<any, any>;
+    _modulePostOrderIndices: Map<any, any>;
+    index: undefined;
+    constructor(options: any);
+    addOptions(options: any): void;
+    get name(): string;
+    set name(value: string);
+    get debugId(): string;
+    get id(): string;
+    unshiftChunk(chunk: any): boolean;
+    insertChunk(chunk: any, before: any): boolean;
+    pushChunk(chunk: any): boolean;
+    replaceChunk(oldChunk: any, newChunk: any): boolean | undefined;
+    removeChunk(chunk: any): boolean;
+    isInitial(): boolean;
+    addChild(group: any): boolean;
+    getChildren(): any;
+    getNumberOfChildren(): number;
+    get childrenIterable(): SortableSet;
+    removeChild(group: any): boolean;
+    addParent(parentChunk: any): boolean;
+    getParents(): any;
+    getNumberOfParents(): number;
+    hasParent(parent: any): boolean;
+    get parentsIterable(): SortableSet;
+    removeParent(chunkGroup: any): boolean;
+    addAsyncEntrypoint(entrypoint: any): boolean;
+    get asyncEntrypointsIterable(): SortableSet;
+    getBlocks(): any;
+    getNumberOfBlocks(): number;
+    hasBlock(block: any): boolean;
+    get blocksIterable(): SortableSet;
+    addBlock(block: any): boolean;
+    addOrigin(module: any, loc: any, request: any): void;
+    getFiles(): unknown[];
+    remove(): void;
+    sortItems(): void;
+    compareTo(chunkGraph: any, otherGroup: any): any;
+    getChildrenByOrders(moduleGraph: any, chunkGraph: any): any;
+    setModulePreOrderIndex(module: any, index: any): void;
+    getModulePreOrderIndex(module: any): any;
+    /**
+     * Sets the bottom-up index of a module in this ChunkGroup
+     */
+    setModulePostOrderIndex(module: any, index: any): void;
+    /**
+     * Gets the bottom-up index of a module in this ChunkGroup
+     */
+    getModulePostOrderIndex(module: any): any;
+    checkConstraints(): void;
+}
+export default ChunkGroup;

package/dist/chunk/ChunkGroup.js

@@ -0,0 +1,341 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = __importDefault(require("util"));
+const SortableSet_1 = __importDefault(require("@/base/SortableSet"));
+const comparators_1 = require("@/base/comparators");
+let debugId = 5000;
+const getArray = set => Array.from(set);
+const sortById = (a, b) => {
+    if (a.id < b.id)
+        return -1;
+    if (b.id < a.id)
+        return 1;
+    return 0;
+};
+const sortOrigin = (a, b) => {
+    const aIdent = a.module ? a.module.identifier() : '';
+    const bIdent = b.module ? b.module.identifier() : '';
+    if (aIdent < bIdent)
+        return -1;
+    if (aIdent > bIdent)
+        return 1;
+    return (0, comparators_1.compareLocations)(a.loc, b.loc);
+};
+class ChunkGroup {
+    constructor(options) {
+        if (typeof options === 'string') {
+            options = { name: options };
+        }
+        else if (!options) {
+            options = { name: undefined };
+        }
+        this.groupDebugId = debugId++;
+        this.options = options;
+        this._children = new SortableSet_1.default(undefined, sortById);
+        this._parents = new SortableSet_1.default(undefined, sortById);
+        this._asyncEntrypoints = new SortableSet_1.default(undefined, sortById);
+        this._blocks = new SortableSet_1.default();
+        this.chunks = [];
+        this.origins = [];
+        /** Indices in top-down order */
+        this._modulePreOrderIndices = new Map();
+        /** Indices in bottom-up order */
+        this._modulePostOrderIndices = new Map();
+        this.index = undefined;
+    }
+    addOptions(options) {
+        for (const key of Object.keys(options)) {
+            if (this.options[key] === undefined) {
+                this.options[key] = options[key];
+            }
+            else if (this.options[key] !== options[key]) {
+                if (key.endsWith('Order')) {
+                    this.options[key] = Math.max(this.options[key], options[key]);
+                }
+                else {
+                    throw new Error(`ChunkGroup.addOptions: No option merge strategy for ${key}`);
+                }
+            }
+        }
+    }
+    get name() {
+        return this.options.name;
+    }
+    set name(value) {
+        this.options.name = value;
+    }
+    get debugId() {
+        return Array.from(this.chunks, x => x.debugId).join('+');
+    }
+    get id() {
+        return Array.from(this.chunks, x => x.id).join('+');
+    }
+    unshiftChunk(chunk) {
+        const oldIdx = this.chunks.indexOf(chunk);
+        if (oldIdx > 0) {
+            this.chunks.splice(oldIdx, 1);
+            this.chunks.unshift(chunk);
+        }
+        else if (oldIdx < 0) {
+            this.chunks.unshift(chunk);
+            return true;
+        }
+        return false;
+    }
+    insertChunk(chunk, before) {
+        const oldIdx = this.chunks.indexOf(chunk);
+        const idx = this.chunks.indexOf(before);
+        if (idx < 0) {
+            throw new Error('before chunk not found');
+        }
+        if (oldIdx >= 0 && oldIdx > idx) {
+            this.chunks.splice(oldIdx, 1);
+            this.chunks.splice(idx, 0, chunk);
+        }
+        else if (oldIdx < 0) {
+            this.chunks.splice(idx, 0, chunk);
+            return true;
+        }
+        return false;
+    }
+    pushChunk(chunk) {
+        const oldIdx = this.chunks.indexOf(chunk);
+        if (oldIdx >= 0) {
+            return false;
+        }
+        this.chunks.push(chunk);
+        return true;
+    }
+    replaceChunk(oldChunk, newChunk) {
+        const oldIdx = this.chunks.indexOf(oldChunk);
+        if (oldIdx < 0)
+            return false;
+        const newIdx = this.chunks.indexOf(newChunk);
+        if (newIdx < 0) {
+            this.chunks[oldIdx] = newChunk;
+            return true;
+        }
+        if (newIdx < oldIdx) {
+            this.chunks.splice(oldIdx, 1);
+            return true;
+        }
+        if (newIdx !== oldIdx) {
+            this.chunks[oldIdx] = newChunk;
+            this.chunks.splice(newIdx, 1);
+            return true;
+        }
+    }
+    removeChunk(chunk) {
+        const idx = this.chunks.indexOf(chunk);
+        if (idx >= 0) {
+            this.chunks.splice(idx, 1);
+            return true;
+        }
+        return false;
+    }
+    isInitial() {
+        return false;
+    }
+    addChild(group) {
+        const size = this._children.size;
+        this._children.add(group);
+        return size !== this._children.size;
+    }
+    getChildren() {
+        return this._children.getFromCache(getArray);
+    }
+    getNumberOfChildren() {
+        return this._children.size;
+    }
+    get childrenIterable() {
+        return this._children;
+    }
+    removeChild(group) {
+        if (!this._children.has(group)) {
+            return false;
+        }
+        this._children.delete(group);
+        group.removeParent(this);
+        return true;
+    }
+    addParent(parentChunk) {
+        if (!this._parents.has(parentChunk)) {
+            this._parents.add(parentChunk);
+            return true;
+        }
+        return false;
+    }
+    getParents() {
+        return this._parents.getFromCache(getArray);
+    }
+    getNumberOfParents() {
+        return this._parents.size;
+    }
+    hasParent(parent) {
+        return this._parents.has(parent);
+    }
+    get parentsIterable() {
+        return this._parents;
+    }
+    removeParent(chunkGroup) {
+        if (this._parents.delete(chunkGroup)) {
+            chunkGroup.removeChild(this);
+            return true;
+        }
+        return false;
+    }
+    addAsyncEntrypoint(entrypoint) {
+        const size = this._asyncEntrypoints.size;
+        this._asyncEntrypoints.add(entrypoint);
+        return size !== this._asyncEntrypoints.size;
+    }
+    get asyncEntrypointsIterable() {
+        return this._asyncEntrypoints;
+    }
+    getBlocks() {
+        return this._blocks.getFromCache(getArray);
+    }
+    getNumberOfBlocks() {
+        return this._blocks.size;
+    }
+    hasBlock(block) {
+        return this._blocks.has(block);
+    }
+    get blocksIterable() {
+        return this._blocks;
+    }
+    addBlock(block) {
+        if (!this._blocks.has(block)) {
+            this._blocks.add(block);
+            return true;
+        }
+        return false;
+    }
+    addOrigin(module, loc, request) {
+        this.origins.push({
+            module,
+            loc,
+            request,
+        });
+    }
+    getFiles() {
+        const files = new Set();
+        for (const chunk of this.chunks) {
+            for (const file of chunk.files) {
+                files.add(file);
+            }
+        }
+        return Array.from(files);
+    }
+    remove() {
+        // cleanup parents
+        for (const parentChunkGroup of this._parents) {
+            // remove this chunk from its parents
+            parentChunkGroup._children.delete(this);
+            // cleanup "sub chunks"
+            for (const chunkGroup of this._children) {
+                /**
+                 * remove this chunk as "intermediary" and connect
+                 * it "sub chunks" and parents directly
+                 */
+                // add parent to each "sub chunk"
+                chunkGroup.addParent(parentChunkGroup);
+                // add "sub chunk" to parent
+                parentChunkGroup.addChild(chunkGroup);
+            }
+        }
+        /**
+         * we need to iterate again over the children
+         * to remove this from the child's parents.
+         * This can not be done in the above loop
+         * as it is not guaranteed that `this._parents` contains anything.
+         */
+        for (const chunkGroup of this._children) {
+            // remove this as parent of every "sub chunk"
+            chunkGroup._parents.delete(this);
+        }
+        // remove chunks
+        for (const chunk of this.chunks) {
+            chunk.removeGroup(this);
+        }
+    }
+    sortItems() {
+        this.origins.sort(sortOrigin);
+    }
+    compareTo(chunkGraph, otherGroup) {
+        if (this.chunks.length > otherGroup.chunks.length)
+            return -1;
+        if (this.chunks.length < otherGroup.chunks.length)
+            return 1;
+        return (0, comparators_1.compareIterables)((0, comparators_1.compareChunks)(chunkGraph))(this.chunks, otherGroup.chunks);
+    }
+    getChildrenByOrders(moduleGraph, chunkGraph) {
+        const lists = new Map();
+        for (const childGroup of this._children) {
+            for (const key of Object.keys(childGroup.options)) {
+                if (key.endsWith('Order')) {
+                    const name = key.slice(0, key.length - 'Order'.length);
+                    let list = lists.get(name);
+                    if (list === undefined) {
+                        lists.set(name, (list = []));
+                    }
+                    list.push({
+                        order: childGroup.options[key],
+                        group: childGroup,
+                    });
+                }
+            }
+        }
+        const result = Object.create(null);
+        for (const [name, list] of lists) {
+            list.sort((a, b) => {
+                const cmp = b.order - a.order;
+                if (cmp !== 0)
+                    return cmp;
+                return a.group.compareTo(chunkGraph, b.group);
+            });
+            result[name] = list.map(i => i.group);
+        }
+        return result;
+    }
+    setModulePreOrderIndex(module, index) {
+        this._modulePreOrderIndices.set(module, index);
+    }
+    getModulePreOrderIndex(module) {
+        return this._modulePreOrderIndices.get(module);
+    }
+    /**
+     * Sets the bottom-up index of a module in this ChunkGroup
+     */
+    setModulePostOrderIndex(module, index) {
+        this._modulePostOrderIndices.set(module, index);
+    }
+    /**
+     * Gets the bottom-up index of a module in this ChunkGroup
+     */
+    getModulePostOrderIndex(module) {
+        return this._modulePostOrderIndices.get(module);
+    }
+    /* istanbul ignore next */
+    checkConstraints() {
+        const chunk = this;
+        for (const child of chunk._children) {
+            if (!child._parents.has(chunk)) {
+                throw new Error(`checkConstraints: child missing parent ${chunk.debugId} -> ${child.debugId}`);
+            }
+        }
+        for (const parentChunk of chunk._parents) {
+            if (!parentChunk._children.has(chunk)) {
+                throw new Error(`checkConstraints: parent missing child ${parentChunk.debugId} <- ${chunk.debugId}`);
+            }
+        }
+    }
+}
+// @ts-ignore
+ChunkGroup.prototype.getModuleIndex = util_1.default.deprecate(ChunkGroup.prototype.getModulePreOrderIndex, 'ChunkGroup.getModuleIndex was renamed to getModulePreOrderIndex', 'DEP_WEBPACK_CHUNK_GROUP_GET_MODULE_INDEX');
+// @ts-ignore
+ChunkGroup.prototype.getModuleIndex2 = util_1.default.deprecate(ChunkGroup.prototype.getModulePostOrderIndex, 'ChunkGroup.getModuleIndex2 was renamed to getModulePostOrderIndex', 'DEP_WEBPACK_CHUNK_GROUP_GET_MODULE_INDEX_2');
+exports.default = ChunkGroup;

package/dist/chunk/CodeGenerationResults.d.ts

@@ -0,0 +1,13 @@
+declare class CodeGenerationResults {
+    map: Map<any, any>;
+    _hashFunction: string;
+    constructor(hashFunction?: string);
+    get(module: any, runtime: any): any;
+    has(module: any, runtime: any): any;
+    getSource(module: any, runtime: any, sourceType: any): any;
+    getRuntimeRequirements(module: any, runtime: any): any;
+    getData(module: any, runtime: any, key: any): any;
+    getHash(module: any, runtime: any): any;
+    add(module: any, runtime: any, result: any): void;
+}
+export default CodeGenerationResults;

package/dist/chunk/CodeGenerationResults.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const MapHelpers_1 = require("@/base/MapHelpers");
+const SetHelpers_1 = require("@/base/SetHelpers");
+const createHash_1 = __importDefault(require("@/base/createHash"));
+const RuntimeHelpers_1 = require("@/module/RuntimeHelpers");
+class CodeGenerationResults {
+    constructor(hashFunction = 'md4') {
+        this.map = new Map();
+        this._hashFunction = hashFunction;
+    }
+    get(module, runtime) {
+        const entry = this.map.get(module);
+        if (entry === undefined) {
+            throw new Error(`No code generation entry for ${module.identifier()} (existing entries: ${Array.from(this.map.keys(), m => m.identifier()).join(', ')})`);
+        }
+        if (runtime === undefined) {
+            if (entry.size > 1) {
+                const results = new Set(entry.values());
+                if (results.size !== 1) {
+                    throw new Error(`No unique code generation entry for unspecified runtime for ${module.identifier()} (existing runtimes: ${Array.from(entry.keys(), r => (0, RuntimeHelpers_1.runtimeToString)(r)).join(', ')}).
+Caller might not support runtime-dependent code generation (opt-out via optimization.usedExports: "global").`);
+                }
+                return (0, SetHelpers_1.first)(results);
+            }
+            return entry.values().next().value;
+        }
+        const result = entry.get(runtime);
+        if (result === undefined) {
+            throw new Error(`No code generation entry for runtime ${(0, RuntimeHelpers_1.runtimeToString)(runtime)} for ${module.identifier()} (existing runtimes: ${Array.from(entry.keys(), r => (0, RuntimeHelpers_1.runtimeToString)(r)).join(', ')})`);
+        }
+        return result;
+    }
+    has(module, runtime) {
+        const entry = this.map.get(module);
+        if (entry === undefined) {
+            return false;
+        }
+        if (runtime !== undefined) {
+            return entry.has(runtime);
+        }
+        if (entry.size > 1) {
+            const results = new Set(entry.values());
+            return results.size === 1;
+        }
+        return entry.size === 1;
+    }
+    getSource(module, runtime, sourceType) {
+        return this.get(module, runtime).sources.get(sourceType);
+    }
+    getRuntimeRequirements(module, runtime) {
+        return this.get(module, runtime).runtimeRequirements;
+    }
+    getData(module, runtime, key) {
+        const data = this.get(module, runtime).data;
+        return data === undefined ? undefined : data.get(key);
+    }
+    getHash(module, runtime) {
+        const info = this.get(module, runtime);
+        if (info.hash !== undefined)
+            return info.hash;
+        const hash = (0, createHash_1.default)(this._hashFunction);
+        for (const [type, source] of info.sources) {
+            hash.update(type);
+            source.updateHash(hash);
+        }
+        if (info.runtimeRequirements) {
+            for (const rr of info.runtimeRequirements)
+                hash.update(rr);
+        }
+        info.hash = hash.digest('hex');
+        return info.hash;
+    }
+    add(module, runtime, result) {
+        const map = (0, MapHelpers_1.getOrInsert)(this.map, module, () => new RuntimeHelpers_1.RuntimeSpecMap());
+        map.set(runtime, result);
+    }
+}
+exports.default = CodeGenerationResults;

package/dist/chunk/Entrypoint.d.ts

@@ -0,0 +1,22 @@
+import ChunkGroup from './ChunkGroup';
+/** @typedef {{ name?: string } & Omit<EntryDescription, "import">} EntryOptions */
+/**
+ * Entrypoint serves as an encapsulation primitive for chunks that are
+ * a part of a single ChunkGroup. They represent all bundles that need to be loaded for a
+ * single instance of a page. Multi-page application architectures will typically yield multiple Entrypoint objects
+ * inside of the compilation, whereas a Single Page App may only contain one with many lazy-loaded chunks.
+ */
+declare class Entrypoint extends ChunkGroup {
+    options: any;
+    _runtimeChunk: undefined;
+    _entrypointChunk: undefined;
+    _initial: boolean;
+    constructor(entryOptions: any, initial?: boolean);
+    isInitial(): boolean;
+    setRuntimeChunk(chunk: any): void;
+    getRuntimeChunk(): any;
+    setEntrypointChunk(chunk: any): void;
+    getEntrypointChunk(): undefined;
+    replaceChunk(oldChunk: any, newChunk: any): boolean | undefined;
+}
+export default Entrypoint;

package/dist/chunk/Entrypoint.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ChunkGroup_1 = __importDefault(require("./ChunkGroup"));
+/** @typedef {{ name?: string } & Omit<EntryDescription, "import">} EntryOptions */
+/**
+ * Entrypoint serves as an encapsulation primitive for chunks that are
+ * a part of a single ChunkGroup. They represent all bundles that need to be loaded for a
+ * single instance of a page. Multi-page application architectures will typically yield multiple Entrypoint objects
+ * inside of the compilation, whereas a Single Page App may only contain one with many lazy-loaded chunks.
+ */
+class Entrypoint extends ChunkGroup_1.default {
+    constructor(entryOptions, initial = true) {
+        if (typeof entryOptions === 'string') {
+            entryOptions = { name: entryOptions };
+        }
+        super({
+            name: entryOptions.name,
+        });
+        this.options = entryOptions;
+        this._runtimeChunk = undefined;
+        this._entrypointChunk = undefined;
+        this._initial = initial;
+    }
+    isInitial() {
+        return this._initial;
+    }
+    setRuntimeChunk(chunk) {
+        this._runtimeChunk = chunk;
+    }
+    getRuntimeChunk() {
+        if (this._runtimeChunk)
+            return this._runtimeChunk;
+        for (const parent of this.parentsIterable) {
+            if (parent instanceof Entrypoint)
+                return parent.getRuntimeChunk();
+        }
+        return null;
+    }
+    setEntrypointChunk(chunk) {
+        this._entrypointChunk = chunk;
+    }
+    getEntrypointChunk() {
+        return this._entrypointChunk;
+    }
+    replaceChunk(oldChunk, newChunk) {
+        if (this._runtimeChunk === oldChunk)
+            this._runtimeChunk = newChunk;
+        if (this._entrypointChunk === oldChunk)
+            this._entrypointChunk = newChunk;
+        return super.replaceChunk(oldChunk, newChunk);
+    }
+}
+exports.default = Entrypoint;

package/dist/chunk/GraphHelpers.d.ts

@@ -0,0 +1,3 @@
+declare const connectChunkGroupAndChunk: (chunkGroup: any, chunk: any) => void;
+declare const connectChunkGroupParentAndChild: (parent: any, child: any) => void;
+export { connectChunkGroupAndChunk, connectChunkGroupParentAndChild };

package/dist/chunk/GraphHelpers.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectChunkGroupParentAndChild = exports.connectChunkGroupAndChunk = void 0;
+const connectChunkGroupAndChunk = (chunkGroup, chunk) => {
+    if (chunkGroup.pushChunk(chunk)) {
+        chunk.addGroup(chunkGroup);
+    }
+};
+exports.connectChunkGroupAndChunk = connectChunkGroupAndChunk;
+const connectChunkGroupParentAndChild = (parent, child) => {
+    if (parent.addChild(child)) {
+        child.addParent(parent);
+    }
+};
+exports.connectChunkGroupParentAndChild = connectChunkGroupParentAndChild;

package/dist/chunk/buildChunkGraph.d.ts

@@ -0,0 +1,2 @@
+declare const buildChunkGraph: (compilation: any, inputEntrypointsAndModules: any) => void;
+export default buildChunkGraph;