xhs-mp-pack 1.1.0-beta.0

package/dist/dependencies/loader/LoaderPlugin.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const NormalModule_1 = __importDefault(require("@/module/NormalModule"));
+const LazySet_1 = __importDefault(require("@/base/LazySet"));
+const LoaderDependency_1 = __importDefault(require("./LoaderDependency"));
+const LoaderImportDependency_1 = __importDefault(require("./LoaderImportDependency"));
+class LoaderPlugin {
+    constructor(options = {}) { }
+    apply(compiler) {
+        compiler.hooks.compilation.tap('LoaderPlugin', (compilation, { normalModuleFactory }) => {
+            compilation.dependencyFactories.set(LoaderDependency_1.default, normalModuleFactory);
+            compilation.dependencyFactories.set(LoaderImportDependency_1.default, normalModuleFactory);
+        });
+        compiler.hooks.compilation.tap('LoaderPlugin', compilation => {
+            const moduleGraph = compilation.moduleGraph;
+            NormalModule_1.default.getCompilationHooks(compilation).loader.tap('LoaderPlugin', loaderContext => {
+                loaderContext.loadModule = (request, callback) => {
+                    const dep = new LoaderDependency_1.default(request);
+                    dep.loc = {
+                        name: request,
+                    };
+                    const factory = compilation.dependencyFactories.get(dep.constructor);
+                    if (factory === undefined) {
+                        return callback(new Error(`No module factory available for dependency type: ${dep.constructor.name}`));
+                    }
+                    compilation.buildQueue.increaseParallelism();
+                    compilation.handleModuleCreation({
+                        factory,
+                        dependencies: [dep],
+                        originModule: loaderContext._module,
+                        context: loaderContext.context,
+                        recursive: false,
+                    }, err => {
+                        compilation.buildQueue.decreaseParallelism();
+                        if (err) {
+                            return callback(err);
+                        }
+                        const referencedModule = moduleGraph.getModule(dep);
+                        if (!referencedModule) {
+                            return callback(new Error('Cannot load the module'));
+                        }
+                        if (referencedModule.getNumberOfErrors() > 0) {
+                            return callback(new Error('The loaded module contains errors'));
+                        }
+                        const moduleSource = referencedModule.originalSource();
+                        if (!moduleSource) {
+                            return callback(new Error('The module created for a LoaderDependency must have an original source'));
+                        }
+                        let source;
+                        let map;
+                        if (moduleSource.sourceAndMap) {
+                            const sourceAndMap = moduleSource.sourceAndMap();
+                            map = sourceAndMap.map;
+                            source = sourceAndMap.source;
+                        }
+                        else {
+                            map = moduleSource.map();
+                            source = moduleSource.source();
+                        }
+                        const fileDependencies = new LazySet_1.default();
+                        const contextDependencies = new LazySet_1.default();
+                        const missingDependencies = new LazySet_1.default();
+                        const buildDependencies = new LazySet_1.default();
+                        referencedModule.addCacheDependencies(fileDependencies, contextDependencies, missingDependencies, buildDependencies);
+                        for (const d of fileDependencies) {
+                            loaderContext.addDependency(d);
+                        }
+                        for (const d of contextDependencies) {
+                            loaderContext.addContextDependency(d);
+                        }
+                        for (const d of missingDependencies) {
+                            loaderContext.addMissingDependency(d);
+                        }
+                        for (const d of buildDependencies) {
+                            loaderContext.addBuildDependency(d);
+                        }
+                        return callback(null, source, map, referencedModule);
+                    });
+                };
+                const importModule = (request, options, callback) => {
+                    const dep = new LoaderImportDependency_1.default(request);
+                    dep.loc = {
+                        name: request,
+                    };
+                    const factory = compilation.dependencyFactories.get(dep.constructor);
+                    if (factory === undefined) {
+                        return callback(new Error(`No module factory available for dependency type: ${dep.constructor.name}`));
+                    }
+                    compilation.buildQueue.increaseParallelism();
+                    compilation.handleModuleCreation({
+                        factory,
+                        dependencies: [dep],
+                        originModule: loaderContext._module,
+                        contextInfo: {
+                            issuerLayer: options.layer,
+                        },
+                        context: loaderContext.context,
+                        connectOrigin: false,
+                    }, err => {
+                        compilation.buildQueue.decreaseParallelism();
+                        if (err) {
+                            return callback(err);
+                        }
+                        const referencedModule = moduleGraph.getModule(dep);
+                        if (!referencedModule) {
+                            return callback(new Error('Cannot load the module'));
+                        }
+                        compilation.executeModule(referencedModule, {
+                            entryOptions: {
+                                baseUri: options.baseUri,
+                                publicPath: options.publicPath,
+                            },
+                        }, (err, result) => {
+                            if (err)
+                                return callback(err);
+                            for (const d of result.fileDependencies) {
+                                loaderContext.addDependency(d);
+                            }
+                            for (const d of result.contextDependencies) {
+                                loaderContext.addContextDependency(d);
+                            }
+                            for (const d of result.missingDependencies) {
+                                loaderContext.addMissingDependency(d);
+                            }
+                            for (const d of result.buildDependencies) {
+                                loaderContext.addBuildDependency(d);
+                            }
+                            if (result.cacheable === false)
+                                loaderContext.cacheable(false);
+                            for (const [name, { source, info }] of result.assets) {
+                                const { buildInfo } = loaderContext._module;
+                                if (!buildInfo.assets) {
+                                    buildInfo.assets = Object.create(null);
+                                    buildInfo.assetsInfo = new Map();
+                                }
+                                buildInfo.assets[name] = source;
+                                buildInfo.assetsInfo.set(name, info);
+                            }
+                            callback(null, result.exports);
+                        });
+                    });
+                };
+                loaderContext.importModule = (request, options, callback) => {
+                    if (!callback) {
+                        return new Promise((resolve, reject) => {
+                            // @ts-ignore
+                            importModule(request, options || {}, (err, result) => {
+                                if (err)
+                                    reject(err);
+                                else
+                                    resolve(result);
+                            });
+                        });
+                    }
+                    return importModule(request, options || {}, callback);
+                };
+            });
+        });
+    }
+}
+exports.default = LoaderPlugin;

