xhs-mp-pack 1.1.0-beta.0

package/dist/plugins/miniCssExtractPlugin/MiniCssUtils.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+declare function trueFn(): boolean;
+declare function findModuleById(compilation: any, id: string | number): any;
+declare function evalModuleCode(loaderContext: any, code: string | Buffer, filename: string): any;
+declare function compareModulesByIdentifier(a: any, b: any): 0 | 1 | -1;
+declare const MODULE_TYPE = "css/mini-extract";
+declare const AUTO_PUBLIC_PATH = "__mini_css_extract_plugin_public_path_auto__";
+declare const ABSOLUTE_PUBLIC_PATH = "webpack:///mini-css-extract-plugin/";
+declare const BASE_URI = "webpack://";
+declare const SINGLE_DOT_PATH_SEGMENT = "__mini_css_extract_plugin_single_dot_path_segment__";
+declare function stringifyRequest(loaderContext: any, request: any): string;
+declare function getUndoPath(filename: any, outputPath: any, enforceRelative: boolean): string;
+declare function stringifyLocal(value: any): any;
+export { trueFn, findModuleById, evalModuleCode, compareModulesByIdentifier, MODULE_TYPE, AUTO_PUBLIC_PATH, ABSOLUTE_PUBLIC_PATH, BASE_URI, SINGLE_DOT_PATH_SEGMENT, stringifyRequest, stringifyLocal, getUndoPath, };

package/dist/plugins/miniCssExtractPlugin/MiniCssUtils.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUndoPath = exports.stringifyLocal = exports.stringifyRequest = exports.SINGLE_DOT_PATH_SEGMENT = exports.BASE_URI = exports.ABSOLUTE_PUBLIC_PATH = exports.AUTO_PUBLIC_PATH = exports.MODULE_TYPE = exports.compareModulesByIdentifier = exports.evalModuleCode = exports.findModuleById = exports.trueFn = void 0;
+const module_1 = __importDefault(require("module"));
+const path_1 = __importDefault(require("path"));
+function trueFn() {
+    return true;
+}
+exports.trueFn = trueFn;
+function findModuleById(compilation, id) {
+    const { modules, chunkGraph } = compilation;
+    for (const module of modules) {
+        const moduleId = typeof chunkGraph !== 'undefined' ? chunkGraph.getModuleId(module) : module.id;
+        if (moduleId === id) {
+            return module;
+        }
+    }
+    return null;
+}
+exports.findModuleById = findModuleById;
+function evalModuleCode(loaderContext, code, filename) {
+    const module = new module_1.default(filename, loaderContext);
+    // @ts-ignore
+    module.paths = module_1.default._nodeModulePaths(loaderContext.context);
+    module.filename = filename;
+    // @ts-ignore
+    module._compile(code, filename); // eslint-disable-line no-underscore-dangle
+    return module.exports;
+}
+exports.evalModuleCode = evalModuleCode;
+function compareIds(a, b) {
+    if (typeof a !== typeof b) {
+        return typeof a < typeof b ? -1 : 1;
+    }
+    if (a < b) {
+        return -1;
+    }
+    if (a > b) {
+        return 1;
+    }
+    return 0;
+}
+function compareModulesByIdentifier(a, b) {
+    return compareIds(a.identifier(), b.identifier());
+}
+exports.compareModulesByIdentifier = compareModulesByIdentifier;
+const MODULE_TYPE = 'css/mini-extract';
+exports.MODULE_TYPE = MODULE_TYPE;
+const AUTO_PUBLIC_PATH = '__mini_css_extract_plugin_public_path_auto__';
+exports.AUTO_PUBLIC_PATH = AUTO_PUBLIC_PATH;
+const ABSOLUTE_PUBLIC_PATH = 'webpack:///mini-css-extract-plugin/';
+exports.ABSOLUTE_PUBLIC_PATH = ABSOLUTE_PUBLIC_PATH;
+const BASE_URI = 'webpack://';
+exports.BASE_URI = BASE_URI;
+const SINGLE_DOT_PATH_SEGMENT = '__mini_css_extract_plugin_single_dot_path_segment__';
+exports.SINGLE_DOT_PATH_SEGMENT = SINGLE_DOT_PATH_SEGMENT;
+function isAbsolutePath(str) {
+    return path_1.default.posix.isAbsolute(str) || path_1.default.win32.isAbsolute(str);
+}
+const RELATIVE_PATH_REGEXP = /^\.\.?[/\\]/;
+function isRelativePath(str) {
+    return RELATIVE_PATH_REGEXP.test(str);
+}
+function stringifyRequest(loaderContext, request) {
+    if (typeof loaderContext.utils !== 'undefined' &&
+        typeof loaderContext.utils.contextify === 'function') {
+        return JSON.stringify(loaderContext.utils.contextify(loaderContext.context || loaderContext.rootContext, request));
+    }
+    const splitted = request.split('!');
+    const { context } = loaderContext;
+    return JSON.stringify(splitted
+        .map(part => {
+        // First, separate singlePath from query, because the query might contain paths again
+        const splittedPart = part.match(/^(.*?)(\?.*)/);
+        const query = splittedPart ? splittedPart[2] : '';
+        let singlePath = splittedPart ? splittedPart[1] : part;
+        if (isAbsolutePath(singlePath) && context) {
+            singlePath = path_1.default.relative(context, singlePath);
+            if (isAbsolutePath(singlePath)) {
+                // If singlePath still matches an absolute path, singlePath was on a different drive than context.
+                // In this case, we leave the path platform-specific without replacing any separators.
+                // @see https://github.com/webpack/loader-utils/pull/14
+                return singlePath + query;
+            }
+            if (isRelativePath(singlePath) === false) {
+                // Ensure that the relative path starts at least with ./ otherwise it would be a request into the modules directory (like node_modules).
+                singlePath = `./${singlePath}`;
+            }
+        }
+        return singlePath.replace(/\\/g, '/') + query;
+    })
+        .join('!'));
+}
+exports.stringifyRequest = stringifyRequest;
+function getUndoPath(filename, outputPath, enforceRelative) {
+    let depth = -1;
+    let append = '';
+    // eslint-disable-next-line no-param-reassign
+    outputPath = outputPath.replace(/[\\/]$/, '');
+    for (const part of filename.split(/[/\\]+/)) {
+        if (part === '..') {
+            if (depth > -1) {
+                // eslint-disable-next-line no-plusplus
+                depth--;
+            }
+            else {
+                const i = outputPath.lastIndexOf('/');
+                const j = outputPath.lastIndexOf('\\');
+                const pos = i < 0 ? j : j < 0 ? i : Math.max(i, j);
+                if (pos < 0) {
+                    return `${outputPath}/`;
+                }
+                append = `${outputPath.slice(pos + 1)}/${append}`;
+                // eslint-disable-next-line no-param-reassign
+                outputPath = outputPath.slice(0, pos);
+            }
+        }
+        else if (part !== '.') {
+            // eslint-disable-next-line no-plusplus
+            depth++;
+        }
+    }
+    return depth > 0 ? `${'../'.repeat(depth)}${append}` : enforceRelative ? `./${append}` : append;
+}
+exports.getUndoPath = getUndoPath;
+function stringifyLocal(value) {
+    return typeof value === 'function' ? value.toString() : JSON.stringify(value);
+}
+exports.stringifyLocal = stringifyLocal;

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

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

