@rspack/core 1.0.10 → 1.0.12

package/dist/util/cleverMerge.js

@@ -1,504 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveByProperty = exports.removeOperations = exports.cleverMerge = exports.cachedSetProperty = exports.cachedCleverMerge = exports.DELETE = void 0;
-const DYNAMIC_INFO = Symbol("cleverMerge dynamic info");
-const mergeCache = new WeakMap();
-const setPropertyCache = new WeakMap();
-exports.DELETE = Symbol("DELETE");
-/**
- * Merges two given objects and caches the result to avoid computation if same objects passed as arguments again.
- * @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 first first object
- * @param second second object
- * @returns  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;
-/**
- * @param obj object
- * @param property property
- * @param value assignment value
- * @returns new object
- */
-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 = {
-        ...obj,
-        [property]: value
-    };
-    mapByValue.set(value, result);
-    return result;
-};
-exports.cachedSetProperty = cachedSetProperty;
-const parseCache = new WeakMap();
-/**
- * @param obj the object
- * @returns parsed object
- */
-const cachedParseObject = (obj) => {
-    const entry = parseCache.get(obj);
-    if (entry !== undefined)
-        return entry;
-    const result = parseObject(obj);
-    parseCache.set(obj, result);
-    return result;
-};
-/**
- * @param {object} obj the object
- * @returns {ParsedObject} parsed object
- */
-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: new Map()
-        };
-        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;
-                        }
-                        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
-    };
-};
-/**
- * @param info static properties (key is property name)
- * @param dynamicInfo dynamic part
- * @returns the object
- */
-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;
-/**
- * @param value a single value
- * @returns {VALUE_TYPE_UNDEFINED | VALUE_TYPE_ATOM | VALUE_TYPE_ARRAY_EXTEND | VALUE_TYPE_OBJECT | VALUE_TYPE_DELETE} value type
- */
-const getValueType = (value) => {
-    if (value === undefined) {
-        return VALUE_TYPE_UNDEFINED;
-    }
-    if (value === exports.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.
- * @param first first object
- * @param second second object
- * @returns merged object of first and second object
- */
-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.
- * @param first first object
- * @param second second object
- * @param internalCaching should parsing of objects and nested merges be cached
- * @returns merged object of first and second object
- */
-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
-    let secondObj = second;
-    if (firstDynamicInfo !== undefined) {
-        let { byProperty, fn } = firstDynamicInfo;
-        const fnInfo = fn[DYNAMIC_INFO];
-        if (fnInfo) {
-            secondObj = internalCaching
-                ? (0, exports.cachedCleverMerge)(fnInfo[1], second)
-                : (0, exports.cleverMerge)(fnInfo[1], second);
-            fn = fnInfo[0];
-        }
-        const newFn = (...args) => {
-            const fnResult = fn(...args);
-            return internalCaching
-                ? (0, exports.cachedCleverMerge)(fnResult, secondObj)
-                : (0, exports.cleverMerge)(fnResult, secondObj);
-        };
-        newFn[DYNAMIC_INFO] = [fn, secondObj];
-        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);
-};
-/**
- * @param firstEntry a
- * @param secondEntry b
- * @param internalCaching should parsing of objects and nested merges be cached
- * @returns new entry
- */
-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`);
-            }
-            // = 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
-            };
-        }
-    }
-};
-/**
- * @param byValues all values
- * @param key value of the selector
- * @returns value
- */
-const getFromByValues = (byValues, key) => {
-    if (key !== "default" && byValues.has(key)) {
-        return byValues.get(key);
-    }
-    return byValues.get("default");
-};
-/**
- * @param a value
- * @param b value
- * @param internalCaching should parsing of objects and nested merges be cached
- * @returns value
- */
-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
-                    ? (0, exports.cachedCleverMerge)(a, b)
-                    : (0, exports.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");
-    }
-};
-/**
- * @param obj the object
- * @returns the object without operations like "..." or DELETE
- */
-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] = (0, exports.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;
-/**
- * @param obj the object
- * @param byProperty the by description
- * @param values values
- * @returns object with merged byProperty
- */
-const resolveByProperty = (obj, byProperty, ...values) => {
-    if (!isPropertyInObject(obj, byProperty)) {
-        return obj;
-    }
-    const { [byProperty]: _byValue, ..._remaining } = obj;
-    const remaining = _remaining;
-    const byValue = _byValue;
-    if (typeof byValue === "object") {
-        const key = values[0];
-        if (key in byValue) {
-            return (0, exports.cachedCleverMerge)(remaining, byValue[key]);
-        }
-        if ("default" in byValue) {
-            return (0, exports.cachedCleverMerge)(remaining, byValue.default);
-        }
-        return remaining;
-    }
-    if (typeof byValue === "function") {
-        const result = byValue.apply(null, values);
-        return (0, exports.cachedCleverMerge)(remaining, (0, exports.resolveByProperty)(result, byProperty, ...values));
-    }
-};
-exports.resolveByProperty = resolveByProperty;
-function isPropertyInObject(obj, property) {
-    return typeof obj === "object" && obj !== null && property in obj;
-}

package/dist/util/comparators.js

@@ -1,108 +0,0 @@
-"use strict";
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack/tree/4b4ca3bb53f36a5b8fc6bc1bd976ed7af161bd80/lib/util
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/webpack/blob/main/LICENSE
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compareNumbers = exports.compareSelect = exports.compareChunkGroupsByIndex = exports.compareChunksById = exports.compareIds = exports.concatComparators = void 0;
-class TwoKeyWeakMap {
-    constructor() {
-        this._map = new WeakMap();
-    }
-    get(key1, key2) {
-        const childMap = this._map.get(key1);
-        if (childMap === undefined) {
-            return undefined;
-        }
-        return childMap.get(key2);
-    }
-    set(key1, key2, value) {
-        let childMap = this._map.get(key1);
-        if (childMap === undefined) {
-            childMap = new WeakMap();
-            this._map.set(key1, childMap);
-        }
-        childMap.set(key2, value);
-    }
-}
-const concatComparatorsCache = new TwoKeyWeakMap();
-const concatComparators = (...comps) => {
-    const [c1, c2, ...cRest] = comps;
-    if (c2 === undefined) {
-        return c1;
-    }
-    if (cRest.length > 0) {
-        const [c3, ...cRest2] = cRest;
-        return (0, exports.concatComparators)(c1, (0, exports.concatComparators)(c2, c3, ...cRest2));
-    }
-    const cacheEntry = concatComparatorsCache.get(c1, c2);
-    if (cacheEntry !== undefined)
-        return cacheEntry;
-    const result = (a, b) => {
-        const res = c1(a, b);
-        if (res !== 0)
-            return res;
-        return c2(a, b);
-    };
-    concatComparatorsCache.set(c1, c2, result);
-    return result;
-};
-exports.concatComparators = concatComparators;
-const compareIds = (a, b) => {
-    if (typeof a !== typeof b) {
-        return typeof a < typeof b ? -1 : 1;
-    }
-    if (a < b)
-        return -1;
-    if (a > b)
-        return 1;
-    return 0;
-};
-exports.compareIds = compareIds;
-const compareChunksById = (a, b) => {
-    return (0, exports.compareIds)(a.id || "", b.id || "");
-};
-exports.compareChunksById = compareChunksById;
-const compareChunkGroupsByIndex = (a, b) => {
-    return a.index < b.index ? -1 : 1;
-};
-exports.compareChunkGroupsByIndex = compareChunkGroupsByIndex;
-const compareSelectCache = new TwoKeyWeakMap();
-const compareSelect = (getter, comparator) => {
-    const cacheEntry = compareSelectCache.get(getter, comparator);
-    if (cacheEntry !== undefined)
-        return cacheEntry;
-    const result = (a, b) => {
-        const aValue = getter(a);
-        const bValue = getter(b);
-        if (aValue !== undefined && aValue !== null) {
-            if (bValue !== undefined && bValue !== null) {
-                return comparator(aValue, bValue);
-            }
-            return -1;
-        }
-        if (bValue !== undefined && bValue !== null) {
-            return 1;
-        }
-        return 0;
-    };
-    compareSelectCache.set(getter, comparator, result);
-    return result;
-};
-exports.compareSelect = compareSelect;
-const compareNumbers = (a, b) => {
-    if (typeof a !== typeof b) {
-        return typeof a < typeof b ? -1 : 1;
-    }
-    if (a < b)
-        return -1;
-    if (a > b)
-        return 1;
-    return 0;
-};
-exports.compareNumbers = compareNumbers;