xhs-mp-pack 1.1.0-beta.0

package/dist/plugins/optimize/RuntimeChunkPlugin.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RuntimeChunkPlugin {
+    constructor(options) {
+        this.options = Object.assign({ name: entrypoint => `runtime~${entrypoint.name}` }, options);
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap('RuntimeChunkPlugin', compilation => {
+            compilation.hooks.addEntry.tap('RuntimeChunkPlugin', (_, { name: entryName }) => {
+                if (entryName === undefined)
+                    return;
+                const data = compilation.entries.get(entryName);
+                if (data.options.runtime === undefined && !data.options.dependOn) {
+                    // Determine runtime chunk name
+                    let name = this.options.name;
+                    if (typeof name === 'function') {
+                        name = name({ name: entryName });
+                    }
+                    data.options.runtime = name;
+                }
+            });
+        });
+    }
+}
+exports.default = RuntimeChunkPlugin;

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

@@ -0,0 +1,7 @@
+declare class SideEffectsFlagPlugin {
+    _analyseSource: boolean;
+    constructor(analyseSource?: boolean);
+    apply(compiler: any): void;
+    static moduleHasSideEffects(moduleName: string, flagValue: undefined | boolean | string | string[], cache: Map<string, RegExp>): any;
+}
+export default SideEffectsFlagPlugin;

package/dist/plugins/optimize/SideEffectsFlagPlugin.js