package/dist/plugins/optimize/AggressiveMergingPlugin.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const OptimizationStages_1 = require("@/plugins/optimize/OptimizationStages");
+class AggressiveMergingPlugin {
+    constructor(options) {
+        if ((options !== undefined && typeof options !== 'object') || Array.isArray(options)) {
+            throw new Error('Argument should be an options object. To use defaults, pass in nothing.\nFor more info on options, see https://webpack.js.org/plugins/');
+        }
+        this.options = options || {};
+    }
+    apply(compiler) {
+        const options = this.options;
+        const minSizeReduce = options.minSizeReduce || 1.5;
+        compiler.hooks.thisCompilation.tap('AggressiveMergingPlugin', compilation => {
+            compilation.hooks.optimizeChunks.tap({
+                name: 'AggressiveMergingPlugin',
+                stage: OptimizationStages_1.STAGE_ADVANCED,
+            }, chunks => {
+                const chunkGraph = compilation.chunkGraph;
+                const combinations = [];
+                for (const a of chunks) {
+                    if (a.canBeInitial())
+                        continue;
+                    for (const b of chunks) {
+                        if (b.canBeInitial())
+                            continue;
+                        if (b === a)
+                            break;
+                        if (!chunkGraph.canChunksBeIntegrated(a, b)) {
+                            continue;
+                        }
+                        const aSize = chunkGraph.getChunkSize(b, {
+                            chunkOverhead: 0,
+                        });
+                        const bSize = chunkGraph.getChunkSize(a, {
+                            chunkOverhead: 0,
+                        });
+                        const abSize = chunkGraph.getIntegratedChunksSize(b, a, {
+                            chunkOverhead: 0,
+                        });
+                        const improvement = (aSize + bSize) / abSize;
+                        combinations.push({
+                            a,
+                            b,
+                            improvement,
+                        });
+                    }
+                }
+                combinations.sort((a, b) => b.improvement - a.improvement);
+                const pair = combinations[0];
+                if (!pair)
+                    return;
+                if (pair.improvement < minSizeReduce)
+                    return;
+                chunkGraph.integrateChunks(pair.b, pair.a);
+                compilation.chunks.delete(pair.a);
+                return true;
+            });
+        });
+    }
+}
+exports.default = AggressiveMergingPlugin;

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

