es-toolkit 0.0.1 → 1.0.0-dev.19

package/coverage/.tmp/coverage-9.json

@@ -1 +0,0 @@
-{"/Users/raon0211/dev/js-utils/src/array/intersectionWith.ts":{"path":"/Users/raon0211/dev/js-utils/src/array/intersectionWith.ts","statementMap":{"0":{"start":{"line":2,"column":2},"end":{"line":6,"column":5}},"1":{"start":{"line":3,"column":4},"end":{"line":5,"column":7}},"2":{"start":{"line":4,"column":6},"end":{"line":4,"column":50}}},"fnMap":{"0":{"name":"intersectionWith","decl":{"start":{"line":1,"column":16},"end":{"line":1,"column":32}},"loc":{"start":{"line":1,"column":69},"end":{"line":7,"column":1}},"line":1},"1":{"name":"(anonymous_1)","decl":{"start":{"line":2,"column":25},"end":{"line":2,"column":26}},"loc":{"start":{"line":2,"column":40},"end":{"line":6,"column":3}},"line":2},"2":{"name":"(anonymous_2)","decl":{"start":{"line":3,"column":26},"end":{"line":3,"column":27}},"loc":{"start":{"line":3,"column":42},"end":{"line":5,"column":5}},"line":3}},"branchMap":{},"s":{"0":2,"1":4,"2":6},"f":{"0":2,"1":4,"2":6},"b":{},"inputSourceMap":{"version":3,"sources":["/Users/raon0211/dev/js-utils/src/array/intersectionWith.ts"],"sourcesContent":["/**\n * @name intersectionWith\n * @description\n * Returns the intersection of two arrays. The identity of two elements is compared with `areItemsEqual`.\n * @param firstArr The first array to get the intersection\n * @param secondArr The second array to get the intersection\n * @param mapper The function to compare the identity of two elements\n * @example\n * intersectionWith([1.2, 2.1], [1.4, 3.1], (x, y) => Math.floor(x) === Math.floor(y)) === [1.2]\n * intersectionWith([{ foo: 1 }, { foo: 2 }], [{ foo: 1 }, { foo: 3 }], (x, y) => x.foo === y.foo) === [{ foo: 1 }]\n */\nexport function intersectionWith<T>(firstArr: T[], secondArr: T[], areItemsEqual: (x: T, y: T) => boolean) {\n  return firstArr.filter(firstItem => {\n    return secondArr.some(secondItem => {\n      return areItemsEqual(firstItem, secondItem);\n    });\n  });\n}"],"mappings":"AAWO,gBAAS,iBAAoB,UAAe,WAAgB,eAAwC;AACzG,SAAO,SAAS,OAAO,eAAa;AAClC,WAAO,UAAU,KAAK,gBAAc;AAClC,aAAO,cAAc,WAAW,UAAU;AAAA,IAC5C,CAAC;AAAA,EACH,CAAC;AACH;","names":[]},"_coverageSchema":"1a1c01bbd47fc00a2c39e90264f33305004495a9","hash":"0548ef75075d65c1d72742e7787cfccbca9a954d"}}

package/rollup.config.js

@@ -1,5 +0,0 @@
-const { generateRollupConfig } = require('@toss/rollup-config');
-
-module.exports = generateRollupConfig({
-  packageDir: __dirname,
-});

package/src/array/chunk.spec.ts

@@ -1,27 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { chunk } from './chunk';
-
-describe('chunk', () => {
-  it('should return an empty array when the input array is empty', () => {
-    expect(chunk([], 3)).toEqual([]);
-  });
-
-  it('should throw if the size is not an integer of is less than 1', () => {
-    expect(() => chunk([1, 2, 3], 0)).toThrowErrorMatchingInlineSnapshot(`[Error: Size must be an integer greater than zero.]`);
-    expect(() => chunk([1, 2, 3], -1)).toThrowErrorMatchingInlineSnapshot(`[Error: Size must be an integer greater than zero.]`)
-    expect(() => chunk([1, 2, 3], 0.5)).toThrowErrorMatchingInlineSnapshot(`[Error: Size must be an integer greater than zero.]`)
-    expect(() => chunk([1, 2, 3], Math.PI)).toThrowErrorMatchingInlineSnapshot(`[Error: Size must be an integer greater than zero.]`)
-  });
-
-  it('should evenly divide all elements into chunks of the specified size when the total length is a multiple of the size', () => {
-    expect(chunk([1, 2, 3, 4, 5, 6], 3)).toEqual([
-      [1, 2, 3],
-      [4, 5, 6],
-    ]);
-  });
-
-  it('should place the remaining elements in the last chunk when the total length is not a multiple of the size', () => {
-    expect(chunk([1, 2, 3, 4], 6)).toEqual([[1, 2, 3, 4]]);
-    expect(chunk([1, 2, 3, 4, 5, 6, 7], 2)).toEqual([[1, 2], [3, 4], [5, 6], [7]]);
-  });
-});

