xhs-mp-pack 1.1.0-beta.0

package/dist/base/smartGrouping.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const smartGrouping = (items, groupConfigs) => {
+    const itemsWithGroups = new Set();
+    const allGroups = new Map();
+    for (const item of items) {
+        const groups = new Set();
+        for (let i = 0; i < groupConfigs.length; i++) {
+            const groupConfig = groupConfigs[i];
+            const keys = groupConfig.getKeys(item);
+            if (keys) {
+                for (const name of keys) {
+                    const key = `${i}:${name}`;
+                    let group = allGroups.get(key);
+                    if (group === undefined) {
+                        allGroups.set(key, (group = {
+                            config: groupConfig,
+                            name,
+                            alreadyGrouped: false,
+                            items: undefined,
+                        }));
+                    }
+                    groups.add(group);
+                }
+            }
+        }
+        itemsWithGroups.add({
+            item,
+            groups,
+        });
+    }
+    const runGrouping = itemsWithGroups => {
+        var _a;
+        const totalSize = itemsWithGroups.size;
+        for (const entry of itemsWithGroups) {
+            for (const group of entry.groups) {
+                if (group.alreadyGrouped)
+                    continue;
+                const items = group.items;
+                if (items === undefined) {
+                    group.items = new Set([entry]);
+                }
+                else {
+                    items.add(entry);
+                }
+            }
+        }
+        const groupMap = new Map();
+        for (const group of allGroups.values()) {
+            if (group.items) {
+                const items = group.items;
+                group.items = undefined;
+                groupMap.set(group, {
+                    items,
+                    options: undefined,
+                    used: false,
+                });
+            }
+        }
+        const results = [];
+        for (;;) {
+            let bestGroup;
+            let bestGroupSize = -1;
+            let bestGroupItems;
+            let bestGroupOptions;
+            for (const [group, state] of groupMap) {
+                const { items, used } = state;
+                let options = state.options;
+                if (options === undefined) {
+                    const groupConfig = group.config;
+                    state.options = options =
+                        ((_a = groupConfig.getOptions) === null || _a === void 0 ? void 0 : _a.call(groupConfig, group.name, Array.from(items, ({ item }) => item))) ||
+                            false;
+                }
+                const force = options === null || options === void 0 ? void 0 : options.force;
+                if (!force) {
+                    if (bestGroupOptions === null || bestGroupOptions === void 0 ? void 0 : bestGroupOptions.force)
+                        continue;
+                    if (used)
+                        continue;
+                    if (items.size <= 1 || totalSize - items.size <= 1) {
+                        continue;
+                    }
+                }
+                const targetGroupCount = (options === null || options === void 0 ? void 0 : options.targetGroupCount) || 4;
+                const sizeValue = force
+                    ? items.size
+                    : Math.min(items.size, (totalSize * 2) / targetGroupCount + itemsWithGroups.size - items.size);
+                if (sizeValue > bestGroupSize ||
+                    (force && (!bestGroupOptions || !bestGroupOptions.force))) {
+                    bestGroup = group;
+                    bestGroupSize = sizeValue;
+                    bestGroupItems = items;
+                    bestGroupOptions = options;
+                }
+            }
+            if (bestGroup === undefined) {
+                break;
+            }
+            const items = new Set(bestGroupItems);
+            const options = bestGroupOptions;
+            const groupChildren = !options || options.groupChildren !== false;
+            for (const item of items) {
+                itemsWithGroups.delete(item);
+                // Remove all groups that items have from the map to not select them again
+                for (const group of item.groups) {
+                    const state = groupMap.get(group);
+                    if (state !== undefined) {
+                        state.items.delete(item);
+                        if (state.items.size === 0) {
+                            groupMap.delete(group);
+                        }
+                        else {
+                            state.options = undefined;
+                            if (groupChildren) {
+                                state.used = true;
+                            }
+                        }
+                    }
+                }
+            }
+            groupMap.delete(bestGroup);
+            const key = bestGroup.name;
+            const groupConfig = bestGroup.config;
+            const allItems = Array.from(items, ({ item }) => item);
+            bestGroup.alreadyGrouped = true;
+            const children = groupChildren ? runGrouping(items) : allItems;
+            bestGroup.alreadyGrouped = false;
+            results.push(groupConfig.createGroup(key, children, allItems));
+        }
+        for (const { item } of itemsWithGroups) {
+            results.push(item);
+        }
+        return results;
+    };
+    return runGrouping(itemsWithGroups);
+};
+exports.default = smartGrouping;

