es-toolkit 0.0.1 → 1.0.0-dev.24

package/src/array/takeWhile.spec.ts

@@ -1,34 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { takeWhile } from './takeWhile'; // adjust the import path as necessary
-
-describe('takeWhile', () => {
-  it('should return elements while the predicate is true', () => {
-    const arr = [1, 2, 3, 4, 5];
-    const result = takeWhile(arr, x => x < 4);
-    expect(result).toEqual([1, 2, 3]);
-  });
-
-  it('should return an empty array if the first element does not satisfy the predicate', () => {
-    const arr = [1, 2, 3, 4, 5];
-    const result = takeWhile(arr, x => x > 4);
-    expect(result).toEqual([]);
-  });
-
-  it('should return all elements if all satisfy the predicate', () => {
-    const arr = [1, 2, 3];
-    const result = takeWhile(arr, x => x < 4);
-    expect(result).toEqual([1, 2, 3]);
-  });
-
-  it('should return an empty array if the input array is empty', () => {
-    const arr: number[] = [];
-    const result = takeWhile(arr, x => x < 4);
-    expect(result).toEqual([]);
-  });
-
-  it('should handle complex predicate functions', () => {
-    const arr = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }];
-    const result = takeWhile(arr, item => item.id < 3);
-    expect(result).toEqual([{ id: 1 }, { id: 2 }]);
-  });
-});

package/src/array/takeWhile.ts

@@ -1,31 +0,0 @@
-/**
- * Returns a new array containing the leading elements of the provided array
- * that satisfy the provided predicate function. It stops taking elements as soon
- * as an element does not satisfy the predicate.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array to process.
- * @param {(element: T) => boolean} shouldContinueTaking - The predicate function that is called with each element. Elements are included in the result as long as this function returns true.
- * @returns {T[]} A new array containing the leading elements that satisfy the predicate.
- *
- * @example
- * // Returns [1, 2]
- * takeWhile([1, 2, 3, 4], x => x < 3);
- *
- * @example
- * // Returns []
- * takeWhile([1, 2, 3, 4], x => x > 3);
- */
-export function takeWhile<T>(arr: T[], shouldContinueTaking: (element: T) => boolean): T[] {
-  const result: T[] = [];
-
-  for (const item of arr) {
-    if (!shouldContinueTaking(item)) {
-      break;
-    }
-
-    result.push(item);
-  }
-
-  return result;
-}

package/src/array/union.spec.ts

@@ -1,10 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { union } from "./union";
-
-describe("union", () => {
-  it("uniq function should return the union of two arrays", () => {
-    expect(union([2, 1], [2])).toEqual([2, 1]);
-    expect(union([2, 1], [2], [2, 3])).toEqual([2, 1, 3]);
-    expect(union([2, 1], [2], [1, [5]])).toEqual([2, 1, [5]]);
-  });
-});

package/src/array/union.ts

@@ -1,14 +0,0 @@
-import { uniq } from "./uniq";
-
-/**
- * `union` function returns the union of the arrays passed as arguments.
- *
- * @example
- * ```ts
- * union([2], [1, 2]);
- * // [2, 1]
- * ```
- */
-export function union<T>(...args: T[][]): T[] {
-  return uniq(args.flat());
-}

package/src/array/unionBy.spec.ts

@@ -1,12 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { unionBy } from "./unionBy";
-
-describe("unionBy", () => {
-  it("should work with a `converter`", () => {
-    expect(unionBy([2.1], [1.2, 2.3], Math.floor)).toEqual([2.1, 1.2]);
-    expect(unionBy([{ x: 1 }], [{ x: 2 }, { x: 1 }], ({ x }) => x)).toEqual([
-      { x: 1 },
-      { x: 2 },
-    ]);
-  });
-});

package/src/array/unionBy.ts