package/src/array/chunk.ts

@@ -1,24 +0,0 @@
-/**
- * @name chunk
- * Separate an array into smaller arrays of length `size`.
- * If the array cannot be separated in equal size, the final sub-array will have the remaining elements.
- * @param arr The array to chunk
- * @param size The size of smaller arrays
- */
-export function chunk<T>(arr: T[], size: number): T[][] {
-  if (!Number.isInteger(size) || size <= 0) {
-    throw new Error(`Size must be an integer greater than zero.`)
-  }
-  
-  const result: T[][] = [];
-  
-  for (const [index, item] of arr.entries()) {
-    if (index % size === 0) {
-      result.push([]);
-    }
-
-    result[result.length - 1].push(item);
-  }
-
-  return result;
-}

package/src/array/difference.spec.ts

@@ -1,10 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { difference } from './difference';
-
-describe('difference', () => {
-  it('should the difference of two arrays', () => {
-    expect(difference([1, 2, 3], [1])).toEqual([2, 3]);
-    expect(difference([], [1, 2, 3])).toEqual([]);
-    expect(difference([1, 2, 3, 4], [2, 4])).toEqual([1, 3]);
-  });
-});

package/src/array/difference.ts

@@ -1,11 +0,0 @@
-/**
- * @name difference
- * Returns the difference of two arrays.
- * @param firstArr The array to get the difference from
- * @param secondArr The elements to exclude from `firstArr`
- */
-export function difference<T>(firstArr: T[], secondArr: T[]): T[] {
-  return firstArr.filter(item => {
-    return !secondArr.includes(item)
-  });
-}

package/src/array/differenceBy.spec.ts

@@ -1,9 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { differenceBy } from './differenceBy';
-
-describe('differenceBy', () => {
-  it('should the difference of two arrays using the `mapper` function', () => {
-    expect(differenceBy([1.2, 2.3, 3.4], [1.2], Math.floor)).toEqual([2.3, 3.4]);
-    expect(differenceBy([], [1.2], Math.floor)).toEqual([]);
-  });
-});

package/src/array/differenceBy.ts

@@ -1,14 +0,0 @@
-/**
- * @name differenceBy
- * Returns the difference of two arrays. The identity of two elements is calculated after the elements are mapped with `mapper`.
- * @param firstArr The array to get the difference from
- * @param secondArr The elements to exclude from `firstArr`
- * @param mapper The function to map the elements when calculating the difference
- */
-export function differenceBy<T, U>(firstArr: T[], secondArr: T[], mapper: (value: T) => U): T[] {
-  const mappedSecondArr = secondArr.map(item => mapper(item));
-  
-  return firstArr.filter(item => {
-    return !mappedSecondArr.includes(mapper(item));
-  });
-}

package/src/array/differenceWith.spec.ts

@@ -1,8 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { differenceWith } from './differenceWith';
-
-describe('differenceWith', () => {
-  it('should the difference of two arrays using the `areItemsEqual` function', () => {
-    expect(differenceWith([1.2, 2.3, 3.4], [1.2], (x, y) => Math.floor(x) === Math.floor(y))).toEqual([2.3, 3.4]);
-  });
-});

package/src/array/differenceWith.ts

@@ -1,14 +0,0 @@
-/**
- * @name differenceWith
- * Returns the difference of two arrays. The identity of two elements is calculated with the function `areItemsEqual`.
- * @param firstArr The array to get the difference from
- * @param secondArr The elements to exclude from `firstArr`
- * @param areItemsEqual The function to determine whether two items are equal
- */
-export function differenceWith<T>(firstArr: T[], secondArr: T[], areItemsEqual: (x: T, y: T) => boolean): T[] {
-  return firstArr.filter(firstItem => {
-    return secondArr.every(secondItem => {
-      return !areItemsEqual(firstItem, secondItem);
-    })
-  })
-}

