xhs-mp-pack 1.1.0-beta.0

package/dist/base/LazyBucketSortedSet.js

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const SetHelpers_1 = require("./SetHelpers");
+const SortableSet_1 = __importDefault(require("./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
+ */
+class LazyBucketSortedSet {
+    constructor(getKey, comparator, ...args) {
+        this._getKey = getKey;
+        this._innerArgs = args;
+        this._leaf = args.length <= 1;
+        this._keys = new SortableSet_1.default(undefined, comparator);
+        this._map = new Map();
+        this._unsortedItems = new Set();
+        this.size = 0;
+    }
+    add(item) {
+        this.size++;
+        this._unsortedItems.add(item);
+    }
+    _addInternal(key, item) {
+        let entry = this._map.get(key);
+        if (entry === undefined) {
+            entry = this._leaf
+                ? new SortableSet_1.default(undefined, this._innerArgs[0])
+                : // @ts-ignore
+                    new LazyBucketSortedSet(...this._innerArgs);
+            this._keys.add(key);
+            this._map.set(key, entry);
+        }
+        entry.add(item);
+    }
+    delete(item) {
+        this.size--;
+        if (this._unsortedItems.has(item)) {
+            this._unsortedItems.delete(item);
+            return;
+        }
+        const key = this._getKey(item);
+        const entry = this._map.get(key);
+        entry.delete(item);
+        if (entry.size === 0) {
+            this._deleteKey(key);
+        }
+    }
+    _deleteKey(key) {
+        this._keys.delete(key);
+        this._map.delete(key);
+    }
+    popFirst() {
+        if (this.size === 0)
+            return undefined;
+        this.size--;
+        if (this._unsortedItems.size > 0) {
+            for (const item of this._unsortedItems) {
+                const key = this._getKey(item);
+                this._addInternal(key, item);
+            }
+            this._unsortedItems.clear();
+        }
+        this._keys.sort();
+        const key = (0, SetHelpers_1.first)(this._keys);
+        const entry = this._map.get(key);
+        if (this._leaf) {
+            const leafEntry = entry;
+            leafEntry.sort();
+            const item = (0, SetHelpers_1.first)(leafEntry);
+            leafEntry.delete(item);
+            if (leafEntry.size === 0) {
+                this._deleteKey(key);
+            }
+            return item;
+        }
+        const nodeEntry = entry;
+        const item = nodeEntry.popFirst();
+        if (nodeEntry.size === 0) {
+            this._deleteKey(key);
+        }
+        return item;
+    }
+    startUpdate(item) {
+        if (this._unsortedItems.has(item)) {
+            return (remove) => {
+                if (remove) {
+                    this._unsortedItems.delete(item);
+                    this.size--;
+                }
+            };
+        }
+        const key = this._getKey(item);
+        if (this._leaf) {
+            const oldEntry = this._map.get(key);
+            return remove => {
+                if (remove) {
+                    this.size--;
+                    oldEntry.delete(item);
+                    if (oldEntry.size === 0) {
+                        this._deleteKey(key);
+                    }
+                    return;
+                }
+                const newKey = this._getKey(item);
+                if (key === newKey) {
+                    // This flags the sortable set as unordered
+                    oldEntry.add(item);
+                }
+                else {
+                    oldEntry.delete(item);
+                    if (oldEntry.size === 0) {
+                        this._deleteKey(key);
+                    }
+                    this._addInternal(newKey, item);
+                }
+            };
+        }
+        const oldEntry = this._map.get(key);
+        const finishUpdate = oldEntry.startUpdate(item);
+        return remove => {
+            if (remove) {
+                this.size--;
+                finishUpdate(true);
+                if (oldEntry.size === 0) {
+                    this._deleteKey(key);
+                }
+                return;
+            }
+            const newKey = this._getKey(item);
+            if (key === newKey) {
+                finishUpdate();
+            }
+            else {
+                finishUpdate(true);
+                if (oldEntry.size === 0) {
+                    this._deleteKey(key);
+                }
+                this._addInternal(newKey, item);
+            }
+        };
+    }
+    _appendIterators(iterators) {
+        if (this._unsortedItems.size > 0)
+            iterators.push(this._unsortedItems[Symbol.iterator]());
+        for (const key of this._keys) {
+            const entry = this._map.get(key);
+            if (this._leaf) {
+                const leafEntry = entry;
+                const iterator = leafEntry[Symbol.iterator]();
+                iterators.push(iterator);
+            }
+            else {
+                const nodeEntry = entry;
+                nodeEntry._appendIterators(iterators);
+            }
+        }
+    }
+    [Symbol.iterator]() {
+        const iterators = [];
+        this._appendIterators(iterators);
+        iterators.reverse();
+        let currentIterator = iterators.pop();
+        return {
+            next: () => {
+                const res = currentIterator.next();
+                if (res.done) {
+                    if (iterators.length === 0)
+                        return res;
+                    currentIterator = iterators.pop();
+                    return currentIterator.next();
+                }
+                return res;
+            },
+        };
+    }
+}
+exports.default = LazyBucketSortedSet;

package/dist/base/LazySet.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Like Set but with an addAll method to eventually add items from another iterable.
+ * Access methods make sure that all delayed operations are executed.
+ * Iteration methods deopts to normal Set performance until clear is called again (because of the chance of modifications during iteration).
+ */
+declare class LazySet {
+    _set: Set<unknown>;
+    _toMerge: Set<unknown>;
+    _toDeepMerge: any[];
+    _needMerge: boolean;
+    _deopt: boolean;
+    constructor(iterable?: any);
+    _flatten(): void;
+    _merge(): void;
+    _isEmpty(): boolean;
+    get size(): number;
+    add(item: any): this;
+    addAll(iterable: any): this;
+    clear(): void;
+    delete(value: any): boolean;
+    entries(): IterableIterator<[unknown, unknown]>;
+    forEach(callbackFn: any, thisArg: any): void;
+    has(item: any): boolean;
+    keys(): IterableIterator<unknown>;
+    values(): IterableIterator<unknown>;
+    [Symbol.iterator](): IterableIterator<unknown>;
+    get [Symbol.toStringTag](): string;
+    serialize({ write }: {
+        write: any;
+    }): void;
+    static deserialize({ read }: {
+        read: any;
+    }): LazySet;
+}
+export default LazySet;

package/dist/base/LazySet.js

@@ -0,0 +1,155 @@
+"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 merge = (targetSet, toMerge) => {
+    for (const set of toMerge) {
+        for (const item of set) {
+            targetSet.add(item);
+        }
+    }
+};
+const flatten = (targetSet, toDeepMerge) => {
+    for (const set of toDeepMerge) {
+        if (set._set.size > 0)
+            targetSet.add(set._set);
+        if (set._needMerge) {
+            for (const mergedSet of set._toMerge) {
+                targetSet.add(mergedSet);
+            }
+            flatten(targetSet, set._toDeepMerge);
+        }
+    }
+};
+/**
+ * Like Set but with an addAll method to eventually add items from another iterable.
+ * Access methods make sure that all delayed operations are executed.
+ * Iteration methods deopts to normal Set performance until clear is called again (because of the chance of modifications during iteration).
+ */
+class LazySet {
+    constructor(iterable) {
+        this._set = new Set(iterable);
+        this._toMerge = new Set();
+        this._toDeepMerge = [];
+        this._needMerge = false;
+        this._deopt = false;
+    }
+    _flatten() {
+        flatten(this._toMerge, this._toDeepMerge);
+        this._toDeepMerge.length = 0;
+    }
+    _merge() {
+        this._flatten();
+        merge(this._set, this._toMerge);
+        this._toMerge.clear();
+        this._needMerge = false;
+    }
+    _isEmpty() {
+        return this._set.size === 0 && this._toMerge.size === 0 && this._toDeepMerge.length === 0;
+    }
+    get size() {
+        if (this._needMerge)
+            this._merge();
+        return this._set.size;
+    }
+    add(item) {
+        this._set.add(item);
+        return this;
+    }
+    addAll(iterable) {
+        if (this._deopt) {
+            const _set = this._set;
+            for (const item of iterable) {
+                _set.add(item);
+            }
+        }
+        else {
+            if (iterable instanceof LazySet) {
+                if (iterable._isEmpty())
+                    return this;
+                this._toDeepMerge.push(iterable);
+                this._needMerge = true;
+                if (this._toDeepMerge.length > 100000) {
+                    this._flatten();
+                }
+            }
+            else {
+                this._toMerge.add(iterable);
+                this._needMerge = true;
+            }
+            if (this._toMerge.size > 100000)
+                this._merge();
+        }
+        return this;
+    }
+    clear() {
+        this._set.clear();
+        this._toMerge.clear();
+        this._toDeepMerge.length = 0;
+        this._needMerge = false;
+        this._deopt = false;
+    }
+    delete(value) {
+        if (this._needMerge)
+            this._merge();
+        return this._set.delete(value);
+    }
+    entries() {
+        this._deopt = true;
+        if (this._needMerge)
+            this._merge();
+        return this._set.entries();
+    }
+    forEach(callbackFn, thisArg) {
+        this._deopt = true;
+        if (this._needMerge)
+            this._merge();
+        this._set.forEach(callbackFn, thisArg);
+    }
+    has(item) {
+        if (this._needMerge)
+            this._merge();
+        return this._set.has(item);
+    }
+    keys() {
+        this._deopt = true;
+        if (this._needMerge)
+            this._merge();
+        return this._set.keys();
+    }
+    values() {
+        this._deopt = true;
+        if (this._needMerge)
+            this._merge();
+        return this._set.values();
+    }
+    [Symbol.iterator]() {
+        this._deopt = true;
+        if (this._needMerge)
+            this._merge();
+        return this._set[Symbol.iterator]();
+    }
+    /* istanbul ignore next */
+    get [Symbol.toStringTag]() {
+        return 'LazySet';
+    }
+    serialize({ write }) {
+        if (this._needMerge)
+            this._merge();
+        write(this._set.size);
+        for (const item of this._set)
+            write(item);
+    }
+    static deserialize({ read }) {
+        const count = read();
+        const items = [];
+        for (let i = 0; i < count; i++) {
+            items.push(read());
+        }
+        return new LazySet(items);
+    }
+}
+(0, makeSerializable_1.default)(LazySet, 'mp-compiler/base/LazySet');
+exports.default = LazySet;

package/dist/base/MapHelpers.d.ts

@@ -0,0 +1,14 @@
+/**
+ * getOrInsert is a helper function for maps that allows you to get a value
+ * from a map if it exists, or insert a new value if it doesn't. If it value doesn't
+ * exist, it will be computed by the provided function.
+ *
+ * @example
+ * ```js
+ * const map = new Map();
+ * const value = getOrInsert(map, "key", () => "value");
+ * console.log(value); // "value"
+ * ```
+ */
+declare const getOrInsert: (map: any, key: any, computer: any) => any;
+export { getOrInsert };

package/dist/base/MapHelpers.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrInsert = void 0;
+/**
+ * getOrInsert is a helper function for maps that allows you to get a value
+ * from a map if it exists, or insert a new value if it doesn't. If it value doesn't
+ * exist, it will be computed by the provided function.
+ *
+ * @example
+ * ```js
+ * const map = new Map();
+ * const value = getOrInsert(map, "key", () => "value");
+ * console.log(value); // "value"
+ * ```
+ */
+const getOrInsert = (map, key, computer) => {
+    // Grab key from map
+    const value = map.get(key);
+    // If the value already exists, return it
+    if (value !== undefined)
+        return value;
+    // Otherwise compute the value, set it in the map, and return it
+    const newValue = computer();
+    map.set(key, newValue);
+    return newValue;
+};
+exports.getOrInsert = getOrInsert;

package/dist/base/ModuleFilenameHelpers.d.ts

@@ -0,0 +1,95 @@
+export declare const ALL_LOADERS_RESOURCE = "[all-loaders][resource]";
+export declare const REGEXP_ALL_LOADERS_RESOURCE: RegExp;
+export declare const LOADERS_RESOURCE = "[loaders][resource]";
+export declare const REGEXP_LOADERS_RESOURCE: RegExp;
+export declare const RESOURCE = "[resource]";
+export declare const REGEXP_RESOURCE: RegExp;
+export declare const ABSOLUTE_RESOURCE_PATH = "[absolute-resource-path]";
+export declare const REGEXP_ABSOLUTE_RESOURCE_PATH: RegExp;
+export declare const RESOURCE_PATH = "[resource-path]";
+export declare const REGEXP_RESOURCE_PATH: RegExp;
+export declare const ALL_LOADERS = "[all-loaders]";
+export declare const REGEXP_ALL_LOADERS: RegExp;
+export declare const LOADERS = "[loaders]";
+export declare const REGEXP_LOADERS: RegExp;
+export declare const QUERY = "[query]";
+export declare const REGEXP_QUERY: RegExp;
+export declare const ID = "[id]";
+export declare const REGEXP_ID: RegExp;
+export declare const HASH = "[hash]";
+export declare const REGEXP_HASH: RegExp;
+export declare const NAMESPACE = "[namespace]";
+export declare const REGEXP_NAMESPACE: RegExp;
+export declare const createFilename: (module: any, options: any, { requestShortener, chunkGraph, hashFunction }: {
+    requestShortener: any;
+    chunkGraph: any;
+    hashFunction?: string | undefined;
+}) => any;
+/**
+ * Replaces duplicate items in an array with new values generated by a callback function.
+ * The callback function is called with the duplicate item, the index of the duplicate item, and the number of times the item has been replaced.
+ * The callback function should return the new value for the duplicate item.
+ *
+ * @template T
+ * @param {T[]} array the array with duplicates to be replaced
+ * @param {(duplicateItem: T, duplicateItemIndex: number, numberOfTimesReplaced: number) => T} fn callback function to generate new values for the duplicate items
+ * @param {(firstElement:T, nextElement:T) => -1 | 0 | 1} [comparator] optional comparator function to sort the duplicate items
+ * @returns {T[]} the array with duplicates replaced
+ *
+ * @example
+ * ```js
+ * const array = ["a", "b", "c", "a", "b", "a"];
+ * const result = replaceDuplicates(array, (item, index, count) => `${item}-${count}`);
+ * // result: ["a-1", "b-1", "c", "a-2", "b-2", "a-3"]
+ * ```
+ */
+export declare const replaceDuplicates: (array: any, fn: any, comparator?: any) => any;
+/**
+ * Tests if a string matches a RegExp or an array of RegExp.
+ *
+ * @param {string} str string to test
+ * @param {Matcher} test value which will be used to match against the string
+ * @returns {boolean} true, when the RegExp matches
+ *
+ * @example
+ * ```js
+ * matchPart("foo.js", "foo"); // true
+ * matchPart("foo.js", "foo.js"); // true
+ * matchPart("foo.js", "foo."); // false
+ * matchPart("foo.js", "foo*"); // false
+ * matchPart("foo.js", "foo.*"); // true
+ * matchPart("foo.js", /^foo/); // true
+ * matchPart("foo.js", [/^foo/, "bar"]); // true
+ * matchPart("foo.js", [/^foo/, "bar"]); // true
+ * matchPart("foo.js", [/^foo/, /^bar/]); // true
+ * matchPart("foo.js", [/^baz/, /^bar/]); // false
+ * ```
+ */
+export declare const matchPart: (str: any, test: any) => any;
+/**
+ * Tests if a string matches a match object. The match object can have the following properties:
+ * - `test`: a RegExp or an array of RegExp
+ * - `include`: a RegExp or an array of RegExp
+ * - `exclude`: a RegExp or an array of RegExp
+ *
+ * The `test` property is tested first, then `include` and then `exclude`.
+ *
+ * @param {MatchObject} obj a match object to test against the string
+ * @param {string} str string to test against the matching object
+ * @returns {boolean} true, when the object matches
+ * @example
+ * ```js
+ * matchObject({ test: "foo.js" }, "foo.js"); // true
+ * matchObject({ test: /^foo/ }, "foo.js"); // true
+ * matchObject({ test: [/^foo/, "bar"] }, "foo.js"); // true
+ * matchObject({ test: [/^foo/, "bar"] }, "baz.js"); // false
+ * matchObject({ include: "foo.js" }, "foo.js"); // true
+ * matchObject({ include: "foo.js" }, "bar.js"); // false
+ * matchObject({ include: /^foo/ }, "foo.js"); // true
+ * matchObject({ include: [/^foo/, "bar"] }, "foo.js"); // true
+ * matchObject({ include: [/^foo/, "bar"] }, "baz.js"); // false
+ * matchObject({ exclude: "foo.js" }, "foo.js"); // false
+ * matchObject({ exclude: [/^foo/, "bar"] }, "foo.js"); // false
+ * ```
+ */
+export declare const matchObject: (obj: any, str: any) => boolean;