gen-jhipster/dist/lib/utils/object.js

VHipster - Spring Boot + Angular/React/Vue in one handy generator

/**
 * Copyright 2013-2026 the original author or authors from the JHipster project.
 *
 * This file is part of the JHipster project, see https://www.jhipster.tech/
 * for more information.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
const filterNullishValues = (value) => value != null;
/**
 * Copy and remove null and undefined values
 * @param object
 * @returns
 */
export function removeFieldsWithNullishValues(object) {
    return filterValue(object, filterNullishValues);
}
/**
 * Copy and remove null and undefined values
 * @param object
 * @returns
 */
function filterValue(object, customFilterValue = filterNullishValues, deep = 1) {
    const clone = {};
    for (const [key, value] of Object.entries(object)) {
        if (customFilterValue(value)) {
            if (typeof value === 'object') {
                if (Array.isArray(value)) {
                    clone[key] = value.filter(customFilterValue);
                }
                else if (deep < 4) {
                    // Avoid recursion depth issues
                    clone[key] = filterValue(value, customFilterValue, deep + 1);
                }
            }
            else {
                clone[key] = value;
            }
        }
    }
    return clone;
}
/**
 * Picks every field from source.
 * A field with undefined value is returned for missing fields.
 */
export const pickFields = (source, fields) => Object.fromEntries(fields.map(field => [field, source[field]]));
const OverrideMutation = Symbol('OverrideMutation');
export const overrideMutateDataProperty = (fn) => {
    fn[OverrideMutation] = true;
    return fn;
};
/**
 * Mutation properties accepts:
 * - functions: receives the data and the return value is set at the data property.
 * - non functions: data property will receive the property in case current value is undefined.
 * - __override__ property: if set to false, functions will not override existing values.
 *
 * Applies each mutation object in order.
 *
 * Note: if data property is expected to be a function, mutation should be a function that returns the desired function.
 *
 * @example
 * // data = { prop: 'foo-bar', prop2: 'foo2', fn: () => 'fn' }
 * mutateData(
 *   data,
 *   { prop: 'foo', prop2: ({ prop }) => prop + 2, fn: () => () => 'fn' },
 *   { prop: ({ prop }) => prop + '-bar', prop2: 'won\'t override' },
 *   { __override__: false, prop: () => 'won\'t override' },
 * );
 */
export const mutateData = (context, ...mutations) => {
    for (const mutation of mutations) {
        const override = mutation.__override__;
        for (const [key, value] of Object.entries(mutation).filter(([key]) => key !== '__override__')) {
            if (typeof value === 'function') {
                if (override !== false || !(key in context) || context[key] === undefined || value[OverrideMutation] === true) {
                    context[key] = value(context);
                }
            }
            else if (!(key in context) || context[key] === undefined || override === true) {
                context[key] = value;
            }
        }
    }
};