package/src/array/drop.spec.ts

@@ -1,9 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { drop } from './drop';
-
-describe('drop', () => {
-  it('should drop `itemsCount` elements from an array from the beginning', () => {
-    expect(drop([1.2, 2.3, 3.4], 1)).toEqual([2.3, 3.4]);
-    expect(drop(['a', 'b', 'c', 'd'], 2)).toEqual(['c', 'd']);
-  });
-});

package/src/array/drop.ts

@@ -1,9 +0,0 @@
-/**
- * @name drop
- * Drop some elements from an array from the beginning. This function returns a new array.
- * @param arr The element to drop items from the beginning
- * @param itemsCount The amount of elements to drop
- */
-export function drop<T>(arr: T[], itemsCount: number) {
-  return arr.slice(itemsCount);
-}

package/src/array/dropRight.spec.ts

@@ -1,9 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { dropRight } from './dropRight';
-
-describe('dropRight', () => {
-  it('should drop `itemsCount` elements from an array from the end', () => {
-    expect(dropRight([1.2, 2.3, 3.4], 1)).toEqual([1.2, 2.3]);
-    expect(dropRight(['a', 'b', 'c', 'd'], 2)).toEqual(['a', 'b']);
-  });
-});

package/src/array/dropRight.ts

@@ -1,9 +0,0 @@
-/**
- * @name dropRight
- * Drop some elements from an array from the end. This function returns a new array.
- * @param arr The element to drop items from the end
- * @param itemsCount The amount of elements to drop
- */
-export function dropRight<T>(arr: T[], itemsCount: number) {
-  return arr.slice(0, -itemsCount);
-}

package/src/array/dropRightWhile.spec.ts

@@ -1,16 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { dropRightWhile } from './dropRightWhile';
-
-describe('dropRightWhile', () => {
-  it('should drop elements from an array until `canContinueDropping` returns false, from the end', () => {
-    expect(dropRightWhile([1.2, 2.3, 3.4], x => x < 2)).toEqual([1.2, 2.3, 3.4]);
-
-    const items = [{ id: 1, enabled: false }, { id: 2, enabled: true }, { id: 3, enabled: false }];
-
-    expect(dropRightWhile(items, x => !x.enabled)).toEqual([{
-      id: 1, enabled: false
-    }, {
-      id: 2, enabled: true
-    }]);
-  });
-});

package/src/array/dropRightWhile.ts

@@ -1,13 +0,0 @@
-import { dropWhile } from "./dropWhile";
-
-/**
- * @name dropRightWhile
- * Drop some elements from an array from the end, until `predicate` returns false.
- * @param arr The element to drop items from the end
- * @param canContinueDropping The predicate to check if the function can continue dropping elements.
- */
-export function dropRightWhile<T>(arr: T[], canContinueDropping: (item: T) => boolean) {
-  const reversed = arr.slice().reverse();
-  const dropped = dropWhile(reversed, canContinueDropping);
-  return dropped.slice().reverse();
-}

package/src/array/dropWhile.spec.ts

@@ -1,14 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { dropWhile } from './dropWhile';
-
-describe('dropWhile', () => {
-  it('should drop elements from an array until `canContinueDropping` returns false, from the beginning', () => {
-    expect(dropWhile([1.2, 2.3, 3.4], x => x < 2)).toEqual([2.3, 3.4]);
-
-    const items = [{ id: 1, enabled: false }, { id: 2, enabled: true }, { id: 3, enabled: false }];
-
-    expect(dropWhile(items, x => !x.enabled)).toEqual([{
-      id: 2, enabled: true
-    }, { id: 3, enabled: false }]);
-  });
-});

package/src/array/dropWhile.ts

@@ -1,10 +0,0 @@
-/**
- * @name dropWhile
- * Drop some elements from an array from the beginning, until `predicate` returns false.
- * @param arr The element to drop items from the beginning
- * @param canContinueDropping The predicate to check if the function can continue dropping elements.
- */
-export function dropWhile<T>(arr: T[], canContinueDropping: (item: T) => boolean) {
-  const dropEndIndex = arr.findIndex(item => !canContinueDropping(item));
-  return arr.slice(dropEndIndex);
-}

package/src/array/groupBy.ts

@@ -1,3 +0,0 @@
-export function groupBy() {
-  throw new Error('Not implemented');
-}

