moderndash 0.0.6 → 0.0.8

package/README.md

@@ -0,0 +1,92 @@
+![ModernDash Logo](/website/src/assets/moderndashLogo.svg)
+
+<p align=center>
+  A Typescript-First utility library inspired by Lodash.
+  Optimized for modern browsers.
+</p>
+<p align=center>
+  ✅ ESM
+  ✅ Tree-shakable
+  ✅ Typescript Strict Mode (no any types)
+  ✅ Zero dependencies
+</p>
+
+-------
+
+> **Warning**
+> This library is still in development and is not ready for production use.
+
+## Documentation
+The documentation is WIP.
+
+## Removed Functions because of trivial native alternatives
+Look at [You-Dont-Need-Lodash](https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore) for native replacements.
+
+### Array Functions
+- compact
+- concat
+- differenceBy property shorthand
+- drop
+- dropRight
+- fill
+- findIndex
+- findLastIndex
+- first/head
+- flatten
+- flattenDeep
+- flattenDepth
+- fromPairs
+- initial
+- join
+- last
+- lastIndexOf
+- nth
+- without
+- reverse
+- slice
+- sortedIndexOf
+- tail
+- take
+- takeRight
+- without
+
+### Collection Functions
+- each/forEach
+- every
+- filter
+- find
+- flatMap
+- includes
+
+### String Functions
+- lowerCase
+- trim
+- trimEnd
+- trimStart
+- pad
+- padEnd
+- padStart
+
+Functions are not considered trivial if they:
+ - include reduce methods
+ - include multiple nested function calls
+
+## TODO
+- More unzip tests
+- Check if flatmapdeep, flatmapDepth is included in native flatmap
+- GroupBy Property Shorthand
+
+## Might be added later (open for discussion)
+- pull functions (pull, pullAll, pullAllBy, pullAllWith, pullAt)
+- remove
+- sorted functions (sortedIndex, sortedIndexBy, sortedIndexOf, sortedLastIndex, sortedLastIndexBy, sortedLastIndexOf, sortedUniq, sortedUniqBy)
+  - if performance is better than native alternatives (testing needed)
+- xor functions (xor, xorBy, xorWith)
+- zipObject, zipObjectDeep
+- forEachRight
+- findLast
+- lowerFirst
+- keyBy
+
+## Continue at
+ - invokeMap

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "moderndash",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "type": "module",
   "description": "A lodash inspired utility framework for ESM/Typescript/ES2020",
   "scripts": {
     "build": "ctix create ----startAt src --overwrite --noBackup & tsup",
-    "prepublishOnly": "npm run build && @powershell cp '../README.md' './dist/README.md'",
+    "prepublishOnly": "npm run build && @powershell cp '../README.md' './README.md'",
+    "postpublish": "@powershell rm './README.md'",
     "test": "vitest",
     "test-ui": "vitest --ui"
   },

package/.ctiignore

@@ -1,3 +0,0 @@
-{
-  "src/helpers": "*",
-}

package/test/.eslintrc.cjs

@@ -1,5 +0,0 @@
-module.exports = {
-    rules: {
-        "unicorn/consistent-function-scoping": "off"
-    }
-}

package/test/array/chunk.test.ts

@@ -1,19 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { chunk } from '@array/chunk';
-
-describe('Chunk', () => {
-    const array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-
-    it('should chunk an array', () => {
-        expect(chunk(2, array)).toEqual([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]);
-    });
-
-    it('should return the last chunk as remaining elements', () => {
-        expect(chunk(3, array)).toEqual([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]);
-    });
-
-    it('should coerce `size` to an integer', () => {
-        expect(chunk(array.length / 4, array)).toEqual([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]);
-    });
-});

package/test/array/differenceMethods.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { difference } from '@array/difference';
-import { differenceBy } from '@array/differenceBy';
-import { differenceWith } from '@array/differenceWith';
-
-describe('difference', () => {
-    it('should return the difference between two arrays', () => {
-        const array1 = [1, undefined, null, NaN, 3, 4, 5];
-        const array2 = [2, 4, undefined, NaN, null, 8];
-        const result = difference(array1, array2);
-        expect(result).toEqual([1, NaN, 3, 5]);
-    });
-});
-
-describe('differenceBy', () => {
-    it('should return match based on input function', () => {
-        expect(differenceBy(Math.floor, [2.1, 1.2], [2.3, 3.4], [99])).toEqual([1.2]);
-    });
-});
-
-
-describe('differenceWith', () => {
-    it('should return an array containing the elements that are present in the first array but not in the other arrays', () => {
-        const array1 = [1, 2, 3, 4];
-        const array2 = [2, 3, 5, 6];
-        const array3 = [3, 4, 5, 6];
-
-        const difference = differenceWith((a, b) => a === b, array1, array2, array3);
-        expect(difference).toEqual([1]);
-    });
-
-    it('should return an empty array if no elements are present in the first array but not in the other arrays', () => {
-        const array1 = [1, 2, 3, 4];
-        const array2 = [1, 2];
-        const array3 = [3, 4];
-
-        const difference = differenceWith((a, b) => a === b, array1, array2, array3);
-        expect(difference).toEqual([]);
-    });
-
-    it('should return the first array if no elements are present in the other arrays', () => {
-        const array1 = [1, 2, 3, 4];
-        const array2: number[] = [];
-
-        const difference = differenceWith((a, b) => a === b, array1, array2);
-        expect(difference).toEqual(array1);
-    });
-});