@@ -0,0 +1,7 @@
+declare class AggressiveSplittingPlugin {
+    options: any;
+    constructor(options?: {});
+    static wasChunkRecorded(chunk: any): boolean;
+    apply(compiler: any): void;
+}
+export default AggressiveSplittingPlugin;

package/dist/plugins/optimize/AggressiveSplittingPlugin.js

@@ -0,0 +1,247 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const OptimizationStages_1 = require("@/plugins/optimize/OptimizationStages");
+const SetHelpers_1 = require("@/base/SetHelpers");
+const comparators_1 = require("@/base/comparators");
+const identifierUtils = __importStar(require("@/base/identifier"));
+const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => module => {
+    chunkGraph.disconnectChunkAndModule(oldChunk, module);
+    chunkGraph.connectChunkAndModule(newChunk, module);
+};
+const isNotAEntryModule = (chunkGraph, chunk) => module => !chunkGraph.isEntryModuleInChunk(module, chunk);
+const recordedChunks = new WeakSet();
+class AggressiveSplittingPlugin {
+    constructor(options = {}) {
+        this.options = options;
+        if (typeof this.options.minSize !== 'number') {
+            this.options.minSize = 30 * 1024;
+        }
+        if (typeof this.options.maxSize !== 'number') {
+            this.options.maxSize = 50 * 1024;
+        }
+        if (typeof this.options.chunkOverhead !== 'number') {
+            this.options.chunkOverhead = 0;
+        }
+        if (typeof this.options.entryChunkMultiplicator !== 'number') {
+            this.options.entryChunkMultiplicator = 1;
+        }
+    }
+    static wasChunkRecorded(chunk) {
+        return recordedChunks.has(chunk);
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap('AggressiveSplittingPlugin', compilation => {
+            let needAdditionalSeal = false;
+            let newSplits;
+            let fromAggressiveSplittingSet;
+            let chunkSplitDataMap;
+            compilation.hooks.optimize.tap('AggressiveSplittingPlugin', () => {
+                newSplits = [];
+                fromAggressiveSplittingSet = new Set();
+                chunkSplitDataMap = new Map();
+            });
+            compilation.hooks.optimizeChunks.tap({
+                name: 'AggressiveSplittingPlugin',
+                stage: OptimizationStages_1.STAGE_ADVANCED,
+            }, chunks => {
+                var _a;
+                const chunkGraph = compilation.chunkGraph;
+                // Precompute stuff
+                const nameToModuleMap = new Map();
+                const moduleToNameMap = new Map();
+                const makePathsRelative = identifierUtils.makePathsRelative.bindContextCache(compiler.context, compiler.root);
+                for (const m of compilation.modules) {
+                    const name = makePathsRelative(m.identifier());
+                    nameToModuleMap.set(name, m);
+                    moduleToNameMap.set(m, name);
+                }
+                // Check used chunk ids
+                const usedIds = new Set();
+                for (const chunk of chunks) {
+                    usedIds.add(chunk.id);
+                }
+                const recordedSplits = ((_a = compilation.records) === null || _a === void 0 ? void 0 : _a.aggressiveSplits) || [];
+                const usedSplits = newSplits ? recordedSplits.concat(newSplits) : recordedSplits;
+                const minSize = this.options.minSize;
+                const maxSize = this.options.maxSize;
+                const applySplit = splitData => {
+                    // Cannot split if id is already taken
+                    if (splitData.id !== undefined && usedIds.has(splitData.id)) {
+                        return false;
+                    }
+                    // Get module objects from names
+                    const selectedModules = splitData.modules.map(name => nameToModuleMap.get(name));
+                    // Does the modules exist at all?
+                    if (!selectedModules.every(Boolean))
+                        return false;
+                    // Check if size matches (faster than waiting for hash)
+                    let size = 0;
+                    for (const m of selectedModules)
+                        size += m.size();
+                    if (size !== splitData.size)
+                        return false;
+                    // get chunks with all modules
+                    const selectedChunks = (0, SetHelpers_1.intersect)(selectedModules.map(m => new Set(chunkGraph.getModuleChunksIterable(m))));
+                    // No relevant chunks found
+                    if (selectedChunks.size === 0)
+                        return false;
+                    // The found chunk is already the split or similar
+                    if (selectedChunks.size === 1 &&
+                        chunkGraph.getNumberOfChunkModules(Array.from(selectedChunks)[0]) ===
+                            selectedModules.length) {
+                        const chunk = Array.from(selectedChunks)[0];
+                        if (fromAggressiveSplittingSet.has(chunk))
+                            return false;
+                        fromAggressiveSplittingSet.add(chunk);
+                        chunkSplitDataMap.set(chunk, splitData);
+                        return true;
+                    }
+                    // split the chunk into two parts
+                    const newChunk = compilation.addChunk();
+                    newChunk.chunkReason = 'aggressive splitted';
+                    for (const chunk of selectedChunks) {
+                        selectedModules.forEach(moveModuleBetween(chunkGraph, chunk, newChunk));
+                        chunk.split(newChunk);
+                        chunk.name = null;
+                    }
+                    fromAggressiveSplittingSet.add(newChunk);
+                    chunkSplitDataMap.set(newChunk, splitData);
+                    if (splitData.id !== null && splitData.id !== undefined) {
+                        newChunk.id = splitData.id;
+                        newChunk.ids = [splitData.id];
+                    }
+                    return true;
+                };
+                // try to restore to recorded splitting
+                let changed = false;
+                for (let j = 0; j < usedSplits.length; j++) {
+                    const splitData = usedSplits[j];
+                    if (applySplit(splitData))
+                        changed = true;
+                }
+                // for any chunk which isn't splitted yet, split it and create a new entry
+                // start with the biggest chunk
+                const cmpFn = (0, comparators_1.compareChunks)(chunkGraph);
+                const sortedChunks = Array.from(chunks).sort((a, b) => {
+                    const diff1 = chunkGraph.getChunkModulesSize(b) - chunkGraph.getChunkModulesSize(a);
+                    if (diff1)
+                        return diff1;
+                    const diff2 = chunkGraph.getNumberOfChunkModules(a) - chunkGraph.getNumberOfChunkModules(b);
+                    if (diff2)
+                        return diff2;
+                    return cmpFn(a, b);
+                });
+                for (const chunk of sortedChunks) {
+                    if (fromAggressiveSplittingSet.has(chunk))
+                        continue;
+                    const size = chunkGraph.getChunkModulesSize(chunk);
+                    if (size > maxSize && chunkGraph.getNumberOfChunkModules(chunk) > 1) {
+                        const modules = chunkGraph
+                            .getOrderedChunkModules(chunk, comparators_1.compareModulesByIdentifier)
+                            .filter(isNotAEntryModule(chunkGraph, chunk));
+                        const selectedModules = [];
+                        let selectedModulesSize = 0;
+                        for (let k = 0; k < modules.length; k++) {
+                            const module = modules[k];
+                            const newSize = selectedModulesSize + module.size();
+                            if (newSize > maxSize && selectedModulesSize >= minSize) {
+                                break;
+                            }
+                            selectedModulesSize = newSize;
+                            selectedModules.push(module);
+                        }
+                        if (selectedModules.length === 0)
+                            continue;
+                        const splitData = {
+                            modules: selectedModules.map(m => moduleToNameMap.get(m)).sort(),
+                            size: selectedModulesSize,
+                        };
+                        if (applySplit(splitData)) {
+                            newSplits = (newSplits || []).concat(splitData);
+                            changed = true;
+                        }
+                    }
+                }
+                if (changed)
+                    return true;
+            });
+            compilation.hooks.recordHash.tap('AggressiveSplittingPlugin', records => {
+                var _a;
+                // 4. save made splittings to records
+                const allSplits = new Set();
+                const invalidSplits = new Set();
+                // Check if some splittings are invalid
+                // We remove invalid splittings and try again
+                for (const chunk of compilation.chunks) {
+                    const splitData = chunkSplitDataMap.get(chunk);
+                    if (splitData !== undefined) {
+                        if (splitData.hash && chunk.hash !== splitData.hash) {
+                            // Split was successful, but hash doesn't equal
+                            // We can throw away the split since it's useless now
+                            invalidSplits.add(splitData);
+                        }
+                    }
+                }
+                if (invalidSplits.size > 0) {
+                    records.aggressiveSplits = records.aggressiveSplits.filter(splitData => !invalidSplits.has(splitData));
+                    needAdditionalSeal = true;
+                }
+                else {
+                    // set hash and id values on all (new) splittings
+                    for (const chunk of compilation.chunks) {
+                        const splitData = chunkSplitDataMap.get(chunk);
+                        if (splitData !== undefined) {
+                            splitData.hash = chunk.hash;
+                            splitData.id = chunk.id;
+                            allSplits.add(splitData);
+                            // set flag for stats
+                            recordedChunks.add(chunk);
+                        }
+                    }
+                    // Also add all unused historical splits (after the used ones)
+                    // They can still be used in some future compilation
+                    const recordedSplits = (_a = compilation.records) === null || _a === void 0 ? void 0 : _a.aggressiveSplits;
+                    if (recordedSplits) {
+                        for (const splitData of recordedSplits) {
+                            if (!invalidSplits.has(splitData))
+                                allSplits.add(splitData);
+                        }
+                    }
+                    // record all splits
+                    records.aggressiveSplits = Array.from(allSplits);
+                    needAdditionalSeal = false;
+                }
+            });
+            compilation.hooks.needAdditionalSeal.tap('AggressiveSplittingPlugin', () => {
+                if (needAdditionalSeal) {
+                    needAdditionalSeal = false;
+                    return true;
+                }
+            });
+        });
+    }
+}
+exports.default = AggressiveSplittingPlugin;

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

