xhs-mp-pack 1.1.0-beta.0

package/dist/module/ModuleGraph.js

@@ -0,0 +1,470 @@
+"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 ExportsInfo_1 = require("@/module/ExportsInfo");
+const SortableSet_1 = __importDefault(require("@/base/SortableSet"));
+const WeakTupleMap_1 = __importDefault(require("@/base/WeakTupleMap"));
+const ModuleGraphConnection_1 = require("./ModuleGraphConnection");
+const EMPTY_SET = new Set();
+const getConnectionsByOriginModule = set => {
+    const map = new Map();
+    let lastModule = 0;
+    let lastList;
+    for (const connection of set) {
+        const { originModule } = connection;
+        if (lastModule === originModule) {
+            lastList.push(connection);
+        }
+        else {
+            lastModule = originModule;
+            const list = map.get(originModule);
+            if (list !== undefined) {
+                lastList = list;
+                list.push(connection);
+            }
+            else {
+                const list = [connection];
+                lastList = list;
+                map.set(originModule, list);
+            }
+        }
+    }
+    return map;
+};
+const getConnectionsByModule = set => {
+    const map = new Map();
+    let lastModule = 0;
+    let lastList;
+    for (const connection of set) {
+        const { module } = connection;
+        if (lastModule === module) {
+            lastList.push(connection);
+        }
+        else {
+            lastModule = module;
+            const list = map.get(module);
+            if (list !== undefined) {
+                lastList = list;
+                list.push(connection);
+            }
+            else {
+                const list = [connection];
+                lastList = list;
+                map.set(module, list);
+            }
+        }
+    }
+    return map;
+};
+class ModuleGraphModule {
+    constructor() {
+        this.incomingConnections = new SortableSet_1.default();
+        this.outgoingConnections = undefined;
+        this.issuer = undefined;
+        this.optimizationBailout = [];
+        this.exports = new ExportsInfo_1.ExportsInfo();
+        this.preOrderIndex = null;
+        this.postOrderIndex = null;
+        this.depth = null;
+        this.profile = undefined;
+        this.async = false;
+        this._unassignedConnections = undefined;
+    }
+}
+class ModuleGraph {
+    constructor() {
+        this._dependencyMap = new WeakMap();
+        this._moduleMap = new Map();
+        this._metaMap = new WeakMap();
+        this._cache = undefined;
+        this._moduleMemCaches = undefined;
+        this._cacheStage = undefined;
+    }
+    _getModuleGraphModule(module) {
+        let mgm = this._moduleMap.get(module);
+        if (mgm === undefined) {
+            mgm = new ModuleGraphModule();
+            this._moduleMap.set(module, mgm);
+        }
+        return mgm;
+    }
+    setParents(dependency, block, module, indexInBlock = -1) {
+        dependency._parentDependenciesBlockIndex = indexInBlock;
+        dependency._parentDependenciesBlock = block;
+        dependency._parentModule = module;
+    }
+    getParentModule(dependency) {
+        return dependency._parentModule;
+    }
+    getParentBlock(dependency) {
+        return dependency._parentDependenciesBlock;
+    }
+    getParentBlockIndex(dependency) {
+        return dependency._parentDependenciesBlockIndex;
+    }
+    setResolvedModule(originModule, dependency, module) {
+        const connection = new ModuleGraphConnection_1.ModuleGraphConnection(originModule, dependency, module, undefined, dependency.weak, dependency.getCondition(this));
+        const connections = this._getModuleGraphModule(module).incomingConnections;
+        connections.add(connection);
+        if (originModule) {
+            const mgm = this._getModuleGraphModule(originModule);
+            if (mgm._unassignedConnections === undefined) {
+                mgm._unassignedConnections = [];
+            }
+            mgm._unassignedConnections.push(connection);
+            if (mgm.outgoingConnections === undefined) {
+                mgm.outgoingConnections = new SortableSet_1.default();
+            }
+            mgm.outgoingConnections.add(connection);
+        }
+        else {
+            this._dependencyMap.set(dependency, connection);
+        }
+    }
+    updateModule(dependency, module) {
+        const connection = this.getConnection(dependency);
+        if (connection.module === module)
+            return;
+        const newConnection = connection.clone();
+        newConnection.module = module;
+        this._dependencyMap.set(dependency, newConnection);
+        connection.setActive(false);
+        const originMgm = this._getModuleGraphModule(connection.originModule);
+        originMgm.outgoingConnections.add(newConnection);
+        const targetMgm = this._getModuleGraphModule(module);
+        targetMgm.incomingConnections.add(newConnection);
+    }
+    removeConnection(dependency) {
+        const connection = this.getConnection(dependency);
+        const targetMgm = this._getModuleGraphModule(connection.module);
+        targetMgm.incomingConnections.delete(connection);
+        const originMgm = this._getModuleGraphModule(connection.originModule);
+        originMgm.outgoingConnections.delete(connection);
+        this._dependencyMap.set(dependency, null);
+    }
+    addExplanation(dependency, explanation) {
+        const connection = this.getConnection(dependency);
+        connection.addExplanation(explanation);
+    }
+    cloneModuleAttributes(sourceModule, targetModule) {
+        const oldMgm = this._getModuleGraphModule(sourceModule);
+        const newMgm = this._getModuleGraphModule(targetModule);
+        newMgm.postOrderIndex = oldMgm.postOrderIndex;
+        newMgm.preOrderIndex = oldMgm.preOrderIndex;
+        newMgm.depth = oldMgm.depth;
+        newMgm.exports = oldMgm.exports;
+        newMgm.async = oldMgm.async;
+    }
+    removeModuleAttributes(module) {
+        const mgm = this._getModuleGraphModule(module);
+        mgm.postOrderIndex = null;
+        mgm.preOrderIndex = null;
+        mgm.depth = null;
+        mgm.async = false;
+    }
+    removeAllModuleAttributes() {
+        for (const mgm of this._moduleMap.values()) {
+            mgm.postOrderIndex = null;
+            mgm.preOrderIndex = null;
+            mgm.depth = null;
+            mgm.async = false;
+        }
+    }
+    moveModuleConnections(oldModule, newModule, filterConnection) {
+        if (oldModule === newModule)
+            return;
+        const oldMgm = this._getModuleGraphModule(oldModule);
+        const newMgm = this._getModuleGraphModule(newModule);
+        // Outgoing connections
+        const oldConnections = oldMgm.outgoingConnections;
+        if (oldConnections !== undefined) {
+            if (newMgm.outgoingConnections === undefined) {
+                newMgm.outgoingConnections = new SortableSet_1.default();
+            }
+            const newConnections = newMgm.outgoingConnections;
+            for (const connection of oldConnections) {
+                if (filterConnection(connection)) {
+                    connection.originModule = newModule;
+                    newConnections.add(connection);
+                    oldConnections.delete(connection);
+                }
+            }
+        }
+        // Incoming connections
+        const oldConnections2 = oldMgm.incomingConnections;
+        const newConnections2 = newMgm.incomingConnections;
+        for (const connection of oldConnections2) {
+            if (filterConnection(connection)) {
+                connection.module = newModule;
+                newConnections2.add(connection);
+                oldConnections2.delete(connection);
+            }
+        }
+    }
+    copyOutgoingModuleConnections(oldModule, newModule, filterConnection) {
+        if (oldModule === newModule)
+            return;
+        const oldMgm = this._getModuleGraphModule(oldModule);
+        const newMgm = this._getModuleGraphModule(newModule);
+        // Outgoing connections
+        const oldConnections = oldMgm.outgoingConnections;
+        if (oldConnections !== undefined) {
+            if (newMgm.outgoingConnections === undefined) {
+                newMgm.outgoingConnections = new SortableSet_1.default();
+            }
+            const newConnections = newMgm.outgoingConnections;
+            for (const connection of oldConnections) {
+                if (filterConnection(connection)) {
+                    const newConnection = connection.clone();
+                    newConnection.originModule = newModule;
+                    newConnections.add(newConnection);
+                    if (newConnection.module !== undefined) {
+                        const otherMgm = this._getModuleGraphModule(newConnection.module);
+                        otherMgm.incomingConnections.add(newConnection);
+                    }
+                }
+            }
+        }
+    }
+    addExtraReason(module, explanation) {
+        const connections = this._getModuleGraphModule(module).incomingConnections;
+        connections.add(new ModuleGraphConnection_1.ModuleGraphConnection(null, null, module, explanation));
+    }
+    getResolvedModule(dependency) {
+        const connection = this.getConnection(dependency);
+        return connection !== undefined ? connection.resolvedModule : null;
+    }
+    getConnection(dependency) {
+        const connection = this._dependencyMap.get(dependency);
+        if (connection === undefined) {
+            const module = this.getParentModule(dependency);
+            if (module !== undefined) {
+                const mgm = this._getModuleGraphModule(module);
+                if (mgm._unassignedConnections && mgm._unassignedConnections.length !== 0) {
+                    let foundConnection;
+                    for (const connection of mgm._unassignedConnections) {
+                        this._dependencyMap.set(connection.dependency, connection);
+                        if (connection.dependency === dependency)
+                            foundConnection = connection;
+                    }
+                    mgm._unassignedConnections.length = 0;
+                    if (foundConnection !== undefined) {
+                        return foundConnection;
+                    }
+                }
+            }
+            this._dependencyMap.set(dependency, null);
+            return undefined;
+        }
+        return connection === null ? undefined : connection;
+    }
+    getModule(dependency) {
+        const connection = this.getConnection(dependency);
+        return connection !== undefined ? connection.module : null;
+    }
+    getOrigin(dependency) {
+        const connection = this.getConnection(dependency);
+        return connection !== undefined ? connection.originModule : null;
+    }
+    getResolvedOrigin(dependency) {
+        const connection = this.getConnection(dependency);
+        return connection !== undefined ? connection.resolvedOriginModule : null;
+    }
+    getIncomingConnections(module) {
+        const connections = this._getModuleGraphModule(module).incomingConnections;
+        return connections;
+    }
+    getOutgoingConnections(module) {
+        const connections = this._getModuleGraphModule(module).outgoingConnections;
+        return connections === undefined ? EMPTY_SET : connections;
+    }
+    getIncomingConnectionsByOriginModule(module) {
+        const connections = this._getModuleGraphModule(module).incomingConnections;
+        return connections.getFromUnorderedCache(getConnectionsByOriginModule);
+    }
+    getOutgoingConnectionsByModule(module) {
+        const connections = this._getModuleGraphModule(module).outgoingConnections;
+        return connections === undefined
+            ? undefined
+            : connections.getFromUnorderedCache(getConnectionsByModule);
+    }
+    getProfile(module) {
+        const mgm = this._getModuleGraphModule(module);
+        return mgm.profile;
+    }
+    setProfile(module, profile) {
+        const mgm = this._getModuleGraphModule(module);
+        mgm.profile = profile;
+    }
+    getIssuer(module) {
+        const mgm = this._getModuleGraphModule(module);
+        return mgm.issuer;
+    }
+    setIssuer(module, issuer) {
+        const mgm = this._getModuleGraphModule(module);
+        mgm.issuer = issuer;
+    }
+    setIssuerIfUnset(module, issuer) {
+        const mgm = this._getModuleGraphModule(module);
+        if (mgm.issuer === undefined)
+            mgm.issuer = issuer;
+    }
+    getOptimizationBailout(module) {
+        const mgm = this._getModuleGraphModule(module);
+        return mgm.optimizationBailout;
+    }
+    getProvidedExports(module) {
+        const mgm = this._getModuleGraphModule(module);
+        return mgm.exports.getProvidedExports();
+    }
+    isExportProvided(module, exportName) {
+        const mgm = this._getModuleGraphModule(module);
+        const result = mgm.exports.isExportProvided(exportName);
+        return result === undefined ? null : result;
+    }
+    getExportsInfo(module) {
+        const mgm = this._getModuleGraphModule(module);
+        return mgm.exports;
+    }
+    getExportInfo(module, exportName) {
+        const mgm = this._getModuleGraphModule(module);
+        return mgm.exports.getExportInfo(exportName);
+    }
+    getReadOnlyExportInfo(module, exportName) {
+        const mgm = this._getModuleGraphModule(module);
+        return mgm.exports.getReadOnlyExportInfo(exportName);
+    }
+    /**
+     * false: module is not used at all.
+     * true: the module namespace/object export is used.
+     * SortableSet<string>: these export names are used.
+     * empty SortableSet<string>: module is used but no export.
+     * null: unknown, worst case should be assumed.
+     */
+    getUsedExports(module, runtime) {
+        const mgm = this._getModuleGraphModule(module);
+        return mgm.exports.getUsedExports(runtime);
+    }
+    getPreOrderIndex(module) {
+        const mgm = this._getModuleGraphModule(module);
+        return mgm.preOrderIndex;
+    }
+    getPostOrderIndex(module) {
+        const mgm = this._getModuleGraphModule(module);
+        return mgm.postOrderIndex;
+    }
+    setPreOrderIndex(module, index) {
+        const mgm = this._getModuleGraphModule(module);
+        mgm.preOrderIndex = index;
+    }
+    setPreOrderIndexIfUnset(module, index) {
+        const mgm = this._getModuleGraphModule(module);
+        if (mgm.preOrderIndex === null) {
+            mgm.preOrderIndex = index;
+            return true;
+        }
+        return false;
+    }
+    setPostOrderIndex(module, index) {
+        const mgm = this._getModuleGraphModule(module);
+        mgm.postOrderIndex = index;
+    }
+    setPostOrderIndexIfUnset(module, index) {
+        const mgm = this._getModuleGraphModule(module);
+        if (mgm.postOrderIndex === null) {
+            mgm.postOrderIndex = index;
+            return true;
+        }
+        return false;
+    }
+    getDepth(module) {
+        const mgm = this._getModuleGraphModule(module);
+        return mgm.depth;
+    }
+    setDepth(module, depth) {
+        const mgm = this._getModuleGraphModule(module);
+        mgm.depth = depth;
+    }
+    setDepthIfLower(module, depth) {
+        const mgm = this._getModuleGraphModule(module);
+        if (mgm.depth === null || mgm.depth > depth) {
+            mgm.depth = depth;
+            return true;
+        }
+        return false;
+    }
+    isAsync(module) {
+        const mgm = this._getModuleGraphModule(module);
+        return mgm.async;
+    }
+    setAsync(module) {
+        const mgm = this._getModuleGraphModule(module);
+        mgm.async = true;
+    }
+    getMeta(thing) {
+        let meta = this._metaMap.get(thing);
+        if (meta === undefined) {
+            meta = Object.create(null);
+            this._metaMap.set(thing, meta);
+        }
+        return meta;
+    }
+    getMetaIfExisting(thing) {
+        return this._metaMap.get(thing);
+    }
+    freeze(cacheStage) {
+        this._cache = new WeakTupleMap_1.default();
+        this._cacheStage = cacheStage;
+    }
+    unfreeze() {
+        this._cache = undefined;
+        this._cacheStage = undefined;
+    }
+    cached(fn, ...args) {
+        if (this._cache === undefined)
+            return fn(this, ...args);
+        return this._cache.provide(fn, ...args, () => fn(this, ...args));
+    }
+    setModuleMemCaches(moduleMemCaches) {
+        this._moduleMemCaches = moduleMemCaches;
+    }
+    dependencyCacheProvide(dependency, ...args) {
+        const fn = args.pop();
+        if (this._moduleMemCaches && this._cacheStage) {
+            const memCache = this._moduleMemCaches.get(this.getParentModule(dependency));
+            if (memCache !== undefined) {
+                return memCache.provide(dependency, this._cacheStage, ...args, () => fn(this, dependency, ...args));
+            }
+        }
+        if (this._cache === undefined)
+            return fn(this, dependency, ...args);
+        return this._cache.provide(dependency, ...args, () => fn(this, dependency, ...args));
+    }
+    static getModuleGraphForModule(module, deprecateMessage, deprecationCode) {
+        const fn = deprecateMap.get(deprecateMessage);
+        if (fn)
+            return fn(module);
+        const newFn = util_1.default.deprecate(module => {
+            const moduleGraph = moduleGraphForModuleMap.get(module);
+            if (!moduleGraph)
+                throw new Error(`${deprecateMessage}There was no ModuleGraph assigned to the Module for backward-compat (Use the new API)`);
+            return moduleGraph;
+        }, `${deprecateMessage}: Use new ModuleGraph API`, deprecationCode);
+        deprecateMap.set(deprecateMessage, newFn);
+        return newFn(module);
+    }
+    static setModuleGraphForModule(module, moduleGraph) {
+        moduleGraphForModuleMap.set(module, moduleGraph);
+    }
+    static clearModuleGraphForModule(module) {
+        moduleGraphForModuleMap.delete(module);
+    }
+}
+// TODO remove in webpack 6
+const moduleGraphForModuleMap = new WeakMap();
+// TODO remove in webpack 6
+const deprecateMap = new Map();
+exports.default = ModuleGraph;

