xhs-mp-pack 1.1.0-beta.0

package/dist/base/deprecation.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFakeHook = exports.deprecateAllProperties = exports.soonFrozenObjectDeprecation = exports.createArrayToSetDeprecationSet = exports.arrayToSetDeprecation = void 0;
+const util = require('util');
+const deprecationCache = new Map();
+const createDeprecation = (message, code) => {
+    const cached = deprecationCache.get(message);
+    if (cached !== undefined)
+        return cached;
+    const fn = util.deprecate(() => { }, message, `DEP_WEBPACK_DEPRECATION_${code}`);
+    deprecationCache.set(message, fn);
+    return fn;
+};
+const COPY_METHODS = [
+    'concat',
+    'entry',
+    'filter',
+    'find',
+    'findIndex',
+    'includes',
+    'indexOf',
+    'join',
+    'lastIndexOf',
+    'map',
+    'reduce',
+    'reduceRight',
+    'slice',
+    'some',
+];
+const DISABLED_METHODS = [
+    'copyWithin',
+    'entries',
+    'fill',
+    'keys',
+    'pop',
+    'reverse',
+    'shift',
+    'splice',
+    'sort',
+    'unshift',
+];
+const arrayToSetDeprecation = (set, name) => {
+    for (const method of COPY_METHODS) {
+        if (set[method])
+            continue;
+        const d = createDeprecation(`${name} was changed from Array to Set (using Array method '${method}' is deprecated)`, 'ARRAY_TO_SET');
+        set[method] = function () {
+            d();
+            const array = Array.from(this);
+            // eslint-disable-next-line prefer-rest-params
+            return Array.prototype[method].apply(array, arguments);
+        };
+    }
+    const dPush = createDeprecation(`${name} was changed from Array to Set (using Array method 'push' is deprecated)`, 'ARRAY_TO_SET_PUSH');
+    const dLength = createDeprecation(`${name} was changed from Array to Set (using Array property 'length' is deprecated)`, 'ARRAY_TO_SET_LENGTH');
+    const dIndexer = createDeprecation(`${name} was changed from Array to Set (indexing Array is deprecated)`, 'ARRAY_TO_SET_INDEXER');
+    set.push = function () {
+        dPush();
+        // eslint-disable-next-line prefer-rest-params
+        for (const item of Array.from(arguments)) {
+            this.add(item);
+        }
+        return this.size;
+    };
+    for (const method of DISABLED_METHODS) {
+        if (set[method])
+            continue;
+        set[method] = () => {
+            throw new Error(`${name} was changed from Array to Set (using Array method '${method}' is not possible)`);
+        };
+    }
+    const createIndexGetter = index => {
+        const fn = function () {
+            dIndexer();
+            let i = 0;
+            for (const item of this) {
+                if (i++ === index)
+                    return item;
+            }
+            return undefined;
+        };
+        return fn;
+    };
+    const defineIndexGetter = index => {
+        Object.defineProperty(set, index, {
+            get: createIndexGetter(index),
+            set(value) {
+                throw new Error(`${name} was changed from Array to Set (indexing Array with write is not possible)`);
+            },
+        });
+    };
+    defineIndexGetter(0);
+    let indexerDefined = 1;
+    Object.defineProperty(set, 'length', {
+        get() {
+            dLength();
+            const length = this.size;
+            for (indexerDefined; indexerDefined < length + 1; indexerDefined++) {
+                defineIndexGetter(indexerDefined);
+            }
+            return length;
+        },
+        set(value) {
+            throw new Error(`${name} was changed from Array to Set (writing to Array property 'length' is not possible)`);
+        },
+    });
+    set[Symbol.isConcatSpreadable] = true;
+};
+exports.arrayToSetDeprecation = arrayToSetDeprecation;
+const createArrayToSetDeprecationSet = name => {
+    let initialized = false;
+    class SetDeprecatedArray extends Set {
+        constructor(items) {
+            super(items);
+            if (!initialized) {
+                initialized = true;
+                arrayToSetDeprecation(SetDeprecatedArray.prototype, name);
+            }
+        }
+    }
+    return SetDeprecatedArray;
+};
+exports.createArrayToSetDeprecationSet = createArrayToSetDeprecationSet;
+const soonFrozenObjectDeprecation = (obj, name, code, note = '') => {
+    const message = `${name} will be frozen in future, all modifications are deprecated.${note && `\n${note}`}`;
+    return new Proxy(obj, {
+        set: util.deprecate((target, property, value, receiver) => Reflect.set(target, property, value, receiver), message, code),
+        defineProperty: util.deprecate((target, property, descriptor) => Reflect.defineProperty(target, property, descriptor), message, code),
+        deleteProperty: util.deprecate((target, property) => Reflect.deleteProperty(target, property), message, code),
+        setPrototypeOf: util.deprecate((target, proto) => Reflect.setPrototypeOf(target, proto), message, code),
+    });
+};
+exports.soonFrozenObjectDeprecation = soonFrozenObjectDeprecation;
+const deprecateAllProperties = (obj, message, code) => {
+    const newObj = {};
+    const descriptors = Object.getOwnPropertyDescriptors(obj);
+    for (const name of Object.keys(descriptors)) {
+        const descriptor = descriptors[name];
+        if (typeof descriptor.value === 'function') {
+            Object.defineProperty(newObj, name, Object.assign(Object.assign({}, descriptor), { value: util.deprecate(descriptor.value, message, code) }));
+        }
+        else if (descriptor.get || descriptor.set) {
+            Object.defineProperty(newObj, name, Object.assign(Object.assign({}, descriptor), { get: descriptor.get && util.deprecate(descriptor.get, message, code), set: descriptor.set && util.deprecate(descriptor.set, message, code) }));
+        }
+        else {
+            let value = descriptor.value;
+            Object.defineProperty(newObj, name, {
+                configurable: descriptor.configurable,
+                enumerable: descriptor.enumerable,
+                get: util.deprecate(() => value, message, code),
+                // eslint-disable-next-line no-return-assign
+                set: descriptor.writable ? util.deprecate(v => (value = v), message, code) : undefined,
+            });
+        }
+    }
+    return newObj;
+};
+exports.deprecateAllProperties = deprecateAllProperties;
+const createFakeHook = (fakeHook, message, code) => {
+    if (message && code) {
+        fakeHook = deprecateAllProperties(fakeHook, message, code);
+    }
+    return Object.freeze(Object.assign(fakeHook, { _fakeHook: true }));
+};
+exports.createFakeHook = createFakeHook;

