xhs-mp-pack 1.1.0-beta.0

package/dist/base/cleverMerge.js

@@ -0,0 +1,450 @@
+"use strict";
+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 });
+exports.resolveByProperty = exports.removeOperations = exports.cleverMerge = exports.cachedSetProperty = exports.cachedCleverMerge = exports.DELETE = void 0;
+const mergeCache = new WeakMap();
+const setPropertyCache = new WeakMap();
+const DELETE = Symbol('DELETE');
+exports.DELETE = DELETE;
+const DYNAMIC_INFO = Symbol('cleverMerge dynamic info');
+/**
+ * Merges two given objects and caches the result to avoid computation if same objects passed as arguments again.
+ * @template T
+ * @template O
+ * @example
+ * // performs cleverMerge(first, second), stores the result in WeakMap and returns result
+ * cachedCleverMerge({a: 1}, {a: 2})
+ * {a: 2}
+ *  // when same arguments passed, gets the result from WeakMap and returns it.
+ * cachedCleverMerge({a: 1}, {a: 2})
+ * {a: 2}
+ * @param {T} first first object
+ * @param {O} second second object
+ * @returns {T & O | T | O} merged object of first and second object
+ */
+const cachedCleverMerge = (first, second) => {
+    if (second === undefined)
+        return first;
+    if (first === undefined)
+        return second;
+    if (typeof second !== 'object' || second === null)
+        return second;
+    if (typeof first !== 'object' || first === null)
+        return first;
+    let innerCache = mergeCache.get(first);
+    if (innerCache === undefined) {
+        innerCache = new WeakMap();
+        mergeCache.set(first, innerCache);
+    }
+    const prevMerge = innerCache.get(second);
+    if (prevMerge !== undefined)
+        return prevMerge;
+    const newMerge = _cleverMerge(first, second, true);
+    innerCache.set(second, newMerge);
+    return newMerge;
+};
+exports.cachedCleverMerge = cachedCleverMerge;
+const cachedSetProperty = (obj, property, value) => {
+    let mapByProperty = setPropertyCache.get(obj);
+    if (mapByProperty === undefined) {
+        mapByProperty = new Map();
+        setPropertyCache.set(obj, mapByProperty);
+    }
+    let mapByValue = mapByProperty.get(property);
+    if (mapByValue === undefined) {
+        mapByValue = new Map();
+        mapByProperty.set(property, mapByValue);
+    }
+    let result = mapByValue.get(value);
+    if (result)
+        return result;
+    result = Object.assign(Object.assign({}, obj), { [property]: value });
+    mapByValue.set(value, result);
+    return result;
+};
+exports.cachedSetProperty = cachedSetProperty;
+const parseCache = new WeakMap();
+const cachedParseObject = (obj) => {
+    const entry = parseCache.get(obj);
+    if (entry !== undefined)
+        return entry;
+    const result = parseObject(obj);
+    parseCache.set(obj, result);
+    return result;
+};
+const parseObject = obj => {
+    const info = new Map();
+    let dynamicInfo;
+    const getInfo = p => {
+        const entry = info.get(p);
+        if (entry !== undefined)
+            return entry;
+        const newEntry = {
+            base: undefined,
+            byProperty: undefined,
+            byValues: undefined,
+        };
+        info.set(p, newEntry);
+        return newEntry;
+    };
+    for (const key of Object.keys(obj)) {
+        if (key.startsWith('by')) {
+            const byProperty = key;
+            const byObj = obj[byProperty];
+            if (typeof byObj === 'object') {
+                for (const byValue of Object.keys(byObj)) {
+                    const obj = byObj[byValue];
+                    for (const key of Object.keys(obj)) {
+                        const entry = getInfo(key);
+                        if (entry.byProperty === undefined) {
+                            entry.byProperty = byProperty;
+                            entry.byValues = new Map();
+                        }
+                        else if (entry.byProperty !== byProperty) {
+                            throw new Error(`${byProperty} and ${entry.byProperty} for a single property is not supported`);
+                        }
+                        entry.byValues.set(byValue, obj[key]);
+                        if (byValue === 'default') {
+                            for (const otherByValue of Object.keys(byObj)) {
+                                if (!entry.byValues.has(otherByValue))
+                                    entry.byValues.set(otherByValue, undefined);
+                            }
+                        }
+                    }
+                }
+            }
+            else if (typeof byObj === 'function') {
+                if (dynamicInfo === undefined) {
+                    dynamicInfo = {
+                        byProperty: key,
+                        fn: byObj,
+                    };
+                }
+                else {
+                    throw new Error(`${key} and ${dynamicInfo.byProperty} when both are functions is not supported`);
+                }
+            }
+            else {
+                const entry = getInfo(key);
+                entry.base = obj[key];
+            }
+        }
+        else {
+            const entry = getInfo(key);
+            entry.base = obj[key];
+        }
+    }
+    return {
+        static: info,
+        dynamic: dynamicInfo,
+    };
+};
+const serializeObject = (info, dynamicInfo) => {
+    const obj = {};
+    // Setup byProperty structure
+    for (const entry of info.values()) {
+        if (entry.byProperty !== undefined) {
+            const byObj = (obj[entry.byProperty] = obj[entry.byProperty] || {});
+            for (const byValue of entry.byValues.keys()) {
+                byObj[byValue] = byObj[byValue] || {};
+            }
+        }
+    }
+    for (const [key, entry] of info) {
+        if (entry.base !== undefined) {
+            obj[key] = entry.base;
+        }
+        // Fill byProperty structure
+        if (entry.byProperty !== undefined) {
+            const byObj = (obj[entry.byProperty] = obj[entry.byProperty] || {});
+            for (const byValue of Object.keys(byObj)) {
+                const value = getFromByValues(entry.byValues, byValue);
+                if (value !== undefined)
+                    byObj[byValue][key] = value;
+            }
+        }
+    }
+    if (dynamicInfo !== undefined) {
+        obj[dynamicInfo.byProperty] = dynamicInfo.fn;
+    }
+    return obj;
+};
+const VALUE_TYPE_UNDEFINED = 0;
+const VALUE_TYPE_ATOM = 1;
+const VALUE_TYPE_ARRAY_EXTEND = 2;
+const VALUE_TYPE_OBJECT = 3;
+const VALUE_TYPE_DELETE = 4;
+const getValueType = value => {
+    if (value === undefined) {
+        return VALUE_TYPE_UNDEFINED;
+    }
+    if (value === DELETE) {
+        return VALUE_TYPE_DELETE;
+    }
+    if (Array.isArray(value)) {
+        if (value.lastIndexOf('...') !== -1)
+            return VALUE_TYPE_ARRAY_EXTEND;
+        return VALUE_TYPE_ATOM;
+    }
+    if (typeof value === 'object' &&
+        value !== null &&
+        (!value.constructor || value.constructor === Object)) {
+        return VALUE_TYPE_OBJECT;
+    }
+    return VALUE_TYPE_ATOM;
+};
+/**
+ * Merges two objects. Objects are deeply clever merged.
+ * Arrays might reference the old value with "...".
+ * Non-object values take preference over object values.
+ */
+const cleverMerge = (first, second) => {
+    if (second === undefined)
+        return first;
+    if (first === undefined)
+        return second;
+    if (typeof second !== 'object' || second === null)
+        return second;
+    if (typeof first !== 'object' || first === null)
+        return first;
+    return _cleverMerge(first, second, false);
+};
+exports.cleverMerge = cleverMerge;
+/**
+ * Merges two objects. Objects are deeply clever merged.
+ */
+const _cleverMerge = (first, second, internalCaching = false) => {
+    const firstObject = internalCaching ? cachedParseObject(first) : parseObject(first);
+    const { static: firstInfo, dynamic: firstDynamicInfo } = firstObject;
+    // If the first argument has a dynamic part we modify the dynamic part to merge the second argument
+    if (firstDynamicInfo !== undefined) {
+        let { byProperty, fn } = firstDynamicInfo;
+        const fnInfo = fn[DYNAMIC_INFO];
+        if (fnInfo) {
+            second = internalCaching
+                ? cachedCleverMerge(fnInfo[1], second)
+                : cleverMerge(fnInfo[1], second);
+            fn = fnInfo[0];
+        }
+        const newFn = (...args) => {
+            const fnResult = fn(...args);
+            return internalCaching ? cachedCleverMerge(fnResult, second) : cleverMerge(fnResult, second);
+        };
+        newFn[DYNAMIC_INFO] = [fn, second];
+        return serializeObject(firstObject.static, { byProperty, fn: newFn });
+    }
+    // If the first part is static only, we merge the static parts and keep the dynamic part of the second argument
+    const secondObject = internalCaching ? cachedParseObject(second) : parseObject(second);
+    const { static: secondInfo, dynamic: secondDynamicInfo } = secondObject;
+    const resultInfo = new Map();
+    for (const [key, firstEntry] of firstInfo) {
+        const secondEntry = secondInfo.get(key);
+        const entry = secondEntry !== undefined
+            ? mergeEntries(firstEntry, secondEntry, internalCaching)
+            : firstEntry;
+        resultInfo.set(key, entry);
+    }
+    for (const [key, secondEntry] of secondInfo) {
+        if (!firstInfo.has(key)) {
+            resultInfo.set(key, secondEntry);
+        }
+    }
+    return serializeObject(resultInfo, secondDynamicInfo);
+};
+const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
+    switch (getValueType(secondEntry.base)) {
+        case VALUE_TYPE_ATOM:
+        case VALUE_TYPE_DELETE:
+            // No need to consider firstEntry at all
+            // second value override everything
+            // = second.base + second.byProperty
+            return secondEntry;
+        case VALUE_TYPE_UNDEFINED:
+            if (!firstEntry.byProperty) {
+                // = first.base + second.byProperty
+                return {
+                    base: firstEntry.base,
+                    byProperty: secondEntry.byProperty,
+                    byValues: secondEntry.byValues,
+                };
+            }
+            if (firstEntry.byProperty !== secondEntry.byProperty) {
+                throw new Error(`${firstEntry.byProperty} and ${secondEntry.byProperty} for a single property is not supported`);
+            }
+            else {
+                // = first.base + (first.byProperty + second.byProperty)
+                // need to merge first and second byValues
+                const newByValues = new Map(firstEntry.byValues);
+                for (const [key, value] of secondEntry.byValues) {
+                    const firstValue = getFromByValues(firstEntry.byValues, key);
+                    newByValues.set(key, mergeSingleValue(firstValue, value, internalCaching));
+                }
+                return {
+                    base: firstEntry.base,
+                    byProperty: firstEntry.byProperty,
+                    byValues: newByValues,
+                };
+            }
+        default: {
+            if (!firstEntry.byProperty) {
+                // The simple case
+                // = (first.base + second.base) + second.byProperty
+                return {
+                    base: mergeSingleValue(firstEntry.base, secondEntry.base, internalCaching),
+                    byProperty: secondEntry.byProperty,
+                    byValues: secondEntry.byValues,
+                };
+            }
+            let newBase;
+            const intermediateByValues = new Map(firstEntry.byValues);
+            for (const [key, value] of intermediateByValues) {
+                intermediateByValues.set(key, mergeSingleValue(value, secondEntry.base, internalCaching));
+            }
+            if (Array.from(firstEntry.byValues.values()).every(value => {
+                const type = getValueType(value);
+                return type === VALUE_TYPE_ATOM || type === VALUE_TYPE_DELETE;
+            })) {
+                // = (first.base + second.base) + ((first.byProperty + second.base) + second.byProperty)
+                newBase = mergeSingleValue(firstEntry.base, secondEntry.base, internalCaching);
+            }
+            else {
+                // = first.base + ((first.byProperty (+default) + second.base) + second.byProperty)
+                newBase = firstEntry.base;
+                if (!intermediateByValues.has('default'))
+                    intermediateByValues.set('default', secondEntry.base);
+            }
+            if (!secondEntry.byProperty) {
+                // = first.base + (first.byProperty + second.base)
+                return {
+                    base: newBase,
+                    byProperty: firstEntry.byProperty,
+                    byValues: intermediateByValues,
+                };
+            }
+            if (firstEntry.byProperty !== secondEntry.byProperty) {
+                throw new Error(`${firstEntry.byProperty} and ${secondEntry.byProperty} for a single property is not supported`);
+            }
+            const newByValues = new Map(intermediateByValues);
+            for (const [key, value] of secondEntry.byValues) {
+                const firstValue = getFromByValues(intermediateByValues, key);
+                newByValues.set(key, mergeSingleValue(firstValue, value, internalCaching));
+            }
+            return {
+                base: newBase,
+                byProperty: firstEntry.byProperty,
+                byValues: newByValues,
+            };
+        }
+    }
+};
+const getFromByValues = (byValues, key) => {
+    if (key !== 'default' && byValues.has(key)) {
+        return byValues.get(key);
+    }
+    return byValues.get('default');
+};
+const mergeSingleValue = (a, b, internalCaching) => {
+    const bType = getValueType(b);
+    const aType = getValueType(a);
+    switch (bType) {
+        case VALUE_TYPE_DELETE:
+        case VALUE_TYPE_ATOM:
+            return b;
+        case VALUE_TYPE_OBJECT: {
+            return aType !== VALUE_TYPE_OBJECT
+                ? b
+                : internalCaching
+                    ? cachedCleverMerge(a, b)
+                    : cleverMerge(a, b);
+        }
+        case VALUE_TYPE_UNDEFINED:
+            return a;
+        case VALUE_TYPE_ARRAY_EXTEND:
+            switch (aType !== VALUE_TYPE_ATOM
+                ? aType
+                : Array.isArray(a)
+                    ? VALUE_TYPE_ARRAY_EXTEND
+                    : VALUE_TYPE_OBJECT) {
+                case VALUE_TYPE_UNDEFINED:
+                    return b;
+                case VALUE_TYPE_DELETE:
+                    return b.filter(item => item !== '...');
+                case VALUE_TYPE_ARRAY_EXTEND: {
+                    const newArray = [];
+                    for (const item of b) {
+                        if (item === '...') {
+                            for (const item of a) {
+                                newArray.push(item);
+                            }
+                        }
+                        else {
+                            newArray.push(item);
+                        }
+                    }
+                    return newArray;
+                }
+                case VALUE_TYPE_OBJECT:
+                    return b.map(item => (item === '...' ? a : item));
+                default:
+                    throw new Error('Not implemented');
+            }
+        default:
+            throw new Error('Not implemented');
+    }
+};
+const removeOperations = obj => {
+    const newObj = {};
+    for (const key of Object.keys(obj)) {
+        const value = obj[key];
+        const type = getValueType(value);
+        switch (type) {
+            case VALUE_TYPE_UNDEFINED:
+            case VALUE_TYPE_DELETE:
+                break;
+            case VALUE_TYPE_OBJECT:
+                newObj[key] = removeOperations(value);
+                break;
+            case VALUE_TYPE_ARRAY_EXTEND:
+                newObj[key] = value.filter(i => i !== '...');
+                break;
+            default:
+                newObj[key] = value;
+                break;
+        }
+    }
+    return newObj;
+};
+exports.removeOperations = removeOperations;
+const resolveByProperty = (obj, byProperty, ...values) => {
+    if (typeof obj !== 'object' || obj === null || !(byProperty in obj)) {
+        return obj;
+    }
+    const _a = obj, _b = byProperty, _byValue = _a[_b], _remaining = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+    const remaining = _remaining;
+    const byValue = _byValue;
+    if (typeof byValue === 'object') {
+        const key = values[0];
+        if (key in byValue) {
+            return cachedCleverMerge(remaining, byValue[key]);
+        }
+        if ('default' in byValue) {
+            return cachedCleverMerge(remaining, byValue.default);
+        }
+        return remaining;
+    }
+    if (typeof byValue === 'function') {
+        const result = byValue.apply(null, values);
+        return cachedCleverMerge(remaining, resolveByProperty(result, byProperty, ...values));
+    }
+};
+exports.resolveByProperty = resolveByProperty;