package/dist/module/ModuleGraphConnection.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Module itself is not connected, but transitive modules are connected transitively.
+ */
+declare const TRANSITIVE_ONLY: unique symbol;
+/**
+ * While determining the active state, this flag is used to signal a circular connection.
+ */
+declare const CIRCULAR_CONNECTION: unique symbol;
+type ConnectionState = boolean | typeof TRANSITIVE_ONLY | typeof CIRCULAR_CONNECTION;
+declare const addConnectionStates: (a: ConnectionState, b: ConnectionState) => boolean | typeof TRANSITIVE_ONLY | typeof CIRCULAR_CONNECTION;
+declare class ModuleGraphConnection {
+    originModule: any;
+    resolvedOriginModule: any;
+    dependency: any;
+    resolvedModule: any;
+    module: any;
+    weak: boolean;
+    conditional: boolean;
+    _active: boolean;
+    condition: any;
+    explanations: any;
+    constructor(originModule: any, dependency: any, module: any, explanation?: string, weak?: boolean, condition?: any);
+    clone(): ModuleGraphConnection;
+    addCondition(condition: any): void;
+    addExplanation(explanation: string): void;
+    get explanation(): string;
+    get active(): void;
+    isActive(runtime: any): boolean;
+    isTargetActive(runtime: any): boolean;
+    getActiveState(runtime: any): any;
+    setActive(value: boolean): void;
+}
+export { TRANSITIVE_ONLY, CIRCULAR_CONNECTION, addConnectionStates, ModuleGraphConnection };

