xhs-mp-pack 1.1.0-beta.0

package/dist/module/RuntimeHelpers.js

@@ -0,0 +1,548 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeSpecSet = exports.RuntimeSpecMap = exports.filterRuntime = exports.keyToRuntime = exports.subtractRuntimeCondition = exports.subtractRuntime = exports.intersectRuntime = exports.compareRuntime = exports.mergeRuntime = exports.mergeRuntimeCondition = exports.mergeRuntimeConditionNonFalse = exports.runtimeEqual = exports.runtimeConditionToString = exports.runtimeToString = exports.mergeRuntimeOwned = exports.getRuntimeKey = exports.forEachRuntime = exports.getEntryRuntime = void 0;
+const SortableSet_1 = __importDefault(require("../base/SortableSet"));
+const getEntryRuntime = (compilation, name, options) => {
+    let dependOn;
+    let runtime;
+    if (options) {
+        ;
+        ({ dependOn, runtime } = options);
+    }
+    else {
+        const entry = compilation.entries.get(name);
+        if (!entry)
+            return name;
+        ({ dependOn, runtime } = entry.options);
+    }
+    if (dependOn) {
+        let result;
+        const queue = new Set(dependOn);
+        for (const name of queue) {
+            const dep = compilation.entries.get(name);
+            if (!dep)
+                continue;
+            const { dependOn, runtime } = dep.options;
+            if (dependOn) {
+                for (const name of dependOn) {
+                    queue.add(name);
+                }
+            }
+            else {
+                result = mergeRuntimeOwned(result, runtime || name);
+            }
+        }
+        return result || name;
+    }
+    return runtime || name;
+};
+exports.getEntryRuntime = getEntryRuntime;
+const forEachRuntime = (runtime, fn, deterministicOrder = false) => {
+    if (runtime === undefined) {
+        fn(undefined);
+    }
+    else if (typeof runtime === 'string') {
+        fn(runtime);
+    }
+    else {
+        if (deterministicOrder)
+            runtime.sort();
+        for (const r of runtime) {
+            fn(r);
+        }
+    }
+};
+exports.forEachRuntime = forEachRuntime;
+const getRuntimesKey = set => {
+    set.sort();
+    return Array.from(set).join('\n');
+};
+const getRuntimeKey = runtime => {
+    if (runtime === undefined)
+        return '*';
+    if (typeof runtime === 'string')
+        return runtime;
+    return runtime.getFromUnorderedCache(getRuntimesKey);
+};
+exports.getRuntimeKey = getRuntimeKey;
+const keyToRuntime = key => {
+    if (key === '*')
+        return undefined;
+    const items = key.split('\n');
+    if (items.length === 1)
+        return items[0];
+    return new SortableSet_1.default(items);
+};
+exports.keyToRuntime = keyToRuntime;
+const getRuntimesString = set => {
+    set.sort();
+    return Array.from(set).join('+');
+};
+const runtimeToString = runtime => {
+    if (runtime === undefined)
+        return '*';
+    if (typeof runtime === 'string')
+        return runtime;
+    return runtime.getFromUnorderedCache(getRuntimesString);
+};
+exports.runtimeToString = runtimeToString;
+const runtimeConditionToString = runtimeCondition => {
+    if (runtimeCondition === true)
+        return 'true';
+    if (runtimeCondition === false)
+        return 'false';
+    return runtimeToString(runtimeCondition);
+};
+exports.runtimeConditionToString = runtimeConditionToString;
+const runtimeEqual = (a, b) => {
+    if (a === b) {
+        return true;
+    }
+    if (a === undefined || b === undefined || typeof a === 'string' || typeof b === 'string') {
+        return false;
+    }
+    if (a.size !== b.size) {
+        return false;
+    }
+    a.sort();
+    b.sort();
+    const aIt = a[Symbol.iterator]();
+    const bIt = b[Symbol.iterator]();
+    for (;;) {
+        const aV = aIt.next();
+        if (aV.done)
+            return true;
+        const bV = bIt.next();
+        if (aV.value !== bV.value)
+            return false;
+    }
+};
+exports.runtimeEqual = runtimeEqual;
+const compareRuntime = (a, b) => {
+    if (a === b) {
+        return 0;
+    }
+    if (a === undefined) {
+        return -1;
+    }
+    if (b === undefined) {
+        return 1;
+    }
+    const aKey = getRuntimeKey(a);
+    const bKey = getRuntimeKey(b);
+    if (aKey < bKey)
+        return -1;
+    if (aKey > bKey)
+        return 1;
+    return 0;
+};
+exports.compareRuntime = compareRuntime;
+const mergeRuntime = (a, b) => {
+    if (a === undefined) {
+        return b;
+    }
+    if (b === undefined) {
+        return a;
+    }
+    if (a === b) {
+        return a;
+    }
+    if (typeof a === 'string') {
+        if (typeof b === 'string') {
+            const set = new SortableSet_1.default();
+            set.add(a);
+            set.add(b);
+            return set;
+        }
+        if (b.has(a)) {
+            return b;
+        }
+        const set = new SortableSet_1.default(b);
+        set.add(a);
+        return set;
+    }
+    if (typeof b === 'string') {
+        if (a.has(b))
+            return a;
+        const set = new SortableSet_1.default(a);
+        set.add(b);
+        return set;
+    }
+    const set = new SortableSet_1.default(a);
+    for (const item of b)
+        set.add(item);
+    if (set.size === a.size)
+        return a;
+    return set;
+};
+exports.mergeRuntime = mergeRuntime;
+const mergeRuntimeCondition = (a, b, runtime) => {
+    if (a === false)
+        return b;
+    if (b === false)
+        return a;
+    if (a === true || b === true)
+        return true;
+    const merged = mergeRuntime(a, b);
+    if (merged === undefined)
+        return undefined;
+    if (typeof merged === 'string') {
+        if (typeof runtime === 'string' && merged === runtime)
+            return true;
+        return merged;
+    }
+    if (typeof runtime === 'string' || runtime === undefined)
+        return merged;
+    if (merged.size === runtime.size)
+        return true;
+    return merged;
+};
+exports.mergeRuntimeCondition = mergeRuntimeCondition;
+const mergeRuntimeConditionNonFalse = (a, b, runtime) => {
+    if (a === true || b === true)
+        return true;
+    const merged = mergeRuntime(a, b);
+    if (merged === undefined)
+        return undefined;
+    if (typeof merged === 'string') {
+        if (typeof runtime === 'string' && merged === runtime)
+            return true;
+        return merged;
+    }
+    if (typeof runtime === 'string' || runtime === undefined)
+        return merged;
+    if (merged.size === runtime.size)
+        return true;
+    return merged;
+};
+exports.mergeRuntimeConditionNonFalse = mergeRuntimeConditionNonFalse;
+const mergeRuntimeOwned = (a, b) => {
+    if (b === undefined) {
+        return a;
+    }
+    if (a === b) {
+        return a;
+    }
+    if (a === undefined) {
+        if (typeof b === 'string') {
+            return b;
+        }
+        return new SortableSet_1.default(b);
+    }
+    if (typeof a === 'string') {
+        if (typeof b === 'string') {
+            const set = new SortableSet_1.default();
+            set.add(a);
+            set.add(b);
+            return set;
+        }
+        const set = new SortableSet_1.default(b);
+        set.add(a);
+        return set;
+    }
+    if (typeof b === 'string') {
+        a.add(b);
+        return a;
+    }
+    for (const item of b)
+        a.add(item);
+    return a;
+};
+exports.mergeRuntimeOwned = mergeRuntimeOwned;
+const intersectRuntime = (a, b) => {
+    if (a === undefined) {
+        return b;
+    }
+    if (b === undefined) {
+        return a;
+    }
+    if (a === b) {
+        return a;
+    }
+    if (typeof a === 'string') {
+        if (typeof b === 'string') {
+            return undefined;
+        }
+        if (b.has(a)) {
+            return a;
+        }
+        return undefined;
+    }
+    if (typeof b === 'string') {
+        if (a.has(b))
+            return b;
+        return undefined;
+    }
+    const set = new SortableSet_1.default();
+    for (const item of b) {
+        if (a.has(item))
+            set.add(item);
+    }
+    if (set.size === 0)
+        return undefined;
+    if (set.size === 1)
+        for (const item of set)
+            return item;
+    return set;
+};
+exports.intersectRuntime = intersectRuntime;
+const subtractRuntime = (a, b) => {
+    if (a === undefined) {
+        return undefined;
+    }
+    if (b === undefined) {
+        return a;
+    }
+    if (a === b) {
+        return undefined;
+    }
+    if (typeof a === 'string') {
+        if (typeof b === 'string') {
+            return a;
+        }
+        if (b.has(a)) {
+            return undefined;
+        }
+        return a;
+    }
+    if (typeof b === 'string') {
+        if (!a.has(b))
+            return a;
+        if (a.size === 2) {
+            for (const item of a) {
+                if (item !== b)
+                    return item;
+            }
+        }
+        const set = new SortableSet_1.default(a);
+        set.delete(b);
+    }
+    else {
+        const set = new SortableSet_1.default();
+        for (const item of a) {
+            if (!b.has(item))
+                set.add(item);
+        }
+        if (set.size === 0)
+            return undefined;
+        if (set.size === 1)
+            for (const item of set)
+                return item;
+        return set;
+    }
+};
+exports.subtractRuntime = subtractRuntime;
+const subtractRuntimeCondition = (a, b, runtime) => {
+    if (b === true)
+        return false;
+    if (b === false)
+        return a;
+    if (a === false)
+        return false;
+    const result = subtractRuntime(a === true ? runtime : a, b);
+    return result === undefined ? false : result;
+};
+exports.subtractRuntimeCondition = subtractRuntimeCondition;
+const filterRuntime = (runtime, filter) => {
+    if (runtime === undefined)
+        return filter(undefined);
+    if (typeof runtime === 'string')
+        return filter(runtime);
+    let some = false;
+    let every = true;
+    let result;
+    for (const r of runtime) {
+        const v = filter(r);
+        if (v) {
+            some = true;
+            result = mergeRuntimeOwned(result, r);
+        }
+        else {
+            every = false;
+        }
+    }
+    if (!some)
+        return false;
+    if (every)
+        return true;
+    return result;
+};
+exports.filterRuntime = filterRuntime;
+class RuntimeSpecMap {
+    constructor(clone) {
+        this._mode = clone ? clone._mode : 0; // 0 = empty, 1 = single entry, 2 = map
+        this._singleRuntime = clone ? clone._singleRuntime : undefined;
+        this._singleValue = clone ? clone._singleValue : undefined;
+        // @ts-ignore
+        this._map = (clone === null || clone === void 0 ? void 0 : clone._map) ? new Map(clone._map) : undefined;
+    }
+    get(runtime) {
+        switch (this._mode) {
+            case 0:
+                return undefined;
+            case 1:
+                return runtimeEqual(this._singleRuntime, runtime) ? this._singleValue : undefined;
+            default:
+                return this._map.get(getRuntimeKey(runtime));
+        }
+    }
+    has(runtime) {
+        switch (this._mode) {
+            case 0:
+                return false;
+            case 1:
+                return runtimeEqual(this._singleRuntime, runtime);
+            default:
+                return this._map.has(getRuntimeKey(runtime));
+        }
+    }
+    set(runtime, value) {
+        switch (this._mode) {
+            case 0:
+                this._mode = 1;
+                this._singleRuntime = runtime;
+                this._singleValue = value;
+                break;
+            case 1:
+                if (runtimeEqual(this._singleRuntime, runtime)) {
+                    this._singleValue = value;
+                    break;
+                }
+                this._mode = 2;
+                this._map = new Map();
+                this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+                this._singleRuntime = undefined;
+                this._singleValue = undefined;
+            /* falls through */
+            default:
+                this._map.set(getRuntimeKey(runtime), value);
+        }
+    }
+    provide(runtime, computer) {
+        switch (this._mode) {
+            case 0:
+                this._mode = 1;
+                this._singleRuntime = runtime;
+                this._singleValue = computer();
+                return this._singleValue;
+            case 1: {
+                if (runtimeEqual(this._singleRuntime, runtime)) {
+                    return this._singleValue;
+                }
+                this._mode = 2;
+                this._map = new Map();
+                this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+                this._singleRuntime = undefined;
+                this._singleValue = undefined;
+                const newValue = computer();
+                this._map.set(getRuntimeKey(runtime), newValue);
+                return newValue;
+            }
+            default: {
+                const key = getRuntimeKey(runtime);
+                const value = this._map.get(key);
+                if (value !== undefined)
+                    return value;
+                const newValue = computer();
+                this._map.set(key, newValue);
+                return newValue;
+            }
+        }
+    }
+    delete(runtime) {
+        switch (this._mode) {
+            case 0:
+                return;
+            case 1:
+                if (runtimeEqual(this._singleRuntime, runtime)) {
+                    this._mode = 0;
+                    this._singleRuntime = undefined;
+                    this._singleValue = undefined;
+                }
+                return;
+            default:
+                this._map.delete(getRuntimeKey(runtime));
+        }
+    }
+    update(runtime, fn) {
+        switch (this._mode) {
+            case 0:
+                throw new Error('runtime passed to update must exist');
+            case 1: {
+                if (runtimeEqual(this._singleRuntime, runtime)) {
+                    this._singleValue = fn(this._singleValue);
+                    break;
+                }
+                const newValue = fn(undefined);
+                if (newValue !== undefined) {
+                    this._mode = 2;
+                    this._map = new Map();
+                    this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+                    this._singleRuntime = undefined;
+                    this._singleValue = undefined;
+                    this._map.set(getRuntimeKey(runtime), newValue);
+                }
+                break;
+            }
+            default: {
+                const key = getRuntimeKey(runtime);
+                const oldValue = this._map.get(key);
+                const newValue = fn(oldValue);
+                if (newValue !== oldValue)
+                    this._map.set(key, newValue);
+            }
+        }
+    }
+    keys() {
+        switch (this._mode) {
+            case 0:
+                return [];
+            case 1:
+                return [this._singleRuntime];
+            default:
+                return Array.from(this._map.keys(), keyToRuntime);
+        }
+    }
+    values() {
+        switch (this._mode) {
+            case 0:
+                return [][Symbol.iterator]();
+            case 1:
+                return [this._singleValue][Symbol.iterator]();
+            default:
+                return this._map.values();
+        }
+    }
+    get size() {
+        if (this._mode <= 1)
+            return this._mode;
+        return this._map.size;
+    }
+}
+exports.RuntimeSpecMap = RuntimeSpecMap;
+class RuntimeSpecSet {
+    constructor(iterable) {
+        this._map = new Map();
+        if (iterable) {
+            for (const item of iterable) {
+                this.add(item);
+            }
+        }
+    }
+    add(runtime) {
+        this._map.set(getRuntimeKey(runtime), runtime);
+    }
+    has(runtime) {
+        return this._map.has(getRuntimeKey(runtime));
+    }
+    [Symbol.iterator]() {
+        return this._map.values();
+    }
+    get size() {
+        return this._map.size;
+    }
+}
+exports.RuntimeSpecSet = RuntimeSpecSet;

