es-toolkit 0.0.1

package/src/array/take.ts

@@ -0,0 +1,25 @@
+/**
+ * Returns a new array containing the first `count` elements from the input array `arr`.
+ * If `count` is greater than the length of `arr`, the entire array is returned.
+ *
+ * @template T - Type of elements in the input array.
+ * 
+ * @param {T[]} arr - The array to take elements from.
+ * @param {number} count - The number of elements to take.
+ * @returns {T[]} A new array containing the first `count` elements from `arr`.
+ * 
+ * @example
+ * // Returns [1, 2, 3]
+ * take([1, 2, 3, 4, 5], 3);
+ * 
+ * @example
+ * // Returns ['a', 'b']
+ * take(['a', 'b', 'c'], 2);
+ * 
+ * @example
+ * // Returns [1, 2, 3]
+ * take([1, 2, 3], 5);
+ */
+export function take<T>(arr: T[], count: number) {
+  return arr.slice(0, count);
+}

package/src/array/takeRight.spec.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest"
+import { takeRight } from "./takeRight"
+
+describe('takeRight', () => {
+  it('returns the last n elements from the array', () => {
+    expect(takeRight([1, 2, 3, 4, 5], 2)).toEqual([4, 5]);
+    expect(takeRight(['a', 'b', 'c', 'd'], 2)).toEqual(['c', 'd']);
+    expect(takeRight([true, false, true], 1)).toEqual([true]);
+    expect(takeRight([1, 2, 3], 5)).toEqual([1, 2, 3]);
+    expect(takeRight([1, 2, 3], 0)).toEqual([]);
+    expect(takeRight([], 3)).toEqual([]);
+  });
+
+  it('handles cases where count is greater than array length', () => {
+    expect(takeRight([1, 2, 3], 5)).toEqual([1, 2, 3]);
+  });
+
+  it('handles cases where count is zero', () => {
+    expect(takeRight([1, 2, 3], 0)).toEqual([]);
+  });
+
+  it('handles empty arrays', () => {
+    expect(takeRight([], 3)).toEqual([]);
+  });
+});

package/src/array/takeRight.ts

@@ -0,0 +1,29 @@
+/**
+ * Returns a new array containing the last `count` elements from the input array `arr`.
+ * If `count` is greater than the length of `arr`, the entire array is returned.
+ *
+ * @template T - Type of elements in the input array.
+ * 
+ * @param {T[]} arr - The array to take elements from.
+ * @param {number} count - The number of elements to take.
+ * @returns {T[]} A new array containing the last `count` elements from `arr`.
+ * 
+ * @example
+ * // Returns [4, 5]
+ * takeRight([1, 2, 3, 4, 5], 2);
+ * 
+ * @example
+ * // Returns ['b', 'c']
+ * takeRight(['a', 'b', 'c'], 2);
+ * 
+ * @example
+ * // Returns [1, 2, 3]
+ * takeRight([1, 2, 3], 5);
+ */
+export function takeRight<T>(arr: T[], count: number) {
+  if (count === 0) {
+    return [];
+  }
+
+  return arr.slice(-count);
+}

package/src/array/takeRightWhile.spec.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest"
+import { takeRightWhile } from "./takeRightWhile"
+
+describe('takeRightWhile', () => {
+  it('returns elements from the end while the predicate returns true', () => {
+    expect(takeRightWhile([5, 4, 3, 2, 1], n => n < 4)).toEqual([3, 2, 1]);
+    expect(takeRightWhile([1, 2, 3], n => n > 3)).toEqual([]);
+    expect(takeRightWhile([1, 2, 3, 4, 5], n => n > 2)).toEqual([3, 4, 5]);
+    expect(takeRightWhile([1, 2, 3, 4, 5], n => n < 6)).toEqual([1, 2, 3, 4, 5]);
+    expect(takeRightWhile([], n => n < 6)).toEqual([]);
+  });
+
+  it('handles empty arrays', () => {
+    expect(takeRightWhile([], n => n < 6)).toEqual([]);
+  });
+});

package/src/array/takeRightWhile.ts

@@ -0,0 +1,26 @@
+/**
+ * Takes elements from the end of the array while the predicate function returns `true`.
+ * 
+ * @template T - Type of elements in the input array.
+ * 
+ * @param {T[]} arr - The array to take elements from.
+ * @param {function(T): boolean} shouldContinueTaking - The function invoked per element.
+ * @returns {T[]} A new array containing the elements taken from the end while the predicate returns `true`.
+ * 
+ * @example
+ * // Returns [3, 2, 1]
+ * takeRightWhile([5, 4, 3, 2, 1], n => n < 4);
+ * 
+ * @example
+ * // Returns []
+ * takeRightWhile([1, 2, 3], n => n > 3);
+ */
+export function takeRightWhile<T>(arr: T[], shouldContinueTaking: (item: T) => boolean): T[] {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (!shouldContinueTaking(arr[i])) {
+      return arr.slice(i + 1);
+    }
+  }
+
+  return arr.slice();
+}

package/src/array/takeWhile.spec.ts

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,31 @@
+/**
+ * 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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,35 @@
+/**
+ * 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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,16 @@
+/**
+ * @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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,23 @@
+/**
+ * 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;
+}