package/dist/base/common.d.ts

@@ -0,0 +1,7 @@
+declare const getTsConfigPath: (projectPath: string) => string | undefined;
+declare const toUnixPath: (pathStr?: string) => string;
+declare const unixJoin: (...paths: string[]) => string;
+declare const unixResolve: (...paths: string[]) => string;
+declare const getNodeModules: (projectPath: string) => void;
+declare const isString: (val: unknown) => val is string;
+export { getTsConfigPath, getNodeModules, isString, toUnixPath, unixJoin, unixResolve };

package/dist/base/common.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unixResolve = exports.unixJoin = exports.toUnixPath = exports.isString = exports.getNodeModules = exports.getTsConfigPath = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const getTsConfigPath = (projectPath) => {
+    if (fs_extra_1.default.existsSync(`${projectPath}/tsconfig.json`)) {
+        return `${projectPath}/tsconfig.json`;
+    }
+    return undefined;
+};
+exports.getTsConfigPath = getTsConfigPath;
+const toUnixPath = (pathStr = '') => pathStr.split(path_1.default.sep).join(path_1.default.posix.sep);
+exports.toUnixPath = toUnixPath;
+const unixJoin = (...paths) => toUnixPath(path_1.default.join(...paths));
+exports.unixJoin = unixJoin;
+const unixResolve = (...paths) => toUnixPath(path_1.default.resolve(...paths));
+exports.unixResolve = unixResolve;
+const getNodeModules = (projectPath) => { };
+exports.getNodeModules = getNodeModules;
+const isString = (val) => typeof val === 'string';
+exports.isString = isString;