@@ -0,0 +1,47 @@
+import { CachedSource } from 'webpack-sources';
+import Module from '@/module/Module';
+import NormalModule from '@/module/NormalModule';
+declare class ConcatenatedModule extends Module {
+    rootModule: NormalModule;
+    _identifier: any;
+    _modules: any;
+    _runtime: any;
+    static create(rootModule: any, modules: any, runtime: any, associatedObjectForCache: any, hashFunction?: string): ConcatenatedModule;
+    constructor({ identifier, rootModule, modules, runtime, }: {
+        identifier: string;
+        rootModule?: Module;
+        modules?: Set<Module>;
+        runtime: any;
+    });
+    updateCacheModule(module: any): void;
+    getSourceTypes(): Set<string>;
+    get modules(): unknown[];
+    identifier(): any;
+    readableIdentifier(requestShortener: any): string;
+    libIdent(options: any): any;
+    nameForCondition(): any;
+    getSideEffectsConnectionState(moduleGraph: any): any;
+    build(options: any, compilation: any, resolver: any, fs: any, callback: any): void;
+    size(type?: string): number;
+    _createConcatenationList(rootModule: any, modulesSet: any, runtime: any, moduleGraph: any): any[];
+    static _createIdentifier(rootModule: any, modules: any, associatedObjectForCache?: Object, hashFunction?: string): string;
+    addCacheDependencies(fileDependencies: any, contextDependencies: any, missingDependencies: any, buildDependencies: any): void;
+    codeGeneration({ dependencyTemplates, runtimeTemplate, moduleGraph, chunkGraph, runtime: generationRuntime, codeGenerationResults, }: {
+        dependencyTemplates: any;
+        runtimeTemplate: any;
+        moduleGraph: any;
+        chunkGraph: any;
+        runtime: any;
+        codeGenerationResults: any;
+    }): {
+        sources: Map<string, CachedSource>;
+        data: Map<any, any>;
+        runtimeRequirements: Set<unknown>;
+    };
+    _analyseModule(modulesMap: any, info: any, dependencyTemplates: any, runtimeTemplate: any, moduleGraph: any, chunkGraph: any, runtime: any, codeGenerationResults: any): void;
+    _getModulesWithInfo(moduleGraph: any, runtime: any): (any[] | Map<any, any>)[];
+    findNewName(oldName: any, usedNamed1: any, usedNamed2: any, extraInfo: any): string;
+    updateHash(hash: any, context: any): void;
+    static deserialize(context: any): ConcatenatedModule;
+}
+export default ConcatenatedModule;