@@ -1,35 +0,0 @@
-/**
- * Creates an array of unique values, in order, from all given arrays using a provided mapping function to determine equality.
- *
- * @template T - Type of elements in the input arrays.
- * @template U - Type of the values returned by the mapping function.
- * 
- * @param {T[]} arr1 - The first array.
- * @param {T[]} arr2 - The second array.
- * @param {function(item: T): U} mapper - The function to map array elements to comparison values.
- * @returns {T[]} A new array containing the union of unique elements from `arr1` and `arr2`, based on the values returned by the mapping function.
- * 
- * @example
- * // Custom mapping function for numbers (modulo comparison)
- * const moduloMapper = (x) => x % 3;
- * unionBy([1, 2, 3], [4, 5, 6], moduloMapper);
- * // Returns [1, 2, 3]
- * 
- * @example
- * // Custom mapping function for objects with an 'id' property
- * const idMapper = (obj) => obj.id;
- * unionBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper);
- * // Returns [{ id: 1 }, { id: 2 }, { id: 3 }]
- */
-export function unionBy<T, U>(arr1: T[], arr2: T[], mapper: (item: T) => U): T[] {
-  const map = new Map<U, T>();
-
-  for (const item of [...arr1, ...arr2]) {
-    const key = mapper(item);
-    if (!map.has(key)) {
-      map.set(key, item);
-    }
-  }
-
-  return [...map.values()];
-}

package/src/array/unionWith.spec.ts

@@ -1,23 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { unionWith } from "./unionWith";
-
-describe("unionWith", () => {
-  it("should work with a `comparator`", () => {
-    expect(
-      unionWith(
-        [
-          { x: 1, y: 2 },
-          { x: 2, y: 1 },
-        ],
-        [
-          { x: 1, y: 1 },
-          { x: 1, y: 2 },
-        ],
-        (a, b) => a.x === b.x
-      )
-    ).toEqual([
-      { x: 1, y: 2 },
-      { x: 2, y: 1 },
-    ]);
-  });
-});

package/src/array/unionWith.ts

@@ -1,18 +0,0 @@
-import { uniqWith } from "./uniqWith";
-
-/**
- * `unionWith` function returns the union of multiple arrays passed as arguments. During this process, it removes any duplicated elements.
- *
- * @example
- * ```ts
- * unionWith(
- *   [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }],
- *   [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }],
- *   (x, y) => x === y
- * );
- * // [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
- * ```
- */
-export function unionWith<T>(arr1: T[], arr2: T[], areItemsEqual: (item1: T, item2: T) => boolean): T[] {
-  return uniqWith([...arr1, ...arr2], areItemsEqual);
-}

package/src/array/uniq.spec.ts

@@ -1,8 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { uniq } from "./uniq";
-
-describe("uniq", () => {
-  it("uniq function creates unique elements from the array passed as an argument.", () => {
-    expect(uniq([11, 2, 3, 44, 11, 2, 3])).toEqual([11, 2, 3, 44]);
-  });
-});

package/src/array/uniq.ts

@@ -1,16 +0,0 @@
-/**
- * @name uniq
- * @description
- * `uniq` removes duplicated elements from the array given as an argument.
- *
- * It filters out elements with the same value, so duplicates of data types like Objects are not checked.
- *
- * @example
- * ```ts
- * uniq([1, 1, 2, 3, 5, 5, 7, 'foo', 'bar', 'bar']);
- * // [1, 2, 3, 5, 7, 'foo', 'bar']
- * ```
- */
-export function uniq<T>(arr: T[]): T[] {
-  return Array.from(new Set(arr));
-}

package/src/array/uniqBy.spec.ts

@@ -1,8 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { uniqBy } from "./uniqBy";
-
-describe("uniqBy", () => {
-  it("should work with a `converter`", () => {
-    expect(uniqBy([2.1, 1.2, 2.3], Math.floor)).toEqual([2.1, 1.2]);
-  });
-});

package/src/array/uniqBy.ts

