xhs-mp-pack 1.1.0-beta.0

package/dist/dependencies/harmony/HarmonyExportInitFragment.d.ts

@@ -0,0 +1,14 @@
+import InitFragment from '@/base/InitFragment';
+declare class HarmonyExportInitFragment extends InitFragment {
+    exportsArgument: string;
+    exportMap: Map<string, string>;
+    unusedExports: Set<string>;
+    constructor(exportsArgument: string, exportMap?: Map<any, any>, unusedExports?: Set<unknown>);
+    mergeAll(fragments: HarmonyExportInitFragment[]): HarmonyExportInitFragment;
+    merge(other: any): HarmonyExportInitFragment;
+    getContent({ runtimeTemplate, runtimeRequirements }: {
+        runtimeTemplate: any;
+        runtimeRequirements: any;
+    }): string;
+}
+export default HarmonyExportInitFragment;

package/dist/dependencies/harmony/HarmonyExportInitFragment.js

@@ -0,0 +1,147 @@
+"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 InitFragment_1 = __importDefault(require("@/base/InitFragment"));
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const SetHelpers_1 = require("@/base/SetHelpers");
+const propertyName_1 = require("@/base/propertyName");
+const joinIterableWithComma = iterable => {
+    // This is more performant than Array.from().join(", ")
+    // as it doesn't create an array
+    let str = '';
+    let first = true;
+    for (const item of iterable) {
+        if (first) {
+            first = false;
+        }
+        else {
+            str += ', ';
+        }
+        str += item;
+    }
+    return str;
+};
+const EMPTY_MAP = new Map();
+const EMPTY_SET = new Set();
+class HarmonyExportInitFragment extends InitFragment_1.default {
+    constructor(exportsArgument, exportMap = EMPTY_MAP, unusedExports = EMPTY_SET) {
+        super('', InitFragment_1.default.STAGE_HARMONY_EXPORTS, 1, 'harmony-exports');
+        this.exportsArgument = exportsArgument;
+        this.exportMap = exportMap;
+        this.unusedExports = unusedExports;
+    }
+    mergeAll(fragments) {
+        let exportMap;
+        let exportMapOwned = false;
+        let unusedExports;
+        let unusedExportsOwned = false;
+        for (const fragment of fragments) {
+            if (fragment.exportMap.size !== 0) {
+                if (exportMap === undefined) {
+                    exportMap = fragment.exportMap;
+                    exportMapOwned = false;
+                }
+                else {
+                    if (!exportMapOwned) {
+                        exportMap = new Map(exportMap);
+                        exportMapOwned = true;
+                    }
+                    for (const [key, value] of fragment.exportMap) {
+                        if (!exportMap.has(key))
+                            exportMap.set(key, value);
+                    }
+                }
+            }
+            if (fragment.unusedExports.size !== 0) {
+                if (unusedExports === undefined) {
+                    unusedExports = fragment.unusedExports;
+                    unusedExportsOwned = false;
+                }
+                else {
+                    if (!unusedExportsOwned) {
+                        unusedExports = new Set(unusedExports);
+                        unusedExportsOwned = true;
+                    }
+                    for (const value of fragment.unusedExports) {
+                        unusedExports.add(value);
+                    }
+                }
+            }
+        }
+        return new HarmonyExportInitFragment(this.exportsArgument, exportMap, unusedExports);
+    }
+    merge(other) {
+        let exportMap;
+        if (this.exportMap.size === 0) {
+            exportMap = other.exportMap;
+        }
+        else if (other.exportMap.size === 0) {
+            exportMap = this.exportMap;
+        }
+        else {
+            exportMap = new Map(other.exportMap);
+            for (const [key, value] of this.exportMap) {
+                if (!exportMap.has(key))
+                    exportMap.set(key, value);
+            }
+        }
+        let unusedExports;
+        if (this.unusedExports.size === 0) {
+            unusedExports = other.unusedExports;
+        }
+        else if (other.unusedExports.size === 0) {
+            unusedExports = this.unusedExports;
+        }
+        else {
+            unusedExports = new Set(other.unusedExports);
+            for (const value of this.unusedExports) {
+                unusedExports.add(value);
+            }
+        }
+        return new HarmonyExportInitFragment(this.exportsArgument, exportMap, unusedExports);
+    }
+    getContent({ runtimeTemplate, runtimeRequirements }) {
+        runtimeRequirements.add(RuntimeGlobals.exports);
+        runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+        const unusedPart = this.unusedExports.size > 1
+            ? `/* unused harmony exports ${joinIterableWithComma(this.unusedExports)} */\n`
+            : this.unusedExports.size > 0
+                ? `/* unused harmony export ${(0, SetHelpers_1.first)(this.unusedExports)} */\n`
+                : '';
+        const definitions = [];
+        const orderedExportMap = Array.from(this.exportMap).sort(([a], [b]) => (a < b ? -1 : 1));
+        for (const [key, value] of orderedExportMap) {
+            definitions.push(`\n/* harmony export */   ${(0, propertyName_1.propertyName)(key)}: ${runtimeTemplate.returningFunction(value)}`);
+        }
+        const definePart = this.exportMap.size > 0
+            ? `/* harmony export */ ${RuntimeGlobals.definePropertyGetters}(${this.exportsArgument}, {${definitions.join(',')}\n/* harmony export */ });\n`
+            : '';
+        return `${definePart}${unusedPart}`;
+    }
+}
+exports.default = HarmonyExportInitFragment;

