xhs-mp-pack 1.1.0-beta.0

package/dist/base/AsyncQueue.js

@@ -0,0 +1,263 @@
+"use strict";
+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 HookBaseError_1 = require("./errors/HookBaseError");
+const BaseError_1 = __importDefault(require("./errors/BaseError"));
+const ArrayQueue_1 = __importDefault(require("./ArrayQueue"));
+const QUEUED_STATE = 0;
+const PROCESSING_STATE = 1;
+const DONE_STATE = 2;
+let inHandleResult = 0;
+class AsyncQueueEntry {
+    constructor(item, callback) {
+        this.item = item;
+        this.state = QUEUED_STATE;
+        this.callback = callback;
+        this.callbacks = undefined;
+        this.result = undefined;
+        this.error = undefined;
+    }
+}
+class AsyncQueue {
+    constructor({ name, parallelism, parent, processor, getKey, }) {
+        this._name = name;
+        this._parallelism = parallelism || 1;
+        this._processor = processor;
+        this._getKey = getKey || (item => item);
+        this._entries = new Map();
+        this._queued = new ArrayQueue_1.default();
+        this._children = undefined;
+        this._activeTasks = 0;
+        this._willEnsureProcessing = false;
+        this._needProcessing = false;
+        this._stopped = false;
+        this._root = parent ? parent._root : this;
+        if (parent) {
+            if (this._root._children === undefined) {
+                this._root._children = [this];
+            }
+            else {
+                this._root._children.push(this);
+            }
+        }
+        this.hooks = {
+            beforeAdd: new tapable_1.AsyncSeriesHook(['item']),
+            added: new tapable_1.SyncHook(['item']),
+            beforeStart: new tapable_1.AsyncSeriesHook(['item']),
+            started: new tapable_1.SyncHook(['item']),
+            result: new tapable_1.SyncHook(['item', 'error', 'result']),
+        };
+        this._ensureProcessing = this._ensureProcessing.bind(this);
+    }
+    add(item, callback) {
+        if (this._stopped)
+            return callback(new BaseError_1.default('Queue was stopped'));
+        this.hooks.beforeAdd.callAsync(item, err => {
+            if (err) {
+                callback((0, HookBaseError_1.makeBaseError)(err, `AsyncQueue(${this._name}).hooks.beforeAdd`));
+                return;
+            }
+            const key = this._getKey(item);
+            const entry = this._entries.get(key);
+            if (entry !== undefined) {
+                if (entry.state === DONE_STATE) {
+                    if (inHandleResult++ > 3) {
+                        process.nextTick(() => callback(entry.error, entry.result));
+                    }
+                    else {
+                        callback(entry.error, entry.result);
+                    }
+                    inHandleResult--;
+                }
+                else if (entry.callbacks === undefined) {
+                    entry.callbacks = [callback];
+                }
+                else {
+                    entry.callbacks.push(callback);
+                }
+                return;
+            }
+            const newEntry = new AsyncQueueEntry(item, callback);
+            if (this._stopped) {
+                this.hooks.added.call(item);
+                this._root._activeTasks++;
+                process.nextTick(() => this._handleResult(newEntry, new BaseError_1.default('Queue was stopped')));
+            }
+            else {
+                this._entries.set(key, newEntry);
+                this._queued.enqueue(newEntry);
+                const root = this._root;
+                root._needProcessing = true;
+                if (root._willEnsureProcessing === false) {
+                    root._willEnsureProcessing = true;
+                    setImmediate(root._ensureProcessing);
+                }
+                this.hooks.added.call(item);
+            }
+        });
+    }
+    invalidate(item) {
+        const key = this._getKey(item);
+        const entry = this._entries.get(key);
+        this._entries.delete(key);
+        if (entry.state === QUEUED_STATE) {
+            this._queued.delete(entry);
+        }
+    }
+    waitFor(item, callback) {
+        const key = this._getKey(item);
+        const entry = this._entries.get(key);
+        if (entry === undefined) {
+            return callback(new BaseError_1.default('waitFor can only be called for an already started item'));
+        }
+        if (entry.state === DONE_STATE) {
+            process.nextTick(() => callback(entry.error, entry.result));
+        }
+        else if (entry.callbacks === undefined) {
+            entry.callbacks = [callback];
+        }
+        else {
+            entry.callbacks.push(callback);
+        }
+    }
+    stop() {
+        this._stopped = true;
+        const queue = this._queued;
+        this._queued = new ArrayQueue_1.default();
+        const root = this._root;
+        for (const entry of queue) {
+            this._entries.delete(this._getKey(entry.item));
+            root._activeTasks++;
+            this._handleResult(entry, new BaseError_1.default('Queue was stopped'));
+        }
+    }
+    increaseParallelism() {
+        const root = this._root;
+        root._parallelism++;
+        /* istanbul ignore next */
+        if (root._willEnsureProcessing === false && root._needProcessing) {
+            root._willEnsureProcessing = true;
+            setImmediate(root._ensureProcessing);
+        }
+    }
+    decreaseParallelism() {
+        const root = this._root;
+        root._parallelism--;
+    }
+    isProcessing(item) {
+        const key = this._getKey(item);
+        const entry = this._entries.get(key);
+        return entry !== undefined && entry.state === PROCESSING_STATE;
+    }
+    isQueued(item) {
+        const key = this._getKey(item);
+        const entry = this._entries.get(key);
+        return entry !== undefined && entry.state === QUEUED_STATE;
+    }
+    isDone(item) {
+        const key = this._getKey(item);
+        const entry = this._entries.get(key);
+        return entry !== undefined && entry.state === DONE_STATE;
+    }
+    _ensureProcessing() {
+        while (this._activeTasks < this._parallelism) {
+            const entry = this._queued.dequeue();
+            if (entry === undefined)
+                break;
+            this._activeTasks++;
+            entry.state = PROCESSING_STATE;
+            this._startProcessing(entry);
+        }
+        this._willEnsureProcessing = false;
+        if (this._queued.length > 0)
+            return;
+        if (this._children !== undefined) {
+            for (const child of this._children) {
+                while (this._activeTasks < this._parallelism) {
+                    const entry = child._queued.dequeue();
+                    if (entry === undefined)
+                        break;
+                    this._activeTasks++;
+                    entry.state = PROCESSING_STATE;
+                    child._startProcessing(entry);
+                }
+                if (child._queued.length > 0)
+                    return;
+            }
+        }
+        if (!this._willEnsureProcessing)
+            this._needProcessing = false;
+    }
+    _startProcessing(entry) {
+        this.hooks.beforeStart.callAsync(entry.item, err => {
+            if (err) {
+                this._handleResult(entry, (0, HookBaseError_1.makeBaseError)(err, `AsyncQueue(${this._name}).hooks.beforeStart`));
+                return;
+            }
+            let inCallback = false;
+            try {
+                this._processor(entry.item, (e, r) => {
+                    inCallback = true;
+                    this._handleResult(entry, e, r);
+                });
+            }
+            catch (err) {
+                if (inCallback)
+                    throw err;
+                this._handleResult(entry, err, null);
+            }
+            this.hooks.started.call(entry.item);
+        });
+    }
+    _handleResult(entry, err, result) {
+        this.hooks.result.callAsync(entry.item, err, result, hookError => {
+            const error = hookError
+                ? (0, HookBaseError_1.makeBaseError)(hookError, `AsyncQueue(${this._name}).hooks.result`)
+                : err;
+            const callback = entry.callback;
+            const callbacks = entry.callbacks;
+            entry.state = DONE_STATE;
+            entry.callback = undefined;
+            entry.callbacks = undefined;
+            entry.result = result;
+            entry.error = error;
+            const root = this._root;
+            root._activeTasks--;
+            if (root._willEnsureProcessing === false && root._needProcessing) {
+                root._willEnsureProcessing = true;
+                setImmediate(root._ensureProcessing);
+            }
+            if (inHandleResult++ > 3) {
+                process.nextTick(() => {
+                    callback(error, result);
+                    if (callbacks !== undefined) {
+                        for (const callback of callbacks) {
+                            callback(error, result);
+                        }
+                    }
+                });
+            }
+            else {
+                callback(error, result);
+                if (callbacks !== undefined) {
+                    for (const callback of callbacks) {
+                        callback(error, result);
+                    }
+                }
+            }
+            inHandleResult--;
+        });
+    }
+    clear() {
+        this._entries.clear();
+        this._queued.clear();
+        this._activeTasks = 0;
+        this._willEnsureProcessing = false;
+        this._needProcessing = false;
+        this._stopped = false;
+    }
+}
+exports.default = AsyncQueue;

