@adaptabletools/adaptable/src/Utilities/Extensions/ObjectExtensions.js

Powerful AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements

export function setInPath(obj, path, value) {
    if (path.length === 1) {
        return {
            ...obj,
            [path[0]]: value,
        };
    }
    return {
        ...obj,
        [path[0]]: setInPath(obj?.[path[0]] ?? {}, path.slice(1), value),
    };
}
export function isObjectEmpty(obj) {
    return !obj || Object.keys(obj).length === 0;
}
export const deepClone = (obj) => {
    return JSON.parse(JSON.stringify(obj));
};
export const diff = (obj1, obj2) => {
    let changed = [];
    for (const key of Object.keys(obj1)) {
        if (obj1[key] !== obj2[key]) {
            changed.push(key);
        }
    }
    return changed;
};
export function isObject(value) {
    const type = typeof value;
    return value != null && (type === 'object' || type === 'function');
}
export function isPlainObject(value) {
    if (value === null || value === undefined || typeof value !== 'object') {
        return false;
    }
    const proto = Object.getPrototypeOf(value);
    if (proto === null) {
        return true;
    }
    return proto === Object.prototype;
}
export function isEqual(value, other) {
    return _baseIsEqual(value, other, new Map());
}
function _baseIsEqual(a, b, seen) {
    if (a === b) {
        return true;
    }
    if (a !== a && b !== b) {
        return true;
    }
    if (a == null || b == null) {
        return false;
    }
    const typeA = typeof a;
    const typeB = typeof b;
    if (typeA !== typeB) {
        return false;
    }
    if (typeA !== 'object') {
        return false;
    }
    if (a instanceof Date && b instanceof Date) {
        return a.getTime() === b.getTime();
    }
    if (a instanceof RegExp && b instanceof RegExp) {
        return a.source === b.source && a.flags === b.flags;
    }
    if (a instanceof Date !== b instanceof Date) {
        return false;
    }
    if (a instanceof RegExp !== b instanceof RegExp) {
        return false;
    }
    if (seen.has(a)) {
        return seen.get(a) === b;
    }
    seen.set(a, b);
    if (Array.isArray(a)) {
        if (!Array.isArray(b) || a.length !== b.length) {
            return false;
        }
        for (let i = 0; i < a.length; i++) {
            if (!_baseIsEqual(a[i], b[i], seen)) {
                return false;
            }
        }
        return true;
    }
    if (Array.isArray(b)) {
        return false;
    }
    if (a instanceof Map && b instanceof Map) {
        if (a.size !== b.size) {
            return false;
        }
        for (const [key, val] of a) {
            if (!b.has(key) || !_baseIsEqual(val, b.get(key), seen)) {
                return false;
            }
        }
        return true;
    }
    if (a instanceof Set && b instanceof Set) {
        if (a.size !== b.size) {
            return false;
        }
        for (const valA of a) {
            let found = false;
            for (const valB of b) {
                if (_baseIsEqual(valA, valB, new Map(seen))) {
                    found = true;
                    break;
                }
            }
            if (!found) {
                return false;
            }
        }
        return true;
    }
    if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
        const viewA = a;
        const viewB = b;
        if (viewA.length !== viewB.length) {
            return false;
        }
        for (let i = 0; i < viewA.length; i++) {
            if (viewA[i] !== viewB[i]) {
                return false;
            }
        }
        return true;
    }
    const keysA = Object.keys(a);
    const keysB = Object.keys(b);
    if (keysA.length !== keysB.length) {
        return false;
    }
    for (const key of keysA) {
        if (!Object.prototype.hasOwnProperty.call(b, key)) {
            return false;
        }
        if (!_baseIsEqual(a[key], b[key], seen)) {
            return false;
        }
    }
    return true;
}
export function cloneDeepWith(value, customizer) {
    return _baseCloneDeep(value, customizer, new Map());
}
function _baseCloneDeep(value, customizer, seen) {
    const customResult = customizer(value);
    if (customResult !== undefined) {
        return customResult;
    }
    if (value === null || typeof value !== 'object') {
        return value;
    }
    if (seen.has(value)) {
        return seen.get(value);
    }
    if (value instanceof Date) {
        return new Date(value.getTime());
    }
    if (value instanceof RegExp) {
        return new RegExp(value.source, value.flags);
    }
    if (value instanceof Map) {
        const cloned = new Map();
        seen.set(value, cloned);
        value.forEach((v, k) => {
            cloned.set(_baseCloneDeep(k, customizer, seen), _baseCloneDeep(v, customizer, seen));
        });
        return cloned;
    }
    if (value instanceof Set) {
        const cloned = new Set();
        seen.set(value, cloned);
        value.forEach((v) => {
            cloned.add(_baseCloneDeep(v, customizer, seen));
        });
        return cloned;
    }
    if (Array.isArray(value)) {
        const cloned = [];
        seen.set(value, cloned);
        for (let i = 0; i < value.length; i++) {
            cloned[i] = _baseCloneDeep(value[i], customizer, seen);
        }
        return cloned;
    }
    const cloned = Object.create(Object.getPrototypeOf(value));
    seen.set(value, cloned);
    const keys = Object.keys(value);
    for (const key of keys) {
        cloned[key] = _baseCloneDeep(value[key], customizer, seen);
    }
    return cloned;
}
function _baseMerge(target, source) {
    if (source == null) {
        return target;
    }
    const keys = Object.keys(source);
    for (const key of keys) {
        const srcValue = source[key];
        const tgtValue = target[key];
        if (Array.isArray(srcValue)) {
            if (!Array.isArray(tgtValue)) {
                target[key] = [];
            }
            _baseMerge(target[key], srcValue);
        }
        else if (isPlainObject(srcValue)) {
            if (!isPlainObject(tgtValue)) {
                target[key] = {};
            }
            _baseMerge(target[key], srcValue);
        }
        else if (srcValue !== undefined) {
            target[key] = srcValue;
        }
    }
    return target;
}
export function merge(target, ...sources) {
    for (const source of sources) {
        _baseMerge(target, source);
    }
    return target;
}
function _baseMergeWith(target, source, customizer) {
    if (source == null) {
        return target;
    }
    const keys = Object.keys(source);
    for (const key of keys) {
        const srcValue = source[key];
        const tgtValue = target[key];
        const customResult = customizer(tgtValue, srcValue, key, target, source);
        if (customResult !== undefined) {
            target[key] = customResult;
        }
        else if (Array.isArray(srcValue)) {
            if (!Array.isArray(tgtValue)) {
                target[key] = [];
            }
            _baseMergeWith(target[key], srcValue, customizer);
        }
        else if (isPlainObject(srcValue)) {
            if (!isPlainObject(tgtValue)) {
                target[key] = {};
            }
            _baseMergeWith(target[key], srcValue, customizer);
        }
        else if (srcValue !== undefined) {
            target[key] = srcValue;
        }
    }
    return target;
}
export function mergeWith(target, ...args) {
    const customizer = args[args.length - 1];
    const sources = args.slice(0, -1);
    for (const source of sources) {
        _baseMergeWith(target, source, customizer);
    }
    return target;
}
export function defaultsDeep(target, ...sources) {
    for (const source of sources) {
        _baseDefaultsDeep(target, source);
    }
    return target;
}
function _baseDefaultsDeep(target, defaults) {
    if (defaults == null) {
        return target;
    }
    const keys = Object.keys(defaults);
    for (const key of keys) {
        const defaultValue = defaults[key];
        const targetValue = target[key];
        if (targetValue === undefined) {
            target[key] = _cloneDefaultValue(defaultValue);
        }
        else if (isPlainObject(defaultValue) && isPlainObject(targetValue)) {
            const childCopy = { ...targetValue };
            _baseDefaultsDeep(childCopy, defaultValue);
            target[key] = childCopy;
        }
    }
    return target;
}
function _cloneDefaultValue(value) {
    if (value === null || typeof value !== 'object') {
        return value;
    }
    if (Array.isArray(value)) {
        return value.map(_cloneDefaultValue);
    }
    if (isPlainObject(value)) {
        const out = {};
        for (const k of Object.keys(value)) {
            out[k] = _cloneDefaultValue(value[k]);
        }
        return out;
    }
    return value;
}