package/dist/module/RuntimeModule.d.ts

@@ -0,0 +1,39 @@
+import Compilation from '@/Compilation';
+import Module from './Module';
+import Chunk from '../chunk/Chunk';
+import ChunkGraph from '../chunk/ChunkGraph';
+declare class RuntimeModule extends Module {
+    name: any;
+    stage: number;
+    buildMeta: any;
+    buildInfo: any;
+    compilation: Compilation;
+    chunk: Chunk;
+    chunkGraph: ChunkGraph;
+    fullHash: boolean;
+    dependentHash: boolean;
+    _cachedGeneratedCode: any;
+    useSourceMap: any;
+    useSimpleSourceMap: any;
+    static STAGE_ATTACH: number;
+    static STAGE_NORMAL: number;
+    static STAGE_BASIC: number;
+    static STAGE_TRIGGER: number;
+    constructor(name: any, stage?: number);
+    attach(compilation: any, chunk: any, chunkGraph?: any): void;
+    identifier(): string;
+    readableIdentifier(requestShortener: any): string;
+    needBuild(context: any, callback: any): any;
+    build(options: any, compilation: any, resolver: any, fs: any, callback: any): void;
+    updateHash(hash: any, context: any): void;
+    getSourceTypes(): Set<string>;
+    codeGeneration(context: any): {
+        sources: Map<any, any>;
+        runtimeRequirements: null;
+    };
+    size(type: any): any;
+    generate(): void;
+    getGeneratedCode(): any;
+    shouldIsolate(): boolean;
+}
+export default RuntimeModule;

