@rzl-zone/utils-js/dist/chunk-LJHPTLWB.js

A modern, lightweight set of JavaScript utility functions with TypeScript support for everyday development, crafted to enhance code readability and maintainability.

/*!
 * ====================================================
 * Rzl Utils-JS.
 * ----------------------------------------------------
 * Version: 3.11.0.
 * Author: Rizalvin Dwiky.
 * Repository: https://github.com/rzl-zone/utils-js.
 * ====================================================
 */
import { safeJsonParse } from './chunk-BOYP3ARU.js';
import { isEqual } from './chunk-GXKQ3LHF.js';
import { isEmptyArray } from './chunk-GOFINGT6.js';
import { assertIsArray } from './chunk-RZOGBYIS.js';
import { safeStableStringify } from './chunk-AXDYWO67.js';
import { isPlainObject, isNonEmptyArray, isObjectOrArray, isArray, isNaN, isUndefined } from './chunk-MSUW5VHZ.js';

var findDuplicates = (values) => {
  assertIsArray(values, {
    message: ({ currentType, validType }) => `First parameter (\`values\`) must be of type \`${validType}\` (array literal or instance), but received: \`${currentType}\`.`
  });
  const duplicates = [];
  values.forEach((item, index) => {
    for (let i = index + 1; i < values.length; i++) {
      if (isEqual(item, values[i])) {
        if (!duplicates.some((dup) => isEqual(dup, item))) {
          duplicates.push(item);
        }
        break;
      }
    }
  });
  return duplicates;
};

var omitKeys = (object, keysToOmit) => {
  if (!isPlainObject(object)) return {};
  assertIsArray(keysToOmit, {
    message: ({ currentType, validType }) => `Second parameter (\`keysToOmit\`) must be of type \`${validType}\` (array literal or instance), but received: \`${currentType}\`.`
  });
  const duplicates = findDuplicates(keysToOmit);
  if (duplicates.length > 0) {
    throw new Error(
      `Function "omitKeys" Error: Duplicate keys detected - \`${duplicates}\``
    );
  }
  return Object.fromEntries(
    Object.entries(object).filter(([key]) => !keysToOmit.includes(key))
  );
};

var omitKeysDeep = (object, keysToOmit) => {
  if (!isPlainObject(object)) return {};
  assertIsArray(keysToOmit, {
    message: ({ currentType, validType }) => `Second parameter (\`keysToOmit\`) must be of type \`${validType}\` (array literal or instance), but received: \`${currentType}\`.`
  });
  const duplicates = findDuplicates(keysToOmit);
  if (isNonEmptyArray(duplicates)) {
    throw new Error(
      `Function "omitKeysDeep" Error: Duplicate keys detected - \`${safeStableStringify(
        duplicates,
        {
          keepUndefined: true
        }
      )}\`.`
    );
  }
  const omitAtPath = (obj, pathParts) => {
    if (!isObjectOrArray(obj)) return obj;
    const [current, ...rest] = pathParts;
    if (isEmptyArray(rest)) {
      if (isArray(obj)) {
        const index = parseInt(current);
        if (!isNaN(index) && index in obj) {
          obj.splice(index, 1);
        }
      } else {
        delete obj[current];
      }
    } else {
      const next = obj[current];
      if (isObjectOrArray(next)) {
        obj[current] = omitAtPath(next, rest);
      }
    }
    return obj;
  };
  const deepRemoveEmptyObjects = (obj) => {
    if (isArray(obj)) {
      return obj.map(deepRemoveEmptyObjects).filter((item) => !(isObjectOrArray(item) && Object.keys(item).length === 0));
    }
    if (isObjectOrArray(obj)) {
      const cleaned = Object.fromEntries(
        Object.entries(obj).map(([k, v]) => [k, deepRemoveEmptyObjects(v)]).filter(
          ([, v]) => !isUndefined(v) && !(isObjectOrArray(v) && Object.keys(v).length === 0)
        )
      );
      return cleaned;
    }
    return obj;
  };
  const result = safeJsonParse(safeStableStringify(object));
  for (const key of keysToOmit) {
    const parts = key.split(".");
    omitAtPath(result, parts);
  }
  return deepRemoveEmptyObjects(result);
};

export { findDuplicates, omitKeys, omitKeysDeep };