xhs-mp-pack 1.1.0-beta.0

package/dist/module/ExternalModuleFactoryPlugin.js

@@ -0,0 +1,176 @@
+"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 cleverMerge_1 = require("@/base/cleverMerge");
+const ExternalModule_1 = __importDefault(require("./ExternalModule"));
+const UNSPECIFIED_EXTERNAL_TYPE_REGEXP = /^[a-z0-9-]+ /;
+const EMPTY_RESOLVE_OPTIONS = {};
+// TODO webpack 6 remove this
+const callDeprecatedExternals = util_1.default.deprecate((externalsFunction, context, request, cb) => {
+    externalsFunction.call(null, context, request, cb);
+}, 'The externals-function should be defined like ({context, request}, cb) => { ... }', 'DEP_WEBPACK_EXTERNALS_FUNCTION_PARAMETERS');
+const cache = new WeakMap();
+const resolveLayer = (obj, layer) => {
+    let map = cache.get(obj);
+    if (map === undefined) {
+        map = new Map();
+        cache.set(obj, map);
+    }
+    else {
+        const cacheEntry = map.get(layer);
+        if (cacheEntry !== undefined)
+            return cacheEntry;
+    }
+    const result = (0, cleverMerge_1.resolveByProperty)(obj, 'byLayer', layer);
+    map.set(layer, result);
+    return result;
+};
+class ExternalModuleFactoryPlugin {
+    constructor(type, externals) {
+        this.type = type;
+        this.externals = externals;
+    }
+    apply(normalModuleFactory) {
+        const globalType = this.type;
+        normalModuleFactory.hooks.factorize.tapAsync('ExternalModuleFactoryPlugin', (data, callback) => {
+            const context = data.context;
+            const contextInfo = data.contextInfo;
+            const dependency = data.dependencies[0];
+            const dependencyType = data.dependencyType;
+            const handleExternal = (value, type, callback) => {
+                if (value === false) {
+                    // Not externals, fallback to original factory
+                    return callback();
+                }
+                let externalConfig;
+                if (value === true) {
+                    externalConfig = dependency.request;
+                }
+                else {
+                    externalConfig = value;
+                }
+                // When no explicit type is specified, extract it from the externalConfig
+                if (type === undefined) {
+                    if (typeof externalConfig === 'string' &&
+                        UNSPECIFIED_EXTERNAL_TYPE_REGEXP.test(externalConfig)) {
+                        const idx = externalConfig.indexOf(' ');
+                        type = externalConfig.slice(0, idx);
+                        externalConfig = externalConfig.slice(idx + 1);
+                    }
+                    else if (Array.isArray(externalConfig) &&
+                        externalConfig.length > 0 &&
+                        UNSPECIFIED_EXTERNAL_TYPE_REGEXP.test(externalConfig[0])) {
+                        const firstItem = externalConfig[0];
+                        const idx = firstItem.indexOf(' ');
+                        type = firstItem.slice(0, idx);
+                        externalConfig = [firstItem.slice(idx + 1), ...externalConfig.slice(1)];
+                    }
+                }
+                callback(null, new ExternalModule_1.default(externalConfig, type || globalType, dependency.request));
+            };
+            const handleExternals = (externals, callback) => {
+                if (typeof externals === 'string') {
+                    if (externals === dependency.request) {
+                        return handleExternal(dependency.request, undefined, callback);
+                    }
+                }
+                else if (Array.isArray(externals)) {
+                    let i = 0;
+                    const next = () => {
+                        let asyncFlag;
+                        const handleExternalsAndCallback = (err, module) => {
+                            if (err)
+                                return callback(err);
+                            if (!module) {
+                                if (asyncFlag) {
+                                    asyncFlag = false;
+                                    return;
+                                }
+                                return next();
+                            }
+                            callback(null, module);
+                        };
+                        do {
+                            asyncFlag = true;
+                            if (i >= externals.length)
+                                return callback();
+                            handleExternals(externals[i++], handleExternalsAndCallback);
+                        } while (!asyncFlag);
+                        asyncFlag = false;
+                    };
+                    next();
+                    return;
+                }
+                else if (externals instanceof RegExp) {
+                    if (externals.test(dependency.request)) {
+                        return handleExternal(dependency.request, undefined, callback);
+                    }
+                }
+                else if (typeof externals === 'function') {
+                    const cb = (err, value, type) => {
+                        if (err)
+                            return callback(err);
+                        if (value !== undefined) {
+                            handleExternal(value, type, callback);
+                        }
+                        else {
+                            callback();
+                        }
+                    };
+                    if (externals.length === 3) {
+                        // TODO webpack 6 remove this
+                        callDeprecatedExternals(externals, context, dependency.request, cb);
+                    }
+                    else {
+                        const promise = externals({
+                            context,
+                            request: dependency.request,
+                            dependencyType,
+                            contextInfo,
+                            getResolve: options => (context, request, callback) => {
+                                const resolveContext = {
+                                    fileDependencies: data.fileDependencies,
+                                    missingDependencies: data.missingDependencies,
+                                    contextDependencies: data.contextDependencies,
+                                };
+                                let resolver = normalModuleFactory.getResolver('normal', dependencyType
+                                    ? (0, cleverMerge_1.cachedSetProperty)(data.resolveOptions || EMPTY_RESOLVE_OPTIONS, 'dependencyType', dependencyType)
+                                    : data.resolveOptions);
+                                if (options)
+                                    resolver = resolver.withOptions(options);
+                                if (callback) {
+                                    resolver.resolve({}, context, request, resolveContext, callback);
+                                }
+                                else {
+                                    return new Promise((resolve, reject) => {
+                                        resolver.resolve({}, context, request, resolveContext, (err, result) => {
+                                            if (err)
+                                                reject(err);
+                                            else
+                                                resolve(result);
+                                        });
+                                    });
+                                }
+                            },
+                        }, cb);
+                        if (promise === null || promise === void 0 ? void 0 : promise.then)
+                            promise.then(r => cb(null, r), cb);
+                    }
+                    return;
+                }
+                else if (typeof externals === 'object') {
+                    const resolvedExternals = resolveLayer(externals, contextInfo.issuerLayer);
+                    if (Object.prototype.hasOwnProperty.call(resolvedExternals, dependency.request)) {
+                        return handleExternal(resolvedExternals[dependency.request], undefined, callback);
+                    }
+                }
+                callback();
+            };
+            handleExternals(this.externals, callback);
+        });
+    }
+}
+exports.default = ExternalModuleFactoryPlugin;