package/dist/dependencies/processExportInfo.d.ts

@@ -0,0 +1,2 @@
+declare const processExportInfo: (runtime: any, referencedExports: any, prefix: any, exportInfo: any, defaultPointsToSelf?: boolean, alreadyVisited?: Set<unknown>) => void;
+export default processExportInfo;

package/dist/dependencies/processExportInfo.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ExportsInfo_1 = require("@/module/ExportsInfo");
+const processExportInfo = (runtime, referencedExports, prefix, exportInfo, defaultPointsToSelf = false, alreadyVisited = new Set()) => {
+    if (!exportInfo) {
+        referencedExports.push(prefix);
+        return;
+    }
+    const used = exportInfo.getUsed(runtime);
+    if (used === ExportsInfo_1.UsageState.Unused)
+        return;
+    if (alreadyVisited.has(exportInfo)) {
+        referencedExports.push(prefix);
+        return;
+    }
+    alreadyVisited.add(exportInfo);
+    if (used !== ExportsInfo_1.UsageState.OnlyPropertiesUsed ||
+        !exportInfo.exportsInfo ||
+        exportInfo.exportsInfo.otherExportsInfo.getUsed(runtime) !== ExportsInfo_1.UsageState.Unused) {
+        alreadyVisited.delete(exportInfo);
+        referencedExports.push(prefix);
+        return;
+    }
+    const exportsInfo = exportInfo.exportsInfo;
+    for (const exportInfo of exportsInfo.orderedExports) {
+        processExportInfo(runtime, referencedExports, defaultPointsToSelf && exportInfo.name === 'default'
+            ? prefix
+            : prefix.concat(exportInfo.name), exportInfo, false, alreadyVisited);
+    }
+    alreadyVisited.delete(exportInfo);
+};
+exports.default = processExportInfo;

