xhs-mp-pack 1.1.0-beta.0

package/dist/base/SetHelpers.d.ts

@@ -0,0 +1,36 @@
+/**
+ * intersect creates Set containing the intersection of elements between all sets
+ * @template T
+ * @param {Set<T>[]} sets an array of sets being checked for shared elements
+ * @returns {Set<T>} returns a new Set containing the intersecting items
+ */
+declare const intersect: (sets: any) => Set<unknown>;
+/**
+ * Checks if a set is the subset of another set
+ * @template T
+ * @param {Set<T>} bigSet a Set which contains the original elements to compare against
+ * @param {Set<T>} smallSet the set whose elements might be contained inside of bigSet
+ * @returns {boolean} returns true if smallSet contains all elements inside of the bigSet
+ */
+declare const isSubset: (bigSet: any, smallSet: any) => boolean;
+/**
+ * @template T
+ * @param {Set<T>} set a set
+ * @param {function(T): boolean} fn selector function
+ * @returns {T | undefined} found item
+ */
+declare const find: (set: any, fn: any) => any;
+/**
+ * @template T
+ * @param {Set<T>} set a set
+ * @returns {T | undefined} first item
+ */
+declare const first: (set: any) => any;
+/**
+ * @template T
+ * @param {Set<T>} a first
+ * @param {Set<T>} b second
+ * @returns {Set<T>} combined set, may be identical to a or b
+ */
+declare const combine: (a: any, b: any) => any;
+export { intersect, isSubset, find, first, combine };

package/dist/base/SetHelpers.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combine = exports.first = exports.find = exports.isSubset = exports.intersect = void 0;
+/**
+ * intersect creates Set containing the intersection of elements between all sets
+ * @template T
+ * @param {Set<T>[]} sets an array of sets being checked for shared elements
+ * @returns {Set<T>} returns a new Set containing the intersecting items
+ */
+const intersect = sets => {
+    if (sets.length === 0)
+        return new Set();
+    if (sets.length === 1)
+        return new Set(sets[0]);
+    let minSize = Infinity;
+    let minIndex = -1;
+    for (let i = 0; i < sets.length; i++) {
+        const size = sets[i].size;
+        if (size < minSize) {
+            minIndex = i;
+            minSize = size;
+        }
+    }
+    const current = new Set(sets[minIndex]);
+    for (let i = 0; i < sets.length; i++) {
+        if (i === minIndex)
+            continue;
+        const set = sets[i];
+        for (const item of current) {
+            if (!set.has(item)) {
+                current.delete(item);
+            }
+        }
+    }
+    return current;
+};
+exports.intersect = intersect;
+/**
+ * Checks if a set is the subset of another set
+ * @template T
+ * @param {Set<T>} bigSet a Set which contains the original elements to compare against
+ * @param {Set<T>} smallSet the set whose elements might be contained inside of bigSet
+ * @returns {boolean} returns true if smallSet contains all elements inside of the bigSet
+ */
+const isSubset = (bigSet, smallSet) => {
+    if (bigSet.size < smallSet.size)
+        return false;
+    for (const item of smallSet) {
+        if (!bigSet.has(item))
+            return false;
+    }
+    return true;
+};
+exports.isSubset = isSubset;
+/**
+ * @template T
+ * @param {Set<T>} set a set
+ * @param {function(T): boolean} fn selector function
+ * @returns {T | undefined} found item
+ */
+const find = (set, fn) => {
+    for (const item of set) {
+        if (fn(item))
+            return item;
+    }
+};
+exports.find = find;
+/**
+ * @template T
+ * @param {Set<T>} set a set
+ * @returns {T | undefined} first item
+ */
+const first = set => {
+    const entry = set.values().next();
+    return entry.done ? undefined : entry.value;
+};
+exports.first = first;
+/**
+ * @template T
+ * @param {Set<T>} a first
+ * @param {Set<T>} b second
+ * @returns {Set<T>} combined set, may be identical to a or b
+ */
+const combine = (a, b) => {
+    if (b.size === 0)
+        return a;
+    if (a.size === 0)
+        return b;
+    const set = new Set(a);
+    for (const item of b)
+        set.add(item);
+    return set;
+};
+exports.combine = combine;

package/dist/base/SizeFormatHelpers.d.ts

@@ -0,0 +1,2 @@
+declare const formatSize: (size: number) => string;
+export { formatSize };