package/test/array/dropMethods.test.ts

@@ -1,30 +0,0 @@
-import { it, expect, describe } from 'vitest';
-
-import { dropRightWhile } from '@array/dropRightWhile';
-import { dropWhile } from '@array/dropWhile';
-
-const array = [2, 4, 5, 6];
-
-describe('dropWhile', () => {
-    it('removes elements from the start of the array until the predicate returns false', () => {
-        expect(dropWhile(x => x % 2 === 0, array)).toEqual([5, 6]);
-    });
-
-    it('returns an empty array if the predicate always returns true', () => {
-        expect(dropWhile(() => true, array)).toEqual([]);
-    });
-
-    it('returns the original array if the predicate always returns false', () => {
-        expect(dropWhile(() => false, array)).toEqual(array);
-    });
-
-    it('returns an empty array if the input array is empty', () => {
-        expect(dropWhile(() => true, [])).toEqual([]);
-    });
-});
-
-describe('dropRightWhile', () => {
-    it('should drop elements while `predicate` returns truthy', () => {
-        expect(dropRightWhile(n => n > 4, array)).toEqual([2, 4]);
-    });
-});

package/test/array/intersectionMethods.test.ts

@@ -1,36 +0,0 @@
-import { expect, it, describe } from 'vitest';
-
-import { intersection } from '@array/intersection';
-import { intersectionBy } from '@array/intersectionBy';
-import { intersectionWith } from '@array/intersectionWith';
-
-describe('intersection', () => {
-    it('returns the correct intersections', () => {
-        const arr1 = [1, 2, 3, 4, 5];
-        const arr2 = [3, 4, 5, 6, 7];
-
-        const result = intersection(arr1, arr2);
-        expect(result).toEqual([3, 4, 5]);
-    });
-});
-
-describe('intersectionBy', () => {
-    it('returns the correct intersections', () => {
-        const arr1 = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }];
-        const arr2 = [{ id: 3 }, { id: 4 }, { id: 5 }, { id: 6 }, { id: 7 }];
-
-        const result = intersectionBy(value => value.id, arr1, arr2);
-        expect(result).toEqual([{ id: 3 }, { id: 4 }, { id: 5 }]);
-    });
-});
-
-
-describe('intersectionWith', () => {
-    it('returns the correct intersections', () => {
-        const arr1 = [1, 2, 3, 4, 5];
-        const arr2 = [3, 4, 5, 6, 7];
-
-        const result = intersectionWith((a, b) => a % 2 === 0 && a === b, arr1, arr2);
-        expect(result).toEqual([4]);
-    });
-});

package/test/array/shuffle.test.ts

@@ -1,17 +0,0 @@
-import { test, describe, expect } from 'vitest';
-
-import { shuffle } from '@array/shuffle';
-
-describe('shuffle', () => {
-    test('should shuffle the elements of the array', () => {
-        const array = [1, 2, 3, 4, 5];
-        const shuffledArray = shuffle(array);
-        expect(shuffledArray).not.toEqual(array);
-    });
-
-    test('should not modify the original array', () => {
-        const array = [1, 2, 3, 4, 5];
-        shuffle(array);
-        expect(array).toEqual([1, 2, 3, 4, 5]);
-    });
-});

package/test/array/takeMethods.test.ts