@@ -1,17 +0,0 @@
-import { uniq } from "./uniq";
-import { uniqWith } from "./uniqWith";
-
-/**
- * The `uniqBy` function takes an array as its first argument and a 'converter' function as the second. It maps the array elements using the converter function, then removes any duplicates.
- *
- * It filters out elements with the same value, meaning it does not check for duplicates in data types like Objects.
- *
- * @example
- * ```ts
- * uniqBy([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], Math.floor);
- * // [1.2, 2.1, 3.3, 5.7, 7.19]
- * ```
- */
-export function uniqBy<T, U>(arr: T[], converter: (item: T) => U): T[] {
-  return uniqWith(arr, (item1, item2) => converter(item1) === converter(item2));
-}

package/src/array/uniqWith.spec.ts

@@ -1,16 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { uniqWith } from "./uniqWith";
-
-describe("uniqWith", () => {
-  it("should work with a `comparator`", () => {
-    expect(
-      uniqWith(
-        [
-          { x: 1, y: 2 },
-          { x: 1, y: 3 },
-        ],
-        (a, b) => a.x === b.x
-      )
-    ).toEqual([{ x: 1, y: 2 }]);
-  });
-});

package/src/array/uniqWith.ts

@@ -1,29 +0,0 @@
-import { uniq } from "./uniq";
-
-/**
- * The `uniqWith` function takes an array as its first argument and a 'comparator' function as the second.
- *
- * It evaluates the elements of the array using the comparator function, and if true is returned, it considers those elements as duplicates and removes them.
- *
- * @example
- * ```ts
- * uniqWith([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], (a, b) => );
- * // [1, 2, 3, 5, 7]
- * ```
- */
-export function uniqWith<T>(
-  arr: T[],
-  areItemsEqual: (item1: T, item2: T) => boolean
-): T[] {
-  const result: T[] = [];
-
-  for (const item of arr) {
-    const isUniq = result.every((v) => !areItemsEqual(v, item));
-
-    if (isUniq) {
-      result.push(item);
-    }
-  }
-
-  return result;
-}

package/src/array/xor.spec.ts

@@ -1,13 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { xor } from "./xor"
-
-describe('xor', () => {
-  it('computes the symmetric difference between two arrays', () => {
-    expect(xor([1, 2, 3, 4], [3, 4, 5, 6])).toEqual([1, 2, 5, 6]);
-    expect(xor(['a', 'b'], ['b', 'c'])).toEqual(['a', 'c']);
-    expect(xor([1, 2, 3], [4, 5, 6])).toEqual([1, 2, 3, 4, 5, 6]);
-    expect(xor([1, 2, 3], [1, 2, 3])).toEqual([]);
-    expect(xor([], [1, 2, 3])).toEqual([1, 2, 3]);
-    expect(xor([1, 2, 3], [])).toEqual([1, 2, 3]);
-  })
-})

package/src/array/xor.ts

@@ -1,25 +0,0 @@
-import { difference } from "./difference";
-import { intersection } from "./intersection";
-import { union } from "./union";
-
-/**
- * Computes the symmetric difference between two arrays. The symmetric difference is the set of elements
- * which are in either of the arrays, but not in their intersection.
- *
- * @template T - Type of elements in the input arrays.
- * 
- * @param {T[]} arr1 - The first array.
- * @param {T[]} arr2 - The second array.
- * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both.
- * 
- * @example
- * // Returns [1, 2, 5, 6]
- * xor([1, 2, 3, 4], [3, 4, 5, 6]);
- * 
- * @example
- * // Returns ['a', 'c']
- * xor(['a', 'b'], ['b', 'c']);
- */
-export function xor<T>(arr1: T[], arr2: T[]): T[] {
-  return difference(union(arr1, arr2), intersection(arr1, arr2));
-}

package/src/array/xorBy.spec.ts