package/dist/base/SizeFormatHelpers.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSize = void 0;
+const formatSize = (size) => {
+    if (typeof size !== 'number' || Number.isNaN(size) === true) {
+        return 'unknown size';
+    }
+    if (size <= 0) {
+        return '0 bytes';
+    }
+    const abbreviations = ['bytes', 'KiB', 'MiB', 'GiB'];
+    const index = Math.floor(Math.log(size) / Math.log(1024));
+    return `${+(size / Math.pow(1024, index)).toPrecision(3)} ${abbreviations[index]}`;
+};
+exports.formatSize = formatSize;

package/dist/base/SizeOnlySource.d.ts

@@ -0,0 +1,14 @@
+import { Source } from 'webpack-sources';
+declare class SizeOnlySource extends Source {
+    _size: any;
+    constructor(size: any);
+    _error(): Error;
+    size(): any;
+    source(options?: any): string;
+    node(): void;
+    listMap(): void;
+    map(options?: any): any;
+    listNode(): void;
+    updateHash(): void;
+}
+export default SizeOnlySource;

package/dist/base/SizeOnlySource.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_sources_1 = require("webpack-sources");
+class SizeOnlySource extends webpack_sources_1.Source {
+    constructor(size) {
+        super();
+        this._size = size;
+    }
+    _error() {
+        return new Error('Content and Map of this Source is no longer available (only size() is supported)');
+    }
+    size() {
+        return this._size;
+    }
+    source(options) {
+        throw this._error();
+    }
+    node() {
+        throw this._error();
+    }
+    listMap() {
+        throw this._error();
+    }
+    map(options) {
+        throw this._error();
+    }
+    listNode() {
+        throw this._error();
+    }
+    updateHash() {
+        throw this._error();
+    }
+}
+exports.default = SizeOnlySource;

package/dist/base/SortableSet.d.ts

@@ -0,0 +1,18 @@
+declare class SortableSet extends Set {
+    _sortFn: any;
+    _lastActiveSortFn: any;
+    _cache: any;
+    _cacheOrderIndependent: any;
+    constructor(initialIterable?: any, defaultSort?: any);
+    add(value: any): this;
+    delete(value: any): boolean;
+    clear(): void;
+    sortWith(sortFn: any): void;
+    sort(): this;
+    getFromCache(fn: any): any;
+    getFromUnorderedCache(fn: any): any;
+    _invalidateCache(): void;
+    _invalidateOrderedCache(): void;
+    toJSON(): any[];
+}
+export default SortableSet;

package/dist/base/SortableSet.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const NONE = Symbol('not sorted');
+class SortableSet extends Set {
+    constructor(initialIterable, defaultSort) {
+        super(initialIterable);
+        this._sortFn = defaultSort;
+        this._lastActiveSortFn = NONE;
+        this._cache = undefined;
+        this._cacheOrderIndependent = undefined;
+    }
+    add(value) {
+        this._lastActiveSortFn = NONE;
+        this._invalidateCache();
+        this._invalidateOrderedCache();
+        super.add(value);
+        return this;
+    }
+    delete(value) {
+        this._invalidateCache();
+        this._invalidateOrderedCache();
+        return super.delete(value);
+    }
+    clear() {
+        this._invalidateCache();
+        this._invalidateOrderedCache();
+        return super.clear();
+    }
+    sortWith(sortFn) {
+        if (this.size <= 1 || sortFn === this._lastActiveSortFn) {
+            // already sorted - nothing to do
+            return;
+        }
+        const sortedArray = Array.from(this).sort(sortFn);
+        super.clear();
+        for (let i = 0; i < sortedArray.length; i += 1) {
+            super.add(sortedArray[i]);
+        }
+        this._lastActiveSortFn = sortFn;
+        this._invalidateCache();
+    }
+    sort() {
+        this.sortWith(this._sortFn);
+        return this;
+    }
+    getFromCache(fn) {
+        if (this._cache === undefined) {
+            this._cache = new Map();
+        }
+        else {
+            const result = this._cache.get(fn);
+            const data = result;
+            if (data !== undefined) {
+                return data;
+            }
+        }
+        const newData = fn(this);
+        this._cache.set(fn, newData);
+        return newData;
+    }
+    getFromUnorderedCache(fn) {
+        if (this._cacheOrderIndependent === undefined) {
+            this._cacheOrderIndependent = new Map();
+        }
+        else {
+            const result = this._cacheOrderIndependent.get(fn);
+            const data = result;
+            if (data !== undefined) {
+                return data;
+            }
+        }
+        const newData = fn(this);
+        this._cacheOrderIndependent.set(fn, newData);
+        return newData;
+    }
+    _invalidateCache() {
+        if (this._cache !== undefined) {
+            this._cache.clear();
+        }
+    }
+    _invalidateOrderedCache() {
+        if (this._cacheOrderIndependent !== undefined) {
+            this._cacheOrderIndependent.clear();
+        }
+    }
+    toJSON() {
+        return Array.from(this);
+    }
+}
+exports.default = SortableSet;