package/dist/dependencies/harmony/HarmonyExportSpecifierDependency.d.ts

@@ -0,0 +1,17 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class HarmonyExportSpecifierDependency extends NullDependency {
+    id: any;
+    name: any;
+    constructor(id: any, name: any);
+    get type(): string;
+    getExports(moduleGraph: any): {
+        exports: any[];
+        priority: number;
+        terminalBinding: boolean;
+        dependencies: undefined;
+    };
+    getModuleEvaluationSideEffectsState(moduleGraph: any): boolean;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default HarmonyExportSpecifierDependency;

package/dist/dependencies/harmony/HarmonyExportSpecifierDependency.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const NullDependency_1 = __importDefault(require("@/dependencies/NullDependency"));
+const HarmonyExportInitFragment_1 = __importDefault(require("./HarmonyExportInitFragment"));
+class HarmonyExportSpecifierDependency extends NullDependency_1.default {
+    constructor(id, name) {
+        super();
+        this.id = id;
+        this.name = name;
+    }
+    get type() {
+        return 'harmony export specifier';
+    }
+    getExports(moduleGraph) {
+        return {
+            exports: [this.name],
+            priority: 1,
+            terminalBinding: true,
+            dependencies: undefined,
+        };
+    }
+    getModuleEvaluationSideEffectsState(moduleGraph) {
+        return false;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.id);
+        write(this.name);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.id = read();
+        this.name = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(HarmonyExportSpecifierDependency, 'mp-compiler/core/dependencies/HarmonyExportSpecifierDependency');
+HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependencyTemplate extends (NullDependency_1.default.Template) {
+    apply(dependency, source, { module, moduleGraph, initFragments, runtime, concatenationScope }) {
+        const dep = dependency;
+        if (concatenationScope) {
+            concatenationScope.registerExport(dep.name, dep.id);
+            return;
+        }
+        const used = moduleGraph.getExportsInfo(module).getUsedName(dep.name, runtime);
+        if (!used) {
+            const set = new Set();
+            set.add(dep.name || 'namespace');
+            initFragments.push(new HarmonyExportInitFragment_1.default(module.exportsArgument, undefined, set));
+            return;
+        }
+        const map = new Map();
+        map.set(used, `/* binding */ ${dep.id}`);
+        initFragments.push(new HarmonyExportInitFragment_1.default(module.exportsArgument, map, undefined));
+    }
+};
+exports.default = HarmonyExportSpecifierDependency;

package/dist/dependencies/harmony/HarmonyExports.d.ts

@@ -0,0 +1,3 @@
+declare const enable: (parserState: any, isStrictHarmony: any) => void;
+declare const isEnabled: (parserState: any) => boolean;
+export { enable, isEnabled };

package/dist/dependencies/harmony/HarmonyExports.js

@@ -0,0 +1,51 @@
+"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 });
+exports.isEnabled = exports.enable = void 0;
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const parserStateExportsState = new WeakMap();
+const enable = (parserState, isStrictHarmony) => {
+    const value = parserStateExportsState.get(parserState);
+    if (value === false)
+        return;
+    parserStateExportsState.set(parserState, true);
+    if (value !== true) {
+        const buildMeta = parserState.module.buildMeta;
+        buildMeta.exportsType = 'namespace';
+        const buildInfo = parserState.module.buildInfo;
+        buildInfo.strict = true;
+        buildInfo.exportsArgument = RuntimeGlobals.exports;
+        if (isStrictHarmony) {
+            buildMeta.strictHarmonyModule = true;
+            buildInfo.moduleArgument = '__webpack_module__';
+        }
+    }
+};
+exports.enable = enable;
+const isEnabled = parserState => {
+    const value = parserStateExportsState.get(parserState);
+    return value === true;
+};
+exports.isEnabled = isEnabled;

package/dist/dependencies/harmony/HarmonyImportDependency.d.ts

@@ -0,0 +1,30 @@
+import HarmonyLinkingError from '@/base/errors/HarmonyLinkingError';
+import ModuleDependency from '@/dependencies/ModuleDependency';
+declare const ExportPresenceModes: {
+    NONE: number;
+    WARN: number;
+    AUTO: number;
+    ERROR: number;
+    fromUserOption(str: any): number;
+};
+declare class HarmonyImportDependency extends ModuleDependency {
+    sourceOrder: any;
+    assertions: any;
+    userRequest: any;
+    request: any;
+    constructor(request: string, sourceOrder: number, assertions?: any);
+    get category(): string;
+    getReferencedExports(moduleGraph: any, runtime: any): any;
+    getImportVar(moduleGraph: any): any;
+    getImportStatement(update: boolean, { runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }: {
+        runtimeTemplate: any;
+        module: any;
+        moduleGraph: any;
+        chunkGraph: any;
+        runtimeRequirements: any;
+    }): any;
+    getLinkingErrors(moduleGraph: any, ids: string[], additionalMessage: string): HarmonyLinkingError[] | undefined;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export { ExportPresenceModes, HarmonyImportDependency };

package/dist/dependencies/harmony/HarmonyImportDependency.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HarmonyImportDependency = exports.ExportPresenceModes = void 0;
+const ConditionalInitFragment_1 = __importDefault(require("@/base/ConditionalInitFragment"));
+const Dependency_1 = __importDefault(require("@/dependencies/Dependency"));
+const HarmonyLinkingError_1 = __importDefault(require("@/base/errors/HarmonyLinkingError"));
+const InitFragment_1 = __importDefault(require("@/base/InitFragment"));
+const Template_1 = require("@/template/Template");
+const AwaitDependenciesInitFragment_1 = __importDefault(require("@/module/async-modules/AwaitDependenciesInitFragment"));
+const RuntimeHelpers_1 = require("@/module/RuntimeHelpers");
+const ModuleDependency_1 = __importDefault(require("@/dependencies/ModuleDependency"));
+const ExportPresenceModes = {
+    NONE: 0,
+    WARN: 1,
+    AUTO: 2,
+    ERROR: 3,
+    fromUserOption(str) {
+        switch (str) {
+            case 'error':
+                return ExportPresenceModes.ERROR;
+            case 'warn':
+                return ExportPresenceModes.WARN;
+            case 'auto':
+                return ExportPresenceModes.AUTO;
+            case false:
+                return ExportPresenceModes.NONE;
+            default:
+                throw new Error(`Invalid export presence value ${str}`);
+        }
+    },
+};
+exports.ExportPresenceModes = ExportPresenceModes;
+class HarmonyImportDependency extends ModuleDependency_1.default {
+    constructor(request, sourceOrder, assertions) {
+        super(request);
+        this.sourceOrder = sourceOrder;
+        this.assertions = assertions;
+    }
+    get category() {
+        return 'esm';
+    }
+    getReferencedExports(moduleGraph, runtime) {
+        return Dependency_1.default.NO_EXPORTS_REFERENCED;
+    }
+    getImportVar(moduleGraph) {
+        const module = moduleGraph.getParentModule(this);
+        const meta = moduleGraph.getMeta(module);
+        let importVarMap = meta.importVarMap;
+        if (!importVarMap)
+            meta.importVarMap = importVarMap = new Map();
+        let importVar = importVarMap.get(moduleGraph.getModule(this));
+        if (importVar)
+            return importVar;
+        importVar = `${Template_1.Template.toIdentifier(`${this.userRequest}`)}__WEBPACK_IMPORTED_MODULE_${importVarMap.size}__`;
+        importVarMap.set(moduleGraph.getModule(this), importVar);
+        return importVar;
+    }
+    getImportStatement(update, { runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }) {
+        return runtimeTemplate.importStatement({
+            update,
+            module: moduleGraph.getModule(this),
+            chunkGraph,
+            importVar: this.getImportVar(moduleGraph),
+            request: this.request,
+            originModule: module,
+            runtimeRequirements,
+        });
+    }
+    getLinkingErrors(moduleGraph, ids, additionalMessage) {
+        const importedModule = moduleGraph.getModule(this);
+        // ignore errors for missing or failed modules
+        if (!importedModule || importedModule.getNumberOfErrors() > 0) {
+            return;
+        }
+        const parentModule = moduleGraph.getParentModule(this);
+        const exportsType = importedModule.getExportsType(moduleGraph, parentModule.buildMeta.strictHarmonyModule);
+        if (exportsType === 'namespace' || exportsType === 'default-with-named') {
+            if (ids.length === 0) {
+                return;
+            }
+            if ((exportsType !== 'default-with-named' || ids[0] !== 'default') &&
+                moduleGraph.isExportProvided(importedModule, ids) === false) {
+                // We are sure that it's not provided
+                // Try to provide detailed info in the error message
+                let pos = 0;
+                let exportsInfo = moduleGraph.getExportsInfo(importedModule);
+                while (pos < ids.length && exportsInfo) {
+                    const id = ids[pos++];
+                    const exportInfo = exportsInfo.getReadOnlyExportInfo(id);
+                    if (exportInfo.provided === false) {
+                        // We are sure that it's not provided
+                        const providedExports = exportsInfo.getProvidedExports();
+                        const moreInfo = !Array.isArray(providedExports)
+                            ? ' (possible exports unknown)'
+                            : providedExports.length === 0
+                                ? ' (module has no exports)'
+                                : ` (possible exports: ${providedExports.join(', ')})`;
+                        return [
+                            new HarmonyLinkingError_1.default(`export ${ids
+                                .slice(0, pos)
+                                .map(id => `'${id}'`)
+                                .join('.')} ${additionalMessage} was not found in '${this.userRequest}'${moreInfo}`),
+                        ];
+                    }
+                    exportsInfo = exportInfo.getNestedExportsInfo();
+                }
+                // General error message
+                return [
+                    new HarmonyLinkingError_1.default(`export ${ids.map(id => `'${id}'`).join('.')} ${additionalMessage} was not found in '${this.userRequest}'`),
+                ];
+            }
+        }
+        switch (exportsType) {
+            case 'default-only':
+                // It's has only a default export
+                if (ids.length > 0 && ids[0] !== 'default') {
+                    // In strict harmony modules we only support the default export
+                    return [
+                        new HarmonyLinkingError_1.default(`Can't import the named export ${ids
+                            .map(id => `'${id}'`)
+                            .join('.')} ${additionalMessage} from default-exporting module (only default export is available)`),
+                    ];
+                }
+                break;
+            case 'default-with-named':
+                // It has a default export and named properties redirect
+                // In some cases we still want to warn here
+                if (ids.length > 0 &&
+                    ids[0] !== 'default' &&
+                    importedModule.buildMeta.defaultObject === 'redirect-warn') {
+                    // For these modules only the default export is supported
+                    return [
+                        new HarmonyLinkingError_1.default(`Should not import the named export ${ids
+                            .map(id => `'${id}'`)
+                            .join('.')} ${additionalMessage} from default-exporting module (only default export is available soon)`),
+                    ];
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.sourceOrder);
+        write(this.assertions);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.sourceOrder = read();
+        this.assertions = read();
+        super.deserialize(context);
+    }
+}
+exports.HarmonyImportDependency = HarmonyImportDependency;
+const importEmittedMap = new WeakMap();
+HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends (ModuleDependency_1.default.Template) {
+    apply(dependency, source, templateContext) {
+        const dep = dependency;
+        const { module, chunkGraph, moduleGraph, runtime } = templateContext;
+        const connection = moduleGraph.getConnection(dep);
+        if (connection && !connection.isTargetActive(runtime))
+            return;
+        const referencedModule = connection === null || connection === void 0 ? void 0 : connection.module;
+        if ((connection === null || connection === void 0 ? void 0 : connection.weak) &&
+            referencedModule &&
+            chunkGraph.getModuleId(referencedModule) === null) {
+            // in weak references, module might not be in any chunk
+            // but that's ok, we don't need that logic in this case
+            return;
+        }
+        const moduleKey = referencedModule ? referencedModule.identifier() : dep.request;
+        const key = `harmony import ${moduleKey}`;
+        const runtimeCondition = dep.weak
+            ? false
+            : connection
+                ? (0, RuntimeHelpers_1.filterRuntime)(runtime, r => connection.isTargetActive(r))
+                : true;
+        if (module && referencedModule) {
+            let emittedModules = importEmittedMap.get(module);
+            if (emittedModules === undefined) {
+                emittedModules = new WeakMap();
+                importEmittedMap.set(module, emittedModules);
+            }
+            let mergedRuntimeCondition = runtimeCondition;
+            const oldRuntimeCondition = emittedModules.get(referencedModule) || false;
+            if (oldRuntimeCondition !== false && mergedRuntimeCondition !== true) {
+                if (mergedRuntimeCondition === false || oldRuntimeCondition === true) {
+                    mergedRuntimeCondition = oldRuntimeCondition;
+                }
+                else {
+                    mergedRuntimeCondition = (0, RuntimeHelpers_1.mergeRuntime)(oldRuntimeCondition, mergedRuntimeCondition);
+                }
+            }
+            emittedModules.set(referencedModule, mergedRuntimeCondition);
+        }
+        const importStatement = dep.getImportStatement(false, templateContext);
+        if (referencedModule && templateContext.moduleGraph.isAsync(referencedModule)) {
+            templateContext.initFragments.push(new ConditionalInitFragment_1.default(importStatement[0], InitFragment_1.default.STAGE_HARMONY_IMPORTS, dep.sourceOrder, key, runtimeCondition));
+            templateContext.initFragments.push(new AwaitDependenciesInitFragment_1.default(new Set([dep.getImportVar(templateContext.moduleGraph)])));
+            templateContext.initFragments.push(new ConditionalInitFragment_1.default(importStatement[1], InitFragment_1.default.STAGE_ASYNC_HARMONY_IMPORTS, dep.sourceOrder, `${key} compat`, runtimeCondition));
+        }
+        else {
+            templateContext.initFragments.push(new ConditionalInitFragment_1.default(importStatement[0] + importStatement[1], InitFragment_1.default.STAGE_HARMONY_IMPORTS, dep.sourceOrder, key, runtimeCondition));
+        }
+    }
+    static getImportEmittedRuntime(module, referencedModule) {
+        const emittedModules = importEmittedMap.get(module);
+        if (emittedModules === undefined)
+            return false;
+        return emittedModules.get(referencedModule) || false;
+    }
+};

package/dist/dependencies/harmony/HarmonyImportDependencyParserPlugin.d.ts

@@ -0,0 +1,9 @@
+declare const harmonySpecifierTag: unique symbol;
+declare function getAssertions(node: any): {} | undefined;
+declare class HarmonyImportDependencyParserPlugin {
+    exportPresenceMode: number;
+    strictThisContextOnImports: any;
+    constructor(options: any);
+    apply(parser: any): void;
+}
+export { getAssertions, HarmonyImportDependencyParserPlugin, harmonySpecifierTag };