@@ -1,41 +0,0 @@
-import { it, expect, describe } from 'vitest';
-
-import { takeRightWhile } from '@array/takeRightWhile';
-import { takeWhile } from '@array/takeWhile';
-
-describe('takeWhile', () => {
-    const numbers = [2, 4, 5, 6, 7, 8, 9, 10];
-    it('should return the elements from the input array until the predicate returns false', () => {
-        const evenNumbers = takeWhile((n) => n % 2 === 0, numbers);
-        expect(evenNumbers).toEqual([2, 4]);
-    });
-
-    it('should return an empty array if the predicate always returns false', () => {
-        const evenNumbers = takeWhile((n) => n > 10, numbers);
-        expect(evenNumbers).toEqual([]);
-    });
-
-    it('should deal with different types', () => {
-        const mixed = [1, 2, 3, '4', 5, '6', 7, '8', 9, '10', [], {}, undefined];
-        const evenNumbers = takeWhile((n) => typeof n === 'number', mixed);
-        expect(evenNumbers).toEqual([1, 2, 3]);
-    });
-});
-
-describe('takeRightWhile', () => {
-    const numbers = [2, 3, 5, 7, 11, 14, 17, 19, 23, 29];
-    it('should return a new array with the last elements that satisfy the condition specified by the predicate function', () => {
-        const result = takeRightWhile(n => n % 2 === 1, numbers);
-        expect(result).toEqual([17, 19, 23, 29]);
-    });
-
-    it('should return an empty array if no elements satisfy the condition', () => {
-        const result = takeRightWhile((n: number) => n % 100 === 1, numbers);
-        expect(result).toEqual([]);
-    });
-
-    it('should return the original array if all elements satisfy the condition', () => {
-        const result = takeRightWhile(() => true,  numbers);
-        expect(result).toEqual(numbers);
-    });
-});

package/test/array/unionMethods.test.ts

@@ -1,41 +0,0 @@
-import { it, expect, describe } from 'vitest';
-
-import { union } from '@array/union';
-import { unionBy } from '@array/unionBy';
-import { unionWith } from '@array/unionWith';
-
-
-describe('union', () => {
-    const array1 = [1, 2, 3];
-    const array2 = [2, 3, 4];
-    const array3 = [3, 4, [5]];
-
-    it('should return a new array with the unique elements from all of the provided arrays', () => {
-        const result = union(array1, array2, array3);
-        expect(result).toEqual([1, 2, 3, 4, [5]]);
-    });
-});
-
-
-describe('unionWith', () => {
-    it('returns a new array containing the unique values from the input arrays', () => {
-        const result = unionWith((a, b) => a === b, [1, 2, 3], [2, 3, 4], [3, 4, 5]);
-        expect(result).toEqual([1, 2, 3, 4, 5]);
-    });
-
-    it('uses the comparator function to determine uniqueness', () => {
-        const result = unionWith((a, b) => a.id === b.id, [{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }]);
-        expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
-    });
-});
-
-describe('unionBy', () => {
-    it('should return the union of the arrays, using the iteratee to determine uniqueness', () => {
-        const objects = [{ x: 1 }, { x: 2 }, { x: 3 }];
-        const moreObjects = [{ x: 2 }, { x: 3 }, { x: 4 }];
-        expect(unionBy(o => o.x, objects, moreObjects)).toEqual([{ x: 1 }, { x: 2 }, { x: 3 }, { x: 4 }]);
-
-        // The `property` iteratee shorthand.
-        expect(unionBy('x', objects, moreObjects)).toEqual([{ x: 1 }, { x: 2 }, { x: 3 }, { x: 4 }]);
-    });
-});

package/test/array/uniqMethods.test.ts

@@ -1,18 +0,0 @@
-import { it, expect, describe } from 'vitest';
-
-import { uniq } from '@array/uniq';
-
-describe('uniq', () => {
-    it('should return an array with only unique values', () => {
-        const input = [1, 2, 3, 3, 4, 5, 5, 6];
-        const expectedOutput = [1, 2, 3, 4, 5, 6];
-        expect(uniq(input)).toEqual(expectedOutput);
-    });
-
-    it('should handle objects and arrays correctly', () => {
-        const input = [{ a: 1 }, { a: 2 }, { a: 1 }, [1, 2], [1, 2], [1, 2, 3]
-        ];
-        const expectedOutput = [{ a: 1 }, { a: 2 }, [1, 2], [1, 2, 3]];
-        expect(uniq(input)).toEqual(expectedOutput);
-    });
-});

package/test/array/unzipMethods.test.ts

@@ -1,13 +0,0 @@
-import { describe, test, expect } from 'vitest';
-
-import { unzipWith } from '@array/unzipWith';
-
-describe('unzipWith', () => {
-    test('should unzip an arrays with a function', () => {
-        const array: [number, string, boolean?][] = [[1, 'a', true], [2, 'b', false], [3, 'c']];
-        const iteratee = (x: number, y: string, z?: boolean) => x.toString() + y + (z ? '!' : '');
-
-        const result = unzipWith(iteratee, array);
-        expect(result).toEqual(['1a!', '2b', '3c']);
-    });
-});

package/test/array/zipMethods.test.ts