package/dist/module/RuntimeModule.js

@@ -0,0 +1,114 @@
+"use strict";
+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 Module_1 = __importDefault(require("./Module"));
+const ModuleTypeConstants_1 = require("./ModuleTypeConstants");
+const TYPES = new Set([ModuleTypeConstants_1.WEBPACK_MODULE_TYPE_RUNTIME]);
+class RuntimeModule extends Module_1.default {
+    constructor(name, stage = 0) {
+        super(ModuleTypeConstants_1.WEBPACK_MODULE_TYPE_RUNTIME);
+        this.name = name;
+        this.stage = stage;
+        this.buildMeta = {};
+        this.buildInfo = {};
+        this.fullHash = false;
+        this.dependentHash = false;
+        this._cachedGeneratedCode = undefined;
+    }
+    attach(compilation, chunk, chunkGraph = compilation.chunkGraph) {
+        this.compilation = compilation;
+        this.chunk = chunk;
+        this.chunkGraph = chunkGraph;
+    }
+    identifier() {
+        return `webpack/runtime/${this.name}`;
+    }
+    readableIdentifier(requestShortener) {
+        return `webpack/runtime/${this.name}`;
+    }
+    needBuild(context, callback) {
+        return callback(null, false);
+    }
+    build(options, compilation, resolver, fs, callback) {
+        // do nothing
+        // should not be called as runtime modules are added later to the compilation
+        callback();
+    }
+    updateHash(hash, context) {
+        hash.update(this.name);
+        hash.update(`${this.stage}`);
+        try {
+            if (this.fullHash || this.dependentHash) {
+                // Do not use getGeneratedCode here, because i. e. compilation hash might be not
+                // ready at this point. We will cache it later instead.
+                hash.update(this.generate());
+            }
+            else {
+                hash.update(this.getGeneratedCode());
+            }
+        }
+        catch (err) {
+            hash.update(err.message);
+        }
+        super.updateHash(hash, context);
+    }
+    getSourceTypes() {
+        return TYPES;
+    }
+    codeGeneration(context) {
+        const sources = new Map();
+        const generatedCode = this.getGeneratedCode();
+        if (generatedCode) {
+            sources.set(ModuleTypeConstants_1.WEBPACK_MODULE_TYPE_RUNTIME, this.useSourceMap || this.useSimpleSourceMap
+                ? new webpack_sources_1.OriginalSource(generatedCode, this.identifier())
+                : new webpack_sources_1.RawSource(generatedCode));
+        }
+        return {
+            sources,
+            runtimeRequirements: null,
+        };
+    }
+    size(type) {
+        try {
+            const source = this.getGeneratedCode();
+            return source ? source.length : 0;
+        }
+        catch (e) {
+            return 0;
+        }
+    }
+    generate() {
+        const AbstractMethodError = require('@/base/errors/AbstractMethodError').default;
+        throw new AbstractMethodError();
+    }
+    getGeneratedCode() {
+        if (this._cachedGeneratedCode) {
+            return this._cachedGeneratedCode;
+        }
+        this._cachedGeneratedCode = this.generate();
+        return this._cachedGeneratedCode;
+    }
+    shouldIsolate() {
+        return true;
+    }
+}
+/**
+ * Runtime modules without any dependencies to other runtime modules
+ */
+RuntimeModule.STAGE_NORMAL = 0;
+/**
+ * Runtime modules with simple dependencies on other runtime modules
+ */
+RuntimeModule.STAGE_BASIC = 5;
+/**
+ * Runtime modules which attach to handlers of other runtime modules
+ */
+RuntimeModule.STAGE_ATTACH = 10;
+/**
+ * Runtime modules which trigger actions on bootstrap
+ */
+RuntimeModule.STAGE_TRIGGER = 20;
+exports.default = RuntimeModule;

package/dist/module/RuntimePlugin.d.ts

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