@@ -1,16 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { xorBy } from "./xorBy"
-
-describe('xorBy', () => {
-  it('computes the symmetric difference between two arrays using a custom mapping function', () => {
-    const identity = (x: number) => x;
-    const idMapper = (obj: { id: number }) => obj.id;
-
-    expect(xorBy([1, 2, 3, 4], [3, 4, 5, 6], identity)).toEqual([1, 2, 5, 6]);
-    expect(xorBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper)).toEqual([{ id: 1 }, { id: 3 }]);
-    expect(xorBy([1, 2, 3], [4, 5, 6], identity)).toEqual([1, 2, 3, 4, 5, 6]);
-    expect(xorBy([1, 2, 3], [1, 2, 3], identity)).toEqual([]);
-    expect(xorBy([], [1, 2, 3], identity)).toEqual([1, 2, 3]);
-    expect(xorBy([1, 2, 3], [], identity)).toEqual([1, 2, 3]);
-  });
-});

package/src/array/xorBy.ts

@@ -1,29 +0,0 @@
-import { differenceBy } from "./differenceBy";
-import { intersectionBy } from "./intersectionBy";
-import { unionBy } from "./unionBy";
-
-/**
- * Computes the symmetric difference between two arrays using a custom mapping function. 
- * The symmetric difference is the set of elements which are in either of the arrays, 
- * but not in their intersection, determined by the result of the mapping function.
- *
- * @template T - Type of elements in the input arrays.
- * @template U - Type of the values returned by the mapping function.
- * 
- * @param {T[]} arr1 - The first array.
- * @param {T[]} arr2 - The second array.
- * @param {function(item: T): U} mapper - The function to map array elements to comparison values.
- * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the values returned by the mapping function.
- * 
- * @example
- * // Custom mapping function for objects with an 'id' property
- * const idMapper = obj => obj.id;
- * xorBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper);
- * // Returns [{ id: 1 }, { id: 3 }]
- */
-export function xorBy<T, U>(arr1: T[], arr2: T[], mapper: (item: T) => U): T[] {
-  const union = unionBy(arr1, arr2, mapper);
-  const intersection = intersectionBy(arr1, arr2, mapper);
-  
-  return differenceBy(union, intersection, mapper);
-}

package/src/array/xorWith.spec.ts

@@ -1,16 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { xorWith } from "./xorWith"
-
-describe('xorWith', () => {
-  it('computes the symmetric difference between two arrays using a custom equality function', () => {
-    const areNumbersEqual = (a: number, b: number) => a === b;
-    const areObjectsEqual = (a: { id: number }, b: { id: number }) => a.id === b.id;
-
-    expect(xorWith([1, 2, 3, 4], [3, 4, 5, 6], areNumbersEqual)).toEqual([1, 2, 5, 6]);
-    expect(xorWith([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], areObjectsEqual)).toEqual([{ id: 1 }, { id: 3 }]);
-    expect(xorWith([1, 2, 3], [4, 5, 6], areNumbersEqual)).toEqual([1, 2, 3, 4, 5, 6]);
-    expect(xorWith([1, 2, 3], [1, 2, 3], areNumbersEqual)).toEqual([]);
-    expect(xorWith([], [1, 2, 3], areNumbersEqual)).toEqual([1, 2, 3]);
-    expect(xorWith([1, 2, 3], [], areNumbersEqual)).toEqual([1, 2, 3]);
-  })
-})

package/src/array/xorWith.ts

@@ -1,28 +0,0 @@
-import { differenceWith } from "./differenceWith";
-import { intersectionWith } from "./intersectionWith";
-import { unionWith } from "./unionWith";
-
-/**
- * Computes the symmetric difference between two arrays using a custom equality function. 
- * The symmetric difference is the set of elements which are in either of the arrays, 
- * but not in their intersection.
- *
- * @template T - Type of elements in the input arrays.
- * 
- * @param {T[]} arr1 - The first array.
- * @param {T[]} arr2 - The second array.
- * @param {(item1: T, item2: T) => boolean} areElementsEqual - The custom equality function to compare elements.
- * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the custom equality function.
- * 
- * @example
- * // Custom equality function for objects with an 'id' property
- * const areObjectsEqual = (a, b) => a.id === b.id;
- * xorWith([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], areObjectsEqual);
- * // Returns [{ id: 1 }, { id: 3 }]
- */
-export function xorWith<T>(arr1: T[], arr2: T[], areElementsEqual: (item1: T, item2: T) => boolean): T[] {
-  const union = unionWith(arr1, arr2, areElementsEqual);
-  const intersection = intersectionWith(arr1, arr2, areElementsEqual);
-  
-  return differenceWith(union, intersection, areElementsEqual);
-}