package/dist/base/deterministicGrouping.d.ts

@@ -0,0 +1,8 @@
+declare const _default: ({ maxSize, minSize, items, getSize, getKey }: {
+    maxSize: any;
+    minSize: any;
+    items: any;
+    getSize: any;
+    getKey: any;
+}) => any[];
+export default _default;

package/dist/base/deterministicGrouping.js

@@ -0,0 +1,395 @@
+"use strict";
+// Simulations show these probabilities for a single change
+// 93.1% that one group is invalidated
+// 4.8% that two groups are invalidated
+// 1.1% that 3 groups are invalidated
+// 0.1% that 4 or more groups are invalidated
+//
+// And these for removing/adding 10 lexically adjacent files
+// 64.5% that one group is invalidated
+// 24.8% that two groups are invalidated
+// 7.8% that 3 groups are invalidated
+// 2.7% that 4 or more groups are invalidated
+//
+// And these for removing/adding 3 random files
+// 0% that one group is invalidated
+// 3.7% that two groups are invalidated
+// 80.8% that 3 groups are invalidated
+// 12.3% that 4 groups are invalidated
+// 3.2% that 5 or more groups are invalidated
+Object.defineProperty(exports, "__esModule", { value: true });
+const similarity = (a, b) => {
+    const l = Math.min(a.length, b.length);
+    let dist = 0;
+    for (let i = 0; i < l; i++) {
+        const ca = a.charCodeAt(i);
+        const cb = b.charCodeAt(i);
+        dist += Math.max(0, 10 - Math.abs(ca - cb));
+    }
+    return dist;
+};
+const getName = (a, b, usedNames) => {
+    const l = Math.min(a.length, b.length);
+    let i = 0;
+    while (i < l) {
+        if (a.charCodeAt(i) !== b.charCodeAt(i)) {
+            i++;
+            break;
+        }
+        i++;
+    }
+    while (i < l) {
+        const name = a.slice(0, i);
+        const lowerName = name.toLowerCase();
+        if (!usedNames.has(lowerName)) {
+            usedNames.add(lowerName);
+            return name;
+        }
+        i++;
+    }
+    // names always contain a hash, so this is always unique
+    // we don't need to check usedNames nor add it
+    return a;
+};
+const addSizeTo = (total, size) => {
+    for (const key of Object.keys(size)) {
+        total[key] = (total[key] || 0) + size[key];
+    }
+};
+const subtractSizeFrom = (total, size) => {
+    for (const key of Object.keys(size)) {
+        total[key] -= size[key];
+    }
+};
+const sumSize = (nodes) => {
+    const sum = Object.create(null);
+    for (const node of nodes) {
+        addSizeTo(sum, node.size);
+    }
+    return sum;
+};
+const isTooBig = (size, maxSize) => {
+    for (const key of Object.keys(size)) {
+        const s = size[key];
+        if (s === 0)
+            continue;
+        const maxSizeValue = maxSize[key];
+        if (typeof maxSizeValue === 'number') {
+            if (s > maxSizeValue)
+                return true;
+        }
+    }
+    return false;
+};
+const isTooSmall = (size, minSize) => {
+    for (const key of Object.keys(size)) {
+        const s = size[key];
+        if (s === 0)
+            continue;
+        const minSizeValue = minSize[key];
+        if (typeof minSizeValue === 'number') {
+            if (s < minSizeValue)
+                return true;
+        }
+    }
+    return false;
+};
+const getTooSmallTypes = (size, minSize) => {
+    const types = new Set();
+    for (const key of Object.keys(size)) {
+        const s = size[key];
+        if (s === 0)
+            continue;
+        const minSizeValue = minSize[key];
+        if (typeof minSizeValue === 'number') {
+            if (s < minSizeValue)
+                types.add(key);
+        }
+    }
+    return types;
+};
+const getNumberOfMatchingSizeTypes = (size, types) => {
+    let i = 0;
+    for (const key of Object.keys(size)) {
+        if (size[key] !== 0 && types.has(key))
+            i++;
+    }
+    return i;
+};
+const selectiveSizeSum = (size, types) => {
+    let sum = 0;
+    for (const key of Object.keys(size)) {
+        if (size[key] !== 0 && types.has(key))
+            sum += size[key];
+    }
+    return sum;
+};
+/**
+ * @template T
+ */
+class Node {
+    constructor(item, key, size) {
+        this.item = item;
+        this.key = key;
+        this.size = size;
+    }
+}
+class Group {
+    constructor(nodes, similarities, size) {
+        this.similarities = [];
+        this.nodes = nodes;
+        this.similarities = similarities;
+        this.size = size || sumSize(nodes);
+        this.key = undefined;
+    }
+    popNodes(filter) {
+        const newNodes = [];
+        const newSimilarities = [];
+        const resultNodes = [];
+        let lastNode;
+        for (let i = 0; i < this.nodes.length; i++) {
+            const node = this.nodes[i];
+            if (filter(node)) {
+                resultNodes.push(node);
+            }
+            else {
+                if (newNodes.length > 0) {
+                    newSimilarities.push(lastNode === this.nodes[i - 1]
+                        ? this.similarities[i - 1]
+                        : similarity(lastNode.key, node.key));
+                }
+                newNodes.push(node);
+                lastNode = node;
+            }
+        }
+        if (resultNodes.length === this.nodes.length)
+            return undefined;
+        this.nodes = newNodes;
+        this.similarities = newSimilarities;
+        this.size = sumSize(newNodes);
+        return resultNodes;
+    }
+}
+const getSimilarities = (nodes) => {
+    // calculate similarities between lexically adjacent nodes
+    const similarities = [];
+    let last;
+    for (const node of nodes) {
+        if (last !== undefined) {
+            similarities.push(similarity(last.key, node.key));
+        }
+        last = node;
+    }
+    return similarities;
+};
+exports.default = ({ maxSize, minSize, items, getSize, getKey }) => {
+    const result = [];
+    const nodes = Array.from(items, item => new Node(item, getKey(item), getSize(item)));
+    const initialNodes = [];
+    // lexically ordering of keys
+    nodes.sort((a, b) => {
+        if (a.key < b.key)
+            return -1;
+        if (a.key > b.key)
+            return 1;
+        return 0;
+    });
+    // return nodes bigger than maxSize directly as group
+    // But make sure that minSize is not violated
+    for (const node of nodes) {
+        if (isTooBig(node.size, maxSize) && !isTooSmall(node.size, minSize)) {
+            result.push(new Group([node], []));
+        }
+        else {
+            initialNodes.push(node);
+        }
+    }
+    if (initialNodes.length > 0) {
+        const initialGroup = new Group(initialNodes, getSimilarities(initialNodes));
+        const removeProblematicNodes = (group, consideredSize = group.size) => {
+            const problemTypes = getTooSmallTypes(consideredSize, minSize);
+            if (problemTypes.size > 0) {
+                // We hit an edge case where the working set is already smaller than minSize
+                // We merge problematic nodes with the smallest result node to keep minSize intact
+                const problemNodes = group.popNodes(n => getNumberOfMatchingSizeTypes(n.size, problemTypes) > 0);
+                if (problemNodes === undefined)
+                    return false;
+                // Only merge it with result nodes that have the problematic size type
+                const possibleResultGroups = result.filter(n => getNumberOfMatchingSizeTypes(n.size, problemTypes) > 0);
+                if (possibleResultGroups.length > 0) {
+                    const bestGroup = possibleResultGroups.reduce((min, group) => {
+                        const minMatches = getNumberOfMatchingSizeTypes(min, problemTypes);
+                        const groupMatches = getNumberOfMatchingSizeTypes(group, problemTypes);
+                        if (minMatches !== groupMatches)
+                            return minMatches < groupMatches ? group : min;
+                        if (selectiveSizeSum(min.size, problemTypes) > selectiveSizeSum(group.size, problemTypes))
+                            return group;
+                        return min;
+                    });
+                    for (const node of problemNodes)
+                        bestGroup.nodes.push(node);
+                    bestGroup.nodes.sort((a, b) => {
+                        if (a.key < b.key)
+                            return -1;
+                        if (a.key > b.key)
+                            return 1;
+                        return 0;
+                    });
+                }
+                else {
+                    // There are no other nodes with the same size types
+                    // We create a new group and have to accept that it's smaller than minSize
+                    result.push(new Group(problemNodes, []));
+                }
+                return true;
+            }
+            return false;
+        };
+        if (initialGroup.nodes.length > 0) {
+            const queue = [initialGroup];
+            while (queue.length) {
+                const group = queue.pop();
+                // only groups bigger than maxSize need to be splitted
+                if (!isTooBig(group.size, maxSize)) {
+                    result.push(group);
+                    continue;
+                }
+                // If the group is already too small
+                // we try to work only with the unproblematic nodes
+                if (removeProblematicNodes(group)) {
+                    // This changed something, so we try this group again
+                    queue.push(group);
+                    continue;
+                }
+                // find unsplittable area from left and right
+                // going minSize from left and right
+                // at least one node need to be included otherwise we get stuck
+                let left = 1;
+                const leftSize = Object.create(null);
+                addSizeTo(leftSize, group.nodes[0].size);
+                while (left < group.nodes.length && isTooSmall(leftSize, minSize)) {
+                    addSizeTo(leftSize, group.nodes[left].size);
+                    left++;
+                }
+                let right = group.nodes.length - 2;
+                const rightSize = Object.create(null);
+                addSizeTo(rightSize, group.nodes[group.nodes.length - 1].size);
+                while (right >= 0 && isTooSmall(rightSize, minSize)) {
+                    addSizeTo(rightSize, group.nodes[right].size);
+                    right--;
+                }
+                //      left v   v right
+                // [ O O O ] O O O [ O O O ]
+                // ^^^^^^^^^ leftSize
+                //       rightSize ^^^^^^^^^
+                // leftSize > minSize
+                // rightSize > minSize
+                // Perfect split: [ O O O ] [ O O O ]
+                //                right === left - 1
+                if (left - 1 > right) {
+                    // We try to remove some problematic nodes to "fix" that
+                    let prevSize;
+                    if (right < group.nodes.length - left) {
+                        subtractSizeFrom(rightSize, group.nodes[right + 1].size);
+                        prevSize = rightSize;
+                    }
+                    else {
+                        subtractSizeFrom(leftSize, group.nodes[left - 1].size);
+                        prevSize = leftSize;
+                    }
+                    if (removeProblematicNodes(group, prevSize)) {
+                        // This changed something, so we try this group again
+                        queue.push(group);
+                        continue;
+                    }
+                    // can't split group while holding minSize
+                    // because minSize is preferred of maxSize we return
+                    // the problematic nodes as result here even while it's too big
+                    // To avoid this make sure maxSize > minSize * 3
+                    result.push(group);
+                    continue;
+                }
+                if (left <= right) {
+                    // when there is a area between left and right
+                    // we look for best split point
+                    // we split at the minimum similarity
+                    // here key space is separated the most
+                    // But we also need to make sure to not create too small groups
+                    let best = -1;
+                    let bestSimilarity = Infinity;
+                    let pos = left;
+                    const rightSize = sumSize(group.nodes.slice(pos));
+                    //       pos v   v right
+                    // [ O O O ] O O O [ O O O ]
+                    // ^^^^^^^^^ leftSize
+                    // rightSize ^^^^^^^^^^^^^^^
+                    while (pos <= right + 1) {
+                        const similarity = group.similarities[pos - 1];
+                        if (similarity < bestSimilarity &&
+                            !isTooSmall(leftSize, minSize) &&
+                            !isTooSmall(rightSize, minSize)) {
+                            best = pos;
+                            bestSimilarity = similarity;
+                        }
+                        addSizeTo(leftSize, group.nodes[pos].size);
+                        subtractSizeFrom(rightSize, group.nodes[pos].size);
+                        pos++;
+                    }
+                    if (best < 0) {
+                        // This can't happen
+                        // but if that assumption is wrong
+                        // fallback to a big group
+                        result.push(group);
+                        continue;
+                    }
+                    left = best;
+                    right = best - 1;
+                }
+                // create two new groups for left and right area
+                // and queue them up
+                const rightNodes = [group.nodes[right + 1]];
+                const rightSimilarities = [];
+                for (let i = right + 2; i < group.nodes.length; i++) {
+                    rightSimilarities.push(group.similarities[i - 1]);
+                    rightNodes.push(group.nodes[i]);
+                }
+                queue.push(new Group(rightNodes, rightSimilarities));
+                const leftNodes = [group.nodes[0]];
+                const leftSimilarities = [];
+                for (let i = 1; i < left; i++) {
+                    leftSimilarities.push(group.similarities[i - 1]);
+                    leftNodes.push(group.nodes[i]);
+                }
+                queue.push(new Group(leftNodes, leftSimilarities));
+            }
+        }
+    }
+    // lexically ordering
+    result.sort((a, b) => {
+        if (a.nodes[0].key < b.nodes[0].key)
+            return -1;
+        if (a.nodes[0].key > b.nodes[0].key)
+            return 1;
+        return 0;
+    });
+    // give every group a name
+    const usedNames = new Set();
+    for (let i = 0; i < result.length; i++) {
+        const group = result[i];
+        if (group.nodes.length === 1) {
+            group.key = group.nodes[0].key;
+        }
+        else {
+            const first = group.nodes[0];
+            const last = group.nodes[group.nodes.length - 1];
+            const name = getName(first.key, last.key, usedNames);
+            group.key = name;
+        }
+    }
+    // return the results
+    return result.map(group => ({
+        key: group.key,
+        items: group.nodes.map(node => node.item),
+        size: group.size,
+    }));
+};

