xhs-mp-pack 1.1.0-beta.0

package/dist/template/LibraryTemplatePlugin.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const EnableLibraryPlugin_1 = __importDefault(require("../library/EnableLibraryPlugin"));
+class LibraryTemplatePlugin {
+    constructor(name, target, umdNamedDefine, auxiliaryComment, exportProperty) {
+        this.library = {
+            type: target || 'var',
+            name,
+            umdNamedDefine,
+            auxiliaryComment,
+            export: exportProperty,
+        };
+    }
+    apply(compiler) {
+        const { output } = compiler.options;
+        output.library = this.library;
+        new EnableLibraryPlugin_1.default(this.library.type).apply(compiler);
+    }
+}
+exports.default = LibraryTemplatePlugin;

package/dist/template/MainTemplate.d.ts

@@ -0,0 +1,10 @@
+declare class MainTemplate {
+    _outputOptions: any;
+    hooks: any;
+    renderCurrentHashCode: (hash: any, length: any) => string;
+    getPublicPath: (options: any) => any;
+    getAssetPath: (path: any, options: any) => any;
+    getAssetPathWithInfo: (path: any, options: any) => any;
+    constructor(outputOptions: any, compilation: any);
+}
+export default MainTemplate;

package/dist/template/MainTemplate.js

@@ -0,0 +1,177 @@
+"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 util_1 = __importDefault(require("util"));
+const RuntimeGlobals = __importStar(require("../module/RuntimeGlobals"));
+const JavascriptModulesPlugin_1 = require("../module/javascript/JavascriptModulesPlugin");
+const LoadScriptRuntimeModule_1 = __importDefault(require("../module/runtime/LoadScriptRuntimeModule"));
+class MainTemplate {
+    constructor(outputOptions, compilation) {
+        this._outputOptions = outputOptions || {};
+        this.hooks = Object.freeze({
+            renderManifest: {
+                tap: util_1.default.deprecate((options, fn) => {
+                    compilation.hooks.renderManifest.tap(options, (entries, options) => {
+                        if (!options.chunk.hasRuntime())
+                            return entries;
+                        return fn(entries, options);
+                    });
+                }, 'MainTemplate.hooks.renderManifest is deprecated (use Compilation.hooks.renderManifest instead)', 'DEP_WEBPACK_MAIN_TEMPLATE_RENDER_MANIFEST'),
+            },
+            modules: {
+                tap: () => {
+                    throw new Error('MainTemplate.hooks.modules has been removed (there is no replacement, please create an issue to request that)');
+                },
+            },
+            moduleObj: {
+                tap: () => {
+                    throw new Error('MainTemplate.hooks.moduleObj has been removed (there is no replacement, please create an issue to request that)');
+                },
+            },
+            require: {
+                tap: util_1.default.deprecate((options, fn) => {
+                    JavascriptModulesPlugin_1.JavascriptModulesPlugin.getCompilationHooks(compilation).renderRequire.tap(options, fn);
+                }, 'MainTemplate.hooks.require is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderRequire instead)', 'DEP_WEBPACK_MAIN_TEMPLATE_REQUIRE'),
+            },
+            beforeStartup: {
+                tap: () => {
+                    throw new Error('MainTemplate.hooks.beforeStartup has been removed (use RuntimeGlobals.startupOnlyBefore instead)');
+                },
+            },
+            startup: {
+                tap: () => {
+                    throw new Error('MainTemplate.hooks.startup has been removed (use RuntimeGlobals.startup instead)');
+                },
+            },
+            afterStartup: {
+                tap: () => {
+                    throw new Error('MainTemplate.hooks.afterStartup has been removed (use RuntimeGlobals.startupOnlyAfter instead)');
+                },
+            },
+            render: {
+                tap: util_1.default.deprecate((options, fn) => {
+                    JavascriptModulesPlugin_1.JavascriptModulesPlugin.getCompilationHooks(compilation).render.tap(options, (source, renderContext) => {
+                        if (renderContext.chunkGraph.getNumberOfEntryModules(renderContext.chunk) === 0 ||
+                            !renderContext.chunk.hasRuntime()) {
+                            return source;
+                        }
+                        return fn(source, renderContext.chunk, compilation.hash, compilation.moduleTemplates.javascript, compilation.dependencyTemplates);
+                    });
+                }, 'MainTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)', 'DEP_WEBPACK_MAIN_TEMPLATE_RENDER'),
+            },
+            renderWithEntry: {
+                tap: util_1.default.deprecate((options, fn) => {
+                    JavascriptModulesPlugin_1.JavascriptModulesPlugin.getCompilationHooks(compilation).render.tap(options, (source, renderContext) => {
+                        if (renderContext.chunkGraph.getNumberOfEntryModules(renderContext.chunk) === 0 ||
+                            !renderContext.chunk.hasRuntime()) {
+                            return source;
+                        }
+                        return fn(source, renderContext.chunk, compilation.hash);
+                    });
+                }, 'MainTemplate.hooks.renderWithEntry is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)', 'DEP_WEBPACK_MAIN_TEMPLATE_RENDER_WITH_ENTRY'),
+            },
+            assetPath: {
+                tap: util_1.default.deprecate((options, fn) => {
+                    compilation.hooks.assetPath.tap(options, fn);
+                }, 'MainTemplate.hooks.assetPath is deprecated (use Compilation.hooks.assetPath instead)', 'DEP_WEBPACK_MAIN_TEMPLATE_ASSET_PATH'),
+                call: util_1.default.deprecate((filename, options) => compilation.getAssetPath(filename, options), 'MainTemplate.hooks.assetPath is deprecated (use Compilation.hooks.assetPath instead)', 'DEP_WEBPACK_MAIN_TEMPLATE_ASSET_PATH'),
+            },
+            hash: {
+                tap: util_1.default.deprecate((options, fn) => {
+                    compilation.hooks.fullHash.tap(options, fn);
+                }, 'MainTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)', 'DEP_WEBPACK_MAIN_TEMPLATE_HASH'),
+            },
+            hashForChunk: {
+                tap: util_1.default.deprecate((options, fn) => {
+                    JavascriptModulesPlugin_1.JavascriptModulesPlugin.getCompilationHooks(compilation).chunkHash.tap(options, (chunk, hash) => {
+                        if (!chunk.hasRuntime())
+                            return;
+                        return fn(hash, chunk);
+                    });
+                }, 'MainTemplate.hooks.hashForChunk is deprecated (use JavascriptModulesPlugin.getCompilationHooks().chunkHash instead)', 'DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK'),
+            },
+            globalHashPaths: {
+                tap: util_1.default.deprecate(() => { }, "MainTemplate.hooks.globalHashPaths has been removed (it's no longer needed)", 'DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK'),
+            },
+            globalHash: {
+                tap: util_1.default.deprecate(() => { }, "MainTemplate.hooks.globalHash has been removed (it's no longer needed)", 'DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK'),
+            },
+            hotBootstrap: {
+                tap: () => {
+                    throw new Error('MainTemplate.hooks.hotBootstrap has been removed (use your own RuntimeModule instead)');
+                },
+            },
+            bootstrap: new tapable_1.SyncWaterfallHook([
+                'source',
+                'chunk',
+                'hash',
+                'moduleTemplate',
+                'dependencyTemplates',
+            ]),
+            localVars: new tapable_1.SyncWaterfallHook(['source', 'chunk', 'hash']),
+            requireExtensions: new tapable_1.SyncWaterfallHook(['source', 'chunk', 'hash']),
+            requireEnsure: new tapable_1.SyncWaterfallHook([
+                'source',
+                'chunk',
+                'hash',
+                'chunkIdExpression',
+            ]),
+            get jsonpScript() {
+                const hooks = LoadScriptRuntimeModule_1.default.getCompilationHooks(compilation);
+                return hooks.createScript;
+            },
+            // get linkPrefetch() {
+            //   const hooks = JsonpTemplatePlugin.getCompilationHooks(compilation)
+            //   return hooks.linkPrefetch
+            // },
+            // get linkPreload() {
+            //   const hooks = JsonpTemplatePlugin.getCompilationHooks(compilation)
+            //   return hooks.linkPreload
+            // },
+        });
+        this.renderCurrentHashCode = util_1.default.deprecate((hash, length) => {
+            if (length) {
+                return `${RuntimeGlobals.getFullHash} ? ${RuntimeGlobals.getFullHash}().slice(0, ${length}) : ${hash.slice(0, length)}`;
+            }
+            return `${RuntimeGlobals.getFullHash} ? ${RuntimeGlobals.getFullHash}() : ${hash}`;
+        }, 'MainTemplate.renderCurrentHashCode is deprecated (use RuntimeGlobals.getFullHash runtime function instead)', 'DEP_WEBPACK_MAIN_TEMPLATE_RENDER_CURRENT_HASH_CODE');
+        this.getPublicPath = util_1.default.deprecate(options => compilation.getAssetPath(compilation.outputOptions.publicPath, options), 'MainTemplate.getPublicPath is deprecated (use Compilation.getAssetPath(compilation.outputOptions.publicPath, options) instead)', 'DEP_WEBPACK_MAIN_TEMPLATE_GET_PUBLIC_PATH');
+        this.getAssetPath = util_1.default.deprecate((path, options) => compilation.getAssetPath(path, options), 'MainTemplate.getAssetPath is deprecated (use Compilation.getAssetPath instead)', 'DEP_WEBPACK_MAIN_TEMPLATE_GET_ASSET_PATH');
+        this.getAssetPathWithInfo = util_1.default.deprecate((path, options) => compilation.getAssetPathWithInfo(path, options), 'MainTemplate.getAssetPathWithInfo is deprecated (use Compilation.getAssetPath instead)', 'DEP_WEBPACK_MAIN_TEMPLATE_GET_ASSET_PATH_WITH_INFO');
+    }
+}
+Object.defineProperty(MainTemplate.prototype, 'requireFn', {
+    get: util_1.default.deprecate(() => RuntimeGlobals.require, `MainTemplate.requireFn is deprecated (use "${RuntimeGlobals.require}")`, 'DEP_WEBPACK_MAIN_TEMPLATE_REQUIRE_FN'),
+});
+Object.defineProperty(MainTemplate.prototype, 'outputOptions', {
+    get: util_1.default.deprecate(function () {
+        return this._outputOptions;
+    }, 'MainTemplate.outputOptions is deprecated (use Compilation.outputOptions instead)', 'DEP_WEBPACK_MAIN_TEMPLATE_OUTPUT_OPTIONS'),
+});
+exports.default = MainTemplate;