@@ -1,48 +0,0 @@
-import { describe, test, expect } from 'vitest';
-
-import { zipWith } from '@array/zipWith';
-
-describe('zipWith function', () => {
-    test('returns the expected result for three arrays of the same length', () => {
-        const array1 = [1, 2, 3];
-        const array2 = [10, 20, 30];
-        const array3 = [100, 200, 300];
-
-        const result = zipWith((a, b, c) => a + b + c, array1, array2, array3);
-
-        expect(result).toEqual([111, 222, 333]);
-    });
-
-    test('returns the expected result for arrays of different lengths', () => {
-        const array1 = [1, 2, 3, 4];
-        const array2 = [10, 20, 30];
-        const array3 = [100, 200];
-
-        const result = zipWith((a, b, c) => a + b + c, array1, array2, array3);
-
-        expect(result).toEqual([111, 222]);
-    });
-
-    test('returns an empty array for empty input arrays', () => {
-        const array1: number[] = [];
-        const array2: number[] = [];
-        const array3: number[] = [];
-
-        const result = zipWith((a, b, c) => a + b + c, array1, array2, array3);
-
-        expect(result).toEqual([]);
-    });
-
-    test('works with arrays of different types', () => {
-        const array1 = ['a', 'b', 'c'];
-        const array2 = [1, 2, 3];
-        const array3 = [true, false, true];
-        // Todo fix type error
-
-        const iteratee = (a: string, b: number, c: boolean) => a + b.toString() + c.toString();
-        //
-        const result = zipWith(iteratee, array1, array2, array3);
-
-        expect(result).toEqual(['a1true', 'b2false', 'c3true']);
-    });
-});

package/test/collection/countBy.test.ts

@@ -1,13 +0,0 @@
-import { describe, test, expect } from 'vitest';
-
-import { countBy } from '@collection/countBy';
-import { sample } from '@array/sample';
-
-describe('countBy function', () => {
-    test('countBy', () => {
-        const array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-        const even = (value: number) => (value % 2 === 0).toString();
-        const result = countBy(even, array);
-        expect(result).toEqual({ 'true': 5, 'false': 5 });
-    });
-});

package/test/collection/groupBy.test.ts

@@ -1,35 +0,0 @@
-import { describe, test, expect } from 'vitest';
-
-import { groupBy } from '@collection/groupBy';
-
-describe('groupBy', () => {
-    test('groups elements by evenness', () => {
-        const array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-        const even = (value: number) => (value % 2 === 0).toString();
-        const result = groupBy(even, array);
-        expect(result).toEqual({ 'true': [2, 4, 6, 8, 10], 'false': [1, 3, 5, 7, 9] });
-    });
-
-    test('should group an array by a property', () => {
-        const array = [
-            { name: 'Alice', age: 30 },
-            { name: 'Bob', age: 35 },
-            { name: 'Charlie', age: 30 },
-            { name: 'Dave', age: 40 },
-            { name: 'Eve', age: 35 }
-        ];
-
-        const result = groupBy(element => element.age, array);
-
-        expect(result).toEqual({
-            30: [{ name: 'Alice', age: 30 }, { name: 'Charlie', age: 30 }],
-            35: [{ name: 'Bob', age: 35 }, { name: 'Eve', age: 35 }],
-            40: [{ name: 'Dave', age: 40 }]
-        });
-    });
-
-    test('should work with an object for `collection`', function () {
-        const actual = groupBy(Math.floor, { 'a': 6.1, 'b': 4.2, 'c': 6.3 } );
-        expect(actual).toEqual({ '4': [4.2], '6': [6.1, 6.3] });
-    });
-});

package/test/collection/sample.test.ts

@@ -1,17 +0,0 @@
-import { test, describe, expect } from 'vitest';
-
-import { sample } from '@array/sample';
-
-describe('sample', () => {
-    test('sample function returns a random value from an array', () => {
-        const collection = [1, 2, 3, 4, 5];
-        const result = sample(collection);
-        expect(collection).toContain(result);
-    });
-
-    test('sample function returns undefined for an empty collection', () => {
-        const collection = [] as unknown[];
-        const result = sample(collection);
-        expect(result).toBeUndefined();
-    });
-});

package/test/collection/sampleSize.test.ts

@@ -1,33 +0,0 @@
-import { describe, expect, test } from 'vitest';
-
-import { sampleSize } from '@array/sampleSize';
-
-describe('sampleSize', () => {
-    test('should return an array of the specified size', () => {
-        const array = [1, 2, 3, 4, 5];
-        const size = 3;
-        const result = sampleSize(size, array);
-        expect(result).toHaveLength(size);
-    });
-
-    test('should return an empty array if size is 0 or less', () => {
-        const array = [1, 2, 3, 4, 5];
-        const size = 0;
-        const result = sampleSize(size, array);
-        expect(result).toHaveLength(0);
-    });
-
-    test('should return an empty array if the input array is empty', () => {
-        const array: number[] = [];
-        const size = 3;
-        const result = sampleSize(size, array);
-        expect(result).toHaveLength(0);
-    });
-
-    test('should return a random subset of the input array', () => {
-        const array = [1, 2, 3, 4, 5];
-        const size = 3;
-        const result = sampleSize(size, array);
-        expect(expect.arrayContaining(result)).toEqual(array);
-    });
-});