package/dist/base/errors/AbstractMethodError.d.ts

@@ -0,0 +1,5 @@
+import BaseError from './BaseError';
+declare class AbstractMethodError extends BaseError {
+    constructor();
+}
+export default AbstractMethodError;

package/dist/base/errors/AbstractMethodError.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+const CURRENT_METHOD_REGEXP = /at ([a-zA-Z0-9_.]*)/;
+function createMessage(method) {
+    return `Abstract method${method ? ` ${method}` : ''}. Must be overridden.`;
+}
+function Message() {
+    this.stack = undefined;
+    Error.captureStackTrace(this);
+    const match = this.stack.split('\n')[3].match(CURRENT_METHOD_REGEXP);
+    this.message = (match === null || match === void 0 ? void 0 : match[1]) ? createMessage(match[1]) : createMessage();
+}
+class AbstractMethodError extends BaseError_1.default {
+    constructor() {
+        super(new Message().message);
+        this.name = 'AbstractMethodError';
+    }
+}
+exports.default = AbstractMethodError;

package/dist/base/errors/AsyncDependencyToInitialChunkError.d.ts

@@ -0,0 +1,8 @@
+import BaseError from './BaseError';
+declare class AsyncDependencyToInitialChunkError extends BaseError {
+    /**
+     * Creates an instance of AsyncDependencyToInitialChunkError.
+     */
+    constructor(chunkName: string, module: any, loc: any);
+}
+export default AsyncDependencyToInitialChunkError;