package/src/array/index.ts

@@ -1,30 +0,0 @@
-export { chunk } from './chunk';
-export { difference } from './difference';
-export { differenceBy } from './differenceBy';
-export { differenceWith } from './differenceWith';
-export { drop } from './drop';
-export { dropRight } from './dropRight';
-export { dropRightWhile } from './dropRightWhile';
-export { dropWhile } from './dropWhile';
-export { groupBy } from './groupBy';
-export { intersection } from './intersection';
-export { intersectionBy } from './intersectionBy';
-export { intersectionWith } from './intersectionWith';
-export { partition } from './partition';
-export { sample } from './sample';
-export { shuffle } from './shuffle';
-export { take } from './take';
-export { takeRight } from './takeRight';
-export { takeRightWhile } from './takeRightWhile';
-export { takeWhile } from './takeWhile';
-export { union } from './union';
-export { unionBy } from './unionBy';
-export { unionWith } from './unionWith';
-export { uniq } from './uniq';
-export { uniqBy } from './uniqBy';
-export { uniqWith } from './uniqWith';
-export { xor } from './xor';
-export { xorBy } from './xorBy';
-export { xorWith } from './xorWith';
-export { zip } from './zip';
-export { zipWith } from './zipWith';

package/src/array/intersection.spec.ts

@@ -1,11 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { intersection } from './intersection';
-
-describe('intersection', () => {
-  it('should return the intersection of two arrays', () => {
-    expect(intersection([1, 2], [1, 3])).toEqual([1]);
-    expect(intersection([1, 2], [3, 1])).toEqual([1]);
-    expect(intersection([1, 2], [3, 4])).toEqual([]);
-    expect(intersection([], [1, 2])).toEqual([]);
-  });
-})

package/src/array/intersection.ts

@@ -1,15 +0,0 @@
-/**
- * @name intersection
- * @description
- * Returns the intersection of two arrays.
- * @param firstArr The first array to get the intersection
- * @param secondArr The second array to get the intersection
- * @example
- * intersection([1, 2], [1, 3]) === [1]
- * intersection([1, 2, 3], [2, 3, 4]) === [2, 3]
- */
-export function intersection<T>(firstArr: T[], secondArr: T[]): T[] {
-  return firstArr.filter(item => {
-    return secondArr.includes(item);
-  });
-}

package/src/array/intersectionBy.spec.ts

@@ -1,9 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { intersectionBy } from './intersectionBy';
-
-describe('intersectionBy', () => {
-  it('should return the intersection of two arrays with `mapper`', () => {
-    expect(intersectionBy([1.2, 2.1], [1.4, 3.1], Math.floor)).toStrictEqual([1.2]);
-    expect(intersectionBy([{ foo: 1 }, { foo: 2 }], [{ foo: 1 }, { foo: 3 }], x => x.foo)).toStrictEqual([{ foo: 1 }]);
-  });
-})

package/src/array/intersectionBy.ts

@@ -1,18 +0,0 @@
-/**
- * @name intersectionBy
- * @description
- * Returns the intersection of two arrays. The identity of two elements is calculated after the elements are mapped with `mapper`.
- * @param firstArr The first array to get the intersection
- * @param secondArr The second array to get the intersection
- * @param mapper The function to map the elements when calculating the intersection
- * @example
- * intersectionBy([1.2, 2.1], [1.4, 3.1], Math.floor) === [1.2]
- * intersectionBy([{ foo: 1 }, { foo: 2 }], [{ foo: 1 }, { foo: 3 }], x => x.foo) === [{ foo: 1 }]
- */
-export function intersectionBy<T, U>(firstArr: T[], secondArr: T[], mapper: (item: T) => U): T[] {
-  const mappedSecondArr = secondArr.map(x => mapper(x));
-  
-  return firstArr.filter(item => {
-    return mappedSecondArr.includes(mapper(item));
-  })
-}

package/src/array/intersectionWith.spec.ts

@@ -1,9 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { intersectionWith } from './intersectionWith';
-
-describe('intersectionWith', () => {
-  it('should return the intersection of two arrays with `mapper`', () => {
-    expect(intersectionWith([1.2, 2.1], [1.4, 3.1], (x, y) => Math.floor(x) === Math.floor(y))).toStrictEqual([1.2]);
-    expect(intersectionWith([{ foo: 1 }, { foo: 2 }], [{ foo: 1 }, { foo: 3 }], (x, y) => x.foo === y.foo)).toStrictEqual([{ foo: 1 }]);
-  });
-})

