es-toolkit 1.0.3-dev.38 → 1.0.3

package/dist/array/intersection.d.ts

@@ -15,6 +15,4 @@
  * const result = intersection(array1, array2);
  * // result will be [3, 4, 5] since these elements are in both arrays.
  */
-declare function intersection<T>(firstArr: T[], secondArr: T[]): T[];
-
-export { intersection };
+export declare function intersection<T>(firstArr: T[], secondArr: T[]): T[];

package/dist/array/intersection.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/intersectionBy.d.ts

@@ -18,6 +18,4 @@
  * const result = intersectionBy(array1, array2, mapper);
  * // result will be [{ id: 2 }] since only this element has a matching id in both arrays.
  */
-declare function intersectionBy<T, U>(firstArr: T[], secondArr: T[], mapper: (item: T) => U): T[];
-
-export { intersectionBy };
+export declare function intersectionBy<T, U>(firstArr: T[], secondArr: T[], mapper: (item: T) => U): T[];

package/dist/array/intersectionBy.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/intersectionWith.d.ts

@@ -19,6 +19,4 @@
  * const result = intersectionWith(array1, array2, areItemsEqual);
  * // result will be [{ id: 2 }] since this element has a matching id in both arrays.
  */
-declare function intersectionWith<T>(firstArr: T[], secondArr: T[], areItemsEqual: (x: T, y: T) => boolean): T[];
-
-export { intersectionWith };
+export declare function intersectionWith<T>(firstArr: T[], secondArr: T[], areItemsEqual: (x: T, y: T) => boolean): T[];

package/dist/array/intersectionWith.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/partition.d.ts

@@ -19,6 +19,4 @@
  * const [even, odd] = partition(array, isEven);
  * // even will be [2, 4], and odd will be [1, 3, 5]
  */
-declare function partition<T>(arr: T[], isInTruthy: (value: T) => boolean): [truthy: T[], falsy: T[]];
-
-export { partition };
+export declare function partition<T>(arr: T[], isInTruthy: (value: T) => boolean): [truthy: T[], falsy: T[]];

package/dist/array/partition.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/sample.d.ts

@@ -11,6 +11,4 @@
  * const randomElement = sample(array);
  * // randomElement will be one of the elements from the array, selected randomly.
  */
-declare function sample<T>(arr: T[]): T;
-
-export { sample };
+export declare function sample<T>(arr: T[]): T;

package/dist/array/sample.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/shuffle.d.ts

@@ -11,6 +11,4 @@
  * const shuffledArray = shuffle(array);
  * // shuffledArray will be a new array with elements of array in random order, e.g., [3, 1, 4, 5, 2]
  */
-declare function shuffle<T>(arr: T[]): T[];
-
-export { shuffle };
+export declare function shuffle<T>(arr: T[]): T[];

package/dist/array/shuffle.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/take.d.ts

@@ -20,6 +20,4 @@
  * // Returns [1, 2, 3]
  * take([1, 2, 3], 5);
  */
-declare function take<T>(arr: T[], count: number): T[];
-
-export { take };
+export declare function take<T>(arr: T[], count: number): T[];

package/dist/array/take.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/takeRight.d.ts

@@ -18,6 +18,4 @@
  * // Returns [1, 2, 3]
  * takeRight([1, 2, 3], 5);
  */
-declare function takeRight<T>(arr: T[], count: number): T[];
-
-export { takeRight };
+export declare function takeRight<T>(arr: T[], count: number): T[];

package/dist/array/takeRight.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/takeRightWhile.d.ts

@@ -15,6 +15,4 @@
  * // Returns []
  * takeRightWhile([1, 2, 3], n => n > 3);
  */
-declare function takeRightWhile<T>(arr: T[], shouldContinueTaking: (item: T) => boolean): T[];
-
-export { takeRightWhile };
+export declare function takeRightWhile<T>(arr: T[], shouldContinueTaking: (item: T) => boolean): T[];

package/dist/array/takeRightWhile.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/takeWhile.d.ts

@@ -16,6 +16,4 @@
  * // Returns []
  * takeWhile([1, 2, 3, 4], x => x > 3);
  */
-declare function takeWhile<T>(arr: T[], shouldContinueTaking: (element: T) => boolean): T[];
-
-export { takeWhile };
+export declare function takeWhile<T>(arr: T[], shouldContinueTaking: (element: T) => boolean): T[];

package/dist/array/takeWhile.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/union.d.ts

@@ -14,6 +14,4 @@
  * const result = union(array1, array2);
  * // result will be [1, 2, 3, 4, 5]
  */
-declare function union<T>(arr1: T[], arr2: T[]): T[];
-
-export { union };
+export declare function union<T>(arr1: T[], arr2: T[]): T[];