package/dist/base/ChunkHelpers.d.ts

@@ -0,0 +1,3 @@
+import Chunk from '@/chunk/Chunk';
+declare const getAllChunks: (entrypoint: any, excludedChunk1?: Chunk, excludedChunk2?: Chunk) => Set<Chunk>;
+export { getAllChunks };

package/dist/base/ChunkHelpers.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllChunks = void 0;
+const Entrypoint_1 = __importDefault(require("@/chunk/Entrypoint"));
+const getAllChunks = (entrypoint, excludedChunk1, excludedChunk2) => {
+    const queue = new Set([entrypoint]);
+    const chunks = new Set();
+    for (const entrypoint of queue) {
+        for (const chunk of entrypoint.chunks) {
+            if (chunk === excludedChunk1)
+                continue;
+            if (chunk === excludedChunk2)
+                continue;
+            chunks.add(chunk);
+        }
+        for (const parent of entrypoint.parentsIterable) {
+            if (parent instanceof Entrypoint_1.default)
+                queue.add(parent);
+        }
+    }
+    return chunks;
+};
+exports.getAllChunks = getAllChunks;

package/dist/base/ConditionalInitFragment.d.ts

@@ -0,0 +1,9 @@
+import InitFragment from '@/base/InitFragment';
+declare class ConditionalInitFragment extends InitFragment {
+    runtimeCondition: boolean;
+    constructor(content: any, stage: number, position: number, key: string | undefined, runtimeCondition?: boolean, endContent?: any);
+    getContent(context: any): any;
+    getEndContent(context: any): any;
+    merge(other: any): any;
+}
+export default ConditionalInitFragment;