@@ -0,0 +1,211 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const glob_to_regexp_1 = __importDefault(require("glob-to-regexp"));
+const ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const HarmonyExportImportedSpecifierDependency_1 = require("@/dependencies/harmony/HarmonyExportImportedSpecifierDependency");
+const HarmonyImportSpecifierDependency_1 = __importDefault(require("@/dependencies/harmony/HarmonyImportSpecifierDependency"));
+const formatLocation_1 = __importDefault(require("@/base/formatLocation"));
+const OptimizationStages_1 = require("./OptimizationStages");
+const globToRegexpCache = new WeakMap();
+const globToRegexp = (glob, cache) => {
+    const cacheEntry = cache.get(glob);
+    if (cacheEntry !== undefined)
+        return cacheEntry;
+    if (!glob.includes('/')) {
+        glob = `**/${glob}`;
+    }
+    const baseRegexp = (0, glob_to_regexp_1.default)(glob, { globstar: true, extended: true });
+    const regexpSource = baseRegexp.source;
+    const regexp = new RegExp(`^(\\./)?${regexpSource.slice(1)}`);
+    cache.set(glob, regexp);
+    return regexp;
+};
+const PLUGIN_NAME = 'SideEffectsFlagPlugin';
+class SideEffectsFlagPlugin {
+    constructor(analyseSource = true) {
+        this._analyseSource = analyseSource;
+    }
+    apply(compiler) {
+        let cache = globToRegexpCache.get(compiler.root);
+        if (cache === undefined) {
+            cache = new Map();
+            globToRegexpCache.set(compiler.root, cache);
+        }
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation, { normalModuleFactory }) => {
+            const moduleGraph = compilation.moduleGraph;
+            normalModuleFactory.hooks.module.tap(PLUGIN_NAME, (module, data) => {
+                const resolveData = data.resourceResolveData;
+                if ((resolveData === null || resolveData === void 0 ? void 0 : resolveData.descriptionFileData) && resolveData.relativePath) {
+                    const sideEffects = resolveData.descriptionFileData.sideEffects;
+                    if (sideEffects !== undefined) {
+                        if (module.factoryMeta === undefined) {
+                            module.factoryMeta = {};
+                        }
+                        const hasSideEffects = SideEffectsFlagPlugin.moduleHasSideEffects(resolveData.relativePath, sideEffects, cache);
+                        module.factoryMeta.sideEffectFree = !hasSideEffects;
+                    }
+                }
+                return module;
+            });
+            normalModuleFactory.hooks.module.tap(PLUGIN_NAME, (module, data) => {
+                if (typeof data.settings.sideEffects === 'boolean') {
+                    if (module.factoryMeta === undefined) {
+                        module.factoryMeta = {};
+                    }
+                    module.factoryMeta.sideEffectFree = !data.settings.sideEffects;
+                }
+                return module;
+            });
+            if (this._analyseSource) {
+                const parserHandler = parser => {
+                    let sideEffectsStatement;
+                    parser.hooks.program.tap(PLUGIN_NAME, () => {
+                        sideEffectsStatement = undefined;
+                    });
+                    parser.hooks.statement.tap({ name: PLUGIN_NAME, stage: -100 }, statement => {
+                        if (sideEffectsStatement)
+                            return;
+                        if (parser.scope.topLevelScope !== true)
+                            return;
+                        switch (statement.type) {
+                            case 'ExpressionStatement':
+                                if (!parser.isPure(statement.expression, statement.range[0])) {
+                                    sideEffectsStatement = statement;
+                                }
+                                break;
+                            case 'IfStatement':
+                            case 'WhileStatement':
+                            case 'DoWhileStatement':
+                                if (!parser.isPure(statement.test, statement.range[0])) {
+                                    sideEffectsStatement = statement;
+                                }
+                                // statement hook will be called for child statements too
+                                break;
+                            case 'ForStatement':
+                                if (!parser.isPure(statement.init, statement.range[0]) ||
+                                    !parser.isPure(statement.test, statement.init ? statement.init.range[1] : statement.range[0]) ||
+                                    !parser.isPure(statement.update, statement.test
+                                        ? statement.test.range[1]
+                                        : statement.init
+                                            ? statement.init.range[1]
+                                            : statement.range[0])) {
+                                    sideEffectsStatement = statement;
+                                }
+                                // statement hook will be called for child statements too
+                                break;
+                            case 'SwitchStatement':
+                                if (!parser.isPure(statement.discriminant, statement.range[0])) {
+                                    sideEffectsStatement = statement;
+                                }
+                                // statement hook will be called for child statements too
+                                break;
+                            case 'VariableDeclaration':
+                            case 'ClassDeclaration':
+                            case 'FunctionDeclaration':
+                                if (!parser.isPure(statement, statement.range[0])) {
+                                    sideEffectsStatement = statement;
+                                }
+                                break;
+                            case 'ExportNamedDeclaration':
+                            case 'ExportDefaultDeclaration':
+                                if (!parser.isPure(statement.declaration, statement.range[0])) {
+                                    sideEffectsStatement = statement;
+                                }
+                                break;
+                            case 'LabeledStatement':
+                            case 'BlockStatement':
+                                // statement hook will be called for child statements too
+                                break;
+                            case 'EmptyStatement':
+                                break;
+                            case 'ExportAllDeclaration':
+                            case 'ImportDeclaration':
+                                // imports will be handled by the dependencies
+                                break;
+                            default:
+                                sideEffectsStatement = statement;
+                                break;
+                        }
+                    });
+                    parser.hooks.finish.tap(PLUGIN_NAME, () => {
+                        if (sideEffectsStatement === undefined) {
+                            parser.state.module.buildMeta.sideEffectFree = true;
+                        }
+                        else {
+                            const { loc, type } = sideEffectsStatement;
+                            moduleGraph
+                                .getOptimizationBailout(parser.state.module)
+                                .push(() => `Statement (${type}) with side effects in source code at ${(0, formatLocation_1.default)(loc)}`);
+                        }
+                    });
+                };
+                for (const key of [
+                    ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_AUTO,
+                    ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_ESM,
+                    ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+                ]) {
+                    normalModuleFactory.hooks.parser.for(key).tap(PLUGIN_NAME, parserHandler);
+                }
+            }
+            compilation.hooks.optimizeDependencies.tap({
+                name: PLUGIN_NAME,
+                stage: OptimizationStages_1.STAGE_DEFAULT,
+            }, modules => {
+                const logger = compilation.getLogger('webpack.SideEffectsFlagPlugin');
+                logger.time('update dependencies');
+                for (const module of modules) {
+                    if (module.getSideEffectsConnectionState(moduleGraph) === false) {
+                        const exportsInfo = moduleGraph.getExportsInfo(module);
+                        for (const connection of moduleGraph.getIncomingConnections(module)) {
+                            const dep = connection.dependency;
+                            let isReexport;
+                            if ((isReexport = dep instanceof HarmonyExportImportedSpecifierDependency_1.HarmonyExportImportedSpecifierDependency) ||
+                                (dep instanceof HarmonyImportSpecifierDependency_1.default && !dep.namespaceObjectAsContext)) {
+                                // TODO improve for export *
+                                if (isReexport && dep.name) {
+                                    const exportInfo = moduleGraph.getExportInfo(connection.originModule, dep.name);
+                                    exportInfo.moveTarget(moduleGraph, ({ module }) => module.getSideEffectsConnectionState(moduleGraph) === false, ({ module: newModule, export: exportName }) => {
+                                        moduleGraph.updateModule(dep, newModule);
+                                        moduleGraph.addExplanation(dep, '(skipped side-effect-free modules)');
+                                        const ids = dep.getIds(moduleGraph);
+                                        dep.setIds(moduleGraph, exportName ? [...exportName, ...ids.slice(1)] : ids.slice(1));
+                                        return moduleGraph.getConnection(dep);
+                                    });
+                                    continue;
+                                }
+                                // TODO improve for nested imports
+                                const ids = dep.getIds(moduleGraph);
+                                if (ids.length > 0) {
+                                    const exportInfo = exportsInfo.getExportInfo(ids[0]);
+                                    const target = exportInfo.getTarget(moduleGraph, ({ module }) => module.getSideEffectsConnectionState(moduleGraph) === false);
+                                    if (!target)
+                                        continue;
+                                    moduleGraph.updateModule(dep, target.module);
+                                    moduleGraph.addExplanation(dep, '(skipped side-effect-free modules)');
+                                    dep.setIds(moduleGraph, target.export ? [...target.export, ...ids.slice(1)] : ids.slice(1));
+                                }
+                            }
+                        }
+                    }
+                }
+                logger.timeEnd('update dependencies');
+            });
+        });
+    }
+    static moduleHasSideEffects(moduleName, flagValue, cache) {
+        switch (typeof flagValue) {
+            case 'undefined':
+                return true;
+            case 'boolean':
+                return flagValue;
+            case 'string':
+                return globToRegexp(flagValue, cache).test(moduleName);
+            case 'object':
+                return flagValue.some(glob => SideEffectsFlagPlugin.moduleHasSideEffects(moduleName, glob, cache));
+        }
+    }
+}
+exports.default = SideEffectsFlagPlugin;

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

@@ -0,0 +1,7 @@
+export default class SplitChunksPlugin {
+    options: any;
+    _cacheGroupCache: WeakMap<any, any>;
+    constructor(options?: any);
+    _getCacheGroup(cacheGroupSource: any): any;
+    apply(compiler: any): void;
+}