moderndash 0.0.5

package/src/string/escapeRegExp.ts

@@ -0,0 +1,3 @@
+export function escapeRegExp(str: string): string {
+    return str.replace(/[$()*+.?[\\\]^{|}]/g, '\\$&');
+}

package/src/string/index.ts

@@ -0,0 +1,11 @@
+export * from './camelCase';
+export * from './capitalize';
+export * from './deburr';
+export * from './escape';
+export * from './escapeRegExp';
+export * from './kebabCase';
+export * from './pascalCase';
+export * from './snakeCase';
+export * from './startCase';
+export * from './stripSpecialChars';
+export * from './unescape';

package/src/string/kebabCase.ts

@@ -0,0 +1,10 @@
+import { splitWords } from '@helpers/stringModifiers';
+
+export function kebabCase(str: string): string {
+    const words = splitWords(str);
+    let kebabCase = '';
+    for (const word of words) {
+        kebabCase += word.toLowerCase() + '-';
+    }
+    return kebabCase.slice(0, -1);
+}

package/src/string/pascalCase.ts

@@ -0,0 +1,10 @@
+import { splitWords } from '@helpers/stringModifiers';
+
+export function pascalCase(str: string): string {
+    const words = splitWords(str);
+    let pascalCase = '';
+    for (const word of words) {
+        pascalCase += word.charAt(0).toUpperCase() + word.slice(1);
+    }
+    return pascalCase;
+}

package/src/string/snakeCase.ts

@@ -0,0 +1,13 @@
+import { splitWords } from '@helpers/stringModifiers';
+
+export function snakeCase(str: string): string {
+    const words = splitWords(str);
+    let snakeCase = '';
+    for (const word of words) {
+        if (snakeCase.length > 0) {
+            snakeCase += '_';
+        }
+        snakeCase += word.toLowerCase();
+    }
+    return snakeCase;
+}

package/src/string/startCase.ts

@@ -0,0 +1,10 @@
+import { splitWords } from '@helpers/stringModifiers';
+
+export function startCase(str: string): string {
+    const words = splitWords(str);
+    let startCase = '';
+    for (const word of words) {
+        startCase += word.charAt(0).toUpperCase() + word.slice(1).toLowerCase() + ' ';
+    }
+    return startCase.trimEnd();
+}

package/src/string/stripSpecialChars.ts

@@ -0,0 +1,6 @@
+import { deburr } from '@string/deburr';
+
+export function stripSpecialChars(str: string): string {
+    str = deburr(str);
+    return str.replace(/[^\s\w]/gi, '');
+}

package/src/string/unescape.ts

@@ -0,0 +1,10 @@
+export function unescapeHTML(html: string): string {
+    const entityMap: Record<string, string> = {
+        '&amp;': '&',
+        '&lt;': '<',
+        '&gt;': '>',
+        '&quot;': '"',
+        '&#39;': '\''
+    };
+    return html.replace(/&(?:amp|#38|lt|#60|gt|#62|apos|#39|quot|#34);/g, (entity: string) => entityMap[entity] || entity);
+}

package/src/types.ts

@@ -0,0 +1,9 @@
+export type MinimumTwoArrays<T> = [T[], T[], ...T[][]];
+
+export type IterateeFunction<T> = (value: T) => unknown;
+export type PropertyShorthand<T> = keyof T;
+
+export type RecordKey = string | number | symbol;
+
+export type Collection<T> = T[] | Record<RecordKey, T>;
+export type NoUnion<T, U = T> = T extends U ? [U] extends [T] ? T : never : never;

package/test/.eslintrc.cjs

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

package/test/array/chunk.test.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,47 @@
+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);
+    });
+});