package/dist/array/union.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/unionBy.d.ts

@@ -18,6 +18,4 @@
  * unionBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper);
  * // Returns [{ id: 1 }, { id: 2 }, { id: 3 }]
  */
-declare function unionBy<T, U>(arr1: T[], arr2: T[], mapper: (item: T) => U): T[];
-
-export { unionBy };
+export declare function unionBy<T, U>(arr1: T[], arr2: T[], mapper: (item: T) => U): T[];

package/dist/array/unionBy.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/unionWith.d.ts

@@ -17,6 +17,4 @@
  * const result = unionWith(array1, array2, areItemsEqual);
  * // result will be [{ id: 1 }, { id: 2 }, { id: 3 }] since { id: 2 } is considered equal in both arrays
  */
-declare function unionWith<T>(arr1: T[], arr2: T[], areItemsEqual: (item1: T, item2: T) => boolean): T[];
-
-export { unionWith };
+export declare function unionWith<T>(arr1: T[], arr2: T[], areItemsEqual: (item1: T, item2: T) => boolean): T[];

package/dist/array/unionWith.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/uniq.d.ts

@@ -12,6 +12,4 @@
  * const result = uniq(array);
  * // result will be [1, 2, 3, 4, 5]
  */
-declare function uniq<T>(arr: T[]): T[];
-
-export { uniq };
+export declare function uniq<T>(arr: T[]): T[];

package/dist/array/uniq.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/uniqBy.d.ts

@@ -9,6 +9,4 @@
  * // [1.2, 2.1, 3.3, 5.7, 7.19]
  * ```
  */
-declare function uniqBy<T, U>(arr: T[], converter: (item: T) => U): T[];
-
-export { uniqBy };
+export declare function uniqBy<T, U>(arr: T[], converter: (item: T) => U): T[];

package/dist/array/uniqBy.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/uniqWith.d.ts

@@ -9,6 +9,4 @@
  * // [1, 2, 3, 5, 7]
  * ```
  */
-declare function uniqWith<T>(arr: T[], areItemsEqual: (item1: T, item2: T) => boolean): T[];
-
-export { uniqWith };
+export declare function uniqWith<T>(arr: T[], areItemsEqual: (item1: T, item2: T) => boolean): T[];

package/dist/array/uniqWith.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/xor.d.ts

@@ -14,6 +14,4 @@
  * // Returns ['a', 'c']
  * xor(['a', 'b'], ['b', 'c']);
  */
-declare function xor<T>(arr1: T[], arr2: T[]): T[];
-
-export { xor };
+export declare function xor<T>(arr1: T[], arr2: T[]): T[];

package/dist/array/xor.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/xorBy.d.ts

@@ -17,6 +17,4 @@
  * xorBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper);
  * // Returns [{ id: 1 }, { id: 3 }]
  */
-declare function xorBy<T, U>(arr1: T[], arr2: T[], mapper: (item: T) => U): T[];
-
-export { xorBy };
+export declare function xorBy<T, U>(arr1: T[], arr2: T[], mapper: (item: T) => U): T[];

package/dist/array/xorBy.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/xorWith.d.ts

@@ -16,6 +16,4 @@
  * xorWith([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], areObjectsEqual);
  * // Returns [{ id: 1 }, { id: 3 }]
  */
-declare function xorWith<T>(arr1: T[], arr2: T[], areElementsEqual: (item1: T, item2: T) => boolean): T[];
-
-export { xorWith };
+export declare function xorWith<T>(arr1: T[], arr2: T[], areElementsEqual: (item1: T, item2: T) => boolean): T[];

package/dist/array/xorWith.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/zip.d.ts

@@ -19,9 +19,7 @@
  * const result2 = zip(arr1, arr2, arr3);
  * // result2 will be [[1, 'a', true], [2, 'b', false], [3, 'c', undefined]]
  */
-declare function zip<T>(arr1: T[]): Array<[T]>;
-declare function zip<T, U>(arr1: T[], arr2: U[]): Array<[T, U]>;
-declare function zip<T, U, V>(arr1: T[], arr2: U[], arr3: V[]): Array<[T, U, V]>;
-declare function zip<T, U, V, W>(arr1: T[], arr2: U[], arr3: V[], arr4: W[]): Array<[T, U, V, W]>;
-
-export { zip };
+export declare function zip<T>(arr1: T[]): [T][];
+export declare function zip<T, U>(arr1: T[], arr2: U[]): [T, U][];
+export declare function zip<T, U, V>(arr1: T[], arr2: U[], arr3: V[]): [T, U, V][];
+export declare function zip<T, U, V, W>(arr1: T[], arr2: U[], arr3: V[], arr4: W[]): [T, U, V, W][];