package/test/collection/sortBy.test.ts

@@ -1,31 +0,0 @@
-import { test, describe, expect } from 'vitest';
-
-import { sortBy } from '@collection/sortBy';
-
-describe('sortBy', () => {
-    test('should sort the array in ascending order based on the iteratee function', () => {
-        const numbers = [3, 1, 2];
-        const sortedNumbers = sortBy(number => number, numbers);
-        expect(sortedNumbers).toEqual([1, 2, 3]);
-    });
-
-    test('should return the original array if it is already sorted', () => {
-        const numbers = [1, 2, 3];
-        const sortedNumbers = sortBy(number => number, numbers);
-        expect(sortedNumbers).toEqual(numbers);
-    });
-
-    test('should work with arrays of objects', () => {
-        const users = [
-            { name: 'Alice', age: 30 },
-            { name: 'Bob', age: 25 },
-            { name: 'Eve', age: 35 }
-        ];
-        const sortedUsers = sortBy(user => user.age, users);
-        expect(sortedUsers).toEqual([
-            { name: 'Bob', age: 25 },
-            { name: 'Alice', age: 30 },
-            { name: 'Eve', age: 35 }
-        ]);
-    });
-});

package/test/function/after.test.ts

@@ -1,19 +0,0 @@
-import { describe, test, vi, expect } from 'vitest';
-
-import { after } from '@function/after';
-
-describe('after', () => {
-    test('after function works correctly', () => {
-        const testFn = vi.fn();
-        const afterFn = after(3, testFn);
-
-        afterFn(1);
-        afterFn(1);
-        expect(testFn).toHaveBeenCalledTimes(0);
-
-        afterFn(1);
-        afterFn(1);
-
-        expect(testFn).toHaveBeenCalledTimes(2);
-    });
-});

package/test/function/before.test.ts

@@ -1,19 +0,0 @@
-import { describe, expect, test, vi } from 'vitest';
-
-import { before } from '@function/before';
-
-describe('before', () => {
-    test('only calls 3 times', () => {
-        const testFn = vi.fn();
-        const beforeFn = before(3, testFn);
-
-        beforeFn();
-        beforeFn();
-        expect(testFn).toHaveBeenCalledTimes(2);
-
-        beforeFn();
-        beforeFn();
-
-        expect(testFn).toHaveBeenCalledTimes(3);
-    });
-});

package/test/function/debounce.test.ts

@@ -1,47 +0,0 @@
-import { afterEach, beforeAll, describe, expect, test, vi } from 'vitest';
-
-import { debounce } from '@function/debounce';
-
-describe('debounce', () => {
-    const testFn = vi.fn((x: number) => x * 2);
-
-    beforeAll(() => {
-        vi.useFakeTimers();
-    });
-
-    afterEach(() => {
-        testFn.mockClear();
-    });
-
-    test('only calls the function once', () => {
-        const debounced = debounce(testFn, 100);
-
-        debounced(1);
-        debounced(1);
-        debounced(1);
-
-        expect(testFn).not.toHaveBeenCalled();
-
-        vi.advanceTimersByTime(99);
-        expect(testFn).not.toHaveBeenCalled();
-
-        vi.advanceTimersByTime(1);
-        expect(testFn).toHaveBeenCalledTimes(1);
-    });
-
-    test('calls the function again after the wait period', () => {
-        const debounced = debounce(testFn, 100);
-
-        debounced(1);
-        vi.advanceTimersByTime(50);
-        debounced(1);
-        vi.advanceTimersByTime(50);
-        debounced(1);
-
-        vi.advanceTimersByTime(50);
-        expect(testFn).not.toHaveBeenCalled();
-
-        vi.advanceTimersByTime(50);
-        expect(testFn).toHaveBeenCalledTimes(1);
-    });
-});

package/test/function/memoize.test.ts

@@ -1,33 +0,0 @@
-import { test, describe, expect, vi, beforeEach } from 'vitest';
-
-import { memoize } from '@function/memoize';
-
-describe('memoize', () => {
-    const testFn = vi.fn((a: number, b: number) => a + b);
-
-    beforeEach(() => {
-        testFn.mockClear();
-    });
-
-
-    test('should memoize a function', () => {
-        const memoizedFunc = memoize(testFn);
-
-        expect(memoizedFunc(1, 2)).to.equal(3);
-        expect(memoizedFunc(1, 2)).to.equal(3);
-        expect(testFn).toHaveBeenCalledOnce();
-    });
-
-    test('should return different results for different arguments', () => {
-        const memoizedFunc = memoize(testFn);
-
-        expect(memoizedFunc(1, 2)).to.equal(3);
-        expect(memoizedFunc(2, 3)).to.equal(5);
-        expect(testFn).toHaveBeenCalledTimes(2);
-    });
-
-    test('should expose a cache property', () => {
-        const memoizedFunc = memoize(testFn);
-        expect(memoizedFunc.cache).to.be.an.instanceof(Map);
-    });
-});