package/dist/base/source.d.ts

@@ -0,0 +1,2 @@
+declare const isSourceEqual: (a: any, b: any) => any;
+export { isSourceEqual };

package/dist/base/source.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSourceEqual = void 0;
+const equalityCache = new WeakMap();
+const _isSourceEqual = (a, b) => {
+    // prefer .buffer(), it's called anyway during emit
+    let aSource = typeof a.buffer === 'function' ? a.buffer() : a.source();
+    let bSource = typeof b.buffer === 'function' ? b.buffer() : b.source();
+    if (aSource === bSource)
+        return true;
+    if (typeof aSource === 'string' && typeof bSource === 'string')
+        return false;
+    if (!Buffer.isBuffer(aSource))
+        aSource = Buffer.from(aSource, 'utf-8');
+    if (!Buffer.isBuffer(bSource))
+        bSource = Buffer.from(bSource, 'utf-8');
+    return aSource.equals(bSource);
+};
+const isSourceEqual = (a, b) => {
+    if (a === b)
+        return true;
+    const cache1 = equalityCache.get(a);
+    if (cache1 !== undefined) {
+        const result = cache1.get(b);
+        if (result !== undefined)
+            return result;
+    }
+    const result = _isSourceEqual(a, b);
+    if (cache1 !== undefined) {
+        cache1.set(b, result);
+    }
+    else {
+        const map = new WeakMap();
+        map.set(b, result);
+        equalityCache.set(a, map);
+    }
+    const cache2 = equalityCache.get(b);
+    if (cache2 !== undefined) {
+        cache2.set(a, result);
+    }
+    else {
+        const map = new WeakMap();
+        map.set(a, result);
+        equalityCache.set(b, map);
+    }
+    return result;
+};
+exports.isSourceEqual = isSourceEqual;

package/dist/base/stats/MultiStats.d.ts

@@ -0,0 +1,19 @@
+declare class MultiStats {
+    stats: any;
+    constructor(stats: any);
+    get hash(): any;
+    hasErrors(): any;
+    hasWarnings(): any;
+    _createChildOptions(options: any, context: any): {
+        version: any;
+        hash: any;
+        errorsCount: any;
+        warningsCount: any;
+        errors: any;
+        warnings: any;
+        children: any;
+    };
+    toJson(options: any): any;
+    toString(options: any): any;
+}
+export default MultiStats;

package/dist/base/stats/MultiStats.js