package/dist/ids/DeterministicChunkIdsPlugin.d.ts

@@ -0,0 +1,10 @@
+interface DeterministicChunkIdsPluginOptions {
+    context?: string;
+    maxLength?: number;
+}
+declare class DeterministicChunkIdsPlugin {
+    options: any;
+    constructor(options?: DeterministicChunkIdsPluginOptions);
+    apply(compiler: any): void;
+}
+export default DeterministicChunkIdsPlugin;

package/dist/ids/DeterministicChunkIdsPlugin.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const comparators_1 = require("@/base/comparators");
+const IdHelpers_1 = require("./IdHelpers");
+class DeterministicChunkIdsPlugin {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap('DeterministicChunkIdsPlugin', compilation => {
+            compilation.hooks.chunkIds.tap('DeterministicChunkIdsPlugin', chunks => {
+                const chunkGraph = compilation.chunkGraph;
+                const context = this.options.context ? this.options.context : compiler.context;
+                const maxLength = this.options.maxLength || 3;
+                const compareNatural = (0, comparators_1.compareChunksNatural)(chunkGraph);
+                const usedIds = (0, IdHelpers_1.getUsedChunkIds)(compilation);
+                (0, IdHelpers_1.assignDeterministicIds)(Array.from(chunks).filter((chunk) => chunk.id === null), chunk => (0, IdHelpers_1.getFullChunkName)(chunk, chunkGraph, context, compiler.root), compareNatural, (chunk, id) => {
+                    const size = usedIds.size;
+                    usedIds.add(`${id}`);
+                    if (size === usedIds.size)
+                        return false;
+                    chunk.id = id;
+                    chunk.ids = [id];
+                    return true;
+                }, [Math.pow(10, maxLength)], 10, usedIds.size);
+            });
+        });
+    }
+}
+exports.default = DeterministicChunkIdsPlugin;

package/dist/ids/DeterministicModuleIdsPlugin.d.ts

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

package/dist/ids/DeterministicModuleIdsPlugin.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const comparators_1 = require("@/base/comparators");
+const IdHelpers_1 = require("./IdHelpers");
+class DeterministicModuleIdsPlugin {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap('DeterministicModuleIdsPlugin', compilation => {
+            compilation.hooks.moduleIds.tap('DeterministicModuleIdsPlugin', () => {
+                const chunkGraph = compilation.chunkGraph;
+                const context = this.options.context ? this.options.context : compiler.context;
+                const maxLength = this.options.maxLength || 3;
+                const failOnConflict = this.options.failOnConflict || false;
+                const fixedLength = this.options.fixedLength || false;
+                const salt = this.options.salt || 0;
+                let conflicts = 0;
+                const [usedIds, modules] = (0, IdHelpers_1.getUsedModuleIdsAndModules)(compilation, this.options.test);
+                (0, IdHelpers_1.assignDeterministicIds)(modules, module => (0, IdHelpers_1.getFullModuleName)(module, context, compiler.root), failOnConflict
+                    ? () => 0
+                    : (0, comparators_1.compareModulesByPreOrderIndexOrIdentifier)(compilation.moduleGraph), (module, id) => {
+                    const size = usedIds.size;
+                    usedIds.add(`${id}`);
+                    if (size === usedIds.size) {
+                        conflicts++;
+                        return false;
+                    }
+                    chunkGraph.setModuleId(module, id);
+                    return true;
+                }, [Math.pow(10, maxLength)], fixedLength ? 0 : 10, usedIds.size, salt);
+                if (failOnConflict && conflicts)
+                    throw new Error(`Assigning deterministic module ids has lead to ${conflicts} conflict${conflicts > 1 ? 's' : ''}.\nIncrease the 'maxLength' to increase the id space and make conflicts less likely (recommended when there are many conflicts or application is expected to grow), or add an 'salt' number to try another hash starting value in the same id space (recommended when there is only a single conflict).`);
+            });
+        });
+    }
+}
+exports.default = DeterministicModuleIdsPlugin;

