xhs-mp-pack 1.1.0-beta.0

package/dist/module/asset/RawDataUrlModule.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_sources_1 = require("webpack-sources");
+const ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const Module_1 = __importDefault(require("../Module"));
+const TYPES = new Set(['javascript']);
+class RawDataUrlModule extends Module_1.default {
+    constructor(url, identifier, readableIdentifier) {
+        super(ModuleTypeConstants_1.ASSET_MODULE_TYPE_RAW_DATA_URL, null);
+        this.url = url;
+        // @ts-ignore
+        this.urlBuffer = url ? Buffer.from(url) : undefined;
+        this.identifierStr = identifier || this.url;
+        this.readableIdentifierStr = readableIdentifier || this.identifierStr;
+    }
+    getSourceTypes() {
+        return TYPES;
+    }
+    /**
+     * @returns {string} a unique identifier of the module
+     */
+    identifier() {
+        return this.identifierStr;
+    }
+    size(type) {
+        if (this.url === undefined)
+            this.url = this.urlBuffer.toString();
+        return Math.max(1, this.url.length);
+    }
+    readableIdentifier(requestShortener) {
+        return requestShortener.shorten(this.readableIdentifierStr);
+    }
+    needBuild(context, callback) {
+        return callback(null, !this.buildMeta);
+    }
+    build(options, compilation, resolver, fs, callback) {
+        this.buildMeta = {};
+        this.buildInfo = {
+            cacheable: true,
+        };
+        callback();
+    }
+    codeGeneration(context) {
+        if (this.url === undefined)
+            this.url = this.urlBuffer.toString();
+        const sources = new Map();
+        sources.set('javascript', new webpack_sources_1.RawSource(`module.exports = ${JSON.stringify(this.url)};`));
+        const data = new Map();
+        data.set('url', this.urlBuffer);
+        const runtimeRequirements = new Set();
+        runtimeRequirements.add(RuntimeGlobals.module);
+        return { sources, runtimeRequirements, data };
+    }
+    updateHash(hash, context) {
+        hash.update(this.urlBuffer);
+        super.updateHash(hash, context);
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.urlBuffer);
+        write(this.identifierStr);
+        write(this.readableIdentifierStr);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.urlBuffer = read();
+        this.identifierStr = read();
+        this.readableIdentifierStr = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(RawDataUrlModule, 'mp-compiler/core/module/asset/RawDataUrlModule');
+exports.default = RawDataUrlModule;

package/dist/module/async-modules/AwaitDependenciesInitFragment.d.ts

@@ -0,0 +1,10 @@
+import InitFragment from '@/base/InitFragment';
+declare class AwaitDependenciesInitFragment extends InitFragment {
+    promises: Set<string>;
+    constructor(promises: Set<string>);
+    merge(other: any): AwaitDependenciesInitFragment;
+    getContent({ runtimeRequirements }: {
+        runtimeRequirements: any;
+    }): string;
+}
+export default AwaitDependenciesInitFragment;

package/dist/module/async-modules/AwaitDependenciesInitFragment.js

@@ -0,0 +1,68 @@
+"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 Template_1 = require("@/template/Template");
+class AwaitDependenciesInitFragment extends InitFragment_1.default {
+    constructor(promises) {
+        super('', InitFragment_1.default.STAGE_ASYNC_DEPENDENCIES, 0, 'await-dependencies');
+        this.promises = promises;
+    }
+    merge(other) {
+        const promises = new Set(other.promises);
+        for (const p of this.promises) {
+            promises.add(p);
+        }
+        return new AwaitDependenciesInitFragment(promises);
+    }
+    getContent({ runtimeRequirements }) {
+        runtimeRequirements.add(RuntimeGlobals.module);
+        const promises = this.promises;
+        if (promises.size === 0) {
+            return '';
+        }
+        if (promises.size === 1) {
+            for (const p of promises) {
+                return Template_1.Template.asString([
+                    `var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${p}]);`,
+                    `${p} = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];`,
+                    '',
+                ]);
+            }
+        }
+        const sepPromises = Array.from(promises).join(', ');
+        // TODO check if destructuring is supported
+        return Template_1.Template.asString([
+            `var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${sepPromises}]);`,
+            `([${sepPromises}] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__);`,
+            '',
+        ]);
+    }
+}
+exports.default = AwaitDependenciesInitFragment;

package/dist/module/async-modules/InferAsyncModulesPlugin.d.ts

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

package/dist/module/async-modules/InferAsyncModulesPlugin.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HarmonyImportDependency_1 = require("@/dependencies/harmony/HarmonyImportDependency");
+class InferAsyncModulesPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap('InferAsyncModulesPlugin', compilation => {
+            const { moduleGraph } = compilation;
+            compilation.hooks.finishModules.tap('InferAsyncModulesPlugin', modules => {
+                var _a;
+                const queue = new Set();
+                for (const module of modules) {
+                    if ((_a = module.buildMeta) === null || _a === void 0 ? void 0 : _a.async) {
+                        queue.add(module);
+                    }
+                }
+                for (const module of queue) {
+                    moduleGraph.setAsync(module);
+                    for (const [originModule, connections,] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+                        if (connections.some(c => c.dependency instanceof HarmonyImportDependency_1.HarmonyImportDependency && c.isTargetActive(undefined))) {
+                            queue.add(originModule);
+                        }
+                    }
+                }
+            });
+        });
+    }
+}
+exports.default = InferAsyncModulesPlugin;