package/dist/base/commonjs.d.ts

@@ -0,0 +1 @@
+export declare function getRuntimeCode(): string;

package/dist/base/commonjs.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRuntimeCode = void 0;
+function getRuntimeCode() {
+    const code = `
+    if (!globalThis.__XHS_RUNTIME_REGISTERED__) {
+      globalThis.__XHS_RUNTIME_REGISTERED__ = true;
+      globalThis.require = function(p) {
+        var path = require.resolve(p);
+        var mod = require.modules[path];
+        if (!mod) throw new Error('failed to require "' + p + '"');
+        if (!mod.exports) {
+          mod.exports = {};
+          mod.call(mod.exports, mod, mod.exports, require.relative(path));
+        }
+        return mod.exports;
+      }
+      require.modules = {};
+      require.resolve = function (path){
+        var orig = path;
+        var reg = path + '.js';
+        var index = path + '/index.js';
+        return require.modules[reg] && reg
+          || require.modules[index] && index
+          || orig;
+      };
+      require.register = function (path, fn){
+        require.modules[path] = fn;
+      };
+      require.relative = function (parent) {
+        return function(p){
+          if ('.' != p.charAt(0)) return require(p);
+          var path = parent.split('/');
+          var segs = p.split('/');
+          path.pop();
+          for (var i = 0; i < segs.length; i++) {
+            var seg = segs[i];
+            if ('..' == seg) path.pop();
+            else if ('.' != seg) path.push(seg);
+          }
+          return require(path.join('/'));
+        };
+      };
+    }
+    `;
+    return code;
+}
+exports.getRuntimeCode = getRuntimeCode;