package/dist/ids/IdHelpers.d.ts

@@ -0,0 +1,16 @@
+import Hash from '@/base/Hash';
+import Module from '../module/Module';
+declare const requestToId: (request: any) => any;
+declare const getShortModuleName: (module: any, context: string, associatedObjectForCache?: Object) => any;
+declare const getLongModuleName: (shortName: string, module: any, context: string, hashFunction: string | Hash, associatedObjectForCache?: Object) => string;
+declare const getFullModuleName: (module: any, context: any, associatedObjectForCache?: any) => any;
+declare const getShortChunkName: (chunk: any, chunkGraph: any, context: string, delimiter: string, hashFunction: any, associatedObjectForCache?: any) => string;
+declare const getLongChunkName: (chunk: any, chunkGraph: any, context: any, delimiter: any, hashFunction: any, associatedObjectForCache?: any) => string;
+declare const getFullChunkName: (chunk: any, chunkGraph: any, context: any, associatedObjectForCache?: any) => any;
+declare const getUsedModuleIdsAndModules: (compilation: any, filter?: any) => (any[] | Set<string>)[];
+declare const getUsedChunkIds: (compilation: any) => Set<unknown>;
+declare const assignNames: (items: any, getShortName: any, getLongName: any, comparator: any, usedIds: any, assignName: any) => any[];
+declare const assignDeterministicIds: (items: any, getName: any, comparator: any, assignId: any, ranges?: number[], expandFactor?: number, extraSpace?: number, salt?: number) => void;
+declare const assignAscendingModuleIds: (usedIds: Set<string>, modules: Iterable<Module>, compilation: any) => void;
+declare const assignAscendingChunkIds: (chunks: any, compilation: any) => void;
+export { requestToId, getShortModuleName, getLongModuleName, getFullModuleName, getShortChunkName, getLongChunkName, getFullChunkName, getUsedModuleIdsAndModules, getUsedChunkIds, assignNames, assignDeterministicIds, assignAscendingModuleIds, assignAscendingChunkIds, };

package/dist/ids/IdHelpers.js

