@baseplate-dev/sync/dist/utils/non-overwriteable-map.js

Library for syncing Baseplate descriptions

import { mergeWith, uniq } from 'es-toolkit';
/**
 * Creates map that has an initial default, but whose keys cannot be overwritten
 * once written.
 */
export function createNonOverwriteableMap(defaults, options = {}) {
    const { name = 'non-overwriteable map', mergeArraysUniquely, defaultsOverwriteable, } = options;
    let overrideValues = defaultsOverwriteable ? {} : defaults;
    return {
        set(key, value) {
            if (key in overrideValues) {
                throw new Error(`Field ${String(key)} already has value in ${name}`);
            }
            overrideValues = {
                ...overrideValues,
                [key]: value,
            };
            return this;
        },
        prepend(key, value) {
            const arrValue = Array.isArray(value) ? value : [value];
            const existingValue = overrideValues[key] ?? [];
            if (!Array.isArray(existingValue)) {
                throw new TypeError(`Field ${key.toString()} is not array and cannot be prepended to in ${name}`);
            }
            overrideValues = {
                ...overrideValues,
                [key]: [...arrValue, ...existingValue],
            };
            return this;
        },
        append(key, value) {
            const arrValue = Array.isArray(value) ? value : [value];
            const existingValue = overrideValues[key] ?? [];
            if (!Array.isArray(existingValue)) {
                throw new TypeError(`Field ${key.toString()} is not array and cannot be appended to in ${name}`);
            }
            overrideValues = {
                ...overrideValues,
                [key]: [...existingValue, ...arrValue],
            };
            return this;
        },
        appendUnique(key, value) {
            const arrValue = Array.isArray(value) ? value : [value];
            const existingValue = overrideValues[key];
            if (existingValue) {
                if (!Array.isArray(existingValue)) {
                    throw new TypeError(`Field ${key.toString()} is not array and cannot be appended to in ${name}`);
                }
                overrideValues = {
                    ...overrideValues,
                    [key]: uniq([...existingValue, ...arrValue]),
                };
            }
            else {
                overrideValues = {
                    ...overrideValues,
                    [key]: arrValue,
                };
            }
            return this;
        },
        merge(value) {
            mergeWith(overrideValues, value, (targetValue, sourceValue, key) => {
                if (key in overrideValues && key in value) {
                    throw new Error(`Cannot merge key ${key} because it already exists.`);
                }
                // eslint-disable-next-line @typescript-eslint/no-unsafe-return -- we're just using the sourceValue
                return sourceValue;
            });
            return this;
        },
        value() {
            return mergeWith({ ...defaults }, overrideValues, (targetValue, sourceValue) => {
                if (mergeArraysUniquely &&
                    Array.isArray(targetValue) &&
                    Array.isArray(sourceValue)) {
                    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-assignment
                    return uniq([...targetValue, ...sourceValue]);
                }
                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                return sourceValue;
            });
        },
        get(key) {
            const override = overrideValues[key];
            const def = defaults[key];
            if (mergeArraysUniquely &&
                Array.isArray(override) &&
                Array.isArray(def)) {
                return uniq([...def, ...override]);
            }
            return (override || def);
        },
    };
}
//# sourceMappingURL=non-overwriteable-map.js.map