package/src/array/intersectionWith.ts

@@ -1,18 +0,0 @@
-/**
- * @name intersectionWith
- * @description
- * Returns the intersection of two arrays. The identity of two elements is compared with `areItemsEqual`.
- * @param firstArr The first array to get the intersection
- * @param secondArr The second array to get the intersection
- * @param areItemsEqual The function to compare the identity of two elements
- * @example
- * intersectionWith([1.2, 2.1], [1.4, 3.1], (x, y) => Math.floor(x) === Math.floor(y)) === [1.2]
- * intersectionWith([{ foo: 1 }, { foo: 2 }], [{ foo: 1 }, { foo: 3 }], (x, y) => x.foo === y.foo) === [{ foo: 1 }]
- */
-export function intersectionWith<T>(firstArr: T[], secondArr: T[], areItemsEqual: (x: T, y: T) => boolean) {
-  return firstArr.filter(firstItem => {
-    return secondArr.some(secondItem => {
-      return areItemsEqual(firstItem, secondItem);
-    });
-  });
-}

package/src/array/partition.spec.ts

@@ -1,23 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { partition } from './partition';
-
-describe('partition', () => {
-  it('creates two arrays: the first array includes items for which isInTruthy returns true, and the second array includes items for which isInTruthy returns false.', () => {
-    expect(partition([true, true, false], x => x)).toEqual([[true, true], [false]])
-    expect(partition([
-      { id: 1, enabled: true },
-      { id: 2, enabled: false },
-      { id: 3, enabled: false },
-      { id: 4, enabled: true },
-    ], x => x.enabled)).toEqual([
-      [
-        { id: 1, enabled: true },
-        { id: 4, enabled: true },
-      ],
-      [
-        { id: 2, enabled: false },
-        { id: 3, enabled: false },
-      ]
-    ])
-  });
-})

package/src/array/partition.ts

@@ -1,21 +0,0 @@
-/**
- * @name partition
- * @description
- * Creates two arrays: the first array includes items for which isInTruthy returns true, and the second array includes items for which isInTruthy returns false.
- * @param arr The array to split into two arrays
- * @param isInTruthy The predicate to tell whether an item is included in the first array
- */
-export function partition<T>(arr: T[], isInTruthy: (value: T) => boolean): [truthy: T[], falsy: T[]] {
-  const truthy: T[] = [];
-  const falsy: T[] = [];
-
-  for (const item of arr) {
-    if (isInTruthy(item)) {
-      truthy.push(item)
-    } else {
-      falsy.push(item)
-    }
-  }
-
-  return [truthy, falsy];
-}

package/src/array/sample.spec.ts

@@ -1,11 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { partition } from './partition';
-import { sample } from './sample';
-
-describe('sample', () => {
-  it('selects a random element from an array', () => {
-    const arr = [1, 2, 3, 4, 5];
-    
-    expect(arr.includes(sample(arr))).toBe(true);
-  });
-})

package/src/array/sample.ts

@@ -1,10 +0,0 @@
-/**
- * @name sample
- * @description
- * Returns a random element from an array.
- * @param arr The element to get a random element
- */
-export function sample<T>(arr: T[]): T {
-  const randomIndex = Math.floor(Math.random() * arr.length)
-  return arr[randomIndex];
-}

package/src/array/shuffle.spec.ts

@@ -1,11 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { sample } from './sample';
-import { shuffle } from './shuffle';
-
-describe('shuffle', () => {
-  it('randomizes the order of an array', () => {
-    const arr = [1, 2, 3, 4, 5];
-    
-    expect(shuffle(arr).slice().sort()).toEqual(arr.slice().sort());
-  });
-})

package/src/array/shuffle.ts

@@ -1,18 +0,0 @@
-/**
- * @name shuffle
- * @description
- * Randomize the order of an array.
- * @param arr The array to shuffle
- */
-export function shuffle<T>(arr: T[]): T[] {
-  /**
-   * https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm
-   */
-  for (let i = arr.length - 1; i >= 1; i--) {
-    const j = Math.floor(Math.random() * i);
-    
-    [arr[i], arr[j]] = [arr[j], arr[i]];
-  }
-
-  return arr;
-}

package/src/array/take.spec.ts

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

package/src/array/take.ts

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

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

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

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

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