@@ -0,0 +1,259 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignAscendingChunkIds = exports.assignAscendingModuleIds = exports.assignDeterministicIds = exports.assignNames = exports.getUsedChunkIds = exports.getUsedModuleIdsAndModules = exports.getFullChunkName = exports.getLongChunkName = exports.getShortChunkName = exports.getFullModuleName = exports.getLongModuleName = exports.getShortModuleName = exports.requestToId = void 0;
+const createHash_1 = __importDefault(require("@/base/createHash"));
+const identifier_1 = require("@/base/identifier");
+const numberHash_1 = __importDefault(require("@/base/numberHash"));
+const getHash = (str, len, hashFunction) => {
+    const hash = (0, createHash_1.default)(hashFunction);
+    hash.update(str);
+    const digest = hash.digest('hex');
+    return digest.slice(0, len);
+};
+const avoidNumber = str => {
+    // max length of a number is 21 chars, bigger numbers a written as "...e+xx"
+    if (str.length > 21)
+        return str;
+    const firstChar = str.charCodeAt(0);
+    // skip everything that doesn't look like a number
+    // charCodes: "-": 45, "1": 49, "9": 57
+    if (firstChar < 49) {
+        if (firstChar !== 45)
+            return str;
+    }
+    else if (firstChar > 57) {
+        return str;
+    }
+    if (str === `${+str}`) {
+        return `_${str}`;
+    }
+    return str;
+};
+const requestToId = request => request.replace(/^(\.\.?\/)+/, '').replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, '_');
+exports.requestToId = requestToId;
+const shortenLongString = (string, delimiter, hashFunction) => {
+    if (string.length < 100)
+        return string;
+    return string.slice(0, 100 - 6 - delimiter.length) + delimiter + getHash(string, 6, hashFunction);
+};
+const getShortModuleName = (module, context, associatedObjectForCache) => {
+    const libIdent = module.libIdent({ context, associatedObjectForCache });
+    if (libIdent)
+        return avoidNumber(libIdent);
+    const nameForCondition = module.nameForCondition();
+    if (nameForCondition)
+        return avoidNumber((0, identifier_1.makePathsRelative)(context, nameForCondition, associatedObjectForCache));
+    return '';
+};
+exports.getShortModuleName = getShortModuleName;
+const getLongModuleName = (shortName, module, context, hashFunction, associatedObjectForCache) => {
+    const fullName = getFullModuleName(module, context, associatedObjectForCache);
+    return `${shortName}?${getHash(fullName, 4, hashFunction)}`;
+};
+exports.getLongModuleName = getLongModuleName;
+const getFullModuleName = (module, context, associatedObjectForCache) => (0, identifier_1.makePathsRelative)(context, module.identifier(), associatedObjectForCache);
+exports.getFullModuleName = getFullModuleName;
+const getShortChunkName = (chunk, chunkGraph, context, delimiter, hashFunction, associatedObjectForCache) => {
+    const modules = chunkGraph.getChunkRootModules(chunk);
+    const shortModuleNames = modules.map(m => requestToId(getShortModuleName(m, context, associatedObjectForCache)));
+    chunk.idNameHints.sort();
+    const chunkName = Array.from(chunk.idNameHints)
+        .concat(shortModuleNames)
+        .filter(Boolean)
+        .join(delimiter);
+    return shortenLongString(chunkName, delimiter, hashFunction);
+};
+exports.getShortChunkName = getShortChunkName;
+const getLongChunkName = (chunk, chunkGraph, context, delimiter, hashFunction, associatedObjectForCache) => {
+    const modules = chunkGraph.getChunkRootModules(chunk);
+    const shortModuleNames = modules.map(m => requestToId(getShortModuleName(m, context, associatedObjectForCache)));
+    const longModuleNames = modules.map(m => requestToId(getLongModuleName('', m, context, hashFunction, associatedObjectForCache)));
+    chunk.idNameHints.sort();
+    const chunkName = Array.from(chunk.idNameHints)
+        .concat(shortModuleNames, longModuleNames)
+        .filter(Boolean)
+        .join(delimiter);
+    return shortenLongString(chunkName, delimiter, hashFunction);
+};
+exports.getLongChunkName = getLongChunkName;
+const getFullChunkName = (chunk, chunkGraph, context, associatedObjectForCache) => {
+    if (chunk.name)
+        return chunk.name;
+    const modules = chunkGraph.getChunkRootModules(chunk);
+    const fullModuleNames = modules.map(m => (0, identifier_1.makePathsRelative)(context, m.identifier(), associatedObjectForCache));
+    return fullModuleNames.join();
+};
+exports.getFullChunkName = getFullChunkName;
+const addToMapOfItems = (map, key, value) => {
+    let array = map.get(key);
+    if (array === undefined) {
+        array = [];
+        map.set(key, array);
+    }
+    array.push(value);
+};
+const getUsedModuleIdsAndModules = (compilation, filter) => {
+    const chunkGraph = compilation.chunkGraph;
+    const modules = [];
+    const usedIds = new Set();
+    if (compilation.usedModuleIds) {
+        for (const id of compilation.usedModuleIds) {
+            usedIds.add(`${id}`);
+        }
+    }
+    for (const module of compilation.modules) {
+        if (!module.needId)
+            continue;
+        const moduleId = chunkGraph.getModuleId(module);
+        if (moduleId !== null) {
+            usedIds.add(`${moduleId}`);
+        }
+        else if ((!filter || filter(module)) && chunkGraph.getNumberOfModuleChunks(module) !== 0) {
+            modules.push(module);
+        }
+    }
+    return [usedIds, modules];
+};
+exports.getUsedModuleIdsAndModules = getUsedModuleIdsAndModules;
+const getUsedChunkIds = compilation => {
+    const usedIds = new Set();
+    if (compilation.usedChunkIds) {
+        for (const id of compilation.usedChunkIds) {
+            usedIds.add(`${id}`);
+        }
+    }
+    for (const chunk of compilation.chunks) {
+        const chunkId = chunk.id;
+        if (chunkId !== null) {
+            usedIds.add(`${chunkId}`);
+        }
+    }
+    return usedIds;
+};
+exports.getUsedChunkIds = getUsedChunkIds;
+const assignNames = (items, getShortName, getLongName, comparator, usedIds, assignName) => {
+    const nameToItems = new Map();
+    for (const item of items) {
+        const name = getShortName(item);
+        addToMapOfItems(nameToItems, name, item);
+    }
+    const nameToItems2 = new Map();
+    for (const [name, items] of nameToItems) {
+        if (items.length > 1 || !name) {
+            for (const item of items) {
+                const longName = getLongName(item, name);
+                addToMapOfItems(nameToItems2, longName, item);
+            }
+        }
+        else {
+            addToMapOfItems(nameToItems2, name, items[0]);
+        }
+    }
+    const unnamedItems = [];
+    for (const [name, items] of nameToItems2) {
+        if (!name) {
+            for (const item of items) {
+                unnamedItems.push(item);
+            }
+        }
+        else if (items.length === 1 && !usedIds.has(name)) {
+            assignName(items[0], name);
+            usedIds.add(name);
+        }
+        else {
+            items.sort(comparator);
+            let i = 0;
+            for (const item of items) {
+                while (nameToItems2.has(name + i) && usedIds.has(name + i))
+                    i++;
+                assignName(item, name + i);
+                usedIds.add(name + i);
+                i++;
+            }
+        }
+    }
+    unnamedItems.sort(comparator);
+    return unnamedItems;
+};
+exports.assignNames = assignNames;
+const assignDeterministicIds = (items, getName, comparator, assignId, ranges = [10], expandFactor = 10, extraSpace = 0, salt = 0) => {
+    items.sort(comparator);
+    // max 5% fill rate
+    const optimalRange = Math.min(items.length * 20 + extraSpace, Number.MAX_SAFE_INTEGER);
+    let i = 0;
+    let range = ranges[i];
+    while (range < optimalRange) {
+        i++;
+        if (i < ranges.length) {
+            range = Math.min(ranges[i], Number.MAX_SAFE_INTEGER);
+        }
+        else if (expandFactor) {
+            range = Math.min(range * expandFactor, Number.MAX_SAFE_INTEGER);
+        }
+        else {
+            break;
+        }
+    }
+    for (const item of items) {
+        const ident = getName(item);
+        let id;
+        let i = salt;
+        do {
+            id = (0, numberHash_1.default)(ident + i++, range);
+        } while (!assignId(item, id));
+    }
+};
+exports.assignDeterministicIds = assignDeterministicIds;
+const assignAscendingModuleIds = (usedIds, modules, compilation) => {
+    const chunkGraph = compilation.chunkGraph;
+    let nextId = 0;
+    let assignId;
+    if (usedIds.size > 0) {
+        assignId = module => {
+            if (chunkGraph.getModuleId(module) === null) {
+                while (usedIds.has(`${nextId}`))
+                    nextId++;
+                chunkGraph.setModuleId(module, nextId++);
+            }
+        };
+    }
+    else {
+        assignId = module => {
+            if (chunkGraph.getModuleId(module) === null) {
+                chunkGraph.setModuleId(module, nextId++);
+            }
+        };
+    }
+    for (const module of modules) {
+        assignId(module);
+    }
+};
+exports.assignAscendingModuleIds = assignAscendingModuleIds;
+const assignAscendingChunkIds = (chunks, compilation) => {
+    const usedIds = getUsedChunkIds(compilation);
+    let nextId = 0;
+    if (usedIds.size > 0) {
+        for (const chunk of chunks) {
+            if (chunk.id === null) {
+                while (usedIds.has(`${nextId}`))
+                    nextId++;
+                chunk.id = nextId;
+                chunk.ids = [nextId];
+                nextId++;
+            }
+        }
+    }
+    else {
+        for (const chunk of chunks) {
+            if (chunk.id === null) {
+                chunk.id = nextId;
+                chunk.ids = [nextId];
+                nextId++;
+            }
+        }
+    }
+};
+exports.assignAscendingChunkIds = assignAscendingChunkIds;

