xhs-mp-pack 1.1.0-beta.0

package/dist/module/runtime/LoadScriptRuntimeModule.js

@@ -0,0 +1,129 @@
+"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 tapable_1 = require("tapable");
+const Compilation_1 = __importDefault(require("@/Compilation"));
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const HelperRuntimeModule_1 = __importDefault(require("./HelperRuntimeModule"));
+const compilationHooksMap = new WeakMap();
+class LoadScriptRuntimeModule extends HelperRuntimeModule_1.default {
+    static getCompilationHooks(compilation) {
+        if (!(compilation instanceof Compilation_1.default)) {
+            throw new TypeError("The 'compilation' argument must be an instance of Compilation");
+        }
+        let hooks = compilationHooksMap.get(compilation);
+        if (hooks === undefined) {
+            hooks = {
+                createScript: new tapable_1.SyncWaterfallHook(['source', 'chunk']),
+            };
+            compilationHooksMap.set(compilation, hooks);
+        }
+        return hooks;
+    }
+    constructor(withCreateScriptUrl, withFetchPriority) {
+        super('load script');
+        this._withCreateScriptUrl = withCreateScriptUrl;
+        this._withFetchPriority = withFetchPriority;
+    }
+    generate() {
+        const compilation = this.compilation;
+        const { runtimeTemplate, outputOptions } = compilation;
+        const { scriptType, chunkLoadTimeout: loadTimeout, crossOriginLoading, uniqueName, charset, } = outputOptions;
+        const fn = RuntimeGlobals.loadScript;
+        const { createScript } = LoadScriptRuntimeModule.getCompilationHooks(compilation);
+        const code = Template_1.Template.asString([
+            "script = document.createElement('script');",
+            scriptType ? `script.type = ${JSON.stringify(scriptType)};` : '',
+            charset ? "script.charset = 'utf-8';" : '',
+            `script.timeout = ${loadTimeout / 1000};`,
+            `if (${RuntimeGlobals.scriptNonce}) {`,
+            Template_1.Template.indent(`script.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`),
+            '}',
+            uniqueName ? 'script.setAttribute("data-webpack", dataWebpackPrefix + key);' : '',
+            this._withFetchPriority
+                ? Template_1.Template.asString([
+                    'if(fetchPriority) {',
+                    Template_1.Template.indent('script.setAttribute("fetchpriority", fetchPriority);'),
+                    '}',
+                ])
+                : '',
+            `script.src = ${this._withCreateScriptUrl ? `${RuntimeGlobals.createScriptUrl}(url)` : 'url'};`,
+            crossOriginLoading
+                ? crossOriginLoading === 'use-credentials'
+                    ? 'script.crossOrigin = "use-credentials";'
+                    : Template_1.Template.asString([
+                        "if (script.src.indexOf(window.location.origin + '/') !== 0) {",
+                        Template_1.Template.indent(`script.crossOrigin = ${JSON.stringify(crossOriginLoading)};`),
+                        '}',
+                    ])
+                : '',
+        ]);
+        return Template_1.Template.asString([
+            'var inProgress = {};',
+            uniqueName
+                ? `var dataWebpackPrefix = ${JSON.stringify(`${uniqueName}:`)};`
+                : '// data-webpack is not used as build has no uniqueName',
+            '// loadScript function to load a script via script tag',
+            `${fn} = ${runtimeTemplate.basicFunction(`url, done, key, chunkId${this._withFetchPriority ? ', fetchPriority' : ''}`, [
+                'if(inProgress[url]) { inProgress[url].push(done); return; }',
+                'var script, needAttach;',
+                'if(key !== undefined) {',
+                Template_1.Template.indent([
+                    'var scripts = document.getElementsByTagName("script");',
+                    'for(var i = 0; i < scripts.length; i++) {',
+                    Template_1.Template.indent([
+                        'var s = scripts[i];',
+                        `if(s.getAttribute("src") == url${uniqueName ? ' || s.getAttribute("data-webpack") == dataWebpackPrefix + key' : ''}) { script = s; break; }`,
+                    ]),
+                    '}',
+                ]),
+                '}',
+                'if(!script) {',
+                Template_1.Template.indent(['needAttach = true;', createScript.call(code, this.chunk)]),
+                '}',
+                'inProgress[url] = [done];',
+                `var onScriptComplete = ${runtimeTemplate.basicFunction('prev, event', Template_1.Template.asString([
+                    '// avoid mem leaks in IE.',
+                    'script.onerror = script.onload = null;',
+                    'clearTimeout(timeout);',
+                    'var doneFns = inProgress[url];',
+                    'delete inProgress[url];',
+                    'script.parentNode && script.parentNode.removeChild(script);',
+                    `doneFns && doneFns.forEach(${runtimeTemplate.returningFunction('fn(event)', 'fn')});`,
+                    'if(prev) return prev(event);',
+                ]))}`,
+                `var timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), ${loadTimeout});`,
+                'script.onerror = onScriptComplete.bind(null, script.onerror);',
+                'script.onload = onScriptComplete.bind(null, script.onload);',
+                'needAttach && document.head.appendChild(script);',
+            ])};`,
+        ]);
+    }
+}
+exports.default = LoadScriptRuntimeModule;

