devextreme/cjs/__internal/core/r1/utils/get_updated_options.js

HTML5 JavaScript Component Suite for Responsive Web Development

/**
 * DevExtreme (cjs/__internal/core/r1/utils/get_updated_options.js)
 * Version: 24.2.6
 * Build date: Mon Mar 17 2025
 *
 * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
 * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
 */

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.getUpdatedOptions = getUpdatedOptions;
var _type = require("../../../../core/utils/type");

function _extends() {
    return _extends = Object.assign ? Object.assign.bind() : function(n) {
        for (var e = 1; e < arguments.length; e++) {
            var t = arguments[e];
            for (var r in t) {
                ({}).hasOwnProperty.call(t, r) && (n[r] = t[r])
            }
        }
        return n
    }, _extends.apply(null, arguments)
}
const defaultNotDeepCopyArrays = ["dataSource", "selectedRowKeys"];
const propsToIgnore = {
    integrationOptions: true
};

function getDiffItem(key, value, previousValue) {
    return {
        path: key,
        value: value,
        previousValue: previousValue
    }
}

function compare(resultPaths, item1, item2, key, fullPropName, notDeepCopyArrays) {
    if (propsToIgnore[key]) {
        return
    }
    const type1 = (0, _type.type)(item1);
    const type2 = (0, _type.type)(item2);
    if (item1 === item2) {
        return
    }
    if (type1 !== type2) {
        resultPaths.push(getDiffItem(key, item2, item1))
    } else if ("object" === type1) {
        if (!(0, _type.isPlainObject)(item2)) {
            resultPaths.push(getDiffItem(key, item2, item1))
        } else {
            const diffPaths = objectDiffs(item1, item2, fullPropName, notDeepCopyArrays);
            resultPaths.push(...diffPaths.map((item => _extends({}, item, {
                path: `${key}.${item.path}`
            }))))
        }
    } else if ("array" === type1) {
        const notDeepCopy = notDeepCopyArrays.some((prop => fullPropName.includes(prop)));
        if (notDeepCopy && item1 !== item2) {
            resultPaths.push(getDiffItem(key, item2, item1))
        } else if (item1.length !== item2.length) {
            resultPaths.push(getDiffItem(key, item2, item1))
        } else {
            const diffPaths = objectDiffs(item1, item2, fullPropName, notDeepCopyArrays);
            [].push.apply(resultPaths, diffPaths.map((item => _extends({}, item, {
                path: `${key}${item.path}`
            }))))
        }
    } else {
        resultPaths.push(getDiffItem(key, item2, item1))
    }
}
const objectDiffsFiltered = propsEnumerator => (oldProps, props, fullPropName, notDeepCopyArrays) => {
    const resultPaths = [];
    const processItem = !Array.isArray(oldProps) ? propName => {
        compare(resultPaths, oldProps[propName], props[propName], propName, `${fullPropName}.${propName}`, notDeepCopyArrays)
    } : propName => {
        compare(resultPaths, oldProps[propName], props[propName], `[${propName}]`, `${fullPropName}.${propName}`, notDeepCopyArrays)
    };
    propsEnumerator(oldProps).forEach(processItem);
    Object.keys(props).filter((propName => !Object.prototype.hasOwnProperty.call(oldProps, propName) && oldProps[propName] !== props[propName])).forEach((propName => {
        resultPaths.push({
            path: propName,
            value: props[propName],
            previousValue: oldProps[propName]
        })
    }));
    return resultPaths
};
const objectDiffs = objectDiffsFiltered((oldProps => Object.keys(oldProps)));
const reactProps = {
    key: true,
    ref: true,
    children: true,
    style: true
};
const objectDiffsWithoutReactProps = objectDiffsFiltered((prop => Object.keys(prop).filter((p => !reactProps[p]))));

function getUpdatedOptions(oldProps, props) {
    let notDeepCopyArrays = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : defaultNotDeepCopyArrays;
    return objectDiffsWithoutReactProps(oldProps, props, "", notDeepCopyArrays)
}