package/dist/ids/NamedChunkIdsPlugin.d.ts

@@ -0,0 +1,11 @@
+interface NamedChunkIdsPluginOptions {
+    context: string;
+    delimiter: string;
+}
+declare class NamedChunkIdsPlugin {
+    delimiter: any;
+    context: any;
+    constructor(options?: NamedChunkIdsPluginOptions);
+    apply(compiler: any): void;
+}
+export default NamedChunkIdsPlugin;

package/dist/ids/NamedChunkIdsPlugin.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const comparators_1 = require("@/base/comparators");
+const IdHelpers_1 = require("./IdHelpers");
+class NamedChunkIdsPlugin {
+    constructor(options) {
+        this.delimiter = (options === null || options === void 0 ? void 0 : options.delimiter) || '-';
+        this.context = options === null || options === void 0 ? void 0 : options.context;
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap('NamedChunkIdsPlugin', compilation => {
+            const hashFunction = compilation.outputOptions.hashFunction;
+            compilation.hooks.chunkIds.tap('NamedChunkIdsPlugin', chunks => {
+                const chunkGraph = compilation.chunkGraph;
+                const context = this.context ? this.context : compiler.context;
+                const delimiter = this.delimiter;
+                const unnamedChunks = (0, IdHelpers_1.assignNames)(Array.from(chunks).filter((chunk) => {
+                    if (chunk.name) {
+                        chunk.id = chunk.name;
+                        chunk.ids = [chunk.name];
+                    }
+                    return chunk.id === null;
+                }), chunk => (0, IdHelpers_1.getShortChunkName)(chunk, chunkGraph, context, delimiter, hashFunction, compiler.root), chunk => (0, IdHelpers_1.getLongChunkName)(chunk, chunkGraph, context, delimiter, hashFunction, compiler.root), (0, comparators_1.compareChunksNatural)(chunkGraph), (0, IdHelpers_1.getUsedChunkIds)(compilation), (chunk, name) => {
+                    chunk.id = name;
+                    chunk.ids = [name];
+                });
+                if (unnamedChunks.length > 0) {
+                    (0, IdHelpers_1.assignAscendingChunkIds)(unnamedChunks, compilation);
+                }
+            });
+        });
+    }
+}
+exports.default = NamedChunkIdsPlugin;