package/dist/base/ConditionalInitFragment.js

@@ -0,0 +1,64 @@
+"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 InitFragment_1 = __importDefault(require("@/base/InitFragment"));
+const Template_1 = require("@/template/Template");
+const RuntimeHelpers_1 = require("@/module/RuntimeHelpers");
+const wrapInCondition = (condition, source) => {
+    if (typeof source === 'string') {
+        return Template_1.Template.asString([`if (${condition}) {`, Template_1.Template.indent(source), '}', '']);
+    }
+    return new webpack_sources_1.ConcatSource(`if (${condition}) {\n`, new webpack_sources_1.PrefixSource('\t', source), '}\n');
+};
+class ConditionalInitFragment extends InitFragment_1.default {
+    constructor(content, stage, position, key, runtimeCondition = true, endContent) {
+        super(content, stage, position, key, endContent);
+        this.runtimeCondition = runtimeCondition;
+    }
+    getContent(context) {
+        if (this.runtimeCondition === false || !this.content)
+            return '';
+        if (this.runtimeCondition === true)
+            return this.content;
+        const expr = context.runtimeTemplate.runtimeConditionExpression({
+            chunkGraph: context.chunkGraph,
+            runtimeRequirements: context.runtimeRequirements,
+            runtime: context.runtime,
+            runtimeCondition: this.runtimeCondition,
+        });
+        if (expr === 'true')
+            return this.content;
+        return wrapInCondition(expr, this.content);
+    }
+    getEndContent(context) {
+        if (this.runtimeCondition === false || !this.endContent)
+            return '';
+        if (this.runtimeCondition === true)
+            return this.endContent;
+        const expr = context.runtimeTemplate.runtimeConditionExpression({
+            chunkGraph: context.chunkGraph,
+            runtimeRequirements: context.runtimeRequirements,
+            runtime: context.runtime,
+            runtimeCondition: this.runtimeCondition,
+        });
+        if (expr === 'true')
+            return this.endContent;
+        return wrapInCondition(expr, this.endContent);
+    }
+    merge(other) {
+        if (this.runtimeCondition === true)
+            return this;
+        if (other.runtimeCondition === true)
+            return other;
+        if (this.runtimeCondition === false)
+            return other;
+        if (other.runtimeCondition === false)
+            return this;
+        const runtimeCondition = (0, RuntimeHelpers_1.mergeRuntime)(this.runtimeCondition, other.runtimeCondition);
+        return new ConditionalInitFragment(this.content, this.stage, this.position, this.key, runtimeCondition, this.endContent);
+    }
+}
+exports.default = ConditionalInitFragment;

package/dist/base/GraphHelpers.d.ts

@@ -0,0 +1,6 @@
+declare const connectChunkGroupAndChunk: (chunkGroup: any, chunk: any) => void;
+declare const connectChunkGroupParentAndChild: (parent: any, child: any) => void;
+declare const connectChunkAndModule: (chunk: any, module: any) => void;
+declare const disconnectChunkAndModule: (chunk: any, module: any) => void;
+declare const connectDependenciesBlockAndChunkGroup: (depBlock: any, chunkGroup: any) => void;
+export { connectChunkGroupAndChunk, connectChunkGroupParentAndChild, connectChunkAndModule, disconnectChunkAndModule, connectDependenciesBlockAndChunkGroup, };