package/dist/module/ExternalsPlugin.d.ts

@@ -0,0 +1,7 @@
+declare class ExternalsPlugin {
+    type: string | undefined;
+    externals: any;
+    constructor(type: string | undefined, externals: any);
+    apply(compiler: any): void;
+}
+export default ExternalsPlugin;

package/dist/module/ExternalsPlugin.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ExternalModuleFactoryPlugin_1 = __importDefault(require("./ExternalModuleFactoryPlugin"));
+class ExternalsPlugin {
+    constructor(type, externals) {
+        this.type = type;
+        this.externals = externals;
+    }
+    apply(compiler) {
+        compiler.hooks.compile.tap('ExternalsPlugin', ({ normalModuleFactory }) => {
+            new ExternalModuleFactoryPlugin_1.default(this.type, this.externals).apply(normalModuleFactory);
+        });
+    }
+}
+exports.default = ExternalsPlugin;

package/dist/module/Generator.d.ts

@@ -0,0 +1,40 @@
+import { RuntimeSpec } from '@/module/RuntimeHelpers';
+import NormalModule from './NormalModule';
+import ChunkGraph from '../chunk/ChunkGraph';
+import RuntimeTemplate from '../template/RuntimeTemplate';
+import ConcatenationScope from '../ConcatenationScope';
+import ModuleGraph from './ModuleGraph';
+import DependencyTemplates from '../dependencies/DependencyTemplates';
+import CodeGenerationResults from '../chunk/CodeGenerationResults';
+interface GenerateContext {
+    dependencyTemplates: DependencyTemplates;
+    runtimeTemplate: RuntimeTemplate;
+    moduleGraph: ModuleGraph;
+    chunkGraph: ChunkGraph;
+    runtimeRequirements: Set<string>;
+    runtime: RuntimeSpec;
+    concatenationScope?: ConcatenationScope;
+    codeGenerationResults?: CodeGenerationResults;
+    type: string;
+    getData?: () => Map<string, any>;
+}
+declare class Generator {
+    static byType(map: any): ByTypeGenerator;
+    getTypes(module: any): void;
+    getSize(module: any, type?: string): any;
+    generate(module: any, { dependencyTemplates, runtimeTemplate, moduleGraph, type }: any): any;
+    getConcatenationBailoutReason(module: any, context: any): string | undefined;
+    updateHash(hash: any, { module, runtime }: {
+        module: any;
+        runtime: any;
+    }): void;
+}
+declare class ByTypeGenerator extends Generator {
+    map: any;
+    _types: Set<string>;
+    constructor(map: any);
+    getTypes(module: NormalModule): Set<string>;
+    getSize(module: NormalModule, type?: string): any;
+    generate(module: NormalModule, generateContext: GenerateContext): any;
+}
+export default Generator;