package/test/function/once.test.ts

@@ -1,29 +0,0 @@
-import { test, describe, expect, vi, afterEach } from 'vitest';
-
-import { once } from '@function/once';
-
-describe('once', () => {
-    const testFn = vi.fn((x: number) => x * 2);
-
-    afterEach(() => {
-        testFn.mockClear();
-    });
-
-    test('only calls the function once', () => {
-        const onceFn = once(testFn);
-
-        onceFn(1);
-        expect(testFn).toHaveBeenCalledTimes(1);
-        onceFn(1);
-        expect(testFn).toHaveBeenCalledTimes(1);
-        onceFn(1);
-        expect(testFn).toHaveBeenCalledTimes(1);
-    });
-
-    test('preserves the return value of the function', () => {
-        const onceFn = once(testFn);
-
-        expect(onceFn(2)).toBe(4);
-        expect(onceFn(3)).toBe(4);
-    });
-});

package/test/function/throttle.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, test, vi } from 'vitest';
-
-import { throttle } from '@function/throttle';
-
-describe('throttle', () => {
-    test('only calls the function once', () => {
-        vi.useFakeTimers();
-
-        const callback = vi.fn();
-        const throttled = throttle(callback, 100);
-
-        throttled();
-        throttled();
-        throttled();
-
-        expect(callback).toHaveBeenCalledTimes(1);
-
-        vi.advanceTimersByTime(99);
-        expect(callback).toHaveBeenCalledTimes(1);
-
-        vi.advanceTimersByTime(1);
-        expect(callback).toHaveBeenCalledTimes(2);
-    });
-});

package/test/lang/isEqualMethods.test.ts

@@ -1,98 +0,0 @@
-import { describe, expect, test } from 'vitest';
-
-import { isEqual } from '@lang/isEqual';
-import { isEqualWith } from '@lang/isEqualWith';
-
-describe('isEqual', () => {
-    test('numbers', () => {
-        expect(isEqual(1, 1)).toBe(true);
-        expect(isEqual(1, 2)).toBe(false);
-    });
-
-    test('strings', () => {
-        expect(isEqual('a', 'a')).toBe(true);
-        expect(isEqual('a', 'b')).toBe(false);
-    });
-
-    test('booleans', () => {
-        expect(isEqual(true, true)).toBe(true);
-        expect(isEqual(true, false)).toBe(false);
-    });
-
-    test('null', () => {
-        expect(isEqual(null, null)).toBe(true);
-        expect(isEqual(null, undefined)).toBe(false);
-    });
-
-    test('undefined', () => {
-        expect(isEqual(undefined, undefined)).toBe(true);
-        expect(isEqual(undefined, null)).toBe(false);
-    });
-
-    test('objects', () => {
-        expect(isEqual({ a: 1 }, { a: 1 })).toBe(true);
-        expect(isEqual({ a: 1 }, { a: 2 })).toBe(false);
-    });
-
-    test('arrays', () => {
-        expect(isEqual([1, 2, 3], [1, 2, 3])).toBe(true);
-        expect(isEqual([1, 2, 3], [1, 2, 4])).toBe(false);
-    });
-
-    test('nested objects', () => {
-        expect(isEqual({ a: { b: 1 } }, { a: { b: 1 } })).toBe(true);
-        expect(isEqual({ a: { b: 1 } }, { a: { b: 2 } })).toBe(false);
-    });
-
-    test('nested arrays', () => {
-        expect(isEqual([[1], [2], [3]], [[1], [2], [3]])).toBe(true);
-        expect(isEqual([[1], [2], [3]], [[1], [2], [4]])).toBe(false);
-    });
-
-    test('nested objects and arrays', () => {
-        expect(isEqual({ a: { b: [1] } }, { a: { b: [1] } })).toBe(true);
-        expect(isEqual({ a: { b: [1] } }, { a: { b: [2] } })).toBe(false);
-    });
-
-    test('objects with different keys', () => {
-        expect(isEqual({ a: 1 }, { b: 1 })).toBe(false);
-    });
-
-    test('arrays with different lengths', () => {
-        expect(isEqual([1, 2, 3], [1, 2])).toBe(false);
-    });
-
-    // eslint-disable-next-line unicorn/consistent-function-scoping
-    const testFunction = () => { return 1 };
-    test('functions', () => {
-        expect(isEqual(() => { return 1 }, () => { return 2 })).toBe(false);
-        expect(isEqual(testFunction, testFunction)).toBe(true);
-    });
-
-    test('objects with functions', () => {
-        expect(isEqual({ a: () => { return 1 } }, { a: () => { return 1 } })).toBe(false);
-        expect(isEqual({ a: testFunction }, { a: testFunction })).toBe(true);
-    });
-
-    test('regExp', () => {
-        expect(isEqual(/a(.*)/, /a(.*)/)).toBe(true);
-        expect(isEqual(/a/, /b.*/)).toBe(false);
-    });
-});
-
-
-describe('isEqualWith', () => {
-    test('should return true if the customizer function returns equal values for both inputs', () => {
-        expect(isEqualWith(Math.floor, 1.3, 1.8)).toBe(true);
-    });
-
-    test('should return false if the customizer function returns different values for both inputs', () => {
-        const customizer = (value: number) => value * 2;
-        expect(isEqualWith(customizer, 2, 5)).toBe(false);
-    });
-
-    test('should work with objects as input', () => {
-        const customizer = (value: { a: number, b: number }) => value.a + value.b;
-        expect(isEqualWith(customizer, { a: 2, b: 3 }, { a: 1, b: 4 })).toBe(true);
-    });
-});