package/dist/base/errors/AsyncDependencyToInitialChunkError.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+class AsyncDependencyToInitialChunkError extends BaseError_1.default {
+    /**
+     * Creates an instance of AsyncDependencyToInitialChunkError.
+     */
+    constructor(chunkName, module, loc) {
+        super(`It's not allowed to load an initial chunk on demand. The chunk name "${chunkName}" is already used by an entrypoint.`);
+        this.name = 'AsyncDependencyToInitialChunkError';
+        this.module = module;
+        this.loc = loc;
+    }
+}
+exports.default = AsyncDependencyToInitialChunkError;

package/dist/base/errors/BaseError.d.ts

@@ -0,0 +1,17 @@
+declare class BaseError extends Error {
+    details: string | undefined;
+    module: any;
+    loc: any;
+    hideStack: boolean | undefined;
+    chunk: any;
+    file: string | undefined;
+    error: any;
+    constructor(message?: string);
+    serialize({ write }: {
+        write: any;
+    }): void;
+    deserialize({ read }: {
+        read: any;
+    }): void;
+}
+export default BaseError;

package/dist/base/errors/BaseError.js

@@ -0,0 +1,39 @@
+"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 inspect = require('util').inspect.custom;
+class BaseError extends Error {
+    constructor(message) {
+        super(message);
+        this.details = undefined;
+        this.module = undefined;
+        this.loc = undefined;
+        this.hideStack = undefined;
+        this.chunk = undefined;
+        this.file = undefined;
+    }
+    [inspect]() {
+        return this.stack + (this.details ? `\n${this.details}` : '');
+    }
+    serialize({ write }) {
+        write(this.name);
+        write(this.message);
+        write(this.stack);
+        write(this.details);
+        write(this.loc);
+        write(this.hideStack);
+    }
+    deserialize({ read }) {
+        this.name = read();
+        this.message = read();
+        this.stack = read();
+        this.details = read();
+        this.loc = read();
+        this.hideStack = read();
+    }
+}
+(0, makeSerializable_1.default)(BaseError, 'mp-compiler/base/errors/BaseError');
+exports.default = BaseError;