package/dist/module/Generator.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Generator {
+    static byType(map) {
+        return new ByTypeGenerator(map);
+    }
+    getTypes(module) {
+        const AbstractMethodError = require('@/base/errors/AbstractMethodError').default;
+        throw new AbstractMethodError();
+    }
+    getSize(module, type) {
+        const AbstractMethodError = require('@/base/errors/AbstractMethodError').default;
+        throw new AbstractMethodError();
+    }
+    generate(module, { dependencyTemplates, runtimeTemplate, moduleGraph, type }) {
+        const AbstractMethodError = require('@/base/errors/AbstractMethodError').default;
+        throw new AbstractMethodError();
+    }
+    getConcatenationBailoutReason(module, context) {
+        return `Module Concatenation is not implemented for ${this.constructor.name}`;
+    }
+    updateHash(hash, { module, runtime }) {
+        // no nothing
+    }
+}
+class ByTypeGenerator extends Generator {
+    constructor(map) {
+        super();
+        this.map = map;
+        this._types = new Set(Object.keys(map));
+    }
+    getTypes(module) {
+        return this._types;
+    }
+    getSize(module, type) {
+        const t = type || 'javascript';
+        const generator = this.map[t];
+        return generator ? generator.getSize(module, t) : 0;
+    }
+    generate(module, generateContext) {
+        const type = generateContext.type;
+        const generator = this.map[type];
+        if (!generator) {
+            throw new Error(`Generator.byType: no generator specified for ${type}`);
+        }
+        return generator.generate(module, generateContext);
+    }
+}
+exports.default = Generator;

package/dist/module/IgnoreErrorModuleFactory.d.ts

@@ -0,0 +1,7 @@
+import ModuleFactory from './ModuleFactory';
+declare class IgnoreErrorModuleFactory extends ModuleFactory {
+    normalModuleFactory: any;
+    constructor(normalModuleFactory: any);
+    create(data: any, callback?: any): void;
+}
+export default IgnoreErrorModuleFactory;

package/dist/module/IgnoreErrorModuleFactory.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ModuleFactory_1 = __importDefault(require("./ModuleFactory"));
+class IgnoreErrorModuleFactory extends ModuleFactory_1.default {
+    constructor(normalModuleFactory) {
+        super();
+        this.normalModuleFactory = normalModuleFactory;
+    }
+    create(data, callback) {
+        this.normalModuleFactory.create(data, (err, result) => callback(null, result));
+    }
+}
+exports.default = IgnoreErrorModuleFactory;

