es-toolkit 1.10.1-dev.230 → 1.10.1-dev.237

package/dist/compat/index.mjs

@@ -83,7 +83,10 @@ import {
 import {
   inRange
 } from "../chunk-BH6HLGBA.mjs";
-import "../chunk-DDH7K4QM.mjs";
+import {
+  set,
+  zipObjectDeep
+} from "../chunk-MKCRW4QT.mjs";
 import {
   xor
 } from "../chunk-L7FQX5MN.mjs";
@@ -332,6 +335,7 @@ export {
   round,
   sample,
   sampleSize,
+  set,
   shuffle,
   snakeCase,
   startCase,
@@ -358,6 +362,7 @@ export {
   xorWith,
   zip,
   zipObject,
+  zipObjectDeep,
   zipWith
 };
 //# sourceMappingURL=index.mjs.map

package/dist/compat/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/compat/array/chunk.ts"],"sourcesContent":["import { chunk as chunkToolkit } from '../../array/chunk.ts';\n\n/**\n * Splits an array into smaller arrays of a specified length.\n *\n * This function takes an input array and divides it into multiple smaller arrays,\n * each of a specified length. If the input array cannot be evenly divided,\n * the final sub-array will contain the remaining elements.\n *\n * @template T The type of elements in the array.\n * @param {T[]} arr - The array to be chunked into smaller arrays.\n * @param {number} size - The size of each smaller array. Must be a positive integer.\n * @returns {T[][]} A two-dimensional array where each sub-array has a maximum length of `size`.\n * @throws {Error} Throws an error if `size` is not a positive integer.\n *\n * @example\n * // Splits an array of numbers into sub-arrays of length 2\n * chunk([1, 2, 3, 4, 5], 2);\n * // Returns: [[1, 2], [3, 4], [5]]\n *\n * @example\n * // Splits an array of strings into sub-arrays of length 3\n * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);\n * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]\n */\nexport function chunk<T>(arr: readonly T[], size: number = 1): T[][] {\n  size = Math.max(Math.floor(size), 0);\n\n  if (size === 0) {\n    return [];\n  }\n\n  return chunkToolkit(arr, size);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBO,SAASA,OAAS,KAAmB,OAAe,GAAU;AACnE,SAAO,KAAK,IAAI,KAAK,MAAM,IAAI,GAAG,CAAC;AAEnC,MAAI,SAAS,GAAG;AACd,WAAO,CAAC;AAAA,EACV;AAEA,SAAO,MAAa,KAAK,IAAI;AAC/B;","names":["chunk"]}
+{"version":3,"sources":["../../src/compat/array/chunk.ts"],"sourcesContent":["import { chunk as chunkToolkit } from '../../array/chunk.ts';\n\n/**\n * Splits an array into smaller arrays of a specified length.\n *\n * This function takes an input array and divides it into multiple smaller arrays,\n * each of a specified length. If the input array cannot be evenly divided,\n * the final sub-array will contain the remaining elements.\n *\n * @template T The type of elements in the array.\n * @param {T[]} arr - The array to be chunked into smaller arrays.\n * @param {number} size - The size of each smaller array. Must be a positive integer.\n * @returns {T[][]} A two-dimensional array where each sub-array has a maximum length of `size`.\n * @throws {Error} Throws an error if `size` is not a positive integer.\n *\n * @example\n * // Splits an array of numbers into sub-arrays of length 2\n * chunk([1, 2, 3, 4, 5], 2);\n * // Returns: [[1, 2], [3, 4], [5]]\n *\n * @example\n * // Splits an array of strings into sub-arrays of length 3\n * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);\n * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]\n */\nexport function chunk<T>(arr: readonly T[], size: number = 1): T[][] {\n  size = Math.max(Math.floor(size), 0);\n\n  if (size === 0) {\n    return [];\n  }\n\n  return chunkToolkit(arr, size);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBO,SAASA,OAAS,KAAmB,OAAe,GAAU;AACnE,SAAO,KAAK,IAAI,KAAK,MAAM,IAAI,GAAG,CAAC;AAEnC,MAAI,SAAS,GAAG;AACd,WAAO,CAAC;AAAA,EACV;AAEA,SAAO,MAAa,KAAK,IAAI;AAC/B;","names":["chunk"]}

package/dist/index.d.mts

@@ -42,6 +42,7 @@ export { xorBy } from './array/xorBy.mjs';
 export { xorWith } from './array/xorWith.mjs';
 export { zip } from './array/zip.mjs';
 export { zipObject } from './array/zipObject.mjs';
+export { z as zipObjectDeep } from './zipObjectDeep-eeZxUsAU.mjs';
 export { zipWith } from './array/zipWith.mjs';
 export { without } from './array/without.mjs';
 export { head } from './array/head.mjs';

package/dist/index.d.ts

@@ -42,6 +42,7 @@ export { xorBy } from './array/xorBy.js';
 export { xorWith } from './array/xorWith.js';
 export { zip } from './array/zip.js';
 export { zipObject } from './array/zipObject.js';
+export { z as zipObjectDeep } from './zipObjectDeep-eeZxUsAU.js';
 export { zipWith } from './array/zipWith.js';
 export { without } from './array/without.js';
 export { head } from './array/head.js';

package/dist/index.js

@@ -118,6 +118,7 @@ __export(src_exports, {
   xorWith: () => xorWith,
   zip: () => zip,
   zipObject: () => zipObject,
+  zipObjectDeep: () => zipObjectDeep,
   zipWith: () => zipWith
 });
 module.exports = __toCommonJS(src_exports);
@@ -580,6 +581,77 @@ function zipObject(keys, values) {
   return result;
 }
 
+// src/compat/_internal/isIndex.ts
+var IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/;
+function isIndex(value) {
+  switch (typeof value) {
+    case "number": {
+      return Number.isInteger(value) && value >= 0 && value < Number.MAX_SAFE_INTEGER;
+    }
+    case "symbol": {
+      return false;
+    }
+    case "string": {
+      return IS_UNSIGNED_INTEGER.test(value);
+    }
+  }
+}
+
+// src/compat/_internal/toPath.ts
+var ESCAPE_REGEXP = /\\(\\)?/g;
+var PROPERTY_REGEXP = RegExp(
+  // Match anything that isn't a dot or bracket.
+  `[^.[\\]]+|\\[(?:([^"'][^[]*)|(["'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))`,
+  "g"
+);
+function toPath(deepKey) {
+  const result = [];
+  if (deepKey[0] === ".") {
+    result.push("");
+  }
+  let match;
+  while ((match = PROPERTY_REGEXP.exec(deepKey)) !== null) {
+    let [key, expr, quote, substr] = match;
+    if (quote) {
+      key = substr.replace(ESCAPE_REGEXP, "$1");
+    } else if (expr) {
+      key = expr.trim();
+    }
+    result.push(key);
+  }
+  return result;
+}
+
+// src/compat/object/set.ts
+function set(obj, path, value) {
+  const resolvedPath = Array.isArray(path) ? path : typeof path === "string" ? toPath(path) : [path];
+  let current = obj;
+  for (let i = 0; i < resolvedPath.length - 1; i++) {
+    const key = resolvedPath[i];
+    const nextKey = resolvedPath[i + 1];
+    if (current[key] == null) {
+      current[key] = isIndex(nextKey) ? [] : {};
+    }
+    current = current[key];
+  }
+  const lastKey = resolvedPath[resolvedPath.length - 1];
+  current[lastKey] = value;
+  return obj;
+}
+
+// src/compat/array/zipObjectDeep.ts
+function zipObjectDeep(keys, values) {
+  const result = {};
+  const zipped = zip(keys, values);
+  for (let i = 0; i < zipped.length; i++) {
+    const [key, value] = zipped[i];
+    if (key != null) {
+      set(result, key, value);
+    }
+  }
+  return result;
+}
+
 // src/array/zipWith.ts
 function zipWith(arr1, ...rest) {
   const arrs = [arr1, ...rest.slice(0, -1)];
@@ -1094,6 +1166,7 @@ function startCase(str) {
   xorWith,
   zip,
   zipObject,
+  zipObjectDeep,
   zipWith
 });
 //# sourceMappingURL=index.js.map