package/dist/module/runtime/MakeNamespaceObjectRuntimeModule.d.ts

@@ -0,0 +1,6 @@
+import HelperRuntimeModule from './HelperRuntimeModule';
+declare class MakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
+    constructor();
+    generate(): string;
+}
+export default MakeNamespaceObjectRuntimeModule;

package/dist/module/runtime/MakeNamespaceObjectRuntimeModule.js

@@ -0,0 +1,53 @@
+"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 RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const HelperRuntimeModule_1 = __importDefault(require("./HelperRuntimeModule"));
+class MakeNamespaceObjectRuntimeModule extends HelperRuntimeModule_1.default {
+    constructor() {
+        super('make namespace object');
+    }
+    generate() {
+        const compilation = this.compilation;
+        const { runtimeTemplate } = compilation;
+        const fn = RuntimeGlobals.makeNamespaceObject;
+        return Template_1.Template.asString([
+            '// define __esModule on exports',
+            `${fn} = ${runtimeTemplate.basicFunction('exports', [
+                "if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {",
+                Template_1.Template.indent([
+                    "Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });",
+                ]),
+                '}',
+                "Object.defineProperty(exports, '__esModule', { value: true });",
+            ])};`,
+        ]);
+    }
+}
+exports.default = MakeNamespaceObjectRuntimeModule;

package/dist/module/runtime/NonceRuntimeModule.d.ts

@@ -0,0 +1,6 @@
+import RuntimeModule from '../RuntimeModule';
+declare class NonceRuntimeModule extends RuntimeModule {
+    constructor();
+    generate(): string;
+}
+export default NonceRuntimeModule;

package/dist/module/runtime/NonceRuntimeModule.js

@@ -0,0 +1,39 @@
+"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 RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const RuntimeModule_1 = __importDefault(require("../RuntimeModule"));
+class NonceRuntimeModule extends RuntimeModule_1.default {
+    constructor() {
+        super('nonce', RuntimeModule_1.default.STAGE_ATTACH);
+    }
+    generate() {
+        return `${RuntimeGlobals.scriptNonce} = undefined;`;
+    }
+}
+exports.default = NonceRuntimeModule;

package/dist/module/runtime/OnChunksLoadedRuntimeModule.d.ts

@@ -0,0 +1,6 @@
+import RuntimeModule from '../RuntimeModule';
+declare class OnChunksLoadedRuntimeModule extends RuntimeModule {
+    constructor();
+    generate(): string;
+}
+export default OnChunksLoadedRuntimeModule;

package/dist/module/runtime/OnChunksLoadedRuntimeModule.js

@@ -0,0 +1,81 @@
+"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 RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const RuntimeModule_1 = __importDefault(require("../RuntimeModule"));
+class OnChunksLoadedRuntimeModule extends RuntimeModule_1.default {
+    constructor() {
+        super('chunk loaded');
+    }
+    generate() {
+        const compilation = this.compilation;
+        const { runtimeTemplate } = compilation;
+        return Template_1.Template.asString([
+            'var deferred = [];',
+            `${RuntimeGlobals.onChunksLoaded} = ${runtimeTemplate.basicFunction('result, chunkIds, fn, priority', [
+                'if(chunkIds) {',
+                Template_1.Template.indent([
+                    'priority = priority || 0;',
+                    'for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];',
+                    'deferred[i] = [chunkIds, fn, priority];',
+                    'return;',
+                ]),
+                '}',
+                'var notFulfilled = Infinity;',
+                'for (var i = 0; i < deferred.length; i++) {',
+                Template_1.Template.indent([
+                    runtimeTemplate.destructureArray(['chunkIds', 'fn', 'priority'], 'deferred[i]'),
+                    'var fulfilled = true;',
+                    'for (var j = 0; j < chunkIds.length; j++) {',
+                    Template_1.Template.indent([
+                        `if ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(${RuntimeGlobals.onChunksLoaded}).every(${runtimeTemplate.returningFunction(`${RuntimeGlobals.onChunksLoaded}[key](chunkIds[j])`, 'key')})) {`,
+                        Template_1.Template.indent(['chunkIds.splice(j--, 1);']),
+                        '} else {',
+                        Template_1.Template.indent([
+                            'fulfilled = false;',
+                            'if(priority < notFulfilled) notFulfilled = priority;',
+                        ]),
+                        '}',
+                    ]),
+                    '}',
+                    'if(fulfilled) {',
+                    Template_1.Template.indent([
+                        'deferred.splice(i--, 1)',
+                        'var r = fn();',
+                        'if (r !== undefined) result = r;',
+                    ]),
+                    '}',
+                ]),
+                '}',
+                'return result;',
+            ])};`,
+        ]);
+    }
+}
+exports.default = OnChunksLoadedRuntimeModule;

