es-toolkit 1.6.1 → 1.7.0-dev.146

package/dist/index.js

@@ -38,6 +38,7 @@ __export(src_exports, {
   chunk: () => chunk,
   clamp: () => clamp,
   compact: () => compact,
+  countBy: () => countBy,
   debounce: () => debounce,
   delay: () => delay,
   difference: () => difference,
@@ -47,6 +48,8 @@ __export(src_exports, {
   dropRight: () => dropRight,
   dropRightWhile: () => dropRightWhile,
   dropWhile: () => dropWhile,
+  fill: () => fill,
+  forEachRight: () => forEachRight,
   groupBy: () => groupBy,
   intersection: () => intersection,
   intersectionBy: () => intersectionBy,
@@ -58,6 +61,7 @@ __export(src_exports, {
   keyBy: () => keyBy,
   maxBy: () => maxBy,
   mean: () => mean,
+  meanBy: () => meanBy,
   minBy: () => minBy,
   noop: () => noop,
   omit: () => omit,
@@ -71,6 +75,7 @@ __export(src_exports, {
   range: () => range,
   round: () => round,
   sample: () => sample,
+  sampleSize: () => sampleSize,
   shuffle: () => shuffle,
   sum: () => sum,
   take: () => take,
@@ -84,6 +89,8 @@ __export(src_exports, {
   uniq: () => uniq,
   uniqBy: () => uniqBy,
   uniqWith: () => uniqWith,
+  unzipWith: () => unzipWith,
+  without: () => without,
   xor: () => xor,
   xorBy: () => xorBy,
   xorWith: () => xorWith,
@@ -119,6 +126,17 @@ function compact(arr) {
   return result;
 }
 
+// src/array/countBy.ts
+function countBy(arr, mapper) {
+  var _a;
+  const result = {};
+  for (const item of arr) {
+    const key = mapper(item);
+    result[key] = ((_a = result[key]) != null ? _a : 0) + 1;
+  }
+  return result;
+}
+
 // src/array/difference.ts
 function difference(firstArr, secondArr) {
   const secondSet = new Set(secondArr);
@@ -168,6 +186,24 @@ function dropRightWhile(arr, canContinueDropping) {
   return dropped.slice().reverse();
 }
 
+// src/array/fill.ts
+function fill(arr, value, start = 0, end = arr.length) {
+  start = Math.max(start, 0);
+  end = Math.min(end, arr.length);
+  for (let i = start; i < end; i++) {
+    arr[i] = value;
+  }
+  return arr;
+}
+
+// src/array/forEachRight.ts
+function forEachRight(arr, callback) {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    const element = arr[i];
+    callback(element, i, arr);
+  }
+}
+
 // src/array/groupBy.ts
 function groupBy(arr, getKeyFromItem) {
   const result = {};
@@ -262,6 +298,41 @@ function sample(arr) {
   return arr[randomIndex];
 }
 
+// src/math/random.ts
+function random(minimum, maximum) {
+  if (maximum == null) {
+    maximum = minimum;
+    minimum = 0;
+  }
+  if (minimum >= maximum) {
+    throw new Error("Invalid input: The maximum value must be greater than the minimum value.");
+  }
+  return Math.random() * (maximum - minimum) + minimum;
+}
+
+// src/math/randomInt.ts
+function randomInt(minimum, maximum) {
+  return Math.floor(random(minimum, maximum));
+}
+
+// src/array/sampleSize.ts
+function sampleSize(array, size) {
+  if (size > array.length) {
+    throw new Error("Size must be less than or equal to the length of array.");
+  }
+  const result = new Array(size);
+  const selected = /* @__PURE__ */ new Set();
+  for (let step = array.length - size, resultIndex = 0; step < array.length; step++, resultIndex++) {
+    let index = randomInt(0, step + 1);
+    if (selected.has(index)) {
+      index = step;
+    }
+    selected.add(index);
+    result[resultIndex] = array[index];
+  }
+  return result;
+}
+
 // src/array/shuffle.ts
 function shuffle(arr) {
   const result = arr.slice();
@@ -358,6 +429,20 @@ function uniqBy(arr, mapper) {
   return Array.from(map.values());
 }
 
+// src/array/unzipWith.ts
+function unzipWith(target, iteratee) {
+  const maxLength = Math.max(...target.map((innerArray) => innerArray.length));
+  const result = new Array(maxLength);
+  for (let i = 0; i < maxLength; i++) {
+    const group = new Array(target.length);
+    for (let j = 0; j < target.length; j++) {
+      group[j] = target[j][i];
+    }
+    result[i] = iteratee(...group);
+  }
+  return result;
+}
+
 // src/array/xor.ts
 function xor(arr1, arr2) {
   return difference(union(arr1, arr2), intersection(arr1, arr2));
@@ -391,6 +476,15 @@ function zip(...arrs) {
   return result;
 }
 
+// src/array/zipObject.ts
+function zipObject(keys, values) {
+  const result = {};
+  for (let i = 0; i < keys.length; i++) {
+    result[keys[i]] = values[i];
+  }
+  return result;
+}
+
 // src/array/zipWith.ts
 function zipWith(arr1, ...rest) {
   const arrs = [arr1, ...rest.slice(0, -1)];
@@ -404,13 +498,10 @@ function zipWith(arr1, ...rest) {
   return result;
 }
 
-// src/array/zipObject.ts
-function zipObject(keys, values) {
-  const result = {};
-  for (let i = 0; i < keys.length; i++) {
-    result[keys[i]] = values[i];
-  }
-  return result;
+// src/array/without.ts
+function without(array, ...values) {
+  const valuesSet = new Set(values);
+  return array.filter((item) => !valuesSet.has(item));
 }
 
 // src/error/AbortError.ts
@@ -503,21 +594,10 @@ function mean(nums) {
   return sum(nums) / nums.length;
 }
 
-// src/math/random.ts
-function random(minimum, maximum) {
-  if (maximum == null) {
-    maximum = minimum;
-    minimum = 0;
-  }
-  if (minimum >= maximum) {
-    throw new Error("Invalid input: The maximum value must be greater than the minimum value.");
-  }
-  return Math.random() * (maximum - minimum) + minimum;
-}
-
-// src/math/randomInt.ts
-function randomInt(minimum, maximum) {
-  return Math.floor(random(minimum, maximum));
+// src/math/meanBy.ts
+function meanBy(items, getValue) {
+  const nums = items.map((x) => getValue(x));
+  return mean(nums);
 }
 
 // src/math/round.ts
@@ -634,6 +714,7 @@ function delay(ms, { signal } = {}) {
   chunk,
   clamp,
   compact,
+  countBy,
   debounce,
   delay,
   difference,
@@ -643,6 +724,8 @@ function delay(ms, { signal } = {}) {
   dropRight,
   dropRightWhile,
   dropWhile,
+  fill,
+  forEachRight,
   groupBy,
   intersection,
   intersectionBy,
@@ -654,6 +737,7 @@ function delay(ms, { signal } = {}) {
   keyBy,
   maxBy,
   mean,
+  meanBy,
   minBy,
   noop,
   omit,
@@ -667,6 +751,7 @@ function delay(ms, { signal } = {}) {
   range,
   round,
   sample,
+  sampleSize,
   shuffle,
   sum,
   take,
@@ -680,6 +765,8 @@ function delay(ms, { signal } = {}) {
   uniq,
   uniqBy,
   uniqWith,
+  unzipWith,
+  without,
   xor,
   xorBy,
   xorWith,