package/dist/base/StackedCacheMap.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @template K
+ * @template V
+ */
+declare class StackedCacheMap {
+    map: Map<any, any>;
+    stack: any[];
+    constructor();
+    addAll(map: any, immutable?: boolean): void;
+    set(item: any, value: any): void;
+    delete(item: any): void;
+    has(item: any): void;
+    get(item: any): any;
+    clear(): void;
+    get size(): number;
+    [Symbol.iterator](): {
+        next(): IteratorResult<[any, any], any>;
+    };
+}
+export default StackedCacheMap;

package/dist/base/StackedCacheMap.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @template K
+ * @template V
+ */
+class StackedCacheMap {
+    constructor() {
+        this.map = new Map();
+        this.stack = [];
+    }
+    addAll(map, immutable) {
+        if (immutable) {
+            this.stack.push(map);
+            // largest map should go first
+            for (let i = this.stack.length - 1; i > 0; i--) {
+                const beforeLast = this.stack[i - 1];
+                if (beforeLast.size >= map.size)
+                    break;
+                this.stack[i] = beforeLast;
+                this.stack[i - 1] = map;
+            }
+        }
+        else {
+            for (const [key, value] of map) {
+                this.map.set(key, value);
+            }
+        }
+    }
+    set(item, value) {
+        this.map.set(item, value);
+    }
+    delete(item) {
+        throw new Error("Items can't be deleted from a StackedCacheMap");
+    }
+    has(item) {
+        throw new Error('Checking StackedCacheMap.has before reading is inefficient, use StackedCacheMap.get and check for undefined');
+    }
+    get(item) {
+        for (const map of this.stack) {
+            const value = map.get(item);
+            if (value !== undefined)
+                return value;
+        }
+        return this.map.get(item);
+    }
+    clear() {
+        this.stack.length = 0;
+        this.map.clear();
+    }
+    get size() {
+        let size = this.map.size;
+        for (const map of this.stack) {
+            size += map.size;
+        }
+        return size;
+    }
+    [Symbol.iterator]() {
+        const iterators = this.stack.map(map => map[Symbol.iterator]());
+        let current = this.map[Symbol.iterator]();
+        return {
+            next() {
+                let result = current.next();
+                while (result.done && iterators.length > 0) {
+                    current = iterators.pop();
+                    result = current.next();
+                }
+                return result;
+            },
+        };
+    }
+}
+exports.default = StackedCacheMap;

package/dist/base/StackedMap.d.ts

@@ -0,0 +1,17 @@
+declare class StackedMap {
+    map: Map<any, any>;
+    stack: any;
+    constructor(parentStack?: any);
+    set(item: any, value: any): void;
+    delete(item: any): void;
+    has(item: any): boolean;
+    get(item: any): any;
+    _compress(): void;
+    asArray(): any[];
+    asSet(): Set<any>;
+    asPairArray(): any[];
+    asMap(): Map<unknown, unknown>;
+    get size(): number;
+    createChild(): StackedMap;
+}
+export default StackedMap;