package/dist/array/zip.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/array/zipWith.d.ts

@@ -26,9 +26,7 @@
  * const result = zipWith(arr1, arr2, arr3, (a, b, c) => `${a}${b}${c}`);
  * // result will be [`135`, `246`]
  */
-declare function zipWith<T, R>(arr1: T[], combine: (item: T) => R): R[];
-declare function zipWith<T, U, R>(arr1: T[], arr2: U[], combine: (item1: T, item2: U) => R): R[];
-declare function zipWith<T, U, V, R>(arr1: T[], arr2: U[], arr3: V[], combine: (item1: T, item2: U, item3: V) => R): R[];
-declare function zipWith<T, U, V, W, R>(arr1: T[], arr2: U[], arr3: V[], arr4: W[], combine: (item1: T, item2: U, item3: V, item4: W) => R): R[];
-
-export { zipWith };
+export declare function zipWith<T, R>(arr1: T[], combine: (item: T) => R): R[];
+export declare function zipWith<T, U, R>(arr1: T[], arr2: U[], combine: (item1: T, item2: U) => R): R[];
+export declare function zipWith<T, U, V, R>(arr1: T[], arr2: U[], arr3: V[], combine: (item1: T, item2: U, item3: V) => R): R[];
+export declare function zipWith<T, U, V, W, R>(arr1: T[], arr2: U[], arr3: V[], arr4: W[], combine: (item1: T, item2: U, item3: V, item4: W) => R): R[];

package/dist/array/zipWith.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/function/debounce.d.ts

@@ -18,9 +18,7 @@
  * // Will not log anything as the previous call is canceled
  * debouncedFunction.cancel();
  */
