xhs-mp-pack 1.1.0-beta.0

package/dist/module/RuntimePlugin.js

@@ -0,0 +1,332 @@
+"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 StringXor_1 = __importDefault(require("@/base/StringXor"));
+const RuntimeGlobals = __importStar(require("./RuntimeGlobals"));
+const RuntimeRequirementsDependency_1 = __importDefault(require("../dependencies/RuntimeRequirementsDependency"));
+const JavascriptModulesPlugin_1 = require("./javascript/JavascriptModulesPlugin");
+const AsyncModuleRuntimeModule_1 = __importDefault(require("./runtime/AsyncModuleRuntimeModule"));
+const AutoPublicPathRuntimeModule_1 = __importDefault(require("./runtime/AutoPublicPathRuntimeModule"));
+const BaseUriRuntimeModule_1 = __importDefault(require("./runtime/BaseUriRuntimeModule"));
+const CompatGetDefaultExportRuntimeModule_1 = __importDefault(require("./runtime/CompatGetDefaultExportRuntimeModule"));
+const CompatRuntimeModule_1 = __importDefault(require("./runtime/CompatRuntimeModule"));
+const CreateFakeNamespaceObjectRuntimeModule_1 = __importDefault(require("./runtime/CreateFakeNamespaceObjectRuntimeModule"));
+const CreateScriptRuntimeModule_1 = __importDefault(require("./runtime/CreateScriptRuntimeModule"));
+const CreateScriptUrlRuntimeModule_1 = __importDefault(require("./runtime/CreateScriptUrlRuntimeModule"));
+const DefinePropertyGettersRuntimeModule_1 = __importDefault(require("./runtime/DefinePropertyGettersRuntimeModule"));
+const EnsureChunkRuntimeModule_1 = __importDefault(require("./runtime/EnsureChunkRuntimeModule"));
+const GetChunkFilenameRuntimeModule_1 = __importDefault(require("./runtime/GetChunkFilenameRuntimeModule"));
+const GetMainFilenameRuntimeModule_1 = __importDefault(require("./runtime/GetMainFilenameRuntimeModule"));
+const GetTrustedTypesPolicyRuntimeModule_1 = __importDefault(require("./runtime/GetTrustedTypesPolicyRuntimeModule"));
+const GlobalRuntimeModule_1 = __importDefault(require("./runtime/GlobalRuntimeModule"));
+const HasOwnPropertyRuntimeModule_1 = __importDefault(require("./runtime/HasOwnPropertyRuntimeModule"));
+const LoadScriptRuntimeModule_1 = __importDefault(require("./runtime/LoadScriptRuntimeModule"));
+const MakeNamespaceObjectRuntimeModule_1 = __importDefault(require("./runtime/MakeNamespaceObjectRuntimeModule"));
+const NonceRuntimeModule_1 = __importDefault(require("./runtime/NonceRuntimeModule"));
+const OnChunksLoadedRuntimeModule_1 = __importDefault(require("./runtime/OnChunksLoadedRuntimeModule"));
+const PublicPathRuntimeModule_1 = __importDefault(require("./runtime/PublicPathRuntimeModule"));
+const RelativeUrlRuntimeModule_1 = __importDefault(require("./runtime/RelativeUrlRuntimeModule"));
+const RuntimeIdRuntimeModule_1 = __importDefault(require("./runtime/RuntimeIdRuntimeModule"));
+const GLOBALS_ON_REQUIRE = [
+    RuntimeGlobals.chunkName,
+    RuntimeGlobals.runtimeId,
+    RuntimeGlobals.compatGetDefaultExport,
+    RuntimeGlobals.createFakeNamespaceObject,
+    RuntimeGlobals.createScript,
+    RuntimeGlobals.createScriptUrl,
+    RuntimeGlobals.getTrustedTypesPolicy,
+    RuntimeGlobals.definePropertyGetters,
+    RuntimeGlobals.ensureChunk,
+    RuntimeGlobals.entryModuleId,
+    RuntimeGlobals.getFullHash,
+    RuntimeGlobals.global,
+    RuntimeGlobals.makeNamespaceObject,
+    RuntimeGlobals.moduleCache,
+    RuntimeGlobals.moduleFactories,
+    RuntimeGlobals.moduleFactoriesAddOnly,
+    RuntimeGlobals.interceptModuleExecution,
+    RuntimeGlobals.publicPath,
+    RuntimeGlobals.baseURI,
+    RuntimeGlobals.relativeUrl,
+    RuntimeGlobals.scriptNonce,
+    RuntimeGlobals.uncaughtErrorHandler,
+    RuntimeGlobals.asyncModule,
+    RuntimeGlobals.wasmInstances,
+    RuntimeGlobals.instantiateWasm,
+    RuntimeGlobals.shareScopeMap,
+    RuntimeGlobals.initializeSharing,
+    RuntimeGlobals.loadScript,
+    RuntimeGlobals.systemContext,
+    RuntimeGlobals.onChunksLoaded,
+];
+const MODULE_DEPENDENCIES = {
+    [RuntimeGlobals.moduleLoaded]: [RuntimeGlobals.module],
+    [RuntimeGlobals.moduleId]: [RuntimeGlobals.module],
+};
+const TREE_DEPENDENCIES = {
+    [RuntimeGlobals.definePropertyGetters]: [RuntimeGlobals.hasOwnProperty],
+    [RuntimeGlobals.compatGetDefaultExport]: [RuntimeGlobals.definePropertyGetters],
+    [RuntimeGlobals.createFakeNamespaceObject]: [
+        RuntimeGlobals.definePropertyGetters,
+        RuntimeGlobals.makeNamespaceObject,
+        RuntimeGlobals.require,
+    ],
+    [RuntimeGlobals.initializeSharing]: [RuntimeGlobals.shareScopeMap],
+    [RuntimeGlobals.shareScopeMap]: [RuntimeGlobals.hasOwnProperty],
+};
+class RuntimePlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap('RuntimePlugin', compilation => {
+            const globalChunkLoading = compilation.outputOptions.chunkLoading;
+            const isChunkLoadingDisabledForChunk = chunk => {
+                const options = chunk.getEntryOptions();
+                const chunkLoading = (options === null || options === void 0 ? void 0 : options.chunkLoading) !== undefined ? options.chunkLoading : globalChunkLoading;
+                return chunkLoading === false;
+            };
+            compilation.dependencyTemplates.set(RuntimeRequirementsDependency_1.default, new RuntimeRequirementsDependency_1.default.Template());
+            for (const req of GLOBALS_ON_REQUIRE) {
+                compilation.hooks.runtimeRequirementInModule
+                    .for(req)
+                    .tap('RuntimePlugin', (module, set) => {
+                    set.add(RuntimeGlobals.requireScope);
+                });
+                compilation.hooks.runtimeRequirementInTree.for(req).tap('RuntimePlugin', (module, set) => {
+                    set.add(RuntimeGlobals.requireScope);
+                });
+            }
+            for (const req of Object.keys(TREE_DEPENDENCIES)) {
+                const deps = TREE_DEPENDENCIES[req];
+                compilation.hooks.runtimeRequirementInTree.for(req).tap('RuntimePlugin', (chunk, set) => {
+                    for (const dep of deps)
+                        set.add(dep);
+                });
+            }
+            for (const req of Object.keys(MODULE_DEPENDENCIES)) {
+                const deps = MODULE_DEPENDENCIES[req];
+                compilation.hooks.runtimeRequirementInModule.for(req).tap('RuntimePlugin', (chunk, set) => {
+                    for (const dep of deps)
+                        set.add(dep);
+                });
+            }
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.definePropertyGetters)
+                .tap('RuntimePlugin', chunk => {
+                compilation.addRuntimeModule(chunk, new DefinePropertyGettersRuntimeModule_1.default());
+                return true;
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.makeNamespaceObject)
+                .tap('RuntimePlugin', chunk => {
+                compilation.addRuntimeModule(chunk, new MakeNamespaceObjectRuntimeModule_1.default());
+                return true;
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.createFakeNamespaceObject)
+                .tap('RuntimePlugin', chunk => {
+                compilation.addRuntimeModule(chunk, new CreateFakeNamespaceObjectRuntimeModule_1.default());
+                return true;
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.hasOwnProperty)
+                .tap('RuntimePlugin', chunk => {
+                compilation.addRuntimeModule(chunk, new HasOwnPropertyRuntimeModule_1.default());
+                return true;
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.compatGetDefaultExport)
+                .tap('RuntimePlugin', chunk => {
+                compilation.addRuntimeModule(chunk, new CompatGetDefaultExportRuntimeModule_1.default());
+                return true;
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.runtimeId)
+                .tap('RuntimePlugin', chunk => {
+                compilation.addRuntimeModule(chunk, new RuntimeIdRuntimeModule_1.default());
+                return true;
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.publicPath)
+                .tap('RuntimePlugin', (chunk, set) => {
+                const { outputOptions } = compilation;
+                const { publicPath: globalPublicPath, scriptType } = outputOptions;
+                const entryOptions = chunk.getEntryOptions();
+                const publicPath = (entryOptions === null || entryOptions === void 0 ? void 0 : entryOptions.publicPath) !== undefined ? entryOptions.publicPath : globalPublicPath;
+                if (publicPath === 'auto') {
+                    const module = new AutoPublicPathRuntimeModule_1.default();
+                    if (scriptType !== 'module')
+                        set.add(RuntimeGlobals.global);
+                    compilation.addRuntimeModule(chunk, module);
+                }
+                else {
+                    const module = new PublicPathRuntimeModule_1.default(publicPath);
+                    if (typeof publicPath !== 'string' || /\[(full)?hash\]/.test(publicPath)) {
+                        module.fullHash = true;
+                    }
+                    compilation.addRuntimeModule(chunk, module);
+                }
+                return true;
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.global)
+                .tap('RuntimePlugin', chunk => {
+                compilation.addRuntimeModule(chunk, new GlobalRuntimeModule_1.default());
+                return true;
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.asyncModule)
+                .tap('RuntimePlugin', chunk => {
+                compilation.addRuntimeModule(chunk, new AsyncModuleRuntimeModule_1.default());
+                return true;
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.getChunkScriptFilename)
+                .tap('RuntimePlugin', (chunk, set) => {
+                if (typeof compilation.outputOptions.chunkFilename === 'string' &&
+                    /\[(full)?hash(:\d+)?\]/.test(compilation.outputOptions.chunkFilename)) {
+                    set.add(RuntimeGlobals.getFullHash);
+                }
+                compilation.addRuntimeModule(chunk, new GetChunkFilenameRuntimeModule_1.default('javascript', 'javascript', RuntimeGlobals.getChunkScriptFilename, chunk => chunk.filenameTemplate ||
+                    (chunk.canBeInitial()
+                        ? compilation.outputOptions.filename
+                        : compilation.outputOptions.chunkFilename), false));
+                return true;
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.getChunkUpdateScriptFilename)
+                .tap('RuntimePlugin', (chunk, set) => {
+                if (/\[(full)?hash(:\d+)?\]/.test(compilation.outputOptions.hotUpdateChunkFilename))
+                    set.add(RuntimeGlobals.getFullHash);
+                compilation.addRuntimeModule(chunk, new GetChunkFilenameRuntimeModule_1.default('javascript', 'javascript update', RuntimeGlobals.getChunkUpdateScriptFilename, c => compilation.outputOptions.hotUpdateChunkFilename, true));
+                return true;
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.getUpdateManifestFilename)
+                .tap('RuntimePlugin', (chunk, set) => {
+                if (/\[(full)?hash(:\d+)?\]/.test(compilation.outputOptions.hotUpdateMainFilename)) {
+                    set.add(RuntimeGlobals.getFullHash);
+                }
+                compilation.addRuntimeModule(chunk, new GetMainFilenameRuntimeModule_1.default('update manifest', RuntimeGlobals.getUpdateManifestFilename, compilation.outputOptions.hotUpdateMainFilename));
+                return true;
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.ensureChunk)
+                .tap('RuntimePlugin', (chunk, set) => {
+                const hasAsyncChunks = chunk.hasAsyncChunks();
+                if (hasAsyncChunks) {
+                    set.add(RuntimeGlobals.ensureChunkHandlers);
+                }
+                compilation.addRuntimeModule(chunk, new EnsureChunkRuntimeModule_1.default(set));
+                return true;
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.ensureChunkIncludeEntries)
+                .tap('RuntimePlugin', (chunk, set) => {
+                set.add(RuntimeGlobals.ensureChunkHandlers);
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.loadScript)
+                .tap('RuntimePlugin', (chunk, set) => {
+                const withCreateScriptUrl = !!compilation.outputOptions.trustedTypes;
+                if (withCreateScriptUrl) {
+                    set.add(RuntimeGlobals.createScriptUrl);
+                }
+                const withFetchPriority = set.has(RuntimeGlobals.hasFetchPriority);
+                compilation.addRuntimeModule(chunk, new LoadScriptRuntimeModule_1.default(withCreateScriptUrl, withFetchPriority));
+                return true;
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.createScript)
+                .tap('RuntimePlugin', (chunk, set) => {
+                if (compilation.outputOptions.trustedTypes) {
+                    set.add(RuntimeGlobals.getTrustedTypesPolicy);
+                }
+                compilation.addRuntimeModule(chunk, new CreateScriptRuntimeModule_1.default());
+                return true;
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.createScriptUrl)
+                .tap('RuntimePlugin', (chunk, set) => {
+                if (compilation.outputOptions.trustedTypes) {
+                    set.add(RuntimeGlobals.getTrustedTypesPolicy);
+                }
+                compilation.addRuntimeModule(chunk, new CreateScriptUrlRuntimeModule_1.default());
+                return true;
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.getTrustedTypesPolicy)
+                .tap('RuntimePlugin', (chunk, set) => {
+                compilation.addRuntimeModule(chunk, new GetTrustedTypesPolicyRuntimeModule_1.default(set));
+                return true;
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.relativeUrl)
+                .tap('RuntimePlugin', (chunk, set) => {
+                compilation.addRuntimeModule(chunk, new RelativeUrlRuntimeModule_1.default());
+                return true;
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.onChunksLoaded)
+                .tap('RuntimePlugin', (chunk, set) => {
+                compilation.addRuntimeModule(chunk, new OnChunksLoadedRuntimeModule_1.default());
+                return true;
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.baseURI)
+                .tap('RuntimePlugin', chunk => {
+                if (isChunkLoadingDisabledForChunk(chunk)) {
+                    compilation.addRuntimeModule(chunk, new BaseUriRuntimeModule_1.default());
+                    return true;
+                }
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.scriptNonce)
+                .tap('RuntimePlugin', chunk => {
+                compilation.addRuntimeModule(chunk, new NonceRuntimeModule_1.default());
+                return true;
+            });
+            // TODO webpack 6: remove CompatRuntimeModule
+            compilation.hooks.additionalTreeRuntimeRequirements.tap('RuntimePlugin', (chunk, set) => {
+                const { mainTemplate } = compilation;
+                if (mainTemplate.hooks.bootstrap.isUsed() ||
+                    mainTemplate.hooks.localVars.isUsed() ||
+                    mainTemplate.hooks.requireEnsure.isUsed() ||
+                    mainTemplate.hooks.requireExtensions.isUsed()) {
+                    compilation.addRuntimeModule(chunk, new CompatRuntimeModule_1.default());
+                }
+            });
+            JavascriptModulesPlugin_1.JavascriptModulesPlugin.getCompilationHooks(compilation).chunkHash.tap('RuntimePlugin', (chunk, hash, { chunkGraph }) => {
+                const xor = new StringXor_1.default();
+                for (const m of chunkGraph.getChunkRuntimeModulesIterable(chunk)) {
+                    xor.add(chunkGraph.getModuleHash(m, chunk.runtime));
+                }
+                xor.updateHash(hash);
+            });
+        });
+    }
+}
+exports.default = RuntimePlugin;

package/dist/module/SelfModuleFactory.d.ts

@@ -0,0 +1,6 @@
+declare class SelfModuleFactory {
+    moduleGraph: any;
+    constructor(moduleGraph: any);
+    create(data: any, callback: any): void;
+}
+export default SelfModuleFactory;

package/dist/module/SelfModuleFactory.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SelfModuleFactory {
+    constructor(moduleGraph) {
+        this.moduleGraph = moduleGraph;
+    }
+    create(data, callback) {
+        const module = this.moduleGraph.getParentModule(data.dependencies[0]);
+        callback(null, {
+            module,
+        });
+    }
+}
+exports.default = SelfModuleFactory;

package/dist/module/asset/AssetGenerator.d.ts

@@ -0,0 +1,30 @@
+import Generator from '../Generator';
+declare class AssetGenerator extends Generator {
+    dataUrlOptions: any;
+    filename: any;
+    publicPath: any;
+    outputPath: any;
+    emit: any;
+    constructor(dataUrlOptions: any, filename?: any, publicPath?: any, outputPath?: any, emit?: any);
+    getSourceFileName(module: any, runtimeTemplate: any): any;
+    getConcatenationBailoutReason(module: any, context: any): undefined;
+    getMimeType(module: any): string;
+    generate(module: any, { runtime, concatenationScope, chunkGraph, runtimeTemplate, runtimeRequirements, type, getData, }: {
+        runtime: any;
+        concatenationScope: any;
+        chunkGraph: any;
+        runtimeTemplate: any;
+        runtimeRequirements: any;
+        type: any;
+        getData: any;
+    }): any;
+    getTypes(module: any): Set<string>;
+    getSize(module: any, type?: string): any;
+    updateHash(hash: any, { module, runtime, runtimeTemplate, chunkGraph }: {
+        module: any;
+        runtime: any;
+        runtimeTemplate: any;
+        chunkGraph: any;
+    }): void;
+}
+export default AssetGenerator;