package/src/array/zip.spec.ts

@@ -1,14 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { zip } from "./zip"
-
-describe('zip', () => {
-  it('zips multiple arrays to create a tuple', () => {
-    expect(zip([1, 2, 3])).toEqual([[1], [2], [3]]);
-
-    expect(zip([1, 2, 3], ['a', 'b', 'c'])).toEqual([[1, 'a'], [2, 'b'], [3, 'c']]);
-    expect(zip([1, 2, 3], ['a', 'b'])).toEqual([[1, 'a'], [2, 'b'], [3, undefined]]);
-
-    expect(zip([1, 2, 3], ['a', 'b', 'c'], [true, true, false])).toEqual([[1, 'a', true], [2, 'b', true], [3, 'c', false]]);
-    expect(zip([1], ['a'], [true], [null])).toEqual([[1, 'a', true, null]]);
-  })
-})

package/src/array/zip.ts

@@ -1,34 +0,0 @@
-import { zipWith } from "./zipWith";
-
-/**
- * Merges multiple arrays element-wise. Returns an array where each element is an array containing
- * elements from the input arrays at the corresponding index.
- * 
- * @param {T[]} arr1 - The first array to be zipped.
- * @param {T[]} arr2 - The second array to be zipped.
- * @param {T[]} arr3 - The third array to be zipped.
- * @param {T[]} arr4 - The fourth array to be zipped.
- */
-export function zip<T>(arr1: T[]): [T][];
-export function zip<T, U>(arr1: T[], arr2: U[]): [T, U][];
-export function zip<T, U, V>(arr1: T[], arr2: U[], arr3: V[]): [T, U, V][];
-export function zip<T, U, V, W>(arr1: T[], arr2: U[], arr3: V[], arr4: W[]): [T, U, V, W][];
-export function zip<T>(...arrs: T[][]): T[][] {
-  const result: T[][] = [];
-
-  const maxIndex = Math.max(...arrs.map(x => x.length));
-
-  for (let i = 0; i < maxIndex; i++) {
-    const element: T[] = [];
-
-    for (const arr of arrs) {
-      element.push(arr[i]);
-    }
-
-    result.push(element);
-  }
-
-  return result;
-}
-
-

package/src/array/zipWith.spec.ts

@@ -1,13 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { zipWith } from "./zipWith"
-
-describe('zipWith', () => {
-  it('zips multiple arrays with the given combine function', () => {
-    expect(zipWith([1, 2, 3], x => x)).toEqual([1, 2, 3]);
-
-    expect(zipWith([1, 2, 3], ['a', 'b', 'c'], (x, y) => `${x}${y}`)).toEqual(['1a', '2b', '3c']);
-    expect(zipWith([1, 2, 3], ['a', 'b'], (x, y) => `${x}${y}`)).toEqual(['1a', '2b', '3undefined']);
-
-    expect(zipWith([1, 2, 3], ['a', 'b', 'c'], [true, true, false], (x, y, z) => `${x}-${y}-${z}`)).toEqual([`1-a-true`, `2-b-true`, `3-c-false`]);
-  })
-})

package/src/array/zipWith.ts

