xhs-mp-pack 1.1.0-beta.0

package/dist/module/javascript/BasicEvaluatedExpression.js

@@ -0,0 +1,481 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const TypeUnknown = 0;
+const TypeUndefined = 1;
+const TypeNull = 2;
+const TypeString = 3;
+const TypeNumber = 4;
+const TypeBoolean = 5;
+const TypeRegExp = 6;
+const TypeConditional = 7;
+const TypeArray = 8;
+const TypeConstArray = 9;
+const TypeIdentifier = 10;
+const TypeWrapped = 11;
+const TypeTemplateString = 12;
+const TypeBigInt = 13;
+class BasicEvaluatedExpression {
+    constructor() {
+        this.range = undefined;
+        this.falsy = false;
+        this.truthy = false;
+        this.nullish = undefined;
+        this.sideEffects = true;
+        this.bool = undefined;
+        this.number = undefined;
+        this.bigint = undefined;
+        this.regExp = undefined;
+        this.string = undefined;
+        this.quasis = undefined;
+        this.parts = undefined;
+        this.array = undefined;
+        this.items = undefined;
+        this.options = undefined;
+        this.prefix = undefined;
+        this.postfix = undefined;
+        this.wrappedInnerExpressions = undefined;
+        this.identifier = undefined;
+        this.rootInfo = undefined;
+        this.getMembers = undefined;
+        this.getMembersOptionals = undefined;
+        this.getMemberRanges = undefined;
+        this.expression = undefined;
+    }
+    isUnknown() {
+        return this.type === TypeUnknown;
+    }
+    isNull() {
+        return this.type === TypeNull;
+    }
+    isUndefined() {
+        return this.type === TypeUndefined;
+    }
+    isString() {
+        return this.type === TypeString;
+    }
+    isNumber() {
+        return this.type === TypeNumber;
+    }
+    isBigInt() {
+        return this.type === TypeBigInt;
+    }
+    isBoolean() {
+        return this.type === TypeBoolean;
+    }
+    isRegExp() {
+        return this.type === TypeRegExp;
+    }
+    isConditional() {
+        return this.type === TypeConditional;
+    }
+    isArray() {
+        return this.type === TypeArray;
+    }
+    isConstArray() {
+        return this.type === TypeConstArray;
+    }
+    isIdentifier() {
+        return this.type === TypeIdentifier;
+    }
+    isWrapped() {
+        return this.type === TypeWrapped;
+    }
+    isTemplateString() {
+        return this.type === TypeTemplateString;
+    }
+    /**
+     * Is expression a primitive or an object type value?
+     * @returns {boolean | undefined} true: primitive type, false: object type, undefined: unknown/runtime-defined
+     */
+    isPrimitiveType() {
+        switch (this.type) {
+            case TypeUndefined:
+            case TypeNull:
+            case TypeString:
+            case TypeNumber:
+            case TypeBoolean:
+            case TypeBigInt:
+            case TypeWrapped:
+            case TypeTemplateString:
+                return true;
+            case TypeRegExp:
+            case TypeArray:
+            case TypeConstArray:
+                return false;
+            default:
+                return undefined;
+        }
+    }
+    /**
+     * Is expression a runtime or compile-time value?
+     * @returns {boolean} true: compile time value, false: runtime value
+     */
+    isCompileTimeValue() {
+        switch (this.type) {
+            case TypeUndefined:
+            case TypeNull:
+            case TypeString:
+            case TypeNumber:
+            case TypeBoolean:
+            case TypeRegExp:
+            case TypeConstArray:
+            case TypeBigInt:
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Gets the compile-time value of the expression
+     * @returns {any} the javascript value
+     */
+    asCompileTimeValue() {
+        switch (this.type) {
+            case TypeUndefined:
+                return undefined;
+            case TypeNull:
+                return null;
+            case TypeString:
+                return this.string;
+            case TypeNumber:
+                return this.number;
+            case TypeBoolean:
+                return this.bool;
+            case TypeRegExp:
+                return this.regExp;
+            case TypeConstArray:
+                return this.array;
+            case TypeBigInt:
+                return this.bigint;
+            default:
+                throw new Error('asCompileTimeValue must only be called for compile-time values');
+        }
+    }
+    isTruthy() {
+        return this.truthy;
+    }
+    isFalsy() {
+        return this.falsy;
+    }
+    isNullish() {
+        return this.nullish;
+    }
+    /**
+     * Can this expression have side effects?
+     */
+    couldHaveSideEffects() {
+        return this.sideEffects;
+    }
+    asBool() {
+        var _a, _b;
+        if (this.truthy)
+            return true;
+        if (this.falsy || this.nullish)
+            return false;
+        if (this.isBoolean())
+            return this.bool;
+        if (this.isNull())
+            return false;
+        if (this.isUndefined())
+            return false;
+        if (this.isString())
+            return this.string !== '';
+        if (this.isNumber())
+            return this.number !== 0;
+        if (this.isBigInt())
+            return this.bigint !== BigInt(0);
+        if (this.isRegExp())
+            return true;
+        if (this.isArray())
+            return true;
+        if (this.isConstArray())
+            return true;
+        if (this.isWrapped()) {
+            return ((_a = this.prefix) === null || _a === void 0 ? void 0 : _a.asBool()) || ((_b = this.postfix) === null || _b === void 0 ? void 0 : _b.asBool())
+                ? true
+                : undefined;
+        }
+        if (this.isTemplateString()) {
+            const str = this.asString();
+            if (typeof str === 'string')
+                return str !== '';
+        }
+        return undefined;
+    }
+    /**
+     * Creates a nullish coalescing representation of this evaluated expression.
+     */
+    asNullish() {
+        const nullish = this.isNullish();
+        if (nullish === true || this.isNull() || this.isUndefined())
+            return true;
+        if (nullish === false)
+            return false;
+        if (this.isTruthy())
+            return false;
+        if (this.isBoolean())
+            return false;
+        if (this.isString())
+            return false;
+        if (this.isNumber())
+            return false;
+        if (this.isBigInt())
+            return false;
+        if (this.isRegExp())
+            return false;
+        if (this.isArray())
+            return false;
+        if (this.isConstArray())
+            return false;
+        if (this.isTemplateString())
+            return false;
+        if (this.isRegExp())
+            return false;
+        return undefined;
+    }
+    /**
+     * Creates a string representation of this evaluated expression.
+     */
+    asString() {
+        if (this.isBoolean())
+            return `${this.bool}`;
+        if (this.isNull())
+            return 'null';
+        if (this.isUndefined())
+            return 'undefined';
+        if (this.isString())
+            return this.string;
+        if (this.isNumber())
+            return `${this.number}`;
+        if (this.isBigInt())
+            return `${this.bigint}`;
+        if (this.isRegExp())
+            return `${this.regExp}`;
+        if (this.isArray()) {
+            const array = [];
+            for (const item of this.items) {
+                const itemStr = item.asString();
+                if (itemStr === undefined)
+                    return undefined;
+                array.push(itemStr);
+            }
+            return `${array}`;
+        }
+        if (this.isConstArray())
+            return `${this.array}`;
+        if (this.isTemplateString()) {
+            let str = '';
+            for (const part of this.parts) {
+                const partStr = part.asString();
+                if (partStr === undefined)
+                    return undefined;
+                str += partStr;
+            }
+            return str;
+        }
+        return undefined;
+    }
+    setString(string) {
+        this.type = TypeString;
+        this.string = string;
+        this.sideEffects = false;
+        return this;
+    }
+    setUndefined() {
+        this.type = TypeUndefined;
+        this.sideEffects = false;
+        return this;
+    }
+    setNull() {
+        this.type = TypeNull;
+        this.sideEffects = false;
+        return this;
+    }
+    /**
+     * Set's the value of this expression to a number
+     */
+    setNumber(number) {
+        this.type = TypeNumber;
+        this.number = number;
+        this.sideEffects = false;
+        return this;
+    }
+    /**
+     * Set's the value of this expression to a BigInt
+     */
+    setBigInt(bigint) {
+        this.type = TypeBigInt;
+        this.bigint = bigint;
+        this.sideEffects = false;
+        return this;
+    }
+    /**
+     * Set's the value of this expression to a boolean
+     */
+    setBoolean(bool) {
+        this.type = TypeBoolean;
+        this.bool = bool;
+        this.sideEffects = false;
+        return this;
+    }
+    /**
+     * Set's the value of this expression to a regular expression
+     */
+    setRegExp(regExp) {
+        this.type = TypeRegExp;
+        this.regExp = regExp;
+        this.sideEffects = false;
+        return this;
+    }
+    setIdentifier(identifier, rootInfo, getMembers, getMembersOptionals, getMemberRanges) {
+        this.type = TypeIdentifier;
+        this.identifier = identifier;
+        this.rootInfo = rootInfo;
+        this.getMembers = getMembers;
+        this.getMembersOptionals = getMembersOptionals;
+        this.getMemberRanges = getMemberRanges;
+        this.sideEffects = true;
+        return this;
+    }
+    /**
+     * Wraps an array of expressions with a prefix and postfix expression.
+     */
+    setWrapped(prefix, postfix, innerExpressions) {
+        this.type = TypeWrapped;
+        this.prefix = prefix;
+        this.postfix = postfix;
+        this.wrappedInnerExpressions = innerExpressions;
+        this.sideEffects = true;
+        return this;
+    }
+    /**
+     * Stores the options of a conditional expression.
+     */
+    setOptions(options) {
+        this.type = TypeConditional;
+        this.options = options;
+        this.sideEffects = true;
+        return this;
+    }
+    /**
+     * Adds options to a conditional expression.
+     */
+    addOptions(options) {
+        if (!this.options) {
+            this.type = TypeConditional;
+            this.options = [];
+            this.sideEffects = true;
+        }
+        for (const item of options) {
+            this.options.push(item);
+        }
+        return this;
+    }
+    /**
+     * Set's the value of this expression to an array of expressions.
+     */
+    setItems(items) {
+        this.type = TypeArray;
+        this.items = items;
+        this.sideEffects = items.some(i => i.couldHaveSideEffects());
+        return this;
+    }
+    /**
+     * Set's the value of this expression to an array of strings.
+     */
+    setArray(array) {
+        this.type = TypeConstArray;
+        this.array = array;
+        this.sideEffects = false;
+        return 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, parts, kind) {
+        this.type = TypeTemplateString;
+        this.quasis = quasis;
+        this.parts = parts;
+        this.templateStringKind = kind;
+        this.sideEffects = parts.some(p => p.sideEffects);
+        return this;
+    }
+    setTruthy() {
+        this.falsy = false;
+        this.truthy = true;
+        this.nullish = false;
+        return this;
+    }
+    setFalsy() {
+        this.falsy = true;
+        this.truthy = false;
+        return this;
+    }
+    /**
+     * Set's the value of the expression to nullish.
+     */
+    setNullish(value) {
+        this.nullish = value;
+        if (value)
+            return this.setFalsy();
+        return this;
+    }
+    /**
+     * Set's the range for the expression.
+     */
+    setRange(range) {
+        this.range = range;
+        return this;
+    }
+    /**
+     * Set whether or not the expression has side effects.
+     */
+    setSideEffects(sideEffects = true) {
+        this.sideEffects = sideEffects;
+        return this;
+    }
+    /**
+     * Set the expression node for the expression.
+     */
+    setExpression(expression) {
+        this.expression = expression;
+        return this;
+    }
+}
+BasicEvaluatedExpression.isValidRegExpFlags = (flags) => {
+    const len = flags.length;
+    if (len === 0)
+        return true;
+    if (len > 4)
+        return false;
+    // cspell:word gimy
+    let remaining = 0b0000; // bit per RegExp flag: gimy
+    for (let i = 0; i < len; i++)
+        switch (flags.charCodeAt(i)) {
+            case 103 /* g */:
+                if (remaining & 0b1000)
+                    return false;
+                remaining |= 0b1000;
+                break;
+            case 105 /* i */:
+                if (remaining & 0b0100)
+                    return false;
+                remaining |= 0b0100;
+                break;
+            case 109 /* m */:
+                if (remaining & 0b0010)
+                    return false;
+                remaining |= 0b0010;
+                break;
+            case 121 /* y */:
+                if (remaining & 0b0001)
+                    return false;
+                remaining |= 0b0001;
+                break;
+            default:
+                return false;
+        }
+    return true;
+};
+exports.default = BasicEvaluatedExpression;

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

@@ -0,0 +1,11 @@
+import Generator from '../Generator';
+declare class JavascriptGenerator extends Generator {
+    getTypes(module: any): Set<string>;
+    getSize(module: any, type?: string): any;
+    getConcatenationBailoutReason(module: any, context: any): string | undefined;
+    generate(module: any, generateContext: any): any;
+    sourceModule(module: any, initFragments: any, source: any, generateContext: any): void;
+    sourceBlock(module: any, block: any, initFragments: any, source: any, generateContext: any): void;
+    sourceDependency(module: any, dependency: any, initFragments: any, source: any, generateContext: any): void;
+}
+export default JavascriptGenerator;

package/dist/module/javascript/JavascriptGenerator.js

@@ -0,0 +1,103 @@
+"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 webpack_sources_1 = require("webpack-sources");
+const InitFragment_1 = __importDefault(require("@/base/InitFragment"));
+const HarmonyCompatibilityDependency_1 = __importDefault(require("@/dependencies/harmony/HarmonyCompatibilityDependency"));
+const Generator_1 = __importDefault(require("../Generator"));
+// TODO: clean up this file
+// replace with newer constructs
+const deprecatedGetInitFragments = util_1.default.deprecate((template, dependency, templateContext) => template.getInitFragments(dependency, templateContext), 'DependencyTemplate.getInitFragment is deprecated (use apply(dep, source, { initFragments }) instead)', 'DEP_WEBPACK_JAVASCRIPT_GENERATOR_GET_INIT_FRAGMENTS');
+const TYPES = new Set(['javascript']);
+class JavascriptGenerator extends Generator_1.default {
+    getTypes(module) {
+        return TYPES;
+    }
+    getSize(module, type) {
+        const originalSource = module.originalSource();
+        if (!originalSource) {
+            return 39;
+        }
+        return originalSource.size();
+    }
+    getConcatenationBailoutReason(module, context) {
+        var _a;
+        // Only harmony modules are valid for optimization
+        if (!module.buildMeta ||
+            module.buildMeta.exportsType !== 'namespace' ||
+            module.presentationalDependencies === undefined ||
+            !module.presentationalDependencies.some(d => d instanceof HarmonyCompatibilityDependency_1.default)) {
+            return 'Module is not an ECMAScript module';
+        }
+        // Some expressions are not compatible with module concatenation
+        // because they may produce unexpected results. The plugin bails out
+        // if some were detected upfront.
+        if ((_a = module.buildInfo) === null || _a === void 0 ? void 0 : _a.moduleConcatenationBailout) {
+            return `Module uses ${module.buildInfo.moduleConcatenationBailout}`;
+        }
+    }
+    generate(module, generateContext) {
+        const originalSource = module.originalSource();
+        if (!originalSource) {
+            return new webpack_sources_1.RawSource("throw new Error('No source available');");
+        }
+        const source = new webpack_sources_1.ReplaceSource(originalSource);
+        const initFragments = [];
+        this.sourceModule(module, initFragments, source, generateContext);
+        return InitFragment_1.default.addToSource(source, initFragments, generateContext);
+    }
+    sourceModule(module, initFragments, source, generateContext) {
+        for (const dependency of module.dependencies) {
+            this.sourceDependency(module, dependency, initFragments, source, generateContext);
+        }
+        if (module.presentationalDependencies !== undefined) {
+            for (const dependency of module.presentationalDependencies) {
+                this.sourceDependency(module, dependency, initFragments, source, generateContext);
+            }
+        }
+        for (const childBlock of module.blocks) {
+            this.sourceBlock(module, childBlock, initFragments, source, generateContext);
+        }
+    }
+    sourceBlock(module, block, initFragments, source, generateContext) {
+        for (const dependency of block.dependencies) {
+            this.sourceDependency(module, dependency, initFragments, source, generateContext);
+        }
+        for (const childBlock of block.blocks) {
+            this.sourceBlock(module, childBlock, initFragments, source, generateContext);
+        }
+    }
+    sourceDependency(module, dependency, initFragments, source, generateContext) {
+        const constructor = dependency.constructor;
+        const template = generateContext.dependencyTemplates.get(constructor);
+        if (!template) {
+            throw new Error(`No template for dependency: ${dependency.constructor.name}`);
+        }
+        const templateContext = {
+            runtimeTemplate: generateContext.runtimeTemplate,
+            dependencyTemplates: generateContext.dependencyTemplates,
+            moduleGraph: generateContext.moduleGraph,
+            chunkGraph: generateContext.chunkGraph,
+            module,
+            runtime: generateContext.runtime,
+            runtimeRequirements: generateContext.runtimeRequirements,
+            concatenationScope: generateContext.concatenationScope,
+            codeGenerationResults: generateContext.codeGenerationResults,
+            initFragments,
+        };
+        template.apply(dependency, source, templateContext);
+        // TODO remove in webpack 6
+        if ('getInitFragments' in template) {
+            const fragments = deprecatedGetInitFragments(template, dependency, templateContext);
+            if (fragments) {
+                for (const fragment of fragments) {
+                    initFragments.push(fragment);
+                }
+            }
+        }
+    }
+}
+exports.default = JavascriptGenerator;

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

@@ -0,0 +1,17 @@
+import Module from '@/module/Module';
+declare const chunkHasJs: (chunk: any, chunkGraph: any) => boolean;
+declare class JavascriptModulesPlugin {
+    options: any;
+    _moduleFactoryCache: WeakMap<any, any>;
+    static getCompilationHooks(compilation: any): any;
+    constructor(options?: {});
+    apply(compiler: any): void;
+    static getChunkFilenameTemplate(chunk: any, outputOptions: any): any;
+    renderModule(module: Module, renderContext: any, hooks: any, factory: boolean): any;
+    renderChunk(renderContext: any, hooks: any): any;
+    renderMain(renderContext: any, hooks: any, compilation: any): any;
+    updateHashWithBootstrap(hash: any, renderContext: any, hooks: any): void;
+    renderBootstrap(renderContext: any, hooks: any): any;
+    renderRequire(renderContext: any, hooks: any): any;
+}
+export { chunkHasJs, JavascriptModulesPlugin };