package/dist/module/ModuleGraphConnection.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleGraphConnection = exports.addConnectionStates = exports.CIRCULAR_CONNECTION = exports.TRANSITIVE_ONLY = void 0;
+/**
+ * Module itself is not connected, but transitive modules are connected transitively.
+ */
+const TRANSITIVE_ONLY = Symbol('transitive only');
+exports.TRANSITIVE_ONLY = TRANSITIVE_ONLY;
+/**
+ * While determining the active state, this flag is used to signal a circular connection.
+ */
+const CIRCULAR_CONNECTION = Symbol('circular connection');
+exports.CIRCULAR_CONNECTION = CIRCULAR_CONNECTION;
+const addConnectionStates = (a, b) => {
+    if (a === true || b === true)
+        return true;
+    if (a === false)
+        return b;
+    if (b === false)
+        return a;
+    if (a === TRANSITIVE_ONLY)
+        return b;
+    if (b === TRANSITIVE_ONLY)
+        return a;
+    return a;
+};
+exports.addConnectionStates = addConnectionStates;
+const intersectConnectionStates = (a, b) => {
+    if (a === false || b === false)
+        return false;
+    if (a === true)
+        return b;
+    if (b === true)
+        return a;
+    if (a === CIRCULAR_CONNECTION)
+        return b;
+    if (b === CIRCULAR_CONNECTION)
+        return a;
+    return a;
+};
+class ModuleGraphConnection {
+    constructor(originModule, dependency, module, explanation, weak = false, condition) {
+        this.originModule = originModule;
+        this.resolvedOriginModule = originModule;
+        this.dependency = dependency;
+        this.resolvedModule = module;
+        this.module = module;
+        this.weak = weak;
+        this.conditional = !!condition;
+        this._active = condition !== false;
+        this.condition = condition || undefined;
+        this.explanations = undefined;
+        if (explanation) {
+            this.explanations = new Set();
+            this.explanations.add(explanation);
+        }
+    }
+    clone() {
+        const clone = new ModuleGraphConnection(this.resolvedOriginModule, this.dependency, this.resolvedModule, undefined, this.weak, this.condition);
+        clone.originModule = this.originModule;
+        clone.module = this.module;
+        clone.conditional = this.conditional;
+        clone._active = this._active;
+        if (this.explanations)
+            clone.explanations = new Set(this.explanations);
+        return clone;
+    }
+    addCondition(condition) {
+        if (this.conditional) {
+            const old = this.condition;
+            this.condition = (c, r) => intersectConnectionStates(old(c, r), condition(c, r));
+        }
+        else if (this._active) {
+            this.conditional = true;
+            this.condition = condition;
+        }
+    }
+    addExplanation(explanation) {
+        if (this.explanations === undefined) {
+            this.explanations = new Set();
+        }
+        this.explanations.add(explanation);
+    }
+    get explanation() {
+        if (this.explanations === undefined)
+            return '';
+        return Array.from(this.explanations).join(' ');
+    }
+    // TODO webpack 5 remove
+    get active() {
+        throw new Error('Use getActiveState instead');
+    }
+    isActive(runtime) {
+        if (!this.conditional)
+            return this._active;
+        return this.condition(this, runtime) !== false;
+    }
+    isTargetActive(runtime) {
+        if (!this.conditional)
+            return this._active;
+        return this.condition(this, runtime) === true;
+    }
+    getActiveState(runtime) {
+        if (!this.conditional)
+            return this._active;
+        return this.condition(this, runtime);
+    }
+    setActive(value) {
+        this.conditional = false;
+        this._active = value;
+    }
+}
+exports.ModuleGraphConnection = ModuleGraphConnection;

