@homer0/object-utils 6.0.2 → 6.0.4

package/dist/index.d.ts

@@ -1,31 +1,26 @@
 /**
  * Creates a deep copy of a given object.
  *
- * @param target  The object to copy.
- * @template T  The type of the input object, which will be the same as the one
- *              returned.
+ * @template T The type of the input object, which will be the same as the one returned.
+ * @param target The object to copy.
  */
 declare const copy: <T>(target: T) => T;
 
 /**
  * The callback that will be used to replace a key.
  *
- * @param substring  The captured string to replace.
- * @param args       The list of groups captured by the expression.
+ * @param substring The captured string to replace.
+ * @param args The list of groups captured by the expression.
  */
 type FormatKeysReplaceFn = (substring: string, ...args: string[]) => string;
 type FormatKeysOptions = {
-    /**
-     * The object to transform.
-     */
+    /** The object to transform. */
     target: unknown;
-    /**
-     * A regular expression to match the keys to transform.
-     */
+    /** A regular expression to match the keys to transform. */
     search: RegExp;
     /**
-     * The callback that will be used to replace the matched substring. Think of `search` and
-     * `replace` as the parameters of `String.replace`.
+     * The callback that will be used to replace the matched substring. Think of `search`
+     * and `replace` as the parameters of `String.replace`.
      */
     replace: FormatKeysReplaceFn;
     /**
@@ -33,12 +28,11 @@ type FormatKeysOptions = {
      * function will use all the keys from the object.
      */
     include?: string[];
-    /**
-     * A list of keys or paths where the transformation won't be made.
-     */
+    /** A list of keys or paths where the transformation won't be made. */
     exclude?: string[];
     /**
-     * The delimiter that will separate the path components for both `include` and `exclude`.
+     * The delimiter that will separate the path components for both `include` and
+     * `exclude`.
      */
     pathDelimiter?: string;
 };
@@ -47,57 +41,54 @@ type FormatKeysExtensionOptions = Omit<FormatKeysOptions, 'search' | 'replace'>;
  * Formats all the keys on an object using a way similar to `.replace(regexp, ...)` but
  * that also works recursively and with _"object paths"_.
  *
- * @param options  The set of options to customize the transformation.
- * @template T  The type of the returned object.
  * @example
- *
  *   const target = {
- *     prop_one: 'Charito!',
+ *   prop_one: 'Charito!',
  *   };
  *   console.log(
- *     formatKeys({
- *       target,
- *       // Find all the keys with snake case.
- *       search: /([a-z])_([a-z])/g,
- *       // Using the same .replace style callback, replace it with lower camel case.
- *       replace: (_, firstLetter, secondLetter) => {
- *         const newSecondLetter = secondLetter.toUpperCase();
- *         return `${firstLetter}${newSecondLetter}`;
- *       },
- *     }),
+ *   formatKeys({
+ *   target,
+ *   // Find all the keys with snake case.
+ *   search: /([a-z])_([a-z])/g,
+ *   // Using the same .replace style callback, replace it with lower camel case.
+ *   replace: (_, firstLetter, secondLetter) => {
+ *   const newSecondLetter = secondLetter.toUpperCase();
+ *   return `${firstLetter}${newSecondLetter}`;
+ *   },
+ *   }),
  *   );
  *   // Will output { propOne: 'Charito!}.
  *