package/dist/base/StackedMap.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const TOMBSTONE = Symbol('tombstone');
+const UNDEFINED_MARKER = Symbol('undefined');
+const extractPair = pair => {
+    const key = pair[0];
+    const val = pair[1];
+    if (val === UNDEFINED_MARKER || val === TOMBSTONE) {
+        return [key, undefined];
+    }
+    return pair;
+};
+class StackedMap {
+    constructor(parentStack) {
+        this.map = new Map();
+        this.stack = parentStack === undefined ? [] : parentStack.slice();
+        this.stack.push(this.map);
+    }
+    set(item, value) {
+        this.map.set(item, value === undefined ? UNDEFINED_MARKER : value);
+    }
+    delete(item) {
+        if (this.stack.length > 1) {
+            this.map.set(item, TOMBSTONE);
+        }
+        else {
+            this.map.delete(item);
+        }
+    }
+    has(item) {
+        const topValue = this.map.get(item);
+        if (topValue !== undefined) {
+            return topValue !== TOMBSTONE;
+        }
+        if (this.stack.length > 1) {
+            for (let i = this.stack.length - 2; i >= 0; i--) {
+                const value = this.stack[i].get(item);
+                if (value !== undefined) {
+                    this.map.set(item, value);
+                    return value !== TOMBSTONE;
+                }
+            }
+            this.map.set(item, TOMBSTONE);
+        }
+        return false;
+    }
+    get(item) {
+        const topValue = this.map.get(item);
+        if (topValue !== undefined) {
+            return topValue === TOMBSTONE || topValue === UNDEFINED_MARKER ? undefined : topValue;
+        }
+        if (this.stack.length > 1) {
+            for (let i = this.stack.length - 2; i >= 0; i--) {
+                const value = this.stack[i].get(item);
+                if (value !== undefined) {
+                    this.map.set(item, value);
+                    return value === TOMBSTONE || value === UNDEFINED_MARKER ? undefined : value;
+                }
+            }
+            this.map.set(item, TOMBSTONE);
+        }
+        return undefined;
+    }
+    _compress() {
+        if (this.stack.length === 1)
+            return;
+        this.map = new Map();
+        for (const data of this.stack) {
+            for (const pair of data) {
+                if (pair[1] === TOMBSTONE) {
+                    this.map.delete(pair[0]);
+                }
+                else {
+                    this.map.set(pair[0], pair[1]);
+                }
+            }
+        }
+        this.stack = [this.map];
+    }
+    asArray() {
+        this._compress();
+        return Array.from(this.map.keys());
+    }
+    asSet() {
+        this._compress();
+        return new Set(this.map.keys());
+    }
+    asPairArray() {
+        this._compress();
+        return Array.from(this.map.entries(), extractPair);
+    }
+    asMap() {
+        return new Map(this.asPairArray());
+    }
+    get size() {
+        this._compress();
+        return this.map.size;
+    }
+    createChild() {
+        return new StackedMap(this.stack);
+    }
+}
+exports.default = StackedMap;

package/dist/base/StartupHelpers.d.ts

@@ -0,0 +1,4 @@
+declare const generateEntryStartup: (chunkGraph: any, runtimeTemplate: any, entries: any, chunk: any, passive: boolean) => string;
+declare const updateHashForEntryStartup: (hash: any, chunkGraph: any, entries: any, chunk: any) => void;
+declare const getInitialChunkIds: (chunk: any, chunkGraph: any, filterFn: any) => Set<unknown>;
+export { generateEntryStartup, updateHashForEntryStartup, getInitialChunkIds };

package/dist/base/StartupHelpers.js