@@ -1,23 +0,0 @@
-/**
- * Combines multiple arrays element-wise using a provided combining function. 
- * Returns an array where each element is the result of applying the combining function 
- * to the corresponding elements from the input arrays.
- */
-export function zipWith<T, R>(arr1: T[], combine: (item: T) => R): R[];
-export function zipWith<T, U, R>(arr1: T[], arr2: U[], combine: (item1: T, item2: U) => R): R[];
-export function zipWith<T, U, V, R>(arr1: T[], arr2: U[], arr3: V[], combine: (item1: T, item2: U, item3: V) => R): R[];
-export 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 function zipWith<T, R>(arr1: T[], ...rest: any[]): R[] {
-  const arrs = [arr1, ...rest.slice(0, -1)];
-  const combine = rest[rest.length - 1] as (...items: T[]) => R;
-
-  const result: R[] = [];
-  const maxIndex = Math.max(...arrs.map(arr => arr.length));
-
-  for (let i = 0; i < maxIndex; i++) {
-    const elements: T[] = arrs.map(arr => arr[i]);
-    result.push(combine(...elements));
-  }
-
-  return result;
-}

package/src/function/debounce.spec.ts

@@ -1,76 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { debounce } from './debounce'; // adjust the import path as necessary
-import { delay } from '../promise';
-
-describe('debounce', () => {
-  it('should debounce function calls', async () => {
-    const func = vi.fn();
-    const waitMs = 50;
-    const debouncedFunc = debounce(func, waitMs);
-
-    debouncedFunc();
-    debouncedFunc();
-    debouncedFunc();
-
-    await delay(waitMs * 2)
-
-    expect(func).toHaveBeenCalledTimes(1);
-  });
-
-  it('should delay the function call by the specified wait time', async () => {
-    const func = vi.fn();
-    const waitMs = 50;
-    const debouncedFunc = debounce(func, waitMs);
-
-    debouncedFunc();
-    await delay(waitMs / 2);
-    expect(func).not.toHaveBeenCalled();
-
-    await delay(waitMs / 2 + 1);
-    expect(func).toHaveBeenCalledTimes(1);
-  });
-
-  it('should reset the wait time if called again before wait time ends', async () => {
-    const func = vi.fn();
-    const waitMs = 50;
-    const debouncedFunc = debounce(func, waitMs);
-
-    debouncedFunc();
-    await delay(waitMs / 2);
-    debouncedFunc();
-    await delay(waitMs / 2);
-    debouncedFunc();
-    await delay(waitMs / 2);
-    debouncedFunc();
-
-    expect(func).not.toHaveBeenCalled();
-
-    await delay(waitMs + 1);
-    expect(func).toHaveBeenCalledTimes(1);
-  });
-
-  it('should cancel the debounced function call', async () => {
-    const func = vi.fn();
-    const waitMs = 50;
-    const debouncedFunc = debounce(func, waitMs);
-
-    debouncedFunc();
-    debouncedFunc.cancel();
-    await delay(waitMs);
-
-    expect(func).not.toHaveBeenCalled();
-  });
-
-  it('should work correctly if the debounced function is called after the wait time', async () => {
-    const func = vi.fn();
-    const waitMs = 50;
-    const debouncedFunc = debounce(func, waitMs);
-
-    debouncedFunc();
-    await delay(waitMs + 1);
-    debouncedFunc();
-    await delay(waitMs + 1);
-
-    expect(func).toHaveBeenCalledTimes(2);
-  });
-});

package/src/function/debounce.ts

@@ -1,42 +0,0 @@
-/**
- * Creates a debounced function that delays invoking the provided function until after `waitMs` 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} waitMs - 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();
- */
-export function debounce(func: () => void, waitMs: number) {
-  let timeoutId: number | NodeJS.Timeout | null = null;
-
-  const debounced = function () {
-    if (timeoutId != null) {
-      clearTimeout(timeoutId);
-    }
-    
-    
-    timeoutId = setTimeout(() => {
-      func();
-    }, waitMs);
-  };
-
-  debounced.cancel = function () {
-    if (timeoutId != null) {
-      clearTimeout(timeoutId);
-    }
-  }  
-
-  return debounced;
-}

package/src/function/index.ts

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