package/test/string/camelCase.test.ts

@@ -1,13 +0,0 @@
-import { describe, expect, test } from 'vitest';
-
-import { camelCase } from '@string/camelCase';
-
-describe('camelCase', () => {
-    test('should convert a string to camel case', () => {
-        expect(camelCase('Foo Bar')).toBe('fooBar');
-        expect(camelCase('fooBar')).toBe('fooBar');
-        expect(camelCase('FooBar')).toBe('fooBar');
-        expect(camelCase('--foo-bar--')).toBe('fooBar');
-        expect(camelCase('__FOO_BAR__')).toBe('fooBar');
-    });
-});

package/test/string/capitalize.test.ts

@@ -1,17 +0,0 @@
-import { expect, test, describe } from 'vitest';
-
-import { capitalize } from '@string/capitalize';
-
-describe('capitalize', () => {
-    test('capitalizes the first letter of a string', () => {
-        expect(capitalize('hello world')).toBe('Hello world');
-    });
-
-    test('returns an empty string for an empty input', () => {
-        expect(capitalize('')).toBe('');
-    });
-
-    test('returns the original string for a single-character string', () => {
-        expect(capitalize('a')).toBe('A');
-    });
-});

package/test/string/deburr.test.ts

@@ -1,16 +0,0 @@
-import { describe, expect, test } from 'vitest';
-
-import { deburr } from '@string/deburr';
-
-describe('deburr', () => {
-    test('removes diacritics from a string', () => {
-        expect(deburr('Mëtàl Hëàd')).toEqual('Metal Head');
-        expect(deburr('Pokémón')).toEqual('Pokemon');
-        expect(deburr('résumé')).toEqual('resume');
-    });
-
-    test('returns the input string if it has no diacritics', () => {
-        expect(deburr('hello')).toEqual('hello');
-        expect(deburr('world')).toEqual('world');
-    });
-});

package/test/string/escape.test.ts

@@ -1,17 +0,0 @@
-import { expect, test, describe } from 'vitest';
-
-import { escape } from '@string/escape';
-
-describe('escapeToHTML', () => {
-    test('should escape special characters to HTML entities', () => {
-        const str = '<p>Hello, World!</p>';
-        const html = escape(str);
-        expect(html).toBe('&lt;p&gt;Hello, World!&lt;/p&gt;');
-    });
-
-    test('should return the original string if it does not contain special characters', () => {
-        const str = 'Hello, World!';
-        const html = escape(str);
-        expect(html).toBe(str);
-    });
-});

package/test/string/escapeRegExp.test.ts

@@ -1,18 +0,0 @@
-import { expect, test, describe } from 'vitest';
-
-import { escapeRegExp } from '@string/escapeRegExp';
-
-describe('escapeRegExp', () => {
-    test('escapes special characters in a string', () => {
-        expect(escapeRegExp('hello.world*')).toBe('hello\\.world\\*');
-        expect(escapeRegExp('[lodash](https://lodash.com/)')).toBe('\\[lodash\\]\\(https://lodash\\.com/\\)');
-    });
-
-    test('returns an empty string for an empty input', () => {
-        expect(escapeRegExp('')).toBe('');
-    });
-
-    test('returns the original string for a string without special characters', () => {
-        expect(escapeRegExp('hello world')).toBe('hello world');
-    });
-});

package/test/string/kebabCase.test.ts

@@ -1,18 +0,0 @@
-import { describe, expect, test } from 'vitest';
-
-import { kebabCase } from '@string/kebabCase';
-
-describe('kebabCase', () => {
-    test('converts a string to kebab case', () => {
-        expect(kebabCase('helloWorld')).toBe('hello-world');
-        expect(kebabCase('helloCRUELWorld')).toBe('hello-cruel-world');
-    });
-
-    test('returns an empty string for an empty input', () => {
-        expect(kebabCase('')).toBe('');
-    });
-
-    test('returns the original string for a single-word string', () => {
-        expect(kebabCase('hello')).toBe('hello');
-    });
-});