@@ -0,0 +1,142 @@
+"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;
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const identifierUtils = __importStar(require("@/base/identifier"));
+const indent = (str, prefix) => {
+    const rem = str.replace(/\n([^\n])/g, `\n${prefix}$1`);
+    return prefix + rem;
+};
+class MultiStats {
+    constructor(stats) {
+        this.stats = stats;
+    }
+    get hash() {
+        return this.stats.map(stat => stat.hash).join('');
+    }
+    hasErrors() {
+        return this.stats.some(stat => stat.hasErrors());
+    }
+    hasWarnings() {
+        return this.stats.some(stat => stat.hasWarnings());
+    }
+    _createChildOptions(options, context) {
+        if (!options) {
+            options = {};
+        }
+        const _a = typeof options === 'string' ? { preset: options } : options, { children: childrenOptions = undefined } = _a, baseOptions = __rest(_a, ["children"]);
+        const children = this.stats.map((stat, idx) => {
+            const childOptions = Array.isArray(childrenOptions) ? childrenOptions[idx] : childrenOptions;
+            return stat.compilation.createStatsOptions(Object.assign(Object.assign({}, baseOptions), (typeof childOptions === 'string'
+                ? { preset: childOptions }
+                : childOptions && typeof childOptions === 'object'
+                    ? childOptions
+                    : undefined)), context);
+        });
+        return {
+            version: children.every(o => o.version),
+            hash: children.every(o => o.hash),
+            errorsCount: children.every(o => o.errorsCount),
+            warningsCount: children.every(o => o.warningsCount),
+            errors: children.every(o => o.errors),
+            warnings: children.every(o => o.warnings),
+            children,
+        };
+    }
+    toJson(options) {
+        options = this._createChildOptions(options, { forToString: false });
+        const obj = {};
+        obj.children = this.stats.map((stat, idx) => {
+            const obj = stat.toJson(options.children[idx]);
+            const compilationName = stat.compilation.name;
+            const name = compilationName &&
+                identifierUtils.makePathsRelative(options.context, compilationName, stat.compilation.compiler.root);
+            obj.name = name;
+            return obj;
+        });
+        if (options.version) {
+            obj.version = obj.children[0].version;
+        }
+        if (options.hash) {
+            obj.hash = obj.children.map(j => j.hash).join('');
+        }
+        const mapError = (j, obj) => (Object.assign(Object.assign({}, obj), { compilerPath: obj.compilerPath ? `${j.name}.${obj.compilerPath}` : j.name }));
+        if (options.errors) {
+            obj.errors = [];
+            for (const j of obj.children) {
+                for (const i of j.errors) {
+                    obj.errors.push(mapError(j, i));
+                }
+            }
+        }
+        if (options.warnings) {
+            obj.warnings = [];
+            for (const j of obj.children) {
+                for (const i of j.warnings) {
+                    obj.warnings.push(mapError(j, i));
+                }
+            }
+        }
+        if (options.errorsCount) {
+            obj.errorsCount = 0;
+            for (const j of obj.children) {
+                obj.errorsCount += j.errorsCount;
+            }
+        }
+        if (options.warningsCount) {
+            obj.warningsCount = 0;
+            for (const j of obj.children) {
+                obj.warningsCount += j.warningsCount;
+            }
+        }
+        return obj;
+    }
+    toString(options) {
+        options = this._createChildOptions(options, { forToString: true });
+        const results = this.stats.map((stat, idx) => {
+            const str = stat.toString(options.children[idx]);
+            const compilationName = stat.compilation.name;
+            const name = compilationName &&
+                identifierUtils
+                    .makePathsRelative(options.context, compilationName, stat.compilation.compiler.root)
+                    .replace(/\|/g, ' ');
+            if (!str)
+                return str;
+            return name ? `${name}:\n${indent(str, '  ')}` : str;
+        });
+        return results.filter(Boolean).join('\n\n');
+    }
+}
+exports.default = MultiStats;

package/dist/base/stats/Stats.d.ts

@@ -0,0 +1,13 @@
+declare class Stats {
+    compilation: any;
+    constructor(compilation: any);
+    get hash(): any;
+    get startTime(): any;
+    get endTime(): any;
+    get buildReason(): any;
+    hasWarnings(): any;
+    hasErrors(): any;
+    toJson(options?: any): any;
+    toString(options: any): any;
+}
+export default Stats;

package/dist/base/stats/Stats.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Stats {
+    constructor(compilation) {
+        this.compilation = compilation;
+    }
+    get hash() {
+        return this.compilation.hash;
+    }
+    get startTime() {
+        return this.compilation.startTime;
+    }
+    get endTime() {
+        return this.compilation.endTime;
+    }
+    get buildReason() {
+        return this.compilation.compiler.watching.buildReason;
+    }
+    hasWarnings() {
+        return (this.compilation.warnings.length > 0 ||
+            this.compilation.children.some(child => child.getStats().hasWarnings()));
+    }
+    hasErrors() {
+        return (this.compilation.errors.length > 0 ||
+            this.compilation.children.some(child => child.getStats().hasErrors()));
+    }
+    toJson(options) {
+        options = this.compilation.createStatsOptions(options, {
+            forToString: false,
+        });
+        const statsFactory = this.compilation.createStatsFactory(options);
+        return statsFactory.create('compilation', this.compilation, {
+            compilation: this.compilation,
+        });
+    }
+    toString(options) {
+        options = this.compilation.createStatsOptions(options, {
+            forToString: true,
+        });
+        const statsFactory = this.compilation.createStatsFactory(options);
+        const statsPrinter = this.compilation.createStatsPrinter(options);
+        const data = statsFactory.create('compilation', this.compilation, {
+            compilation: this.compilation,
+        });
+        const result = statsPrinter.print('compilation', data);
+        return result === undefined ? '' : result;
+    }
+}
+exports.default = Stats;