package/dist/ids/NamedModuleIdsPlugin.d.ts

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

package/dist/ids/NamedModuleIdsPlugin.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const comparators_1 = require("@/base/comparators");
+const IdHelpers_1 = require("./IdHelpers");
+class NamedModuleIdsPlugin {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    apply(compiler) {
+        const { root } = compiler;
+        compiler.hooks.compilation.tap('NamedModuleIdsPlugin', compilation => {
+            const hashFunction = compilation.outputOptions.hashFunction;
+            compilation.hooks.moduleIds.tap('NamedModuleIdsPlugin', () => {
+                const chunkGraph = compilation.chunkGraph;
+                const context = this.options.context ? this.options.context : compiler.context;
+                const [usedIds, modules] = (0, IdHelpers_1.getUsedModuleIdsAndModules)(compilation);
+                const unnamedModules = (0, IdHelpers_1.assignNames)(modules, m => (0, IdHelpers_1.getShortModuleName)(m, context, root), (m, shortName) => (0, IdHelpers_1.getLongModuleName)(shortName, m, context, hashFunction, root), comparators_1.compareModulesByIdentifier, usedIds, (m, name) => chunkGraph.setModuleId(m, name));
+                if (unnamedModules.length > 0) {
+                    (0, IdHelpers_1.assignAscendingModuleIds)(usedIds, unnamedModules, compilation);
+                }
+            });
+        });
+    }
+}
+exports.default = NamedModuleIdsPlugin;

package/dist/ids/NaturalChunkIdsPlugin.d.ts

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