@adaptabletools/adaptable/src/Utilities/Helpers/AdaptableHelper.js

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

import { cloneDeepWith } from '../Extensions/ObjectExtensions';
import { isPlainObject } from '../Extensions/ObjectExtensions';
import { createUuid } from '../../AdaptableState/Uuid';
import { ACCESS_LEVEL_FULL, ACCESS_LEVEL_READ_ONLY, } from '../Constants/GeneralConstants';
import packageJson from '../../../package.json';
const GET_CURRENT_VERSION = () => {
    const globalObject = typeof globalThis !== 'undefined' ? globalThis : window;
    return ((typeof globalObject['GET_CURRENT_ADAPTABLE_VERSION'] === 'function'
        ? globalObject['GET_CURRENT_ADAPTABLE_VERSION']()
        : packageJson.version) ?? packageJson.version);
};
export function addUuidsToInitialState(initialState) {
    const objectsToEnrich = new Set();
    for (const moduleKey in initialState) {
        const moduleState = initialState[moduleKey];
        if (isPlainObject(moduleState)) {
            objectsToEnrich.add(moduleState);
            for (const key in moduleState) {
                const value = moduleState[key];
                if (Array.isArray(value)) {
                    for (const item of value) {
                        if (isPlainObject(item)) {
                            objectsToEnrich.add(item);
                            if (Array.isArray(item.ColumnFilters)) {
                                for (const filter of item.ColumnFilters) {
                                    if (isPlainObject(filter)) {
                                        objectsToEnrich.add(filter);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    const customizer = (value) => {
        if (isPlainObject(value) && objectsToEnrich.has(value)) {
            if (value.Uuid == null || value.Uuid == undefined) {
                value.Uuid = createUuid();
            }
            if (value.AdaptableVersion == null) {
                value.AdaptableVersion = GET_CURRENT_VERSION();
            }
        }
    };
    return cloneDeepWith(initialState, customizer);
}
export function getAccessLevelForObject(adaptableObject, moduleAccessLevel) {
    if (moduleAccessLevel == ACCESS_LEVEL_FULL &&
        adaptableObject &&
        adaptableObject.IsReadOnly &&
        adaptableObject.IsReadOnly == true) {
        return ACCESS_LEVEL_READ_ONLY;
    }
    return moduleAccessLevel;
}
export function addAdaptableObjectPrimitives(adaptableObject) {
    if (!adaptableObject.Uuid) {
        adaptableObject.Uuid = createUuid();
    }
    adaptableObject.Source = 'User';
    adaptableObject.AdaptableVersion = GET_CURRENT_VERSION();
    return adaptableObject;
}
export function removeAdaptableObjectPrimitivesInlineDeep(target) {
    if (!target) {
        return target;
    }
    if (Array.isArray(target)) {
        target.forEach(removeAdaptableObjectPrimitivesInlineDeep);
        return target;
    }
    if (typeof target !== 'object') {
        return target;
    }
    delete target.Source;
    delete target.Uuid;
    delete target.AdaptableVersion;
    for (const key in target) {
        removeAdaptableObjectPrimitivesInlineDeep(target[key]);
    }
    return target;
}
export function removeAdaptableObjectPrimitivesInline(target) {
    if (!target) {
        return target;
    }
    if (Array.isArray(target)) {
        target.forEach(removeAdaptableObjectPrimitivesInline);
        return target;
    }
    if (typeof target !== 'object') {
        return target;
    }
    delete target.Source;
    delete target.Uuid;
    delete target.AdaptableVersion;
    return target;
}
export function removeAdaptableObjectPrimitives(adaptableObject) {
    const clonedObject = structuredClone(adaptableObject);
    const sanitiseObject = (object) => {
        for (const key in object) {
            if (key === 'Source' || key === 'Uuid' || key === 'AdaptableVersion') {
                delete object[key];
            }
            else if (Array.isArray(object[key])) {
                object[key].forEach((item) => sanitiseObject(item));
            }
            else if (typeof object[key] === 'object') {
                sanitiseObject(object[key]);
            }
        }
    };
    sanitiseObject(clonedObject);
    return clonedObject;
}
export function isAdaptableObject(object) {
    return object != undefined && typeof object['Uuid'] === 'string';
}
export const AdaptableHelper = {
    addUuidsToInitialState: addUuidsToInitialState,
    getAccessLevelForObject,
    addAdaptableObjectPrimitives,
    removeAdaptableObjectPrimitives,
    removeAdaptableObjectPrimitivesInline,
    removeAdaptableObjectPrimitivesInlineDeep,
    isAdaptableObject,
};
export default AdaptableHelper;