package/dist/base/GraphHelpers.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectDependenciesBlockAndChunkGroup = exports.disconnectChunkAndModule = exports.connectChunkAndModule = exports.connectChunkGroupParentAndChild = exports.connectChunkGroupAndChunk = void 0;
+const connectChunkGroupAndChunk = (chunkGroup, chunk) => {
+    if (chunkGroup.pushChunk(chunk)) {
+        chunk.addGroup(chunkGroup);
+    }
+};
+exports.connectChunkGroupAndChunk = connectChunkGroupAndChunk;
+const connectChunkGroupParentAndChild = (parent, child) => {
+    if (parent.addChild(child)) {
+        child.addParent(parent);
+    }
+};
+exports.connectChunkGroupParentAndChild = connectChunkGroupParentAndChild;
+const connectChunkAndModule = (chunk, module) => {
+    if (module.addChunk(chunk)) {
+        chunk.addModule(module);
+    }
+};
+exports.connectChunkAndModule = connectChunkAndModule;
+const disconnectChunkAndModule = (chunk, module) => {
+    chunk.removeModule(module);
+    module.removeChunk(chunk);
+};
+exports.disconnectChunkAndModule = disconnectChunkAndModule;
+const connectDependenciesBlockAndChunkGroup = (depBlock, chunkGroup) => {
+    if (chunkGroup.addBlock(depBlock)) {
+        depBlock.chunkGroup = chunkGroup;
+    }
+};
+exports.connectDependenciesBlockAndChunkGroup = connectDependenciesBlockAndChunkGroup;

package/dist/base/Hash.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+declare class Hash {
+    update(data: string | Buffer, inputEncoding?: string): void;
+    digest(encoding?: string): void;
+}
+export default Hash;

package/dist/base/Hash.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Hash {
+    update(data, inputEncoding) {
+        const AbstractMethodError = require('./errors/AbstractMethodError').default;
+        throw new AbstractMethodError();
+    }
+    digest(encoding) {
+        const AbstractMethodError = require('./errors/AbstractMethodError').default;
+        throw new AbstractMethodError();
+    }
+}
+exports.default = Hash;

package/dist/base/InitFragment.d.ts

@@ -0,0 +1,22 @@
+import { Source } from 'webpack-sources';
+declare class InitFragment {
+    static STAGE_HARMONY_IMPORTS: any;
+    content: any;
+    stage: any;
+    position: any;
+    key: any;
+    endContent: any;
+    static STAGE_CONSTANTS: number;
+    static STAGE_ASYNC_BOUNDARY: number;
+    static STAGE_HARMONY_EXPORTS: number;
+    static STAGE_PROVIDES: number;
+    static STAGE_ASYNC_DEPENDENCIES: number;
+    static STAGE_ASYNC_HARMONY_IMPORTS: number;
+    constructor(content: string | Source, stage: number, position: number, key?: string, endContent?: string | Source);
+    getContent(context: any): any;
+    getEndContent(context: any): any;
+    static addToSource(source: any, initFragments: any, context: any): any;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default InitFragment;

package/dist/base/InitFragment.js

@@ -0,0 +1,113 @@
+"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 makeSerializable_1 = __importDefault(require("../serialization/makeSerializable"));
+const extractFragmentIndex = (fragment, index) => [fragment, index];
+const sortFragmentWithIndex = ([a, i], [b, j]) => {
+    const stageCmp = a.stage - b.stage;
+    if (stageCmp !== 0)
+        return stageCmp;
+    const positionCmp = a.position - b.position;
+    if (positionCmp !== 0)
+        return positionCmp;
+    return i - j;
+};
+class InitFragment {
+    constructor(content, stage, position, key, endContent) {
+        this.content = content;
+        this.stage = stage;
+        this.position = position;
+        this.key = key;
+        this.endContent = endContent;
+    }
+    getContent(context) {
+        return this.content;
+    }
+    getEndContent(context) {
+        return this.endContent;
+    }
+    static addToSource(source, initFragments, context) {
+        if (initFragments.length > 0) {
+            // Sort fragments by position. If 2 fragments have the same position,
+            // use their index.
+            const sortedFragments = initFragments.map(extractFragmentIndex).sort(sortFragmentWithIndex);
+            // Deduplicate fragments. If a fragment has no key, it is always included.
+            const keyedFragments = new Map();
+            for (const [fragment] of sortedFragments) {
+                if (typeof fragment.mergeAll === 'function') {
+                    if (!fragment.key) {
+                        throw new Error(`InitFragment with mergeAll function must have a valid key: ${fragment.constructor.name}`);
+                    }
+                    const oldValue = keyedFragments.get(fragment.key);
+                    if (oldValue === undefined) {
+                        keyedFragments.set(fragment.key, fragment);
+                    }
+                    else if (Array.isArray(oldValue)) {
+                        oldValue.push(fragment);
+                    }
+                    else {
+                        keyedFragments.set(fragment.key, [oldValue, fragment]);
+                    }
+                    continue;
+                }
+                else if (typeof fragment.merge === 'function') {
+                    const oldValue = keyedFragments.get(fragment.key);
+                    if (oldValue !== undefined) {
+                        keyedFragments.set(fragment.key, fragment.merge(oldValue));
+                        continue;
+                    }
+                }
+                // eslint-disable-next-line symbol-description
+                keyedFragments.set(fragment.key || Symbol(), fragment);
+            }
+            const concatSource = new webpack_sources_1.ConcatSource();
+            const endContents = [];
+            for (let fragment of keyedFragments.values()) {
+                if (Array.isArray(fragment)) {
+                    fragment = fragment[0].mergeAll(fragment);
+                }
+                concatSource.add(fragment.getContent(context));
+                const endContent = fragment.getEndContent(context);
+                if (endContent) {
+                    endContents.push(endContent);
+                }
+            }
+            concatSource.add(source);
+            for (const content of endContents.reverse()) {
+                concatSource.add(content);
+            }
+            return concatSource;
+        }
+        return source;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.content);
+        write(this.stage);
+        write(this.position);
+        write(this.key);
+        write(this.endContent);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.content = read();
+        this.stage = read();
+        this.position = read();
+        this.key = read();
+        this.endContent = read();
+    }
+}
+(0, makeSerializable_1.default)(InitFragment, 'mp-compiler/base/InitFragment');
+// @ts-ignore
+InitFragment.prototype.merge = undefined;
+InitFragment.STAGE_CONSTANTS = 10;
+InitFragment.STAGE_ASYNC_BOUNDARY = 20;
+InitFragment.STAGE_HARMONY_EXPORTS = 30;
+InitFragment.STAGE_HARMONY_IMPORTS = 40;
+InitFragment.STAGE_PROVIDES = 50;
+InitFragment.STAGE_ASYNC_DEPENDENCIES = 60;
+InitFragment.STAGE_ASYNC_HARMONY_IMPORTS = 70;
+exports.default = InitFragment;