-declare function debounce(func: () => void, debounceMs: number): {
+export declare function debounce(func: () => void, debounceMs: number): {
     (): void;
     cancel: () => void;
 };
-
-export { debounce };

package/dist/function/debounce.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/function/index.d.ts

@@ -1,3 +1,3 @@
-export { debounce } from './debounce.js';
-export { once } from './once.js';
-export { throttle } from './throttle.js';
+export { debounce } from './debounce';
+export { once } from './once';
+export { throttle } from './throttle';

package/dist/function/index.js

@@ -1,43 +1,38 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+'use strict';
 
-// src/function/index.ts
-var function_exports = {};
-__export(function_exports, {
-  debounce: () => debounce,
-  once: () => once,
-  throttle: () => throttle
-});
-module.exports = __toCommonJS(function_exports);
+Object.defineProperty(exports, '__esModule', { value: true });
 
-// src/function/debounce.ts
+/**
+ * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds
+ * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`
+ * method to cancel any pending execution.
+ *
+ * @param {() => void} func - The function to debounce.
+ * @param {number} debounceMs - The number of milliseconds to delay.
+ * @returns {{ (): void; cancel: () => void }} A new debounced function with a `cancel` method.
+ *
+ * @example
+ * const debouncedFunction = debounce(() => {
+ *   console.log('Function executed');
+ * }, 1000);
+ *
+ * // Will log 'Function executed' after 1 second if not called again in that time
+ * debouncedFunction();
+ * 
+ * // Will not log anything as the previous call is canceled
+ * debouncedFunction.cancel();
+ */
 function debounce(func, debounceMs) {
-  let timeoutId = null;
-  const debounced = function() {
+  var timeoutId = null;
+  var debounced = function debounced() {
     if (timeoutId != null) {
       clearTimeout(timeoutId);
     }
-    timeoutId = setTimeout(() => {
+    timeoutId = setTimeout(function () {
       func();
     }, debounceMs);
   };
-  debounced.cancel = function() {
+  debounced.cancel = function () {
     if (timeoutId != null) {
       clearTimeout(timeoutId);
     }
@@ -45,26 +40,65 @@ function debounce(func, debounceMs) {
   return debounced;
 }
 
-// src/function/once.ts
+/**
+ * Creates a function that is restricted to invoking the provided function `func` once.
+ * Repeated calls to the function will return the value from the first invocation.
+ *
+ * @param {F} func - The function to restrict.
+ * @returns {F} A new function that invokes `func` once and caches the result.
+ *
+ * @example
+ * const initialize = once(() => {
+ *   console.log('Initialized!');
+ *   return true;
+ * });
+ * 
+ * initialize(); // Logs: 'Initialized!' and returns true
+ * initialize(); // Returns true without logging
+ */
 function once(func) {
-  let called = false;
-  let cache;
-  return function() {
+  var called = false;
+  var cache;
+  return function () {
     if (called) {
       return cache;
     }
-    const result = func();
+    var result = func();
     called = true;
     cache = result;
     return result;
   };
 }
 
-// src/function/throttle.ts
+/**
+ * Creates a throttled function that only invokes the provided function at most once
+ * per every `throttleMs` milliseconds. Subsequent calls to the throttled function
+ * within the wait time will not trigger the execution of the original function.
+ *
+ * @param {() => void} func - The function to throttle.
+ * @param {number} throttleMs - The number of milliseconds to throttle executions to.
+ * @returns {() => void} A new throttled function.
+ *
+ * @example
+ * const throttledFunction = throttle(() => {
+ *   console.log('Function executed');
+ * }, 1000);
+ *
+ * // Will log 'Function executed' immediately
+ * throttledFunction();
+ * 
+ * // Will not log anything as it is within the throttle time
+ * throttledFunction();
+ * 
+ * // After 1 second
+ * setTimeout(() => {
+ *   throttledFunction(); // Will log 'Function executed'
+ * }, 1000);
+ */
 function throttle(func, throttleMs) {
-  let lastCallTime;
-  const throttledFunction = function() {
-    const now = Date.now();
+  var lastCallTime;
+  var throttledFunction = function throttledFunction() {
+    var now = Date.now();
     if (lastCallTime == null || now - lastCallTime >= throttleMs) {
       lastCallTime = now;
       func();
@@ -72,10 +106,7 @@ function throttle(func, throttleMs) {
   };
   return throttledFunction;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  debounce,
-  once,
-  throttle
-});
-//# sourceMappingURL=index.js.map
+
+exports.debounce = debounce;
+exports.once = once;
+exports.throttle = throttle;

package/dist/function/once.d.ts

@@ -14,6 +14,4 @@
  * initialize(); // Logs: 'Initialized!' and returns true
  * initialize(); // Returns true without logging
  */
-declare function once<F extends () => any>(func: F): F;
-
-export { once };
+export declare function once<F extends () => any>(func: F): F;

package/dist/function/once.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/function/throttle.d.ts

@@ -23,6 +23,4 @@
  *   throttledFunction(); // Will log 'Function executed'
  * }, 1000);
  */
-declare function throttle(func: () => void, throttleMs: number): () => void;
-
-export { throttle };
+export declare function throttle(func: () => void, throttleMs: number): () => void;

package/dist/function/throttle.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -1,45 +1,6 @@
-export { chunk } from './array/chunk.js';
-export { difference } from './array/difference.js';
-export { differenceBy } from './array/differenceBy.js';
-export { differenceWith } from './array/differenceWith.js';
-export { drop } from './array/drop.js';
-export { dropRight } from './array/dropRight.js';
-export { dropRightWhile } from './array/dropRightWhile.js';
-export { dropWhile } from './array/dropWhile.js';
-export { groupBy } from './array/groupBy.js';
-export { intersection } from './array/intersection.js';
-export { intersectionBy } from './array/intersectionBy.js';
-export { intersectionWith } from './array/intersectionWith.js';
-export { partition } from './array/partition.js';
-export { sample } from './array/sample.js';
-export { shuffle } from './array/shuffle.js';
-export { take } from './array/take.js';
-export { takeRight } from './array/takeRight.js';
-export { takeRightWhile } from './array/takeRightWhile.js';
-export { takeWhile } from './array/takeWhile.js';
-export { union } from './array/union.js';
-export { unionBy } from './array/unionBy.js';
-export { unionWith } from './array/unionWith.js';
-export { uniq } from './array/uniq.js';
-export { uniqBy } from './array/uniqBy.js';
-export { uniqWith } from './array/uniqWith.js';
-export { xor } from './array/xor.js';
-export { xorBy } from './array/xorBy.js';
-export { xorWith } from './array/xorWith.js';
-export { zip } from './array/zip.js';
-export { zipWith } from './array/zipWith.js';
-export { debounce } from './function/debounce.js';
-export { once } from './function/once.js';
-export { throttle } from './function/throttle.js';
-export { clamp } from './math/clamp.js';
-export { round } from './math/round.js';
-export { sum } from './math/sum.js';
-export { omit } from './object/omit.js';
-export { omitBy } from './object/omitBy.js';
-export { pick } from './object/pick.js';
-export { pickBy } from './object/pickBy.js';
-export { isNil } from './predicate/isNil.js';
-export { isNotNil } from './predicate/isNotNil.js';
-export { isNull } from './predicate/isNull.js';
-export { isUndefined } from './predicate/isUndefined.js';
-export { delay } from './promise/delay.js';
+export * from './array';
+export * from './function';
+export * from './math';
+export * from './object';
+export * from './predicate';
+export * from './promise';