package/dist/template/ModuleTemplate.d.ts

@@ -0,0 +1,7 @@
+declare class ModuleTemplate {
+    _runtimeTemplate: any;
+    type: string;
+    hooks: any;
+    constructor(runtimeTemplate: any, compilation: any);
+}
+export default ModuleTemplate;

package/dist/template/ModuleTemplate.js

@@ -0,0 +1,46 @@
+"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 JavascriptModulesPlugin_1 = require("../module/javascript/JavascriptModulesPlugin");
+class ModuleTemplate {
+    constructor(runtimeTemplate, compilation) {
+        this._runtimeTemplate = runtimeTemplate;
+        this.type = 'javascript';
+        this.hooks = Object.freeze({
+            content: {
+                tap: util_1.default.deprecate((options, fn) => {
+                    JavascriptModulesPlugin_1.JavascriptModulesPlugin.getCompilationHooks(compilation).renderModuleContent.tap(options, (source, module, renderContext) => fn(source, module, renderContext, renderContext.dependencyTemplates));
+                }, 'ModuleTemplate.hooks.content is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContent instead)', 'DEP_MODULE_TEMPLATE_CONTENT'),
+            },
+            module: {
+                tap: util_1.default.deprecate((options, fn) => {
+                    JavascriptModulesPlugin_1.JavascriptModulesPlugin.getCompilationHooks(compilation).renderModuleContent.tap(options, (source, module, renderContext) => fn(source, module, renderContext, renderContext.dependencyTemplates));
+                }, 'ModuleTemplate.hooks.module is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContent instead)', 'DEP_MODULE_TEMPLATE_MODULE'),
+            },
+            render: {
+                tap: util_1.default.deprecate((options, fn) => {
+                    JavascriptModulesPlugin_1.JavascriptModulesPlugin.getCompilationHooks(compilation).renderModuleContainer.tap(options, (source, module, renderContext) => fn(source, module, renderContext, renderContext.dependencyTemplates));
+                }, 'ModuleTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContainer instead)', 'DEP_MODULE_TEMPLATE_RENDER'),
+            },
+            package: {
+                tap: util_1.default.deprecate((options, fn) => {
+                    JavascriptModulesPlugin_1.JavascriptModulesPlugin.getCompilationHooks(compilation).renderModulePackage.tap(options, (source, module, renderContext) => fn(source, module, renderContext, renderContext.dependencyTemplates));
+                }, 'ModuleTemplate.hooks.package is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModulePackage instead)', 'DEP_MODULE_TEMPLATE_PACKAGE'),
+            },
+            hash: {
+                tap: util_1.default.deprecate((options, fn) => {
+                    compilation.hooks.fullHash.tap(options, fn);
+                }, 'ModuleTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)', 'DEP_MODULE_TEMPLATE_HASH'),
+            },
+        });
+    }
+}
+Object.defineProperty(ModuleTemplate.prototype, 'runtimeTemplate', {
+    get: util_1.default.deprecate(function () {
+        return this._runtimeTemplate;
+    }, 'ModuleTemplate.runtimeTemplate is deprecated (use Compilation.runtimeTemplate instead)', 'DEP_WEBPACK_CHUNK_TEMPLATE_OUTPUT_OPTIONS'),
+});
+exports.default = ModuleTemplate;