package/dist/base/comparators.d.ts

@@ -0,0 +1,22 @@
+declare const compareChunksById: (a: any, b: any) => 0 | 1 | -1;
+declare const compareModulesByIdentifier: (a: any, b: any) => 0 | 1 | -1;
+declare const compareModulesById: (arg: any) => any;
+declare const compareNumbers: (a: any, b: any) => 0 | 1 | -1;
+declare const compareStringsNumeric: (a: string, b: string) => 0 | 1 | -1;
+declare const compareModulesByPostOrderIndexOrIdentifier: (arg: any) => any;
+declare const compareModulesByPreOrderIndexOrIdentifier: (arg: any) => any;
+declare const compareModulesByIdOrIdentifier: (arg: any) => any;
+declare const compareChunks: (arg: any) => any;
+declare const compareIds: (a: any, b: any) => 0 | 1 | -1;
+declare const compareStrings: (a: string, b: string) => 0 | 1 | -1;
+declare const compareChunkGroupsByIndex: (a: any, b: any) => 1 | -1;
+declare const concatComparators: (c1: any, c2: any, ...cRest: any[]) => any;
+declare const compareSelect: (getter: any, comparator: any) => any;
+declare const compareIterables: (elementComparator: any) => any;
+declare const keepOriginalOrder: (iterable: any) => (a: any, b: any) => 0 | 1 | -1;
+declare const compareChunksNatural: (chunkGraph: any) => any;
+/**
+ * Compare two locations
+ */
+declare const compareLocations: (a: any, b: any) => 0 | 1 | -1;
+export { compareIds, compareChunksById, compareModulesByIdentifier, compareModulesById, compareNumbers, compareStringsNumeric, compareModulesByPostOrderIndexOrIdentifier, compareModulesByPreOrderIndexOrIdentifier, compareModulesByIdOrIdentifier, compareChunks, compareStrings, compareChunkGroupsByIndex, concatComparators, compareSelect, compareIterables, keepOriginalOrder, compareChunksNatural, compareLocations, };