package/test/string/pascalCase.test.ts

@@ -1,16 +0,0 @@
-import { describe, expect, test } from 'vitest';
-
-import { pascalCase } from '@string/pascalCase';
-
-describe('toPascalCase', () => {
-    test('converts a string to PascalCase', () => {
-        expect(pascalCase('hello world')).toEqual('HelloWorld');
-        expect(pascalCase('this is a.test')).toEqual('ThisIsATest');
-        expect(pascalCase('CamelCase')).toEqual('CamelCase');
-    });
-
-    test('handles empty strings and single words correctly', () => {
-        expect(pascalCase('')).toEqual('');
-        expect(pascalCase('hello')).toEqual('Hello');
-    });
-});

package/test/string/snakeCase.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, test } from 'vitest';
-
-import { snakeCase } from '@string/snakeCase';
-
-describe('snakeCase', () => {
-    test('converts a string to snake_case', () => {
-        expect(snakeCase('someString')).toBe('some_string');
-        expect(snakeCase('someOtherString')).toBe('some_other_string');
-        expect(snakeCase('someStringWithCamelCase')).toBe('some_string_with_camel_case');
-    });
-
-    test('converts a string with multiple uppercase letters to snake_case', () => {
-        expect(snakeCase('someStringWithMultipleUppercaseLetters')).toBe('some_string_with_multiple_uppercase_letters');
-    });
-
-    test('handles strings that are already in snake_case', () => {
-        expect(snakeCase('some_string')).toBe('some_string');
-    });
-
-    test('handles empty strings', () => {
-        expect(snakeCase('')).toBe('');
-    });
-});

package/test/string/startCase.test.ts

@@ -1,14 +0,0 @@
-import { expect, test, describe } from 'vitest';
-
-import { startCase } from '@string/startCase';
-
-describe('startCase', () => {
-    test('should convert a string to start case', () => {
-        expect(startCase('hello world')).toBe('Hello World');
-        expect(startCase('HELLO WORLD')).toBe('Hello World');
-        expect(startCase('Hello World')).toBe('Hello World');
-        expect(startCase('hello-world')).toBe('Hello World');
-        expect(startCase('hello_world')).toBe('Hello World');
-        expect(startCase('hello  world')).toBe('Hello World');
-    });
-});

package/test/string/stripSpecialChars.test.ts

@@ -1,15 +0,0 @@
-import { describe, test, expect } from 'vitest';
-
-import { stripSpecialChars } from '@string/stripSpecialChars';
-
-describe('stripSpecialChars', () => {
-    test('removes special characters from a string', () => {
-        expect(stripSpecialChars('Héllo, world!')).toEqual('Hello world');
-        expect(stripSpecialChars('This string has #$%&*!')).toEqual('This string has ');
-        expect(stripSpecialChars('Testing 123')).toEqual('Testing 123');
-    });
-
-    test('returns an empty string if given an empty string', () => {
-        expect(stripSpecialChars('')).toEqual('');
-    });
-});

package/test/string/unescape.test.ts

@@ -1,17 +0,0 @@
-import { test, expect, describe } from 'vitest';
-
-import { unescapeHTML } from '@string/unescape';
-
-describe('unescapeHTML', () => {
-    test('should unescape HTML entities', () => {
-        const html = '<p>Hello, World!</p>';
-        const str = unescapeHTML(html);
-        expect(str).toBe('<p>Hello, World!</p>');
-    });
-
-    test('should return the original string if it does not contain HTML entities', () => {
-        const html = 'Hello, World!';
-        const str = unescapeHTML(html);
-        expect(str).toBe(html);
-    });
-});

package/tsup.config.js

@@ -1,10 +0,0 @@
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
-    entry: ['src/index.ts'],
-    format: ['esm'],
-    sourcemap: true,
-    clean: true,
-    outDir: 'dist',
-    dts: true
-});

package/vitest.config.ts

@@ -1,27 +0,0 @@
-/// <reference types="vitest" />
-// Configure Vitest (https://vitest.dev/config/)
-
-import { fileURLToPath, URL } from 'url';
-
-import { defineConfig } from 'vite';
-
-const getPath = (path: string) => fileURLToPath(new URL(path, import.meta.url));
-
-export default defineConfig({
-    test: {
-        /* for example, use global to avoid globals imports (describe, test, expect): */
-        // globals: true,
-    },
-    resolve: {
-        alias: {
-            '@array': getPath('src/array'),
-            '@lang': getPath('src/lang'),
-            '@object': getPath('src/object'),
-            '@function': getPath('src/function'),
-            '@collection': getPath('src/collection'),
-            '@string': getPath('src/string'),
-            '@number': getPath('src/number'),
-            '@helpers': getPath('src/helpers')
-        }
-    }
-});