package/dist/module/runtime/PublicPathRuntimeModule.d.ts

@@ -0,0 +1,7 @@
+import RuntimeModule from '../RuntimeModule';
+declare class PublicPathRuntimeModule extends RuntimeModule {
+    publicPath: string;
+    constructor(publicPath: any);
+    generate(): string;
+}
+export default PublicPathRuntimeModule;

package/dist/module/runtime/PublicPathRuntimeModule.js

@@ -0,0 +1,44 @@
+"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 RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const RuntimeModule_1 = __importDefault(require("../RuntimeModule"));
+class PublicPathRuntimeModule extends RuntimeModule_1.default {
+    constructor(publicPath) {
+        super('publicPath', RuntimeModule_1.default.STAGE_BASIC);
+        this.publicPath = publicPath;
+    }
+    generate() {
+        const { publicPath } = this;
+        const compilation = this.compilation;
+        return `${RuntimeGlobals.publicPath} = ${JSON.stringify(compilation.getPath(publicPath || '', {
+            hash: compilation.hash || 'XXXX',
+        }))};`;
+    }
+}
+exports.default = PublicPathRuntimeModule;

package/dist/module/runtime/RelativeUrlRuntimeModule.d.ts

@@ -0,0 +1,6 @@
+import HelperRuntimeModule from './HelperRuntimeModule';
+declare class RelativeUrlRuntimeModule extends HelperRuntimeModule {
+    constructor();
+    generate(): string;
+}
+export default RelativeUrlRuntimeModule;

package/dist/module/runtime/RelativeUrlRuntimeModule.js

@@ -0,0 +1,56 @@
+"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 RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const HelperRuntimeModule_1 = __importDefault(require("./HelperRuntimeModule"));
+class RelativeUrlRuntimeModule extends HelperRuntimeModule_1.default {
+    constructor() {
+        super('relative url');
+    }
+    generate() {
+        const compilation = this.compilation;
+        const { runtimeTemplate } = compilation;
+        return Template_1.Template.asString([
+            `${RuntimeGlobals.relativeUrl} = function RelativeURL(url) {`,
+            Template_1.Template.indent([
+                'var realUrl = new URL(url, "x:/");',
+                'var values = {};',
+                'for (var key in realUrl) values[key] = realUrl[key];',
+                'values.href = url;',
+                'values.pathname = url.replace(/[?#].*/, "");',
+                'values.origin = values.protocol = "";',
+                `values.toString = values.toJSON = ${runtimeTemplate.returningFunction('url')};`,
+                'for (var key in values) Object.defineProperty(this, key, { enumerable: true, configurable: true, value: values[key] });',
+            ]),
+            '};',
+            `${RuntimeGlobals.relativeUrl}.prototype = URL.prototype;`,
+        ]);
+    }
+}
+exports.default = RelativeUrlRuntimeModule;

package/dist/module/runtime/RuntimeIdRuntimeModule.d.ts

@@ -0,0 +1,6 @@
+import RuntimeModule from '../RuntimeModule';
+declare class RuntimeIdRuntimeModule extends RuntimeModule {
+    constructor();
+    generate(): string;
+}
+export default RuntimeIdRuntimeModule;

package/dist/module/runtime/RuntimeIdRuntimeModule.js

@@ -0,0 +1,45 @@
+"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 RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const RuntimeModule_1 = __importDefault(require("../RuntimeModule"));
+class RuntimeIdRuntimeModule extends RuntimeModule_1.default {
+    constructor() {
+        super('runtimeId');
+    }
+    generate() {
+        const chunkGraph = this.chunkGraph;
+        const chunk = this.chunk;
+        const runtime = chunk.runtime;
+        if (typeof runtime !== 'string')
+            throw new Error('RuntimeIdRuntimeModule must be in a single runtime');
+        const id = chunkGraph.getRuntimeId(runtime);
+        return `${RuntimeGlobals.runtimeId} = ${JSON.stringify(id)};`;
+    }
+}
+exports.default = RuntimeIdRuntimeModule;

package/dist/module/runtime/StartupChunkDependenciesPlugin.d.ts

@@ -0,0 +1,11 @@
+interface Options {
+    chunkLoading: any;
+    asyncChunkLoading?: boolean;
+}
+declare class StartupChunkDependenciesPlugin {
+    chunkLoading: any;
+    asyncChunkLoading: any;
+    constructor(options: Options);
+    apply(compiler: any): void;
+}
+export default StartupChunkDependenciesPlugin;