package/dist/base/stats/StatsFactory.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @typedef {Object} KnownStatsFactoryContext
+ * @property {string} type
+ * @property {function(string): string=} makePathsRelative
+ * @property {Compilation=} compilation
+ * @property {Set<Module>=} rootModules
+ * @property {Map<string,Chunk[]>=} compilationFileToChunks
+ * @property {Map<string,Chunk[]>=} compilationAuxiliaryFileToChunks
+ * @property {RuntimeSpec=} runtime
+ * @property {function(Compilation): BaseError[]=} cachedGetErrors
+ * @property {function(Compilation): BaseError[]=} cachedGetWarnings
+ */
+/** @typedef {KnownStatsFactoryContext & Record<string, any>} StatsFactoryContext */
+declare class StatsFactory {
+    hooks: any;
+    _caches: any;
+    _inCreate: boolean;
+    constructor();
+    _getAllLevelHooks(hookMap: any, cache: any, type: any): any;
+    _forEachLevel(hookMap: any, cache: any, type: any, fn: any): any;
+    _forEachLevelWaterfall(hookMap: any, cache: any, type: any, data: any, fn: any): any;
+    _forEachLevelFilter(hookMap: any, cache: any, type: any, items: any, fn: any, forceClone: any): any;
+    create(type: any, data: any, baseContext: any): any;
+    _create(type: any, data: any, baseContext: any): any;
+}
+export default StatsFactory;

package/dist/base/stats/StatsFactory.js