+ *   @template T The type of the returned object.
+ *   @param options The set of options to customize the transformation.
  */
 declare const formatKeys: <T = Record<string, unknown>>(options: FormatKeysOptions) => T;
 
 /**
- * A shorthand method for {@link formatKeys} that transforms the keys from `dash-case`
- * to `lowerCamelCase`.
+ * A shorthand method for {@link formatKeys} that transforms the keys from `dash-case` to
+ * `lowerCamelCase`.
  *
- * @param options  The options to use.
- * @template T  The type of the returned object.
+ * @template T The type of the returned object.
+ * @param options The options to use.
  */
 declare const dashToLowerCamelKeys: <T>(options: FormatKeysExtensionOptions) => T;
 
 /**
- * A shorthand method for {@link formatKeys} that transforms the keys from `dash-case`
- * to `snake_case`.
+ * A shorthand method for {@link formatKeys} that transforms the keys from `dash-case` to
+ * `snake_case`.
  *
- * @param options  The options to use.
- * @template T  The type of the returned object.
+ * @template T The type of the returned object.
+ * @param options The options to use.
  */
 declare const dashToSnakeKeys: <T>(options: FormatKeysExtensionOptions) => T;
 
 /**
- * Used in the {@link extract} function to specify a path for a property, or an "origin path"
- * and an "extraction path".
+ * Used in the {@link extract} function to specify a path for a property, or an "origin
+ * path" and an "extraction path".
  */
 type extractionPath = string | Record<string, string>;
 type ExtractOptions = {
-    /**
-     * The object from where the property/properties will be extracted.
-     */
+    /** The object from where the property/properties will be extracted. */
     target: unknown;
     /**
      * This can be a single path or a list of them. And for this method, the paths are not
@@ -105,9 +96,7 @@ type ExtractOptions = {
      * where to "do the extraction", and the value the path on the target object.
      */
     paths: extractionPath | extractionPath[];
-    /**
-     * The delimiter that will separate the path components.
-     */
+    /** The delimiter that will separate the path components. */
     pathDelimiter?: string;
     /**
      * Whether or not to throw an error when the path is invalid. If this is `false`, the
@@ -118,10 +107,7 @@ type ExtractOptions = {
 /**
  * Extracts a property or properties from an object in order to create a new one.
  *
- * @param options  The options to use.
- * @template T  The type of the returned object.
  * @example
- *
  *   const target = {
  *     name: {
  *       first: 'Pilar',
@@ -140,20 +126,20 @@ type ExtractOptions = {
  *   );
  *   // Will output { name: 'Pilar', age: 3, address: { planet: 'earth' } }
  *
+ * @template T The type of the returned object.
+ * @param options The options to use.
  */
 declare const extract: <T = Record<string, unknown>>(options: ExtractOptions) => T | undefined;
 
 /**
  * Checks whether a key for an array or an Object should be flattened.
  *
- * @param key    The key to check inside its parent.
- * @param value  The value of the key.
+ * @param key The key to check inside its parent.
+ * @param value The value of the key.
  */
 type ShouldFlattenFn = (key: string, value: unknown) => boolean;
 type FlatOptions = {
-    /**
-     * The object to transform.
-     */
+    /** The object to transform. */
     target: unknown;
     /**
      * A custom prefix to be added before the name of the properties. This can be used on
@@ -161,9 +147,7 @@ type FlatOptions = {
      * sub object.
      */
     prefix?: string;
-    /**
-     * The delimiter that will separate the path components.
-     */
+    /** The delimiter that will separate the path components. */
     pathDelimiter?: string;
     /**
      * A custom function that can be used in order to tell the function whether an Object or
@@ -174,49 +158,38 @@ type FlatOptions = {
 /**
  * Flattens an object properties into a single level dictionary.
  *
- * @param options  The options to use.
- * @template T  The type of the returned object.
  * @example
+ *   const target = {
+ *   propOne: {
+ *   propOneSub: 'Charito!',
+ *   },
+ *   propTwo: '!!!',
+ *   };
+ *   console.log(flat({ target });
+ *   // Will output { 'propOne.propOneSub': 'Charito!', propTwo: '!!!' }
  *
- * const target = {
- * propOne: {
- * propOneSub: 'Charito!',
- * },
- * propTwo: '!!!',
- * };
- * console.log(flat({ target });
- * // Will output { 'propOne.propOneSub': 'Charito!', propTwo: '!!!' }
- *
+ * @template T The type of the returned object.
+ * @param options The options to use.
  */
 declare const flat: <T = Record<string, unknown>>(options: FlatOptions) => T;
 
 type GetOptions = {
-    /**
-     * The object from where the property will be read.
-     */
+    /** The object from where the property will be read. */
     target: unknown;
-    /**
-     * The path to the property.
-     */
+    /** The path to the property. */
     path: string;
-    /**
-     * The delimiter that will separate the path components.
-     */
+    /** The delimiter that will separate the path components. */
     pathDelimiter?: string;
     /**
-     * Whether or not to throw an error when the path is invalid. If this is `false`,
-     *  the method will silently fail and return `undefined`.
+     * Whether or not to throw an error when the path is invalid. If this is `false`, the
+     * method will silently fail and return `undefined`.
      */
     failWithError?: boolean;
 };
 /**
  * Returns the value of an object property using a path.
  *
- * @param options  The options to use.
- * @template T  The type of the returned object.
- * @throws {Error} If the path is invalid and `failWithError` is set to `true`.
  * @example
- *
  *   const obj = {
  *     propOne: {
  *       propOneSub: 'Charito!',
@@ -226,16 +199,19 @@ type GetOptions = {
  *   console.log(get({ target: obj, path: 'propOne.propOneSub' }));
  *   // Will output 'Charito!'
  *
+ * @template T The type of the returned object.
+ * @param options The options to use.
+ * @throws {Error} If the path is invalid and `failWithError` is set to `true`.
  */
 declare function get<T>(options: GetOptions): T | undefined;
 declare function get<T>(options: unknown, path: string): T | undefined;
 
 /**
- * A shorthand method for {@link formatKeys} that transforms the keys from
- * `lowerCamelCase` to `dash-case`.
+ * A shorthand method for {@link formatKeys} that transforms the keys from `lowerCamelCase`
+ * to `dash-case`.
  *
- * @param options  The options to use.
- * @template T  The type of the returned object.
+ * @template T The type of the returned object.
+ * @param options The options to use.
  */
 declare const lowerCamelToDashKeys: <T>(options: FormatKeysExtensionOptions) => T;
 
@@ -243,8 +219,8 @@ declare const lowerCamelToDashKeys: <T>(options: FormatKeysExtensionOptions) =>
  * A shorthand method for {@link formatKeys} that transforms the keys from
  * `lowerCamelCase` to `snake_case`.
  *
- * @param options  The options to use.
- * @template T  The type of the returned object.
+ * @template T The type of the returned object.
+ * @param options The options to use.
  */
 declare const lowerCamelToSnakeKeys: <T>(options: FormatKeysExtensionOptions) => T;
 
@@ -253,37 +229,29 @@ declare const lowerCamelToSnakeKeys: <T>(options: FormatKeysExtensionOptions) =>
  * supports arrays: if the first element is an array, it will be merged into an array,
  * otherwise, it will be an object.
  *
- * @param targets  The list of objects to merge.
- * @template T  The type of the merged object that will be returned.
  * @example
- *
  *   const objA = { a: 'first' };
  *   const objB = { b: 'second' };
  *   console.log(merge(objA, objB));
  *   // Will output { a: 'first', b: 'second' }
  *
  * @example
- *
  *   const arrA = [{ a: 'first' }];
  *   const arrB = [{ b: 'second' }];
  *   console.log(merge(objA, objB));
  *   // Will output [{ a: 'first', b: 'second' }]
  *
+ * @template T The type of the merged object that will be returned.
+ * @param targets The list of objects to merge.
  */
 declare const merge: <T = unknown>(...targets: unknown[]) => T;
 
 type RemoveOptions = {
-    /**
-     * The object from where the property will be removed.
-     */
+    /** The object from where the property will be removed. */
     target: unknown;
-    /**
-     * The path to the property.
-     */
+    /** The path to the property. */
     path: string;
-    /**
-     * The delimiter that will separate the path components.
-     */
+    /** The delimiter that will separate the path components. */
     pathDelimiter?: string;
     /**
      * Whether or not to throw an error when the path is invalid. If this is `false`, the
@@ -291,18 +259,15 @@ type RemoveOptions = {
      */
     failWithError?: boolean;
     /**
-     * If this flag is `true` and after removing the property the parent object is empty,
-     * it will remove it recursively until a non empty parent object is found.
+     * If this flag is `true` and after removing the property the parent object is empty, it
+     * will remove it recursively until a non empty parent object is found.
      */
     cleanEmptyProperties?: boolean;
 };
 /**
  * Deletes a property of an object using a path.
  *
- * @param options  The options to use.
- * @template T  The type of the returned object.
  * @example
- *
  *   const target = {
  *     propOne: {
  *       propOneSub: 'Charito!',
@@ -312,30 +277,24 @@ type RemoveOptions = {
  *   console.log(remove({ target, path: 'propOne.propOneSub' }));
  *   // Will output { propTwo: '!!!' }
  *
+ * @template T The type of the returned object.
+ * @param options The options to use.
  */
 declare function remove<T = unknown>(options: RemoveOptions): T | undefined;
 declare function remove<T = unknown>(options: unknown, path: string): T | undefined;
 
 type SetOptions = {
-    /**
-     * The object where the property will be set.
-     */
+    /** The object where the property will be set. */
     target: unknown;
-    /**
-     * The path for the property.
-     */
+    /** The path for the property. */
     path: string;
-    /**
-     * The value to set on the property.
-     */
+    /** The value to set on the property. */
     value: unknown;
-    /**
-     * The delimiter that will separate the path components.
-     */
+    /** The delimiter that will separate the path components. */
     pathDelimiter?: string;
     /**
-     * Whether or not to throw an error when the path is invalid. If this is `false`, the method
-     * will silently fail and return `undefined`.
+     * Whether or not to throw an error when the path is invalid. If this is `false`, the
+     * method will silently fail and return `undefined`.
      */
     failWithError?: boolean;
 };
@@ -343,16 +302,15 @@ type SetOptions = {
  * Sets a property on an object using a path. If the path doesn't exist, it will be
  * created.
  *
- * @param options  The options to use.
- * @template T  The type of the returned object.
- * @throws {Error} If one of the path components is for a non-object property and
- *                 `failWithError` is set to `true`.
  * @example
- *
  *   const target = {};
  *   console.log(set({ target, path: 'some.prop.path', value: 'some-value' }));
  *   // Will output { some: { prop: { path: 'some-value' } } }
  *
+ * @template T The type of the returned object.
+ * @param options The options to use.
+ * @throws {Error} If one of the path components is for a non-object property and
+ *   `failWithError` is set to `true`.
  */
 declare function set<T = Record<string, unknown>>(options: SetOptions): T | undefined;
 declare function set<T = Record<string, unknown>>(options: SetOptions | unknown, path: string, value: unknown): T | undefined;
@@ -361,8 +319,8 @@ declare function set<T = Record<string, unknown>>(options: SetOptions | unknown,
  * A shorthand method for {@link formatKeys} that transforms the keys from `snake_case` to
  * `dash-case`.
  *
- * @param options  The options to use.
- * @template T  The type of the returned object.
+ * @template T The type of the returned object.
+ * @param options The options to use.
  */
 declare const snakeToDashKeys: <T>(options: FormatKeysExtensionOptions) => T;
 
@@ -370,29 +328,22 @@ declare const snakeToDashKeys: <T>(options: FormatKeysExtensionOptions) => T;
  * A shorthand method for {@link formatKeys} that transforms the keys from `snake_case` to
  * `lowerCamelCase`.
  *
- * @param options  The options to use.
- * @template T  The type of the returned object.
+ * @template T The type of the returned object.
+ * @param options The options to use.
  */
 declare const snakeToLowerCamelKeys: <T>(options: FormatKeysExtensionOptions) => T;
 
 type UnflatOptions = {
-    /**
-     * The object to transform.
-     */
+    /** The object to transform. */
     target: unknown;
-    /**
-     * The delimiter that will separate the path components.
-     */
+    /** The delimiter that will separate the path components. */
     pathDelimiter?: string;
 };
 /**
  * This method does the exact opposite from `flat`: It takes an already flatten object and
  * restores it structure.
  *
- * @param options  The options to use.
- * @template T  The type of the returned object.
  * @example
- *
  *   const target = {
  *     'propOne.propOneSub': 'Charito!',
  *     propTwo: '!!!',
@@ -400,6 +351,8 @@ type UnflatOptions = {
  *   console.log(unflat({ target }));
  *   // Will output { propOne: { propOneSub: 'Charito!' }, 'propTwo': '!!!' }
  *
+ * @template T The type of the returned object.
+ * @param options The options to use.
  */
 declare const unflat: <T = Record<string, unknown>>(options: UnflatOptions) => T;
 

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/fns/merge.ts","../src/fns/copy.ts","../src/fns/formatKeys.ts","../src/fns/dashToLowerCamelKeys.ts","../src/fns/dashToSnakeKeys.ts","../src/fns/get.ts","../src/fns/set.ts","../src/fns/extract.ts","../src/fns/flat.ts","../src/fns/lowerCamelToDashKeys.ts","../src/fns/lowerCamelToSnakeKeys.ts","../src/fns/remove.ts","../src/fns/snakeToDashKeys.ts","../src/fns/snakeToLowerCamelKeys.ts","../src/fns/unflat.ts"],"sourcesContent":["import extend from 'extend';\n\n/**\n * This method makes a deep merge of a list of objects into a new one. The method also\n * supports arrays: if the first element is an array, it will be merged into an array,\n * otherwise, it will be an object.\n *\n * @param targets  The list of objects to merge.\n * @template T  The type of the merged object that will be returned.\n * @example\n *\n *   const objA = { a: 'first' };\n *   const objB = { b: 'second' };\n *   console.log(merge(objA, objB));\n *   // Will output { a: 'first', b: 'second' }\n *\n * @example\n *\n *   const arrA = [{ a: 'first' }];\n *   const arrB = [{ b: 'second' }];\n *   console.log(merge(objA, objB));\n *   // Will output [{ a: 'first', b: 'second' }]\n *\n */\nexport const merge = <T = unknown>(...targets: unknown[]): T => {\n  const [firstTarget] = targets;\n  const base = Array.isArray(firstTarget) ? [] : {};\n  return extend(true, base, ...targets) as T;\n};\n","import { merge } from './merge.js';\n\n/**\n * Creates a deep copy of a given object.\n *\n * @param target  The object to copy.\n * @template T  The type of the input object, which will be the same as the one\n *              returned.\n */\nexport const copy = <T>(target: T): T => merge(target);\n","/**\n * The callback that will be used to replace a key.\n *\n * @param substring  The captured string to replace.\n * @param args       The list of groups captured by the expression.\n */\nexport type FormatKeysReplaceFn = (substring: string, ...args: string[]) => string;\n\nexport type FormatKeysOptions = {\n  /**\n   * The object to transform.\n   */\n  target: unknown;\n  /**\n   * A regular expression to match the keys to transform.\n   */\n  search: RegExp;\n  /**\n   * The callback that will be used to replace the matched substring. Think of `search` and\n   * `replace` as the parameters of `String.replace`.\n   */\n  replace: FormatKeysReplaceFn;\n  /**\n   * A list of keys or paths where the transformation will be made. If not specified, the\n   * function will use all the keys from the object.\n   */\n  include?: string[];\n  /**\n   * A list of keys or paths where the transformation won't be made.\n   */\n  exclude?: string[];\n  /**\n   * The delimiter that will separate the path components for both `include` and `exclude`.\n   */\n  pathDelimiter?: string;\n};\n\nexport type FormatKeysExtensionOptions = Omit<FormatKeysOptions, 'search' | 'replace'>;\n\n/**\n * Formats all the keys on an object using a way similar to `.replace(regexp, ...)` but\n * that also works recursively and with _\"object paths\"_.\n *\n * @param options  The set of options to customize the transformation.\n * @template T  The type of the returned object.\n * @example\n *\n *   const target = {\n *     prop_one: 'Charito!',\n *   };\n *   console.log(\n *     formatKeys({\n *       target,\n *       // Find all the keys with snake case.\n *       search: /([a-z])_([a-z])/g,\n *       // Using the same .replace style callback, replace it with lower camel case.\n *       replace: (_, firstLetter, secondLetter) => {\n *         const newSecondLetter = secondLetter.toUpperCase();\n *         return `${firstLetter}${newSecondLetter}`;\n *       },\n *     }),\n *   );\n *   // Will output { propOne: 'Charito!}.\n *\n */\nexport const formatKeys = <T = Record<string, unknown>>(\n  options: FormatKeysOptions,\n): T => {\n  const {\n    target,\n    search,\n    replace,\n    include = [],\n    exclude = [],\n    pathDelimiter = '.',\n  } = options;\n  // Re-case target.\n  const useTarget = target as Record<string, unknown>;\n  // First of all, get all the keys from the target.\n  const keys = Object.keys(target as Record<string, unknown>);\n  /**\n   * Then, check which keys are parent to other objects.\n   * This is saved on a dictionary not only because it makes it easier to check if the\n   * method should make a recursive call for a key, but also because when parsing the\n   * `exclude`\n   * parameter, if one of items is a key (and not an specific path), the method won't make\n   * the recursive call.\n   *\n   * @ignore\n   */\n  const hasChildrenByKey: Record<string, unknown> = {};\n  keys.forEach((key) => {\n    const value = useTarget[key];\n    hasChildrenByKey[key] = !!(\n      value &&\n      typeof value === 'object' &&\n      value !== null &&\n      !Array.isArray(value) &&\n      Object.keys(value)\n    );\n  });\n  /**\n   * Escape the path delimiter and create two regular expression: One that removes the path\n   * delimiter from the start of a path and one that removes it from the end.\n   * They are later used to normalize paths in order to avoid \"incomplete paths\" (paths that\n   * end or start with the delimiter).\n   */\n  const escapedPathDelimiter = pathDelimiter.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, '\\\\$&');\n  const cleanPathStartExpression = new RegExp(`^${escapedPathDelimiter}`, 'i');\n  const cleanPathEndExpression = new RegExp(`${escapedPathDelimiter}$`, 'i');\n  /**\n   * This dictionary will be used to save the `include` parameter that will be sent for specific\n   * keys on recursive calls.\n   * If `include` has a path like `myKey.mySubKey`, `myKey` is not transformed, but `mySubKey`\n   * is saved on this dictionary (`{ myKey: ['mySubKey']}`) and when the method applies the\n   * formatting to the object, if `myKey` has an object, it will make a recursive all and\n   * send `['mySubKey]` as its `include` parameter.\n   */\n  const subIncludeByKey: Record<string, string[]> = {};\n  /**\n   * This will be an array containing the final list of `keys` that should be tranformed.\n   * To be clear, these keys will be from the top level, so, they won't be paths.\n   * Thd following blocks will parse `include` and `exclude` in order to extract the real keys,\n   * prepare the `include` and `exclude` for recursive calls, and save the actual keys\n   * from the object \"at the current level of this call\" (no, it's not thinking about the\n   * children :P).\n   */\n  let keysToFormat: string[];\n  // If the `include` parameter has paths/keys...\n  if (include.length) {\n    keysToFormat = include\n      .map((includePath) => {\n        // Normalize the path/key.\n        const useIncludePath = includePath\n          .replace(cleanPathStartExpression, '')\n          .replace(cleanPathEndExpression, '');\n        // Define the variable that will, eventually, have the real key.\n        let key;\n        // If the value is a path...\n        if (useIncludePath.includes(pathDelimiter)) {\n          // Split all its components.\n          const pathParts = useIncludePath.split(pathDelimiter);\n          // Get the first component, a.k.a. the real key.\n          const pathKey = pathParts.shift()!;\n          /**\n           * This is very important: Since the path was specified with sub components\n           * (like `myProp.mySubProp`), the method won't format the key, but the sub\n           * key(s)\n           * (`mySubProp`).\n           * The `key` is set to `''` so it will be later removed using `.filter`.\n           *\n           * @ignore\n           */\n          key = '';\n          /**\n           * If there's no array for the key on the \"`include` dictionary for recursive calls\",\n           * create an empty one.\n           */\n          if (!subIncludeByKey[pathKey]) {\n            subIncludeByKey[pathKey] = [];\n          }\n          // Save the rest of the path to be sent on the recursive call as `include`.\n          subIncludeByKey[pathKey]!.push(pathParts.join(pathDelimiter));\n        } else {\n          // If the value wasn't a path, assume it's a key, and set it to be returned.\n          key = useIncludePath;\n        }\n\n        return key;\n      })\n      // Remove any _empty keys_.\n      .filter((key) => key);\n  } else {\n    // There's nothing on the `include` parameter, so use all the keys.\n    keysToFormat = keys;\n  }\n  /**\n   * Similar to `subIncludeByKey`, this dictionary will be used to save the `exclude` parameter\n   * that will be sent for specific keys on recursive calls.\n   * If `exclude` has a path like `myKey.mySubKey`, `myKey` will be transformed, but `mySubKey`\n   * is saved on this dictionary (`{ myKey: ['mySubKey']}`) and when the method applies the\n   * formatting to the object, if `myKey` has an object, it will make a recursive all and\n   * send `['mySubKey]` as its `exclude` parameter.\n   */\n  const subExcludeByKey: Record<string, string[]> = {};\n  // If the `include` parameter has paths/keys...\n  if (exclude.length) {\n    /**\n     * Create a dictionary of keys that should be removed from `keysToFormat`.\n     * It's easier to have them on a list and use `.filter` than actually call `.splice` for\n     * every key that should be removed.\n     */\n    const keysToRemove: string[] = [];\n    exclude.forEach((excludePath) => {\n      // Normalize the path/key.\n      const useExcludePath = excludePath\n        .replace(cleanPathStartExpression, '')\n        .replace(cleanPathEndExpression, '');\n      // If the value is a path...\n      if (useExcludePath.includes(pathDelimiter)) {\n        // Split all its components.\n        const pathParts = useExcludePath.split(pathDelimiter);\n        // Get the first component, a.k.a. the real key.\n        const pathKey = pathParts.shift()!;\n        /**\n         * If there's no array for the key on the \"`exclude` dictionary for recursive calls\",\n         * create an empty one.\n         */\n        if (!subExcludeByKey[pathKey]) {\n          subExcludeByKey[pathKey] = [];\n        }\n        // Save the rest of the path to be sent on the recursive call as `exclude`.\n        subExcludeByKey[pathKey]!.push(pathParts.join(pathDelimiter));\n      } else {\n        /**\n         * If the value wasn't a path, assume it's a key, turn the flag on the \"children\n         * dictionary\" to `false`, to prevent recursive calls, and add the key to the list\n         * of keys that will be removed from `keysToFormat`.\n         * Basically: If it's a key, don't format it and don't make recursive calls for\n         * it.\n         *\n         * @ignore\n         */\n        hasChildrenByKey[useExcludePath] = false;\n        keysToRemove.push(useExcludePath);\n      }\n    });\n    // Remove keys that should be excluded.\n    keysToFormat = keysToFormat.filter((key) => key && !keysToRemove.includes(key));\n  }\n  // \"Finally\", reduce all the keys from the object and create the new one...\n  return keys.reduce<Record<string, unknown>>((newObj, key) => {\n    /**\n     * Define the new key and value for the object property. Depending on the validations,\n     * they may be replaced with formatted ones.\n     */\n    let newKey;\n    let newValue;\n    /**\n     * Get the current value for the key, in case it's needed for a recursive call or just\n     * to send it back because it didn't need any change.\n     */\n    const value = useTarget[key];\n    // If the key should be formatted, apply the formatting; otherwise, keep the original.\n    if (keysToFormat.includes(key)) {\n      newKey = key.replace(search, replace);\n    } else {\n      newKey = key;\n    }\n    /**\n     * If the paths/keys on `exclude` didn't modify the \"children dictionary\" for the key and\n     * the value is another object, make a recursive call; otherwise, just use the original\n     * value.\n     */\n    if (hasChildrenByKey[key]) {\n      newValue = formatKeys({\n        target: value,\n        search,\n        replace,\n        include: subIncludeByKey[key] || [],\n        exclude: subExcludeByKey[key] || [],\n        pathDelimiter,\n      });\n    } else {\n      newValue = value;\n    }\n    // \"Done\", return the new object with the \"new key\" and the \"new value\".\n    return { ...newObj, [newKey]: newValue };\n  }, {}) as T;\n};\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `dash-case`\n * to `lowerCamelCase`.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\n */\nexport const dashToLowerCamelKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])-([a-z])/g,\n    replace: (_, firstLetter, secondLetter) => {\n      const newSecondLetter = secondLetter.toUpperCase();\n      return `${firstLetter}${newSecondLetter}`;\n    },\n  });\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `dash-case`\n * to `snake_case`.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\n */\nexport const dashToSnakeKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])-([a-z])/g,\n    replace: (_, firstLetter, secondLetter) => `${firstLetter}_${secondLetter}`,\n  });\n","export type GetOptions = {\n  /**\n   * The object from where the property will be read.\n   */\n  target: unknown;\n  /**\n   * The path to the property.\n   */\n  path: string;\n  /**\n   * The delimiter that will separate the path components.\n   */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`,\n   *  the method will silently fail and return `undefined`.\n   */\n  failWithError?: boolean;\n};\n\n/**\n * Returns the value of an object property using a path.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\n * @throws {Error} If the path is invalid and `failWithError` is set to `true`.\n * @example\n *\n *   const obj = {\n *     propOne: {\n *       propOneSub: 'Charito!',\n *     },\n *     propTwo: '!!!',\n *   };\n *   console.log(get({ target: obj, path: 'propOne.propOneSub' }));\n *   // Will output 'Charito!'\n *\n */\nfunction get<T>(options: GetOptions): T | undefined;\nfunction get<T>(options: unknown, path: string): T | undefined;\nfunction get<T>(options: GetOptions | unknown, path?: string): T | undefined {\n  let useOptions: GetOptions;\n  if (typeof path === 'string') {\n    useOptions = {\n      target: options,\n      path,\n    };\n  } else {\n    useOptions = options as GetOptions;\n  }\n\n  const {\n    target,\n    path: usePath,\n    pathDelimiter = '.',\n    failWithError = false,\n  } = useOptions;\n  const useTarget = target as Record<string, unknown>;\n  const parts = usePath.split(pathDelimiter);\n  const first = parts.shift()!;\n  let currentElement = useTarget[first] as Record<string, unknown>;\n  if (typeof currentElement === 'undefined') {\n    if (failWithError) {\n      throw new Error(`There's nothing on '${usePath}'`);\n    }\n\n    return undefined;\n  }\n\n  if (!parts.length) {\n    return currentElement as T;\n  }\n\n  let currentPath = first;\n  parts.some((currentPart) => {\n    let breakLoop = false;\n    currentPath += `${pathDelimiter}${currentPart}`;\n    currentElement = currentElement[currentPart] as Record<string, unknown>;\n    if (typeof currentElement === 'undefined') {\n      if (failWithError) {\n        throw new Error(`There's nothing on '${currentPath}'`);\n      } else {\n        breakLoop = true;\n      }\n    }\n\n    return breakLoop;\n  });\n\n  return currentElement as T;\n}\n\nexport { get };\n","import { copy } from './copy.js';\n\n/**\n * List of paths that are forbidden to use on the `set` function, as they could lead to\n * security issues.\n *\n * @access protected\n */\nconst FORBIDDEN_PATHS = ['__proto__', 'prototype', 'constructor'];\n\nexport type SetOptions = {\n  /**\n   * The object where the property will be set.\n   */\n  target: unknown;\n  /**\n   * The path for the property.\n   */\n  path: string;\n  /**\n   * The value to set on the property.\n   */\n  value: unknown;\n  /**\n   * The delimiter that will separate the path components.\n   */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`, the method\n   * will silently fail and return `undefined`.\n   */\n  failWithError?: boolean;\n};\n/**\n * Sets a property on an object using a path. If the path doesn't exist, it will be\n * created.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\n * @throws {Error} If one of the path components is for a non-object property and\n *                 `failWithError` is set to `true`.\n * @example\n *\n *   const target = {};\n *   console.log(set({ target, path: 'some.prop.path', value: 'some-value' }));\n *   // Will output { some: { prop: { path: 'some-value' } } }\n *\n */\nfunction set<T = Record<string, unknown>>(options: SetOptions): T | undefined;\nfunction set<T = Record<string, unknown>>(\n  options: SetOptions | unknown,\n  path: string,\n  value: unknown,\n): T | undefined;\nfunction set<T = Record<string, unknown>>(\n  options: SetOptions | unknown,\n  path?: string,\n  value?: unknown,\n): T | undefined {\n  let useOptions: SetOptions;\n  if (typeof path === 'string') {\n    useOptions = {\n      target: options,\n      path,\n      value,\n    };\n  } else {\n    useOptions = options as SetOptions;\n  }\n\n  const {\n    target,\n    path: usePath,\n    value: useValue,\n    pathDelimiter = '.',\n    failWithError = false,\n  } = useOptions;\n  const result = copy(target) as Record<string, unknown>;\n  if (!usePath.includes(pathDelimiter)) {\n    if (!usePath || FORBIDDEN_PATHS.includes(usePath.toLowerCase())) {\n      return undefined;\n    }\n\n    result[usePath] = useValue;\n    return result as T;\n  }\n\n  const parts = usePath.split(pathDelimiter);\n  const isInvalid = parts.some(\n    (part) => !part || FORBIDDEN_PATHS.includes(part.toLowerCase()),\n  );\n\n  if (isInvalid) {\n    return undefined;\n  }\n\n  // Path validation ensures that every component is defined and non-empty.\n  const last = parts.pop()!;\n  let currentElement = result;\n  let currentPath = '';\n  let foundInvalid = false;\n  parts.forEach((part) => {\n    currentPath += `${pathDelimiter}${part}`;\n    const element = currentElement[part];\n    const elementType = typeof element;\n    if (elementType === 'undefined') {\n      currentElement[part] = {};\n      currentElement = currentElement[part] as Record<string, unknown>;\n    } else if (elementType === 'object') {\n      currentElement = currentElement[part] as Record<string, unknown>;\n    } else {\n      const errorPath = currentPath.substring(pathDelimiter.length);\n      if (failWithError) {\n        throw new Error(\n          `There's already an element of type '${elementType}' on '${errorPath}'`,\n        );\n      } else {\n        foundInvalid = true;\n      }\n    }\n  });\n\n  if (foundInvalid) return undefined;\n\n  currentElement[last] = useValue;\n\n  return result as T | undefined;\n}\n\nexport { set };\n","import { get } from './get.js';\nimport { set } from './set.js';\nimport { copy } from './copy.js';\n/**\n * Used in the {@link extract} function to specify a path for a property, or an \"origin path\"\n * and an \"extraction path\".\n */\nexport type extractionPath = string | Record<string, string>;\n\nexport type ExtractOptions = {\n  /**\n   * The object from where the property/properties will be extracted.\n   */\n  target: unknown;\n  /**\n   * This can be a single path or a list of them. And for this method, the paths are not\n   * only strings but can also be an object with a single key, that would be the path to\n   * where to \"do the extraction\", and the value the path on the target object.\n   */\n  paths: extractionPath | extractionPath[];\n  /**\n   * The delimiter that will separate the path components.\n   */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`, the\n   * method will silently fail an empty object.\n   */\n  failWithError?: boolean;\n};\n/**\n * Extracts a property or properties from an object in order to create a new one.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\n * @example\n *\n *   const target = {\n *     name: {\n *       first: 'Pilar',\n *     },\n *     age: 3,\n *     address: {\n *       planet: 'earth',\n *       something: 'else',\n *     },\n *   };\n *   console.log(\n *     extract({\n *       target: obj,\n *       paths: [{ name: 'name.first' }, 'age', 'address.planet'],\n *     }),\n *   );\n *   // Will output { name: 'Pilar', age: 3, address: { planet: 'earth' } }\n *\n */\nexport const extract = <T = Record<string, unknown>>(\n  options: ExtractOptions,\n): T | undefined => {\n  const { target, paths, pathDelimiter = '.', failWithError = false } = options;\n  const copied = copy(target) as Record<string, unknown>;\n  let result: Record<string, unknown> = {};\n  let failed = false;\n  (Array.isArray(paths) ? paths : [paths])\n    .reduce<Array<{ origin: string; customDest: boolean; dest: string }>>(\n      (acc, objPath) => {\n        let destPath: string;\n        let originPath: string;\n        if (typeof objPath === 'string') {\n          destPath = objPath;\n          originPath = objPath;\n        } else {\n          const [firstKey] = Object.keys(objPath);\n          destPath = firstKey!;\n          originPath = objPath[destPath]!;\n        }\n\n        acc.push({\n          origin: originPath,\n          customDest: destPath.includes(pathDelimiter),\n          dest: destPath,\n        });\n        return acc;\n      },\n      [],\n    )\n    .some((pathInfo) => {\n      let breakLoop = false;\n      const value = get({\n        target: copied,\n        path: pathInfo.origin,\n        pathDelimiter,\n        failWithError,\n      });\n      if (typeof value !== 'undefined') {\n        if (pathInfo.customDest) {\n          const withCustomProp = set({\n            target: result,\n            path: pathInfo.dest,\n            value,\n            pathDelimiter,\n            failWithError,\n          });\n          if (typeof withCustomProp === 'undefined') {\n            breakLoop = true;\n            failed = true;\n          } else {\n            result = withCustomProp;\n          }\n        } else {\n          result[pathInfo.dest] = value;\n        }\n      }\n\n      return breakLoop;\n    });\n\n  if (failed) return undefined;\n  return result as T;\n};\n","import { copy } from './copy.js';\nimport { merge } from './merge.js';\n\n/**\n * Checks whether a key for an array or an Object should be flattened.\n *\n * @param key    The key to check inside its parent.\n * @param value  The value of the key.\n */\nexport type ShouldFlattenFn = (key: string, value: unknown) => boolean;\n\nexport type FlatOptions = {\n  /**\n   * The object to transform.\n   */\n  target: unknown;\n  /**\n   * A custom prefix to be added before the name of the properties. This can be used on\n   * custom cases and it's also used when the method calls itself in order to flatten a\n   * sub object.\n   */\n  prefix?: string;\n  /**\n   * The delimiter that will separate the path components.\n   */\n  pathDelimiter?: string;\n  /**\n   * A custom function that can be used in order to tell the function whether an Object or\n   * an Array property should be flatten or not.\n   */\n  shouldFlatten?: ShouldFlattenFn;\n};\n/**\n * Flattens an object properties into a single level dictionary.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\n * @example\n *\n * const target = {\n * propOne: {\n * propOneSub: 'Charito!',\n * },\n * propTwo: '!!!',\n * };\n * console.log(flat({ target });\n * // Will output { 'propOne.propOneSub': 'Charito!', propTwo: '!!!' }\n *\n */\nexport const flat = <T = Record<string, unknown>>(options: FlatOptions): T => {\n  const { target, shouldFlatten, pathDelimiter = '.', prefix = '' } = options;\n  const useTarget = target as Record<string, unknown>;\n  let result: Record<string, unknown> = {};\n  const namePrefix = prefix ? `${prefix}${pathDelimiter}` : '';\n  Object.keys(useTarget).forEach((key) => {\n    const name = `${namePrefix}${key}`;\n    const value = useTarget[key] as unknown;\n    const valueType = typeof value;\n    const isObject = valueType === 'object' && value !== null;\n    if (isObject && (!shouldFlatten || shouldFlatten(key, value))) {\n      result = merge(\n        result,\n        flat({ target: value, pathDelimiter, prefix: name, shouldFlatten }),\n      );\n    } else {\n      result[name] = isObject ? copy(value) : value;\n    }\n  });\n\n  return result as T;\n};\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from\n * `lowerCamelCase` to `dash-case`.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\n */\nexport const lowerCamelToDashKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])([A-Z])/g,\n    replace: (_, firstLetter, secondLetter) => {\n      const newSecondLetter = secondLetter.toLowerCase();\n      return `${firstLetter}-${newSecondLetter}`;\n    },\n  });\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from\n * `lowerCamelCase` to `snake_case`.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\n */\nexport const lowerCamelToSnakeKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])([A-Z])/g,\n    replace: (_, firstLetter, secondLetter) => {\n      const newSecondLetter = secondLetter.toLowerCase();\n      return `${firstLetter}_${newSecondLetter}`;\n    },\n  });\n","import { copy } from './copy.js';\nimport { get } from './get.js';\n\nexport type RemoveOptions = {\n  /**\n   * The object from where the property will be removed.\n   */\n  target: unknown;\n  /**\n   * The path to the property.\n   */\n  path: string;\n  /**\n   * The delimiter that will separate the path components.\n   */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`, the\n   * function will silently fail.\n   */\n  failWithError?: boolean;\n  /**\n   * If this flag is `true` and after removing the property the parent object is empty,\n   * it will remove it recursively until a non empty parent object is found.\n   */\n  cleanEmptyProperties?: boolean;\n};\n/**\n * Deletes a property of an object using a path.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\n * @example\n *\n *   const target = {\n *     propOne: {\n *       propOneSub: 'Charito!',\n *     },\n *     propTwo: '!!!',\n *   };\n *   console.log(remove({ target, path: 'propOne.propOneSub' }));\n *   // Will output { propTwo: '!!!' }\n *\n */\nfunction remove<T = unknown>(options: RemoveOptions): T | undefined;\nfunction remove<T = unknown>(options: unknown, path: string): T | undefined;\nfunction remove<T = unknown>(\n  options: RemoveOptions | unknown,\n  path?: string,\n): T | undefined {\n  let useOptions: RemoveOptions;\n  if (typeof path === 'string') {\n    useOptions = {\n      target: options,\n      path,\n    };\n  } else {\n    useOptions = options as RemoveOptions;\n  }\n\n  const {\n    target,\n    path: usePath,\n    pathDelimiter = '.',\n    cleanEmptyProperties = true,\n    failWithError = false,\n  } = useOptions;\n\n  const parts = usePath.split(pathDelimiter);\n  const last = parts.pop()!;\n  const result = copy(target) as Record<string, unknown>;\n  if (!parts.length) {\n    delete result[last];\n    return result as T;\n  }\n  const parentPath = parts.join(pathDelimiter);\n  const parentObj = get<Record<string, unknown>>({\n    target: result,\n    path: parentPath,\n    pathDelimiter,\n    failWithError,\n  });\n\n  if (typeof parentObj === 'undefined') {\n    return undefined;\n  }\n\n  delete parentObj[last];\n  if (cleanEmptyProperties && !Object.keys(parentObj).length) {\n    return remove({\n      target: result,\n      path: parentPath,\n      pathDelimiter,\n      failWithError,\n      cleanEmptyProperties,\n    }) as T;\n  }\n\n  return result as T;\n}\n\nexport { remove };\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `snake_case` to\n * `dash-case`.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\n */\nexport const snakeToDashKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])_([a-z])/g,\n    replace: (_, firstLetter, secondLetter) => `${firstLetter}-${secondLetter}`,\n  });\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `snake_case` to\n * `lowerCamelCase`.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\n */\nexport const snakeToLowerCamelKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])_([a-z])/g,\n    replace: (_, firstLetter, secondLetter) => {\n      const newSecondLetter = secondLetter.toUpperCase();\n      return `${firstLetter}${newSecondLetter}`;\n    },\n  });\n","import { set } from './set.js';\n\nexport type UnflatOptions = {\n  /**\n   * The object to transform.\n   */\n  target: unknown;\n  /**\n   * The delimiter that will separate the path components.\n   */\n  pathDelimiter?: string;\n};\n/**\n * This method does the exact opposite from `flat`: It takes an already flatten object and\n * restores it structure.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\n * @example\n *\n *   const target = {\n *     'propOne.propOneSub': 'Charito!',\n *     propTwo: '!!!',\n *   };\n *   console.log(unflat({ target }));\n *   // Will output { propOne: { propOneSub: 'Charito!' }, 'propTwo': '!!!' }\n *\n */\nexport const unflat = <T = Record<string, unknown>>(options: UnflatOptions): T => {\n  const { target, pathDelimiter = '.' } = options;\n  const useTarget = target as Record<string, unknown>;\n  return Object.keys(useTarget).reduce<Record<string, unknown>>(\n    (current, key) =>\n      set({ target: current, path: key, value: useTarget[key], pathDelimiter })!,\n    {},\n  ) as T;\n};\n"],"mappings":"AAAA,OAAOA,MAAY,SAwBZ,IAAMC,EAAQ,IAAiBC,IAA0B,CAC9D,GAAM,CAACC,CAAW,EAAID,EAChBE,EAAO,MAAM,QAAQD,CAAW,EAAI,CAAC,EAAI,CAAC,EAChD,OAAOH,EAAO,GAAMI,EAAM,GAAGF,CAAO,CACtC,ECnBO,IAAMG,EAAWC,GAAiBC,EAAMD,CAAM,ECwD9C,IAAME,EACXC,GACM,CACN,GAAM,CACJ,OAAAC,EACA,OAAAC,EACA,QAAAC,EACA,QAAAC,EAAU,CAAC,EACX,QAAAC,EAAU,CAAC,EACX,cAAAC,EAAgB,GAClB,EAAIN,EAEEO,EAAYN,EAEZO,EAAO,OAAO,KAAKP,CAAiC,EAWpDQ,EAA4C,CAAC,EACnDD,EAAK,QAASE,GAAQ,CACpB,IAAMC,EAAQJ,EAAUG,CAAG,EAC3BD,EAAiBC,CAAG,EAAI,CAAC,EACvBC,GACA,OAAOA,GAAU,UACjBA,IAAU,MACV,CAAC,MAAM,QAAQA,CAAK,GACpB,OAAO,KAAKA,CAAK,EAErB,CAAC,EAOD,IAAMC,EAAuBN,EAAc,QAAQ,2BAA4B,MAAM,EAC/EO,EAA2B,IAAI,OAAO,IAAID,CAAoB,GAAI,GAAG,EACrEE,EAAyB,IAAI,OAAO,GAAGF,CAAoB,IAAK,GAAG,EASnEG,EAA4C,CAAC,EAS/CC,EAEAZ,EAAQ,OACVY,EAAeZ,EACZ,IAAKa,GAAgB,CAEpB,IAAMC,EAAiBD,EACpB,QAAQJ,EAA0B,EAAE,EACpC,QAAQC,EAAwB,EAAE,EAEjCJ,EAEJ,GAAIQ,EAAe,SAASZ,CAAa,EAAG,CAE1C,IAAMa,EAAYD,EAAe,MAAMZ,CAAa,EAE9Cc,EAAUD,EAAU,MAAM,EAUhCT,EAAM,GAKDK,EAAgBK,CAAO,IAC1BL,EAAgBK,CAAO,EAAI,CAAC,GAG9BL,EAAgBK,CAAO,EAAG,KAAKD,EAAU,KAAKb,CAAa,CAAC,CAC9D,MAEEI,EAAMQ,EAGR,OAAOR,CACT,CAAC,EAEA,OAAQA,GAAQA,CAAG,EAGtBM,EAAeR,EAUjB,IAAMa,EAA4C,CAAC,EAEnD,GAAIhB,EAAQ,OAAQ,CAMlB,IAAMiB,EAAyB,CAAC,EAChCjB,EAAQ,QAASkB,GAAgB,CAE/B,IAAMC,EAAiBD,EACpB,QAAQV,EAA0B,EAAE,EACpC,QAAQC,EAAwB,EAAE,EAErC,GAAIU,EAAe,SAASlB,CAAa,EAAG,CAE1C,IAAMa,EAAYK,EAAe,MAAMlB,CAAa,EAE9Cc,EAAUD,EAAU,MAAM,EAK3BE,EAAgBD,CAAO,IAC1BC,EAAgBD,CAAO,EAAI,CAAC,GAG9BC,EAAgBD,CAAO,EAAG,KAAKD,EAAU,KAAKb,CAAa,CAAC,CAC9D,MAUEG,EAAiBe,CAAc,EAAI,GACnCF,EAAa,KAAKE,CAAc,CAEpC,CAAC,EAEDR,EAAeA,EAAa,OAAQN,GAAQA,GAAO,CAACY,EAAa,SAASZ,CAAG,CAAC,CAChF,CAEA,OAAOF,EAAK,OAAgC,CAACiB,EAAQf,IAAQ,CAK3D,IAAIgB,EACAC,EAKEhB,EAAQJ,EAAUG,CAAG,EAE3B,OAAIM,EAAa,SAASN,CAAG,EAC3BgB,EAAShB,EAAI,QAAQR,EAAQC,CAAO,EAEpCuB,EAAShB,EAOPD,EAAiBC,CAAG,EACtBiB,EAAW5B,EAAW,CACpB,OAAQY,EACR,OAAAT,EACA,QAAAC,EACA,QAASY,EAAgBL,CAAG,GAAK,CAAC,EAClC,QAASW,EAAgBX,CAAG,GAAK,CAAC,EAClC,cAAAJ,CACF,CAAC,EAEDqB,EAAWhB,EAGN,CAAE,GAAGc,EAAQ,CAACC,CAAM,EAAGC,CAAS,CACzC,EAAG,CAAC,CAAC,CACP,ECpQO,IAAMC,EAA2BC,GACtCC,EAAc,CACZ,GAAGD,EACH,OAAQ,mBACR,QAAS,CAACE,EAAGC,EAAaC,IAAiB,CACzC,IAAMC,EAAkBD,EAAa,YAAY,EACjD,MAAO,GAAGD,CAAW,GAAGE,CAAe,EACzC,CACF,CAAC,ECRI,IAAMC,EAAsBC,GACjCC,EAAc,CACZ,GAAGD,EACH,OAAQ,mBACR,QAAS,CAACE,EAAGC,EAAaC,IAAiB,GAAGD,CAAW,IAAIC,CAAY,EAC3E,CAAC,EC0BH,SAASC,EAAOC,EAA+BC,EAA8B,CAC3E,IAAIC,EACA,OAAOD,GAAS,SAClBC,EAAa,CACX,OAAQF,EACR,KAAAC,CACF,EAEAC,EAAaF,EAGf,GAAM,CACJ,OAAAG,EACA,KAAMC,EACN,cAAAC,EAAgB,IAChB,cAAAC,EAAgB,EAClB,EAAIJ,EACEK,EAAYJ,EACZK,EAAQJ,EAAQ,MAAMC,CAAa,EACnCI,EAAQD,EAAM,MAAM,EACtBE,EAAiBH,EAAUE,CAAK,EACpC,GAAI,OAAOC,EAAmB,IAAa,CACzC,GAAIJ,EACF,MAAM,IAAI,MAAM,uBAAuBF,CAAO,GAAG,EAGnD,MACF,CAEA,GAAI,CAACI,EAAM,OACT,OAAOE,EAGT,IAAIC,EAAcF,EAClB,OAAAD,EAAM,KAAMI,GAAgB,CAC1B,IAAIC,EAAY,GAGhB,GAFAF,GAAe,GAAGN,CAAa,GAAGO,CAAW,GAC7CF,EAAiBA,EAAeE,CAAW,EACvC,OAAOF,EAAmB,IAAa,CACzC,GAAIJ,EACF,MAAM,IAAI,MAAM,uBAAuBK,CAAW,GAAG,EAErDE,EAAY,EAEhB,CAEA,OAAOA,CACT,CAAC,EAEMH,CACT,CClFA,IAAMI,EAAkB,CAAC,YAAa,YAAa,aAAa,EA8ChE,SAASC,EACPC,EACAC,EACAC,EACe,CACf,IAAIC,EACA,OAAOF,GAAS,SAClBE,EAAa,CACX,OAAQH,EACR,KAAAC,EACA,MAAAC,CACF,EAEAC,EAAaH,EAGf,GAAM,CACJ,OAAAI,EACA,KAAMC,EACN,MAAOC,EACP,cAAAC,EAAgB,IAChB,cAAAC,EAAgB,EAClB,EAAIL,EACEM,EAASC,EAAKN,CAAM,EAC1B,GAAI,CAACC,EAAQ,SAASE,CAAa,EACjC,MAAI,CAACF,GAAWP,EAAgB,SAASO,EAAQ,YAAY,CAAC,EAC5D,QAGFI,EAAOJ,CAAO,EAAIC,EACXG,GAGT,IAAME,EAAQN,EAAQ,MAAME,CAAa,EAKzC,GAJkBI,EAAM,KACrBC,GAAS,CAACA,GAAQd,EAAgB,SAASc,EAAK,YAAY,CAAC,CAChE,EAGE,OAIF,IAAMC,EAAOF,EAAM,IAAI,EACnBG,EAAiBL,EACjBM,EAAc,GACdC,EAAe,GAsBnB,GArBAL,EAAM,QAASC,GAAS,CACtBG,GAAe,GAAGR,CAAa,GAAGK,CAAI,GAEtC,IAAMK,EAAc,OADJH,EAAeF,CAAI,EAEnC,GAAIK,IAAgB,YAClBH,EAAeF,CAAI,EAAI,CAAC,EACxBE,EAAiBA,EAAeF,CAAI,UAC3BK,IAAgB,SACzBH,EAAiBA,EAAeF,CAAI,MAC/B,CACL,IAAMM,EAAYH,EAAY,UAAUR,EAAc,MAAM,EAC5D,GAAIC,EACF,MAAM,IAAI,MACR,uCAAuCS,CAAW,SAASC,CAAS,GACtE,EAEAF,EAAe,EAEnB,CACF,CAAC,EAEG,CAAAA,EAEJ,OAAAF,EAAeD,CAAI,EAAIP,EAEhBG,CACT,CCvEO,IAAMU,EACXC,GACkB,CAClB,GAAM,CAAE,OAAAC,EAAQ,MAAAC,EAAO,cAAAC,EAAgB,IAAK,cAAAC,EAAgB,EAAM,EAAIJ,EAChEK,EAASC,EAAKL,CAAM,EACtBM,EAAkC,CAAC,EACnCC,EAAS,GAuDb,IAtDC,MAAM,QAAQN,CAAK,EAAIA,EAAQ,CAACA,CAAK,GACnC,OACC,CAACO,EAAKC,IAAY,CAChB,IAAIC,EACAC,EACJ,GAAI,OAAOF,GAAY,SACrBC,EAAWD,EACXE,EAAaF,MACR,CACL,GAAM,CAACG,CAAQ,EAAI,OAAO,KAAKH,CAAO,EACtCC,EAAWE,EACXD,EAAaF,EAAQC,CAAQ,CAC/B,CAEA,OAAAF,EAAI,KAAK,CACP,OAAQG,EACR,WAAYD,EAAS,SAASR,CAAa,EAC3C,KAAMQ,CACR,CAAC,EACMF,CACT,EACA,CAAC,CACH,EACC,KAAMK,GAAa,CAClB,IAAIC,EAAY,GACVC,EAAQC,EAAI,CAChB,OAAQZ,EACR,KAAMS,EAAS,OACf,cAAAX,EACA,cAAAC,CACF,CAAC,EACD,GAAI,OAAOY,EAAU,IACnB,GAAIF,EAAS,WAAY,CACvB,IAAMI,EAAiBC,EAAI,CACzB,OAAQZ,EACR,KAAMO,EAAS,KACf,MAAAE,EACA,cAAAb,EACA,cAAAC,CACF,CAAC,EACG,OAAOc,EAAmB,KAC5BH,EAAY,GACZP,EAAS,IAETD,EAASW,CAEb,MACEX,EAAOO,EAAS,IAAI,EAAIE,EAI5B,OAAOD,CACT,CAAC,EAEC,CAAAP,EACJ,OAAOD,CACT,ECtEO,IAAMa,EAAqCC,GAA4B,CAC5E,GAAM,CAAE,OAAAC,EAAQ,cAAAC,EAAe,cAAAC,EAAgB,IAAK,OAAAC,EAAS,EAAG,EAAIJ,EAC9DK,EAAYJ,EACdK,EAAkC,CAAC,EACjCC,EAAaH,EAAS,GAAGA,CAAM,GAAGD,CAAa,GAAK,GAC1D,cAAO,KAAKE,CAAS,EAAE,QAASG,GAAQ,CACtC,IAAMC,EAAO,GAAGF,CAAU,GAAGC,CAAG,GAC1BE,EAAQL,EAAUG,CAAG,EAErBG,EADY,OAAOD,IACM,UAAYA,IAAU,KACjDC,IAAa,CAACT,GAAiBA,EAAcM,EAAKE,CAAK,GACzDJ,EAASM,EACPN,EACAP,EAAK,CAAE,OAAQW,EAAO,cAAAP,EAAe,OAAQM,EAAM,cAAAP,CAAc,CAAC,CACpE,EAEAI,EAAOG,CAAI,EAAIE,EAAWE,EAAKH,CAAK,EAAIA,CAE5C,CAAC,EAEMJ,CACT,EC7DO,IAAMQ,EAA2BC,GACtCC,EAAc,CACZ,GAAGD,EACH,OAAQ,kBACR,QAAS,CAACE,EAAGC,EAAaC,IAAiB,CACzC,IAAMC,EAAkBD,EAAa,YAAY,EACjD,MAAO,GAAGD,CAAW,IAAIE,CAAe,EAC1C,CACF,CAAC,ECRI,IAAMC,GAA4BC,GACvCC,EAAc,CACZ,GAAGD,EACH,OAAQ,kBACR,QAAS,CAACE,EAAGC,EAAaC,IAAiB,CACzC,IAAMC,EAAkBD,EAAa,YAAY,EACjD,MAAO,GAAGD,CAAW,IAAIE,CAAe,EAC1C,CACF,CAAC,EC6BH,SAASC,EACPC,EACAC,EACe,CACf,IAAIC,EACA,OAAOD,GAAS,SAClBC,EAAa,CACX,OAAQF,EACR,KAAAC,CACF,EAEAC,EAAaF,EAGf,GAAM,CACJ,OAAAG,EACA,KAAMC,EACN,cAAAC,EAAgB,IAChB,qBAAAC,EAAuB,GACvB,cAAAC,EAAgB,EAClB,EAAIL,EAEEM,EAAQJ,EAAQ,MAAMC,CAAa,EACnCI,EAAOD,EAAM,IAAI,EACjBE,EAASC,EAAKR,CAAM,EAC1B,GAAI,CAACK,EAAM,OACT,cAAOE,EAAOD,CAAI,EACXC,EAET,IAAME,EAAaJ,EAAM,KAAKH,CAAa,EACrCQ,EAAYC,EAA6B,CAC7C,OAAQJ,EACR,KAAME,EACN,cAAAP,EACA,cAAAE,CACF,CAAC,EAED,GAAI,SAAOM,EAAc,KAKzB,OADA,OAAOA,EAAUJ,CAAI,EACjBH,GAAwB,CAAC,OAAO,KAAKO,CAAS,EAAE,OAC3Cd,EAAO,CACZ,OAAQW,EACR,KAAME,EACN,cAAAP,EACA,cAAAE,EACA,qBAAAD,CACF,CAAC,EAGII,CACT,CC1FO,IAAMK,GAAsBC,GACjCC,EAAc,CACZ,GAAGD,EACH,OAAQ,mBACR,QAAS,CAACE,EAAGC,EAAaC,IAAiB,GAAGD,CAAW,IAAIC,CAAY,EAC3E,CAAC,ECLI,IAAMC,GAA4BC,GACvCC,EAAc,CACZ,GAAGD,EACH,OAAQ,mBACR,QAAS,CAACE,EAAGC,EAAaC,IAAiB,CACzC,IAAMC,EAAkBD,EAAa,YAAY,EACjD,MAAO,GAAGD,CAAW,GAAGE,CAAe,EACzC,CACF,CAAC,ECWI,IAAMC,GAAuCC,GAA8B,CAChF,GAAM,CAAE,OAAAC,EAAQ,cAAAC,EAAgB,GAAI,EAAIF,EAClCG,EAAYF,EAClB,OAAO,OAAO,KAAKE,CAAS,EAAE,OAC5B,CAACC,EAASC,IACRC,EAAI,CAAE,OAAQF,EAAS,KAAMC,EAAK,MAAOF,EAAUE,CAAG,EAAG,cAAAH,CAAc,CAAC,EAC1E,CAAC,CACH,CACF","names":["extend","merge","targets","firstTarget","base","copy","target","merge","formatKeys","options","target","search","replace","include","exclude","pathDelimiter","useTarget","keys","hasChildrenByKey","key","value","escapedPathDelimiter","cleanPathStartExpression","cleanPathEndExpression","subIncludeByKey","keysToFormat","includePath","useIncludePath","pathParts","pathKey","subExcludeByKey","keysToRemove","excludePath","useExcludePath","newObj","newKey","newValue","dashToLowerCamelKeys","options","formatKeys","_","firstLetter","secondLetter","newSecondLetter","dashToSnakeKeys","options","formatKeys","_","firstLetter","secondLetter","get","options","path","useOptions","target","usePath","pathDelimiter","failWithError","useTarget","parts","first","currentElement","currentPath","currentPart","breakLoop","FORBIDDEN_PATHS","set","options","path","value","useOptions","target","usePath","useValue","pathDelimiter","failWithError","result","copy","parts","part","last","currentElement","currentPath","foundInvalid","elementType","errorPath","extract","options","target","paths","pathDelimiter","failWithError","copied","copy","result","failed","acc","objPath","destPath","originPath","firstKey","pathInfo","breakLoop","value","get","withCustomProp","set","flat","options","target","shouldFlatten","pathDelimiter","prefix","useTarget","result","namePrefix","key","name","value","isObject","merge","copy","lowerCamelToDashKeys","options","formatKeys","_","firstLetter","secondLetter","newSecondLetter","lowerCamelToSnakeKeys","options","formatKeys","_","firstLetter","secondLetter","newSecondLetter","remove","options","path","useOptions","target","usePath","pathDelimiter","cleanEmptyProperties","failWithError","parts","last","result","copy","parentPath","parentObj","get","snakeToDashKeys","options","formatKeys","_","firstLetter","secondLetter","snakeToLowerCamelKeys","options","formatKeys","_","firstLetter","secondLetter","newSecondLetter","unflat","options","target","pathDelimiter","useTarget","current","key","set"]}
+{"version":3,"sources":["../src/fns/merge.ts","../src/fns/copy.ts","../src/fns/formatKeys.ts","../src/fns/dashToLowerCamelKeys.ts","../src/fns/dashToSnakeKeys.ts","../src/fns/get.ts","../src/fns/set.ts","../src/fns/extract.ts","../src/fns/flat.ts","../src/fns/lowerCamelToDashKeys.ts","../src/fns/lowerCamelToSnakeKeys.ts","../src/fns/remove.ts","../src/fns/snakeToDashKeys.ts","../src/fns/snakeToLowerCamelKeys.ts","../src/fns/unflat.ts"],"sourcesContent":["import extend from 'extend';\n\n/**\n * This method makes a deep merge of a list of objects into a new one. The method also\n * supports arrays: if the first element is an array, it will be merged into an array,\n * otherwise, it will be an object.\n *\n * @example\n *   const objA = { a: 'first' };\n *   const objB = { b: 'second' };\n *   console.log(merge(objA, objB));\n *   // Will output { a: 'first', b: 'second' }\n *\n * @example\n *   const arrA = [{ a: 'first' }];\n *   const arrB = [{ b: 'second' }];\n *   console.log(merge(objA, objB));\n *   // Will output [{ a: 'first', b: 'second' }]\n *\n * @template T The type of the merged object that will be returned.\n * @param targets The list of objects to merge.\n */\nexport const merge = <T = unknown>(...targets: unknown[]): T => {\n  const [firstTarget] = targets;\n  const base = Array.isArray(firstTarget) ? [] : {};\n  return extend(true, base, ...targets) as T;\n};\n","import { merge } from './merge.js';\n\n/**\n * Creates a deep copy of a given object.\n *\n * @template T The type of the input object, which will be the same as the one returned.\n * @param target The object to copy.\n */\nexport const copy = <T>(target: T): T => merge(target);\n","/**\n * The callback that will be used to replace a key.\n *\n * @param substring The captured string to replace.\n * @param args The list of groups captured by the expression.\n */\nexport type FormatKeysReplaceFn = (substring: string, ...args: string[]) => string;\n\nexport type FormatKeysOptions = {\n  /** The object to transform. */\n  target: unknown;\n  /** A regular expression to match the keys to transform. */\n  search: RegExp;\n  /**\n   * The callback that will be used to replace the matched substring. Think of `search`\n   * and `replace` as the parameters of `String.replace`.\n   */\n  replace: FormatKeysReplaceFn;\n  /**\n   * A list of keys or paths where the transformation will be made. If not specified, the\n   * function will use all the keys from the object.\n   */\n  include?: string[];\n  /** A list of keys or paths where the transformation won't be made. */\n  exclude?: string[];\n  /**\n   * The delimiter that will separate the path components for both `include` and\n   * `exclude`.\n   */\n  pathDelimiter?: string;\n};\n\nexport type FormatKeysExtensionOptions = Omit<FormatKeysOptions, 'search' | 'replace'>;\n\n/**\n * Formats all the keys on an object using a way similar to `.replace(regexp, ...)` but\n * that also works recursively and with _\"object paths\"_.\n *\n * @example\n *   const target = {\n *   prop_one: 'Charito!',\n *   };\n *   console.log(\n *   formatKeys({\n *   target,\n *   // Find all the keys with snake case.\n *   search: /([a-z])_([a-z])/g,\n *   // Using the same .replace style callback, replace it with lower camel case.\n *   replace: (_, firstLetter, secondLetter) => {\n *   const newSecondLetter = secondLetter.toUpperCase();\n *   return `${firstLetter}${newSecondLetter}`;\n *   },\n *   }),\n *   );\n *   // Will output { propOne: 'Charito!}.\n *\n *   @template T The type of the returned object.\n *   @param options The set of options to customize the transformation.\n */\nexport const formatKeys = <T = Record<string, unknown>>(\n  options: FormatKeysOptions,\n): T => {\n  const {\n    target,\n    search,\n    replace,\n    include = [],\n    exclude = [],\n    pathDelimiter = '.',\n  } = options;\n  // Re-case target.\n  const useTarget = target as Record<string, unknown>;\n  // First of all, get all the keys from the target.\n  const keys = Object.keys(target as Record<string, unknown>);\n  /**\n   * Then, check which keys are parent to other objects. This is saved on a dictionary not\n   * only because it makes it easier to check if the method should make a recursive call\n   * for a key, but also because when parsing the `exclude` parameter, if one of items is\n   * a key (and not an specific path), the method won't make the recursive call.\n   *\n   * @ignore\n   */\n  const hasChildrenByKey: Record<string, unknown> = {};\n  keys.forEach((key) => {\n    const value = useTarget[key];\n    hasChildrenByKey[key] = !!(\n      value &&\n      typeof value === 'object' &&\n      value !== null &&\n      !Array.isArray(value) &&\n      Object.keys(value)\n    );\n  });\n  /**\n   * Escape the path delimiter and create two regular expression: One that removes the\n   * path delimiter from the start of a path and one that removes it from the end. They\n   * are later used to normalize paths in order to avoid \"incomplete paths\" (paths that\n   * end or start with the delimiter).\n   */\n  const escapedPathDelimiter = pathDelimiter.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, '\\\\$&');\n  const cleanPathStartExpression = new RegExp(`^${escapedPathDelimiter}`, 'i');\n  const cleanPathEndExpression = new RegExp(`${escapedPathDelimiter}$`, 'i');\n  /**\n   * This dictionary will be used to save the `include` parameter that will be sent for\n   * specific keys on recursive calls. If `include` has a path like `myKey.mySubKey`,\n   * `myKey` is not transformed, but `mySubKey` is saved on this dictionary (`{ myKey:\n   * ['mySubKey']}`) and when the method applies the formatting to the object, if `myKey`\n   * has an object, it will make a recursive all and send `['mySubKey]` as its `include`\n   * parameter.\n   */\n  const subIncludeByKey: Record<string, string[]> = {};\n  /**\n   * This will be an array containing the final list of `keys` that should be tranformed.\n   * To be clear, these keys will be from the top level, so, they won't be paths. Thd\n   * following blocks will parse `include` and `exclude` in order to extract the real\n   * keys, prepare the `include` and `exclude` for recursive calls, and save the actual\n   * keys from the object \"at the current level of this call\" (no, it's not thinking about\n   * the children :P).\n   */\n  let keysToFormat: string[];\n  // If the `include` parameter has paths/keys...\n  if (include.length) {\n    keysToFormat = include\n      .map((includePath) => {\n        // Normalize the path/key.\n        const useIncludePath = includePath\n          .replace(cleanPathStartExpression, '')\n          .replace(cleanPathEndExpression, '');\n        // Define the variable that will, eventually, have the real key.\n        let key;\n        // If the value is a path...\n        if (useIncludePath.includes(pathDelimiter)) {\n          // Split all its components.\n          const pathParts = useIncludePath.split(pathDelimiter);\n          // Get the first component, a.k.a. the real key.\n          const pathKey = pathParts.shift()!;\n          /**\n           * This is very important: Since the path was specified with sub components\n           * (like `myProp.mySubProp`), the method won't format the key, but the sub\n           * key(s) (`mySubProp`). The `key` is set to `''` so it will be later removed\n           * using `.filter`.\n           *\n           * @ignore\n           */\n          key = '';\n          /**\n           * If there's no array for the key on the \"`include` dictionary for recursive\n           * calls\", create an empty one.\n           */\n          if (!subIncludeByKey[pathKey]) {\n            subIncludeByKey[pathKey] = [];\n          }\n          // Save the rest of the path to be sent on the recursive call as `include`.\n          subIncludeByKey[pathKey]!.push(pathParts.join(pathDelimiter));\n        } else {\n          // If the value wasn't a path, assume it's a key, and set it to be returned.\n          key = useIncludePath;\n        }\n\n        return key;\n      })\n      // Remove any _empty keys_.\n      .filter((key) => key);\n  } else {\n    // There's nothing on the `include` parameter, so use all the keys.\n    keysToFormat = keys;\n  }\n  /**\n   * Similar to `subIncludeByKey`, this dictionary will be used to save the `exclude`\n   * parameter that will be sent for specific keys on recursive calls. If `exclude` has a\n   * path like `myKey.mySubKey`, `myKey` will be transformed, but `mySubKey` is saved on\n   * this dictionary (`{ myKey: ['mySubKey']}`) and when the method applies the formatting\n   * to the object, if `myKey` has an object, it will make a recursive all and send\n   * `['mySubKey]` as its `exclude` parameter.\n   */\n  const subExcludeByKey: Record<string, string[]> = {};\n  // If the `include` parameter has paths/keys...\n  if (exclude.length) {\n    /**\n     * Create a dictionary of keys that should be removed from `keysToFormat`. It's easier\n     * to have them on a list and use `.filter` than actually call `.splice` for every key\n     * that should be removed.\n     */\n    const keysToRemove: string[] = [];\n    exclude.forEach((excludePath) => {\n      // Normalize the path/key.\n      const useExcludePath = excludePath\n        .replace(cleanPathStartExpression, '')\n        .replace(cleanPathEndExpression, '');\n      // If the value is a path...\n      if (useExcludePath.includes(pathDelimiter)) {\n        // Split all its components.\n        const pathParts = useExcludePath.split(pathDelimiter);\n        // Get the first component, a.k.a. the real key.\n        const pathKey = pathParts.shift()!;\n        /**\n         * If there's no array for the key on the \"`exclude` dictionary for recursive\n         * calls\", create an empty one.\n         */\n        if (!subExcludeByKey[pathKey]) {\n          subExcludeByKey[pathKey] = [];\n        }\n        // Save the rest of the path to be sent on the recursive call as `exclude`.\n        subExcludeByKey[pathKey]!.push(pathParts.join(pathDelimiter));\n      } else {\n        /**\n         * If the value wasn't a path, assume it's a key, turn the flag on the \"children\n         * dictionary\" to `false`, to prevent recursive calls, and add the key to the list\n         * of keys that will be removed from `keysToFormat`. Basically: If it's a key,\n         * don't format it and don't make recursive calls for it.\n         *\n         * @ignore\n         */\n        hasChildrenByKey[useExcludePath] = false;\n        keysToRemove.push(useExcludePath);\n      }\n    });\n    // Remove keys that should be excluded.\n    keysToFormat = keysToFormat.filter((key) => key && !keysToRemove.includes(key));\n  }\n  // \"Finally\", reduce all the keys from the object and create the new one...\n  return keys.reduce<Record<string, unknown>>((newObj, key) => {\n    /**\n     * Define the new key and value for the object property. Depending on the validations,\n     * they may be replaced with formatted ones.\n     */\n    let newKey;\n    let newValue;\n    /**\n     * Get the current value for the key, in case it's needed for a recursive call or just\n     * to send it back because it didn't need any change.\n     */\n    const value = useTarget[key];\n    // If the key should be formatted, apply the formatting; otherwise, keep the original.\n    if (keysToFormat.includes(key)) {\n      newKey = key.replace(search, replace);\n    } else {\n      newKey = key;\n    }\n    /**\n     * If the paths/keys on `exclude` didn't modify the \"children dictionary\" for the key\n     * and the value is another object, make a recursive call; otherwise, just use the\n     * original value.\n     */\n    if (hasChildrenByKey[key]) {\n      newValue = formatKeys({\n        target: value,\n        search,\n        replace,\n        include: subIncludeByKey[key] || [],\n        exclude: subExcludeByKey[key] || [],\n        pathDelimiter,\n      });\n    } else {\n      newValue = value;\n    }\n    // \"Done\", return the new object with the \"new key\" and the \"new value\".\n    return { ...newObj, [newKey]: newValue };\n  }, {}) as T;\n};\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `dash-case` to\n * `lowerCamelCase`.\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const dashToLowerCamelKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])-([a-z])/g,\n    replace: (_, firstLetter, secondLetter) => {\n      const newSecondLetter = secondLetter.toUpperCase();\n      return `${firstLetter}${newSecondLetter}`;\n    },\n  });\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `dash-case` to\n * `snake_case`.\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const dashToSnakeKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])-([a-z])/g,\n    replace: (_, firstLetter, secondLetter) => `${firstLetter}_${secondLetter}`,\n  });\n","export type GetOptions = {\n  /** The object from where the property will be read. */\n  target: unknown;\n  /** The path to the property. */\n  path: string;\n  /** The delimiter that will separate the path components. */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`, the\n   * method will silently fail and return `undefined`.\n   */\n  failWithError?: boolean;\n};\n\n/**\n * Returns the value of an object property using a path.\n *\n * @example\n *   const obj = {\n *     propOne: {\n *       propOneSub: 'Charito!',\n *     },\n *     propTwo: '!!!',\n *   };\n *   console.log(get({ target: obj, path: 'propOne.propOneSub' }));\n *   // Will output 'Charito!'\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n * @throws {Error} If the path is invalid and `failWithError` is set to `true`.\n */\nfunction get<T>(options: GetOptions): T | undefined;\nfunction get<T>(options: unknown, path: string): T | undefined;\nfunction get<T>(options: GetOptions | unknown, path?: string): T | undefined {\n  let useOptions: GetOptions;\n  if (typeof path === 'string') {\n    useOptions = {\n      target: options,\n      path,\n    };\n  } else {\n    useOptions = options as GetOptions;\n  }\n\n  const {\n    target,\n    path: usePath,\n    pathDelimiter = '.',\n    failWithError = false,\n  } = useOptions;\n  const useTarget = target as Record<string, unknown>;\n  const parts = usePath.split(pathDelimiter);\n  const first = parts.shift()!;\n  let currentElement = useTarget[first] as Record<string, unknown>;\n  if (typeof currentElement === 'undefined') {\n    if (failWithError) {\n      throw new Error(`There's nothing on '${usePath}'`);\n    }\n\n    return undefined;\n  }\n\n  if (!parts.length) {\n    return currentElement as T;\n  }\n\n  let currentPath = first;\n  parts.some((currentPart) => {\n    let breakLoop = false;\n    currentPath += `${pathDelimiter}${currentPart}`;\n    currentElement = currentElement[currentPart] as Record<string, unknown>;\n    if (typeof currentElement === 'undefined') {\n      if (failWithError) {\n        throw new Error(`There's nothing on '${currentPath}'`);\n      } else {\n        breakLoop = true;\n      }\n    }\n\n    return breakLoop;\n  });\n\n  return currentElement as T;\n}\n\nexport { get };\n","import { copy } from './copy.js';\n\n/**\n * List of paths that are forbidden to use on the `set` function, as they could lead to\n * security issues.\n *\n * @access protected\n */\nconst FORBIDDEN_PATHS = ['__proto__', 'prototype', 'constructor'];\n\nexport type SetOptions = {\n  /** The object where the property will be set. */\n  target: unknown;\n  /** The path for the property. */\n  path: string;\n  /** The value to set on the property. */\n  value: unknown;\n  /** The delimiter that will separate the path components. */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`, the\n   * method will silently fail and return `undefined`.\n   */\n  failWithError?: boolean;\n};\n/**\n * Sets a property on an object using a path. If the path doesn't exist, it will be\n * created.\n *\n * @example\n *   const target = {};\n *   console.log(set({ target, path: 'some.prop.path', value: 'some-value' }));\n *   // Will output { some: { prop: { path: 'some-value' } } }\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n * @throws {Error} If one of the path components is for a non-object property and\n *   `failWithError` is set to `true`.\n */\nfunction set<T = Record<string, unknown>>(options: SetOptions): T | undefined;\nfunction set<T = Record<string, unknown>>(\n  options: SetOptions | unknown,\n  path: string,\n  value: unknown,\n): T | undefined;\nfunction set<T = Record<string, unknown>>(\n  options: SetOptions | unknown,\n  path?: string,\n  value?: unknown,\n): T | undefined {\n  let useOptions: SetOptions;\n  if (typeof path === 'string') {\n    useOptions = {\n      target: options,\n      path,\n      value,\n    };\n  } else {\n    useOptions = options as SetOptions;\n  }\n\n  const {\n    target,\n    path: usePath,\n    value: useValue,\n    pathDelimiter = '.',\n    failWithError = false,\n  } = useOptions;\n  const result = copy(target) as Record<string, unknown>;\n  if (!usePath.includes(pathDelimiter)) {\n    if (!usePath || FORBIDDEN_PATHS.includes(usePath.toLowerCase())) {\n      return undefined;\n    }\n\n    result[usePath] = useValue;\n    return result as T;\n  }\n\n  const parts = usePath.split(pathDelimiter);\n  const isInvalid = parts.some(\n    (part) => !part || FORBIDDEN_PATHS.includes(part.toLowerCase()),\n  );\n\n  if (isInvalid) {\n    return undefined;\n  }\n\n  // Path validation ensures that every component is defined and non-empty.\n  const last = parts.pop()!;\n  let currentElement = result;\n  let currentPath = '';\n  let foundInvalid = false;\n  parts.forEach((part) => {\n    currentPath += `${pathDelimiter}${part}`;\n    const element = currentElement[part];\n    const elementType = typeof element;\n    if (elementType === 'undefined') {\n      currentElement[part] = {};\n      currentElement = currentElement[part] as Record<string, unknown>;\n    } else if (elementType === 'object') {\n      currentElement = currentElement[part] as Record<string, unknown>;\n    } else {\n      const errorPath = currentPath.substring(pathDelimiter.length);\n      if (failWithError) {\n        throw new Error(\n          `There's already an element of type '${elementType}' on '${errorPath}'`,\n        );\n      } else {\n        foundInvalid = true;\n      }\n    }\n  });\n\n  if (foundInvalid) return undefined;\n\n  currentElement[last] = useValue;\n\n  return result as T | undefined;\n}\n\nexport { set };\n","import { copy } from './copy.js';\nimport { get } from './get.js';\nimport { set } from './set.js';\n/**\n * Used in the {@link extract} function to specify a path for a property, or an \"origin\n * path\" and an \"extraction path\".\n */\nexport type extractionPath = string | Record<string, string>;\n\nexport type ExtractOptions = {\n  /** The object from where the property/properties will be extracted. */\n  target: unknown;\n  /**\n   * This can be a single path or a list of them. And for this method, the paths are not\n   * only strings but can also be an object with a single key, that would be the path to\n   * where to \"do the extraction\", and the value the path on the target object.\n   */\n  paths: extractionPath | extractionPath[];\n  /** The delimiter that will separate the path components. */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`, the\n   * method will silently fail an empty object.\n   */\n  failWithError?: boolean;\n};\n/**\n * Extracts a property or properties from an object in order to create a new one.\n *\n * @example\n *   const target = {\n *     name: {\n *       first: 'Pilar',\n *     },\n *     age: 3,\n *     address: {\n *       planet: 'earth',\n *       something: 'else',\n *     },\n *   };\n *   console.log(\n *     extract({\n *       target: obj,\n *       paths: [{ name: 'name.first' }, 'age', 'address.planet'],\n *     }),\n *   );\n *   // Will output { name: 'Pilar', age: 3, address: { planet: 'earth' } }\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const extract = <T = Record<string, unknown>>(\n  options: ExtractOptions,\n): T | undefined => {\n  const { target, paths, pathDelimiter = '.', failWithError = false } = options;\n  const copied = copy(target) as Record<string, unknown>;\n  let result: Record<string, unknown> = {};\n  let failed = false;\n  (Array.isArray(paths) ? paths : [paths])\n    .reduce<Array<{ origin: string; customDest: boolean; dest: string }>>(\n      (acc, objPath) => {\n        let destPath: string;\n        let originPath: string;\n        if (typeof objPath === 'string') {\n          destPath = objPath;\n          originPath = objPath;\n        } else {\n          const [firstKey] = Object.keys(objPath);\n          destPath = firstKey!;\n          originPath = objPath[destPath]!;\n        }\n\n        acc.push({\n          origin: originPath,\n          customDest: destPath.includes(pathDelimiter),\n          dest: destPath,\n        });\n        return acc;\n      },\n      [],\n    )\n    .some((pathInfo) => {\n      let breakLoop = false;\n      const value = get({\n        target: copied,\n        path: pathInfo.origin,\n        pathDelimiter,\n        failWithError,\n      });\n      if (typeof value !== 'undefined') {\n        if (pathInfo.customDest) {\n          const withCustomProp = set({\n            target: result,\n            path: pathInfo.dest,\n            value,\n            pathDelimiter,\n            failWithError,\n          });\n          if (typeof withCustomProp === 'undefined') {\n            breakLoop = true;\n            failed = true;\n          } else {\n            result = withCustomProp;\n          }\n        } else {\n          result[pathInfo.dest] = value;\n        }\n      }\n\n      return breakLoop;\n    });\n\n  if (failed) return undefined;\n  return result as T;\n};\n","import { copy } from './copy.js';\nimport { merge } from './merge.js';\n\n/**\n * Checks whether a key for an array or an Object should be flattened.\n *\n * @param key The key to check inside its parent.\n * @param value The value of the key.\n */\nexport type ShouldFlattenFn = (key: string, value: unknown) => boolean;\n\nexport type FlatOptions = {\n  /** The object to transform. */\n  target: unknown;\n  /**\n   * A custom prefix to be added before the name of the properties. This can be used on\n   * custom cases and it's also used when the method calls itself in order to flatten a\n   * sub object.\n   */\n  prefix?: string;\n  /** The delimiter that will separate the path components. */\n  pathDelimiter?: string;\n  /**\n   * A custom function that can be used in order to tell the function whether an Object or\n   * an Array property should be flatten or not.\n   */\n  shouldFlatten?: ShouldFlattenFn;\n};\n/**\n * Flattens an object properties into a single level dictionary.\n *\n * @example\n *   const target = {\n *   propOne: {\n *   propOneSub: 'Charito!',\n *   },\n *   propTwo: '!!!',\n *   };\n *   console.log(flat({ target });\n *   // Will output { 'propOne.propOneSub': 'Charito!', propTwo: '!!!' }\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const flat = <T = Record<string, unknown>>(options: FlatOptions): T => {\n  const { target, shouldFlatten, pathDelimiter = '.', prefix = '' } = options;\n  const useTarget = target as Record<string, unknown>;\n  let result: Record<string, unknown> = {};\n  const namePrefix = prefix ? `${prefix}${pathDelimiter}` : '';\n  Object.keys(useTarget).forEach((key) => {\n    const name = `${namePrefix}${key}`;\n    const value = useTarget[key] as unknown;\n    const valueType = typeof value;\n    const isObject = valueType === 'object' && value !== null;\n    if (isObject && (!shouldFlatten || shouldFlatten(key, value))) {\n      result = merge(\n        result,\n        flat({ target: value, pathDelimiter, prefix: name, shouldFlatten }),\n      );\n    } else {\n      result[name] = isObject ? copy(value) : value;\n    }\n  });\n\n  return result as T;\n};\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `lowerCamelCase`\n * to `dash-case`.\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const lowerCamelToDashKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])([A-Z])/g,\n    replace: (_, firstLetter, secondLetter) => {\n      const newSecondLetter = secondLetter.toLowerCase();\n      return `${firstLetter}-${newSecondLetter}`;\n    },\n  });\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from\n * `lowerCamelCase` to `snake_case`.\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const lowerCamelToSnakeKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])([A-Z])/g,\n    replace: (_, firstLetter, secondLetter) => {\n      const newSecondLetter = secondLetter.toLowerCase();\n      return `${firstLetter}_${newSecondLetter}`;\n    },\n  });\n","import { copy } from './copy.js';\nimport { get } from './get.js';\n\nexport type RemoveOptions = {\n  /** The object from where the property will be removed. */\n  target: unknown;\n  /** The path to the property. */\n  path: string;\n  /** The delimiter that will separate the path components. */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`, the\n   * function will silently fail.\n   */\n  failWithError?: boolean;\n  /**\n   * If this flag is `true` and after removing the property the parent object is empty, it\n   * will remove it recursively until a non empty parent object is found.\n   */\n  cleanEmptyProperties?: boolean;\n};\n/**\n * Deletes a property of an object using a path.\n *\n * @example\n *   const target = {\n *     propOne: {\n *       propOneSub: 'Charito!',\n *     },\n *     propTwo: '!!!',\n *   };\n *   console.log(remove({ target, path: 'propOne.propOneSub' }));\n *   // Will output { propTwo: '!!!' }\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nfunction remove<T = unknown>(options: RemoveOptions): T | undefined;\nfunction remove<T = unknown>(options: unknown, path: string): T | undefined;\nfunction remove<T = unknown>(\n  options: RemoveOptions | unknown,\n  path?: string,\n): T | undefined {\n  let useOptions: RemoveOptions;\n  if (typeof path === 'string') {\n    useOptions = {\n      target: options,\n      path,\n    };\n  } else {\n    useOptions = options as RemoveOptions;\n  }\n\n  const {\n    target,\n    path: usePath,\n    pathDelimiter = '.',\n    cleanEmptyProperties = true,\n    failWithError = false,\n  } = useOptions;\n\n  const parts = usePath.split(pathDelimiter);\n  const last = parts.pop()!;\n  const result = copy(target) as Record<string, unknown>;\n  if (!parts.length) {\n    delete result[last];\n    return result as T;\n  }\n  const parentPath = parts.join(pathDelimiter);\n  const parentObj = get<Record<string, unknown>>({\n    target: result,\n    path: parentPath,\n    pathDelimiter,\n    failWithError,\n  });\n\n  if (typeof parentObj === 'undefined') {\n    return undefined;\n  }\n\n  delete parentObj[last];\n  if (cleanEmptyProperties && !Object.keys(parentObj).length) {\n    return remove({\n      target: result,\n      path: parentPath,\n      pathDelimiter,\n      failWithError,\n      cleanEmptyProperties,\n    }) as T;\n  }\n\n  return result as T;\n}\n\nexport { remove };\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `snake_case` to\n * `dash-case`.\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const snakeToDashKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])_([a-z])/g,\n    replace: (_, firstLetter, secondLetter) => `${firstLetter}-${secondLetter}`,\n  });\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `snake_case` to\n * `lowerCamelCase`.\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const snakeToLowerCamelKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])_([a-z])/g,\n    replace: (_, firstLetter, secondLetter) => {\n      const newSecondLetter = secondLetter.toUpperCase();\n      return `${firstLetter}${newSecondLetter}`;\n    },\n  });\n","import { set } from './set.js';\n\nexport type UnflatOptions = {\n  /** The object to transform. */\n  target: unknown;\n  /** The delimiter that will separate the path components. */\n  pathDelimiter?: string;\n};\n/**\n * This method does the exact opposite from `flat`: It takes an already flatten object and\n * restores it structure.\n *\n * @example\n *   const target = {\n *     'propOne.propOneSub': 'Charito!',\n *     propTwo: '!!!',\n *   };\n *   console.log(unflat({ target }));\n *   // Will output { propOne: { propOneSub: 'Charito!' }, 'propTwo': '!!!' }\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const unflat = <T = Record<string, unknown>>(options: UnflatOptions): T => {\n  const { target, pathDelimiter = '.' } = options;\n  const useTarget = target as Record<string, unknown>;\n  return Object.keys(useTarget).reduce<Record<string, unknown>>(\n    (current, key) =>\n      set({ target: current, path: key, value: useTarget[key], pathDelimiter })!,\n    {},\n  ) as T;\n};\n"],"mappings":"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","names":["extend","merge","targets","firstTarget","base","copy","target","merge","formatKeys","options","target","search","replace","include","exclude","pathDelimiter","useTarget","keys","hasChildrenByKey","key","value","escapedPathDelimiter","cleanPathStartExpression","cleanPathEndExpression","subIncludeByKey","keysToFormat","includePath","useIncludePath","pathParts","pathKey","subExcludeByKey","keysToRemove","excludePath","useExcludePath","newObj","newKey","newValue","dashToLowerCamelKeys","options","formatKeys","_","firstLetter","secondLetter","newSecondLetter","dashToSnakeKeys","options","formatKeys","_","firstLetter","secondLetter","get","options","path","useOptions","target","usePath","pathDelimiter","failWithError","useTarget","parts","first","currentElement","currentPath","currentPart","breakLoop","FORBIDDEN_PATHS","set","options","path","value","useOptions","target","usePath","useValue","pathDelimiter","failWithError","result","copy","parts","part","last","currentElement","currentPath","foundInvalid","elementType","errorPath","extract","options","target","paths","pathDelimiter","failWithError","copied","copy","result","failed","acc","objPath","destPath","originPath","firstKey","pathInfo","breakLoop","value","get","withCustomProp","set","flat","options","target","shouldFlatten","pathDelimiter","prefix","useTarget","result","namePrefix","key","name","value","isObject","merge","copy","lowerCamelToDashKeys","options","formatKeys","_","firstLetter","secondLetter","newSecondLetter","lowerCamelToSnakeKeys","options","formatKeys","_","firstLetter","secondLetter","newSecondLetter","remove","options","path","useOptions","target","usePath","pathDelimiter","cleanEmptyProperties","failWithError","parts","last","result","copy","parentPath","parentObj","get","snakeToDashKeys","options","formatKeys","_","firstLetter","secondLetter","snakeToLowerCamelKeys","options","formatKeys","_","firstLetter","secondLetter","newSecondLetter","unflat","options","target","pathDelimiter","useTarget","current","key","set"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@homer0/object-utils",
   "description": "A small collection of utility methods to work with objects.",
-  "version": "6.0.2",
+  "version": "6.0.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/homer0/packages.git",
@@ -37,8 +37,8 @@
     "extend": "^3.0.2"
   },
   "devDependencies": {
-    "@homer0/oxlint-config": "0.3.0",
-    "@homer0/tsconfig": "5.0.0",
+    "@homer0/oxlint-config": "1.0.2",
+    "@homer0/tsconfig": "5.0.1",
     "@types/extend": "^3.0.4",
     "@vitest/coverage-v8": "catalog:",
     "oxlint": "catalog:",
@@ -59,5 +59,5 @@
     "build": "tsup",
     "prepublishOnly": "pnpm run build"
   },
-  "gitHead": "07328e8a7b1f1b73c46837692c8821a7badca190"
+  "gitHead": "e494ba08d9dd4fe6e5d3a9ef54201f3c1f748355"
 }