package/dist/template/RuntimeTemplate.d.ts

@@ -0,0 +1,158 @@
+import Module from '../module/Module';
+import ChunkGraph from '../chunk/ChunkGraph';
+interface ICommonOptions {
+    request?: string;
+    chunkName?: string;
+    chunkReason?: string;
+    message?: string;
+    exportName?: string;
+}
+interface IModuleIdOptions {
+    module: Module;
+    chunkGraph: ChunkGraph;
+    request: string;
+    weak?: boolean;
+}
+interface IWeakErrorOptions {
+    chunkGraph: ChunkGraph;
+    module: Module;
+    request: string;
+    idExpr?: string;
+    type: 'expression' | 'promise' | 'statements';
+}
+declare class RuntimeTemplate {
+    compilation: any;
+    outputOptions: any;
+    requestShortener: any;
+    globalObject: any;
+    contentHashReplacement: string;
+    constructor(compilation: any, outputOptions: any, requestShortener: any);
+    isIIFE(): any;
+    isModule(): any;
+    supportsConst(): any;
+    supportsArrowFunction(): any;
+    supportsOptionalChaining(): any;
+    supportsForOf(): any;
+    supportsDestructuring(): any;
+    supportsBigIntLiteral(): any;
+    supportsDynamicImport(): any;
+    supportsEcmaScriptModuleSyntax(): any;
+    supportTemplateLiteral(): any;
+    returningFunction(returnValue: any, args?: string): string;
+    basicFunction(args: any, body: any): string;
+    concatenation(...args: any[]): any;
+    _es5Concatenation(args: any): any;
+    expressionFunction(expression: any, args?: string): string;
+    emptyFunction(): "x => {}" | "function() {}";
+    destructureArray(items: any, value: any): string;
+    destructureObject(items: any, value: any): string;
+    iife(args: any, body: any): string;
+    forEach(variable: any, array: any, body: any): string;
+    /**
+     * Add a comment
+     */
+    comment({ request, chunkName, chunkReason, message, exportName }: ICommonOptions): string;
+    throwMissingModuleErrorBlock({ request }: {
+        request?: string;
+    }): string;
+    throwMissingModuleErrorFunction({ request }: {
+        request?: string;
+    }): string;
+    missingModule({ request }: {
+        request?: string;
+    }): string;
+    missingModuleStatement({ request }: {
+        request?: string;
+    }): string;
+    missingModulePromise({ request }: {
+        request?: string;
+    }): string;
+    weakError({ module, chunkGraph, request, idExpr, type }: IWeakErrorOptions): string | undefined;
+    moduleId({ module, chunkGraph, request, weak }: IModuleIdOptions): string;
+    moduleRaw({ module, chunkGraph, request, weak, runtimeRequirements }: any): string | undefined;
+    moduleExports({ module, chunkGraph, request, weak, runtimeRequirements }: {
+        module: any;
+        chunkGraph: any;
+        request: any;
+        weak: any;
+        runtimeRequirements: any;
+    }): string | undefined;
+    moduleNamespace({ module, chunkGraph, request, strict, weak, runtimeRequirements }: {
+        module: any;
+        chunkGraph: any;
+        request: any;
+        strict: any;
+        weak: any;
+        runtimeRequirements: any;
+    }): string | undefined;
+    moduleNamespacePromise({ chunkGraph, block, module, request, message, strict, weak, runtimeRequirements, }: {
+        chunkGraph: any;
+        block: any;
+        module: any;
+        request: any;
+        message: any;
+        strict: any;
+        weak: any;
+        runtimeRequirements: any;
+    }): string | undefined;
+    runtimeConditionExpression({ chunkGraph, runtimeCondition, runtime, runtimeRequirements }: {
+        chunkGraph: any;
+        runtimeCondition: any;
+        runtime: any;
+        runtimeRequirements: any;
+    }): string;
+    importStatement({ update, module, chunkGraph, request, importVar, originModule, weak, runtimeRequirements, }: {
+        update: any;
+        module: any;
+        chunkGraph: any;
+        request: any;
+        importVar: any;
+        originModule: any;
+        weak: any;
+        runtimeRequirements: any;
+    }): (string | undefined)[];
+    exportFromImport({ moduleGraph, module, request, exportName, originModule, asiSafe, isCall, callContext, defaultInterop, importVar, initFragments, runtime, runtimeRequirements, }: {
+        moduleGraph: any;
+        module: any;
+        request: any;
+        exportName: any;
+        originModule: any;
+        asiSafe: any;
+        isCall: any;
+        callContext: any;
+        defaultInterop: any;
+        importVar: any;
+        initFragments: any;
+        runtime: any;
+        runtimeRequirements: any;
+    }): any;
+    blockPromise({ block, message, chunkGraph, runtimeRequirements }: {
+        block: any;
+        message: any;
+        chunkGraph: any;
+        runtimeRequirements: any;
+    }): string;
+    asyncModuleFactory({ block, chunkGraph, runtimeRequirements, request }: {
+        block: any;
+        chunkGraph: any;
+        runtimeRequirements: any;
+        request: any;
+    }): string;
+    syncModuleFactory({ dependency, chunkGraph, runtimeRequirements, request }: {
+        dependency: any;
+        chunkGraph: any;
+        runtimeRequirements: any;
+        request: any;
+    }): string;
+    defineEsModuleFlagStatement({ exportsArgument, runtimeRequirements }: {
+        exportsArgument: any;
+        runtimeRequirements: any;
+    }): string;
+    assetUrl({ publicPath, runtime, module, codeGenerationResults }: {
+        publicPath: any;
+        runtime: any;
+        module: any;
+        codeGenerationResults: any;
+    }): any;
+}
+export default RuntimeTemplate;