package/dist/module/runtime/StartupChunkDependenciesPlugin.js

@@ -0,0 +1,69 @@
+"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 RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const StartupChunkDependenciesRuntimeModule_1 = __importDefault(require("./StartupChunkDependenciesRuntimeModule"));
+const StartupEntrypointRuntimeModule_1 = __importDefault(require("./StartupEntrypointRuntimeModule"));
+class StartupChunkDependenciesPlugin {
+    constructor(options) {
+        this.chunkLoading = options.chunkLoading;
+        this.asyncChunkLoading =
+            typeof options.asyncChunkLoading === 'boolean' ? options.asyncChunkLoading : true;
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap('StartupChunkDependenciesPlugin', compilation => {
+            const globalChunkLoading = compilation.outputOptions.chunkLoading;
+            const isEnabledForChunk = chunk => {
+                const options = chunk.getEntryOptions();
+                const chunkLoading = (options === null || options === void 0 ? void 0 : options.chunkLoading) !== undefined ? options.chunkLoading : globalChunkLoading;
+                return chunkLoading === this.chunkLoading;
+            };
+            compilation.hooks.additionalTreeRuntimeRequirements.tap('StartupChunkDependenciesPlugin', (chunk, set, { chunkGraph }) => {
+                if (!isEnabledForChunk(chunk))
+                    return;
+                if (chunkGraph.hasChunkEntryDependentChunks(chunk)) {
+                    set.add(RuntimeGlobals.startup);
+                    set.add(RuntimeGlobals.ensureChunk);
+                    set.add(RuntimeGlobals.ensureChunkIncludeEntries);
+                    compilation.addRuntimeModule(chunk, new StartupChunkDependenciesRuntimeModule_1.default(this.asyncChunkLoading));
+                }
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.startupEntrypoint)
+                .tap('StartupChunkDependenciesPlugin', (chunk, set) => {
+                if (!isEnabledForChunk(chunk))
+                    return;
+                set.add(RuntimeGlobals.require);
+                set.add(RuntimeGlobals.ensureChunk);
+                set.add(RuntimeGlobals.ensureChunkIncludeEntries);
+                compilation.addRuntimeModule(chunk, new StartupEntrypointRuntimeModule_1.default(this.asyncChunkLoading));
+            });
+        });
+    }
+}
+exports.default = StartupChunkDependenciesPlugin;

package/dist/module/runtime/StartupChunkDependenciesRuntimeModule.d.ts

@@ -0,0 +1,7 @@
+import RuntimeModule from '../RuntimeModule';
+declare class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
+    asyncChunkLoading: boolean;
+    constructor(asyncChunkLoading: boolean);
+    generate(): string;
+}
+export default StartupChunkDependenciesRuntimeModule;

package/dist/module/runtime/StartupChunkDependenciesRuntimeModule.js

@@ -0,0 +1,67 @@
+"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 RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const RuntimeModule_1 = __importDefault(require("../RuntimeModule"));
+class StartupChunkDependenciesRuntimeModule extends RuntimeModule_1.default {
+    constructor(asyncChunkLoading) {
+        super('startup chunk dependencies', RuntimeModule_1.default.STAGE_TRIGGER);
+        this.asyncChunkLoading = asyncChunkLoading;
+    }
+    generate() {
+        const chunkGraph = this.chunkGraph;
+        const chunk = this.chunk;
+        const chunkIds = Array.from(chunkGraph.getChunkEntryDependentChunksIterable(chunk)).map((chunk) => chunk.id);
+        const compilation = this.compilation;
+        const { runtimeTemplate } = compilation;
+        return Template_1.Template.asString([
+            `var next = ${RuntimeGlobals.startup};`,
+            `${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction('', !this.asyncChunkLoading
+                ? chunkIds
+                    .map(id => `${RuntimeGlobals.ensureChunk}(${JSON.stringify(id)});`)
+                    .concat('return next();')
+                : chunkIds.length === 1
+                    ? `return ${RuntimeGlobals.ensureChunk}(${JSON.stringify(chunkIds[0])}).then(next);`
+                    : chunkIds.length > 2
+                        ? [
+                            // using map is shorter for 3 or more chunks
+                            `return Promise.all(${JSON.stringify(chunkIds)}.map(${RuntimeGlobals.ensureChunk}, ${RuntimeGlobals.require})).then(next);`,
+                        ]
+                        : [
+                            // calling ensureChunk directly is shorter for 0 - 2 chunks
+                            'return Promise.all([',
+                            Template_1.Template.indent(chunkIds
+                                .map(id => `${RuntimeGlobals.ensureChunk}(${JSON.stringify(id)})`)
+                                .join(',\n')),
+                            ']).then(next);',
+                        ])};`,
+        ]);
+    }
+}
+exports.default = StartupChunkDependenciesRuntimeModule;