@@ -0,0 +1,94 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInitialChunkIds = exports.updateHashForEntryStartup = exports.generateEntryStartup = void 0;
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const SetHelpers_1 = require("@/base/SetHelpers");
+const ChunkHelpers_1 = require("./ChunkHelpers");
+const EXPORT_PREFIX = `var ${RuntimeGlobals.exports} = `;
+const generateEntryStartup = (chunkGraph, runtimeTemplate, entries, chunk, passive) => {
+    const runtime = [
+        `var __webpack_exec__ = ${runtimeTemplate.returningFunction(`${RuntimeGlobals.require}(${RuntimeGlobals.entryModuleId} = moduleId)`, 'moduleId')}`,
+    ];
+    const runModule = id => `__webpack_exec__(${JSON.stringify(id)})`;
+    const outputCombination = (chunks, moduleIds, final) => {
+        if (chunks.size === 0) {
+            runtime.push(`${final ? EXPORT_PREFIX : ''}(${moduleIds.map(runModule).join(', ')});`);
+        }
+        else {
+            const fn = runtimeTemplate.returningFunction(moduleIds.map(runModule).join(', '));
+            runtime.push(`${final && !passive ? EXPORT_PREFIX : ''}${passive ? RuntimeGlobals.onChunksLoaded : RuntimeGlobals.startupEntrypoint}(0, ${JSON.stringify(Array.from(chunks, (c) => c.id))}, ${fn});`);
+            if (final && passive) {
+                runtime.push(`${EXPORT_PREFIX}${RuntimeGlobals.onChunksLoaded}();`);
+            }
+        }
+    };
+    let currentChunks;
+    let currentModuleIds;
+    for (const [module, entrypoint] of entries) {
+        const runtimeChunk = entrypoint.getRuntimeChunk();
+        const moduleId = chunkGraph.getModuleId(module);
+        const chunks = (0, ChunkHelpers_1.getAllChunks)(entrypoint, chunk, runtimeChunk);
+        if (currentChunks && currentChunks.size === chunks.size && (0, SetHelpers_1.isSubset)(currentChunks, chunks)) {
+            currentModuleIds.push(moduleId);
+        }
+        else {
+            if (currentChunks) {
+                outputCombination(currentChunks, currentModuleIds);
+            }
+            currentChunks = chunks;
+            currentModuleIds = [moduleId];
+        }
+    }
+    // output current modules with export prefix
+    if (currentChunks) {
+        outputCombination(currentChunks, currentModuleIds, true);
+    }
+    runtime.push('');
+    return Template_1.Template.asString(runtime);
+};
+exports.generateEntryStartup = generateEntryStartup;
+const updateHashForEntryStartup = (hash, chunkGraph, entries, chunk) => {
+    for (const [module, entrypoint] of entries) {
+        const runtimeChunk = entrypoint.getRuntimeChunk();
+        const moduleId = chunkGraph.getModuleId(module);
+        hash.update(`${moduleId}`);
+        for (const c of (0, ChunkHelpers_1.getAllChunks)(entrypoint, chunk, runtimeChunk))
+            hash.update(`${c.id}`);
+    }
+};
+exports.updateHashForEntryStartup = updateHashForEntryStartup;
+const getInitialChunkIds = (chunk, chunkGraph, filterFn) => {
+    const initialChunkIds = new Set(chunk.ids);
+    for (const c of chunk.getAllInitialChunks()) {
+        if (c === chunk || filterFn(c, chunkGraph))
+            continue;
+        for (const id of c.ids)
+            initialChunkIds.add(id);
+    }
+    return initialChunkIds;
+};
+exports.getInitialChunkIds = getInitialChunkIds;

package/dist/base/StringXor.d.ts

@@ -0,0 +1,53 @@
+/**
+ * StringXor class provides methods for performing
+ * [XOR operations](https://en.wikipedia.org/wiki/Exclusive_or) on strings. In this context
+ * we operating on the character codes of two strings, which are represented as
+ * [Buffer](https://nodejs.org/api/buffer.html) objects.
+ *
+ * We use [StringXor in webpack](https://github.com/webpack/webpack/commit/41a8e2ea483a544c4ccd3e6217bdfb80daffca39)
+ * to create a hash of the current state of the compilation. By XOR'ing the Module hashes, it
+ * doesn't matter if the Module hashes are sorted or not. This is useful because it allows us to avoid sorting the
+ * Module hashes.
+ *
+ * @example
+ * ```js
+ * const xor = new StringXor();
+ * xor.add('hello');
+ * xor.add('world');
+ * console.log(xor.toString());
+ * ```
+ *
+ * @example
+ * ```js
+ * const xor = new StringXor();
+ * xor.add('foo');
+ * xor.add('bar');
+ * const hash = createHash('sha256');
+ * hash.update(xor.toString());
+ * console.log(hash.digest('hex'));
+ * ```
+ */
+declare class StringXor {
+    _value: any;
+    constructor();
+    /**
+     * Adds a string to the current StringXor object.
+     */
+    add(str: string): void;
+    /**
+     * Returns a string that represents the current state of the StringXor object. We chose to use "latin1" encoding
+     * here because "latin1" encoding is a single-byte encoding that can represent all characters in the
+     * [ISO-8859-1 character set](https://en.wikipedia.org/wiki/ISO/IEC_8859-1). This is useful when working
+     * with binary data that needs to be represented as a string.
+     *
+     * @returns {string} Returns a string that represents the current state of the StringXor object.
+     */
+    toString(): any;
+    /**
+     * Updates the hash with the current state of the StringXor object.
+     *
+     * @param {Hash} hash Hash instance
+     */
+    updateHash(hash: any): void;
+}
+export default StringXor;