"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.partialDiff = partialDiff;
exports.deepMerge = deepMerge;
/**
 * Computes the partial difference between two values.
 * Returns `undefined` if the values are equal, or `{ diff }` containing only the changed parts.
 * For arrays, the diff contains only items in `next` that have no deep-equal counterpart in `prev`.
 * For objects, the diff contains only keys whose values changed.
 *
 * @param prev - The original value
 * @param next - The updated value
 * @returns An object containing the diff, or `undefined` if the values are equal
 */
function partialDiff(prev, next) {
    if (prev === next) {
        return;
    }
    else if (Array.isArray(prev) && Array.isArray(next)) {
        const res = { diff: [] };
        for (let newItem of next) {
            let anyEq = false;
            for (let oldItem of prev) {
                if (!partialDiff(oldItem, newItem)) {
                    anyEq = true;
                    break;
                }
            }
            if (!anyEq) {
                res.diff.push(newItem);
            }
        }
        if (res.diff.length) {
            return res;
        }
        else {
            return;
        }
    }
    else if (typeof prev === 'object' && typeof next === 'object') {
        if (prev === null || next === null)
            return { diff: next };
        const res = { diff: {} };
        const keys = Object.keys(next);
        for (let key in prev) {
            if (!keys.includes(key))
                keys.push(key);
        }
        for (let key of keys) {
            const diff = partialDiff(prev[key], next[key]);
            if (diff) {
                res.diff[key] = diff.diff;
            }
        }
        if (Object.keys(res.diff).length) {
            return res;
        }
        else {
            return;
        }
    }
    else {
        return { diff: next };
    }
}
/**
 * Deeply merges multiple values together. Objects are merged key-by-key recursively.
 * Arrays are merged by appending items that are not already present (by deep equality).
 * Primitives are resolved by taking the last argument.
 *
 * @param args - The values to merge, applied left to right
 * @returns The merged result
 */
function deepMerge(...args) {
    const lastItem = args[args.length - 1];
    if (typeof lastItem !== 'object' || !lastItem)
        return lastItem;
    if (Array.isArray(lastItem))
        return deepMergeList(...args.filter((x) => Array.isArray(x)));
    return deepMergeObject(...args.filter((x) => typeof x === 'object' && x && !Array.isArray(x)));
}
function deepMergeList(...args) {
    const res = [];
    for (let arg of args) {
        for (let item of arg) {
            if (!res.some((x) => !partialDiff(x, item))) {
                res.push(item);
            }
        }
    }
    return res;
}
function deepMergeObject(...args) {
    const lastItem = args[args.length - 1];
    if (args.length === 0)
        return lastItem;
    if (args.length === 1)
        args.unshift({});
    const allKeys = new Set(args.flatMap((x) => Object.keys(x)));
    for (const key of allKeys) {
        const filteredValues = args.flatMap((x) => key in x ? [x[key]] : []);
        args[0][key] = deepMerge(...filteredValues);
    }
    return args[0];
}
//# sourceMappingURL=deepMerge.js.map