package/dist/module/javascript/BasicEvaluatedExpression.d.ts

@@ -0,0 +1,139 @@
+declare class BasicEvaluatedExpression {
+    type: any;
+    range: any;
+    falsy: boolean;
+    truthy: boolean;
+    nullish: any;
+    sideEffects: boolean;
+    bool: any;
+    number: any;
+    bigint: any;
+    regExp: any;
+    string: any;
+    quasis: any;
+    parts: any;
+    array: any;
+    items: any;
+    options: any;
+    prefix: any;
+    postfix: any;
+    wrappedInnerExpressions: any;
+    identifier: any;
+    rootInfo: any;
+    getMembers: any;
+    getMembersOptionals: any;
+    getMemberRanges: any;
+    expression: any;
+    templateStringKind: any;
+    static isValidRegExpFlags: (flags: any) => boolean;
+    constructor();
+    isUnknown(): boolean;
+    isNull(): boolean;
+    isUndefined(): boolean;
+    isString(): boolean;
+    isNumber(): boolean;
+    isBigInt(): boolean;
+    isBoolean(): boolean;
+    isRegExp(): boolean;
+    isConditional(): boolean;
+    isArray(): boolean;
+    isConstArray(): boolean;
+    isIdentifier(): boolean;
+    isWrapped(): boolean;
+    isTemplateString(): boolean;
+    /**
+     * Is expression a primitive or an object type value?
+     * @returns {boolean | undefined} true: primitive type, false: object type, undefined: unknown/runtime-defined
+     */
+    isPrimitiveType(): boolean | undefined;
+    /**
+     * Is expression a runtime or compile-time value?
+     * @returns {boolean} true: compile time value, false: runtime value
+     */
+    isCompileTimeValue(): boolean;
+    /**
+     * Gets the compile-time value of the expression
+     * @returns {any} the javascript value
+     */
+    asCompileTimeValue(): any;
+    isTruthy(): boolean;
+    isFalsy(): boolean;
+    isNullish(): any;
+    /**
+     * Can this expression have side effects?
+     */
+    couldHaveSideEffects(): boolean;
+    asBool(): any;
+    /**
+     * Creates a nullish coalescing representation of this evaluated expression.
+     */
+    asNullish(): boolean | undefined;
+    /**
+     * Creates a string representation of this evaluated expression.
+     */
+    asString(): any;
+    setString(string: string): this;
+    setUndefined(): this;
+    setNull(): this;
+    /**
+     * Set's the value of this expression to a number
+     */
+    setNumber(number: number): this;
+    /**
+     * Set's the value of this expression to a BigInt
+     */
+    setBigInt(bigint: bigint): this;
+    /**
+     * Set's the value of this expression to a boolean
+     */
+    setBoolean(bool: boolean): this;
+    /**
+     * Set's the value of this expression to a regular expression
+     */
+    setRegExp(regExp: RegExp): this;
+    setIdentifier(identifier: any, rootInfo: any, getMembers?: any, getMembersOptionals?: any, getMemberRanges?: any): this;
+    /**
+     * Wraps an array of expressions with a prefix and postfix expression.
+     */
+    setWrapped(prefix: any, postfix: any, innerExpressions: any): this;
+    /**
+     * Stores the options of a conditional expression.
+     */
+    setOptions(options: any): this;
+    /**
+     * Adds options to a conditional expression.
+     */
+    addOptions(options: any): this;
+    /**
+     * Set's the value of this expression to an array of expressions.
+     */
+    setItems(items: any): this;
+    /**
+     * Set's the value of this expression to an array of strings.
+     */
+    setArray(array: any): this;
+    /**
+     * Set's the value of this expression to a processed/unprocessed template string. Used
+     * for evaluating TemplateLiteral expressions in the JavaScript Parser.
+     */
+    setTemplateString(quasis: any, parts: any, kind: any): this;
+    setTruthy(): this;
+    setFalsy(): this;
+    /**
+     * Set's the value of the expression to nullish.
+     */
+    setNullish(value: boolean): this;
+    /**
+     * Set's the range for the expression.
+     */
+    setRange(range: any): this;
+    /**
+     * Set whether or not the expression has side effects.
+     */
+    setSideEffects(sideEffects?: boolean): this;
+    /**
+     * Set the expression node for the expression.
+     */
+    setExpression(expression: any): this;
+}
+export default BasicEvaluatedExpression;