package/dist/module/JavascriptMetaInfoPlugin.d.ts

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

package/dist/module/JavascriptMetaInfoPlugin.js

@@ -0,0 +1,65 @@
+"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 ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const InnerGraph = __importStar(require("@/plugins/optimize/InnerGraph"));
+const PLUGIN_NAME = 'JavascriptMetaInfoPlugin';
+class JavascriptMetaInfoPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation, { normalModuleFactory }) => {
+            const handler = parser => {
+                parser.hooks.call.for('eval').tap(PLUGIN_NAME, () => {
+                    const buildInfo = parser.state.module.buildInfo;
+                    buildInfo.moduleConcatenationBailout = 'eval()';
+                    buildInfo.usingEval = true;
+                    const currentSymbol = InnerGraph.getTopLevelSymbol(parser.state);
+                    if (currentSymbol) {
+                        InnerGraph.addUsage(parser.state, null, currentSymbol);
+                    }
+                    else {
+                        InnerGraph.bailout(parser.state);
+                    }
+                });
+                parser.hooks.finish.tap(PLUGIN_NAME, () => {
+                    const buildInfo = parser.state.module.buildInfo;
+                    let topLevelDeclarations = buildInfo.topLevelDeclarations;
+                    if (topLevelDeclarations === undefined) {
+                        topLevelDeclarations = buildInfo.topLevelDeclarations = new Set();
+                    }
+                    for (const name of parser.scope.definitions.asSet()) {
+                        const freeInfo = parser.getFreeInfoFromVariable(name);
+                        if (freeInfo === undefined) {
+                            topLevelDeclarations.add(name);
+                        }
+                    }
+                });
+            };
+            normalModuleFactory.hooks.parser.for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_AUTO).tap(PLUGIN_NAME, handler);
+            normalModuleFactory.hooks.parser.for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_DYNAMIC).tap(PLUGIN_NAME, handler);
+            normalModuleFactory.hooks.parser.for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_ESM).tap(PLUGIN_NAME, handler);
+        });
+    }
+}
+exports.default = JavascriptMetaInfoPlugin;

package/dist/module/LazyModuleFactoryPlugin.d.ts

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

package/dist/module/LazyModuleFactoryPlugin.js