package/dist/base/IterableHelpers.d.ts

@@ -0,0 +1,4 @@
+declare const last: (set: any) => any;
+declare const someInIterable: (iterable: any, filter: any) => boolean;
+declare const countIterable: (iterable: any) => number;
+export { last, someInIterable, countIterable };

package/dist/base/IterableHelpers.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countIterable = exports.someInIterable = exports.last = void 0;
+const last = set => {
+    let last;
+    for (const item of set)
+        last = item;
+    return last;
+};
+exports.last = last;
+const someInIterable = (iterable, filter) => {
+    for (const item of iterable) {
+        if (filter(item))
+            return true;
+    }
+    return false;
+};
+exports.someInIterable = someInIterable;
+const countIterable = iterable => {
+    let i = 0;
+    // eslint-disable-next-line no-unused-vars
+    for (const _ of iterable)
+        i++;
+    return i;
+};
+exports.countIterable = countIterable;

package/dist/base/LazyBucketSortedSet.d.ts

@@ -0,0 +1,34 @@
+import SortableSet from './SortableSet';
+/**
+ * Multi layer bucket sorted set:
+ * Supports adding non-existing items (DO NOT ADD ITEM TWICE),
+ * Supports removing exiting items (DO NOT REMOVE ITEM NOT IN SET),
+ * Supports popping the first items according to defined order,
+ * Supports iterating all items without order,
+ * Supports updating an item in an efficient way,
+ * Supports size property, which is the number of items,
+ * Items are lazy partially sorted when needed
+ * @template T
+ * @template K
+ */
+declare class LazyBucketSortedSet {
+    _getKey: any;
+    _innerArgs: any[];
+    _leaf: boolean;
+    _keys: SortableSet;
+    _map: Map<any, any>;
+    _unsortedItems: Set<unknown>;
+    size: number;
+    constructor(getKey: any, comparator: any, ...args: any[]);
+    add(item: any): void;
+    _addInternal(key: any, item: any): void;
+    delete(item: any): void;
+    _deleteKey(key: any): void;
+    popFirst(): any;
+    startUpdate(item: any): (remove?: any) => void;
+    _appendIterators(iterators: any): void;
+    [Symbol.iterator](): {
+        next: () => any;
+    };
+}
+export default LazyBucketSortedSet;