@@ -0,0 +1,163 @@
+"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 comparators_1 = require("@/base/comparators");
+const smartGrouping_1 = __importDefault(require("@/base/smartGrouping"));
+/**
+ * @typedef {Object} KnownStatsFactoryContext
+ * @property {string} type
+ * @property {function(string): string=} makePathsRelative
+ * @property {Compilation=} compilation
+ * @property {Set<Module>=} rootModules
+ * @property {Map<string,Chunk[]>=} compilationFileToChunks
+ * @property {Map<string,Chunk[]>=} compilationAuxiliaryFileToChunks
+ * @property {RuntimeSpec=} runtime
+ * @property {function(Compilation): BaseError[]=} cachedGetErrors
+ * @property {function(Compilation): BaseError[]=} cachedGetWarnings
+ */
+/** @typedef {KnownStatsFactoryContext & Record<string, any>} StatsFactoryContext */
+class StatsFactory {
+    constructor() {
+        this.hooks = Object.freeze({
+            extract: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(['object', 'data', 'context'])),
+            filter: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(['item', 'context', 'index', 'unfilteredIndex'])),
+            sort: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(['comparators', 'context'])),
+            filterSorted: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(['item', 'context', 'index', 'unfilteredIndex'])),
+            groupResults: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(['groupConfigs', 'context'])),
+            sortResults: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(['comparators', 'context'])),
+            filterResults: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(['item', 'context', 'index', 'unfilteredIndex'])),
+            merge: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(['items', 'context'])),
+            result: new tapable_1.HookMap(() => new tapable_1.SyncWaterfallHook(['result', 'context'])),
+            getItemName: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(['item', 'context'])),
+            getItemFactory: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(['item', 'context'])),
+        });
+        const hooks = this.hooks;
+        this._caches = {};
+        for (const key of Object.keys(hooks)) {
+            this._caches[key] = new Map();
+        }
+        this._inCreate = false;
+    }
+    _getAllLevelHooks(hookMap, cache, type) {
+        const cacheEntry = cache.get(type);
+        if (cacheEntry !== undefined) {
+            return cacheEntry;
+        }
+        const hooks = [];
+        const typeParts = type.split('.');
+        for (let i = 0; i < typeParts.length; i++) {
+            const hook = hookMap.get(typeParts.slice(i).join('.'));
+            if (hook) {
+                hooks.push(hook);
+            }
+        }
+        cache.set(type, hooks);
+        return hooks;
+    }
+    _forEachLevel(hookMap, cache, type, fn) {
+        for (const hook of this._getAllLevelHooks(hookMap, cache, type)) {
+            const result = fn(hook);
+            if (result !== undefined)
+                return result;
+        }
+    }
+    _forEachLevelWaterfall(hookMap, cache, type, data, fn) {
+        for (const hook of this._getAllLevelHooks(hookMap, cache, type)) {
+            data = fn(hook, data);
+        }
+        return data;
+    }
+    _forEachLevelFilter(hookMap, cache, type, items, fn, forceClone) {
+        const hooks = this._getAllLevelHooks(hookMap, cache, type);
+        if (hooks.length === 0)
+            return forceClone ? items.slice() : items;
+        let i = 0;
+        return items.filter((item, idx) => {
+            for (const hook of hooks) {
+                const r = fn(hook, item, idx, i);
+                if (r !== undefined) {
+                    if (r)
+                        i++;
+                    return r;
+                }
+            }
+            i++;
+            return true;
+        });
+    }
+    create(type, data, baseContext) {
+        if (this._inCreate) {
+            return this._create(type, data, baseContext);
+        }
+        try {
+            this._inCreate = true;
+            return this._create(type, data, baseContext);
+        }
+        finally {
+            for (const key of Object.keys(this._caches))
+                this._caches[key].clear();
+            this._inCreate = false;
+        }
+    }
+    _create(type, data, baseContext) {
+        const context = Object.assign(Object.assign({}, baseContext), { type, [type]: data });
+        if (Array.isArray(data)) {
+            // run filter on unsorted items
+            const items = this._forEachLevelFilter(this.hooks.filter, this._caches.filter, type, data, (h, r, idx, i) => h.call(r, context, idx, i), true);
+            // sort items
+            const comparators = [];
+            this._forEachLevel(this.hooks.sort, this._caches.sort, type, h => h.call(comparators, context));
+            if (comparators.length > 0) {
+                items.sort(
+                // @ts-expect-error number of arguments is correct
+                (0, comparators_1.concatComparators)(...comparators, (0, comparators_1.keepOriginalOrder)(items)));
+            }
+            // run filter on sorted items
+            const items2 = this._forEachLevelFilter(this.hooks.filterSorted, this._caches.filterSorted, type, items, (h, r, idx, i) => h.call(r, context, idx, i), false);
+            // for each item
+            let resultItems = items2.map((item, i) => {
+                const itemContext = Object.assign(Object.assign({}, context), { _index: i });
+                // run getItemName
+                const itemName = this._forEachLevel(this.hooks.getItemName, this._caches.getItemName, `${type}[]`, h => h.call(item, itemContext));
+                if (itemName)
+                    itemContext[itemName] = item;
+                const innerType = itemName ? `${type}[].${itemName}` : `${type}[]`;
+                // run getItemFactory
+                const itemFactory = this._forEachLevel(this.hooks.getItemFactory, this._caches.getItemFactory, innerType, h => h.call(item, itemContext)) || this;
+                // run item factory
+                return itemFactory.create(innerType, item, itemContext);
+            });
+            // sort result items
+            const comparators2 = [];
+            this._forEachLevel(this.hooks.sortResults, this._caches.sortResults, type, h => h.call(comparators2, context));
+            if (comparators2.length > 0) {
+                resultItems.sort(
+                // @ts-expect-error number of arguments is correct
+                (0, comparators_1.concatComparators)(...comparators2, (0, comparators_1.keepOriginalOrder)(resultItems)));
+            }
+            // group result items
+            const groupConfigs = [];
+            this._forEachLevel(this.hooks.groupResults, this._caches.groupResults, type, h => h.call(groupConfigs, context));
+            if (groupConfigs.length > 0) {
+                resultItems = (0, smartGrouping_1.default)(resultItems, groupConfigs);
+            }
+            // run filter on sorted result items
+            const finalResultItems = this._forEachLevelFilter(this.hooks.filterResults, this._caches.filterResults, type, resultItems, (h, r, idx, i) => h.call(r, context, idx, i), false);
+            // run merge on mapped items
+            let result = this._forEachLevel(this.hooks.merge, this._caches.merge, type, h => h.call(finalResultItems, context));
+            if (result === undefined)
+                result = finalResultItems;
+            // run result on merged items
+            return this._forEachLevelWaterfall(this.hooks.result, this._caches.result, type, result, (h, r) => h.call(r, context));
+        }
+        const object = {};
+        // run extract on value
+        this._forEachLevel(this.hooks.extract, this._caches.extract, type, h => h.call(object, data, context));
+        // run result on extracted object
+        return this._forEachLevelWaterfall(this.hooks.result, this._caches.result, type, object, (h, r) => h.call(r, context));
+    }
+}
+exports.default = StatsFactory;

package/dist/base/stats/StatsPrinter.d.ts

@@ -0,0 +1,12 @@
+declare class StatsPrinter {
+    hooks: any;
+    _levelHookCache: Map<any, any>;
+    _inPrint: boolean;
+    constructor();
+    _getAllLevelHooks(hookMap: any, type: any): any;
+    _forEachLevel(hookMap: any, type: any, fn: any): any;
+    _forEachLevelWaterfall(hookMap: any, type: any, data: any, fn: any): any;
+    print(type: any, object: any, baseContext: any): any;
+    _print(type: string, object: Object, baseContext?: Object): any;
+}
+export default StatsPrinter;