package/dist/module/ModuleProfile.d.ts

@@ -0,0 +1,40 @@
+declare class ModuleProfile {
+    startTime: number;
+    factoryStartTime: number;
+    factoryEndTime: number;
+    factory: number;
+    factoryParallelismFactor: number;
+    restoringStartTime: number;
+    restoringEndTime: number;
+    restoring: number;
+    restoringParallelismFactor: number;
+    integrationStartTime: number;
+    integrationEndTime: number;
+    integration: number;
+    integrationParallelismFactor: number;
+    buildingStartTime: number;
+    buildingEndTime: number;
+    building: number;
+    buildingParallelismFactor: number;
+    storingStartTime: number;
+    storingEndTime: number;
+    storing: number;
+    storingParallelismFactor: number;
+    additionalFactoryTimes: undefined;
+    additionalFactories: number;
+    additionalFactoriesParallelismFactor: number;
+    additionalIntegration: number;
+    constructor();
+    markFactoryStart(): void;
+    markFactoryEnd(): void;
+    markRestoringStart(): void;
+    markRestoringEnd(): void;
+    markIntegrationStart(): void;
+    markIntegrationEnd(): void;
+    markBuildingStart(): void;
+    markBuildingEnd(): void;
+    markStoringStart(): void;
+    markStoringEnd(): void;
+    mergeInto(realProfile: any): void;
+}
+export default ModuleProfile;