@@ -0,0 +1,171 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_sources_1 = require("webpack-sources");
+const querystring_1 = __importDefault(require("querystring"));
+const const_1 = __importDefault(require("@/base/const"));
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const ModuleFactory_1 = __importDefault(require("@/module/ModuleFactory"));
+const Serialization_1 = __importDefault(require("../serialization/Serialization"));
+const Dependency_1 = __importDefault(require("../dependencies/Dependency"));
+const Module_1 = __importDefault(require("./Module"));
+const { registerNotSerializable } = Serialization_1.default;
+const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
+const moduleType = 'lazy-module';
+const TYPES = new Set(['javascript']);
+class LazyCompilationDependency extends Dependency_1.default {
+    constructor(proxyModule) {
+        super();
+        this.proxyModule = proxyModule;
+    }
+    get category() {
+        return 'esm';
+    }
+    get type() {
+        return 'lazy import()';
+    }
+    getResourceIdentifier() {
+        return this.proxyModule.originalModule.identifier();
+    }
+}
+registerNotSerializable(LazyCompilationDependency);
+class LazyCompilationModule extends Module_1.default {
+    constructor(context, originalModule, request) {
+        super(moduleType, context, originalModule.layer);
+        this.originalModule = originalModule;
+        this.request = request;
+    }
+    identifier() {
+        return `${moduleType}|${this.originalModule.identifier()}`;
+    }
+    readableIdentifier(requestShortener) {
+        return `${moduleType} ${this.originalModule.readableIdentifier(requestShortener)}`;
+    }
+    updateCacheModule(module) {
+        super.updateCacheModule(module);
+        const m = module;
+        this.originalModule = m.originalModule;
+        this.request = m.request;
+    }
+    libIdent(options) {
+        return `${this.originalModule.libIdent(options)}!${moduleType}`;
+    }
+    build(options, compilation, resolver, fs, callback) {
+        this.buildInfo = {};
+        this.buildMeta = {};
+        callback();
+    }
+    needBuild(context, callback) {
+        callback(null, true);
+    }
+    codeGeneration(any) {
+        const sources = new Map();
+        sources.set('javascript', new webpack_sources_1.RawSource(`module.exports = "/**lazy module**/"`));
+        const data = new Map();
+        data.set('url', this.request);
+        return { sources, runtimeRequirements: RUNTIME_REQUIREMENTS, data };
+    }
+    getSourceTypes() {
+        return TYPES;
+    }
+    size(type) {
+        return 200;
+    }
+    updateHash(hash, context) {
+        super.updateHash(hash, context);
+        hash.update(JSON.stringify(`lazy ${this.request}`));
+    }
+}
+registerNotSerializable(LazyCompilationModule);
+class LazyCompilationDependencyFactory extends ModuleFactory_1.default {
+    constructor(factory) {
+        super();
+        this._factory = factory;
+    }
+    create(data, callback) {
+        const dependency = data.dependencies[0];
+        callback(null, {
+            module: dependency.proxyModule.originalModule
+        });
+    }
+}
+class LazyCompilationPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap('LazyCompilationPlugin', (compilation, { normalModuleFactory }) => {
+            normalModuleFactory.hooks.module.tap('LazyCompilationPlugin', (originalModule, createData, resolveData) => {
+                const { project, packSetting } = compiler;
+                if (project.appMode !== 'miniprogram') {
+                    return;
+                }
+                const activePkgs = packSetting.getCompilePkgs();
+                if (!activePkgs.length) {
+                    return new LazyCompilationModule(compiler.context, originalModule, resolveData.request);
+                }
+                // 过滤其他包的entry
+                if (resolveData.request.startsWith('entry-loader')) {
+                    const arr = resolveData.request.split('!')[0].split('?');
+                    if (arr[1]) {
+                        const obj = querystring_1.default.parse(arr[1]);
+                        if ((obj === null || obj === void 0 ? void 0 : obj.pkg) !== const_1.default.FULL_PKG &&
+                            (((obj === null || obj === void 0 ? void 0 : obj.pkg) === const_1.default.MAIN_PKG && !activePkgs.includes(obj === null || obj === void 0 ? void 0 : obj.pkg)) ||
+                                ((obj === null || obj === void 0 ? void 0 : obj.pkg) === const_1.default.SUB_PKG && !activePkgs.includes(obj === null || obj === void 0 ? void 0 : obj.root)))) {
+                            console.log('[lazy module]', resolveData.request);
+                            return new LazyCompilationModule(compiler.context, originalModule, resolveData.request);
+                        }
+                    }
+                    // console.log('normal module', resolveData.request)
+                }
+                else {
+                    // 微盟项目渲染层分包会相互依赖，这个兼容下，暂时注释掉
+                    // 过滤其他包的模块（主包除外）
+                    // const projectMiniprogramPath = project.projectMiniprogramPath
+                    // const subPkgs = project
+                    //   .getSubPackages()
+                    //   .filter(item => !activePkgs.includes(item.root || ''))
+                    // for (const pkgItem of subPkgs) {
+                    //   const absPkgPath = path.posix.join(projectMiniprogramPath, pkgItem.root)
+                    //   if (resolveData?.resource?.startsWith?.(absPkgPath)) {
+                    //     console.log('[lazy module]', resolveData.request)
+                    //     return new LazyCompilationModule(
+                    //       compiler.context,
+                    //       originalModule,
+                    //       resolveData.request,
+                    //     )
+                    //   }
+                    // }
+                    // console.log('normal module', resolveData.request)
+                }
+            });
+            compilation.dependencyFactories.set(LazyCompilationDependency, new LazyCompilationDependencyFactory());
+        });
+    }
+}
+exports.default = LazyCompilationPlugin;