ts-data-forge 5.0.1 → 5.1.1

package/src/array/impl/array-utils-transformation.test.mts

@@ -22,7 +22,7 @@ import {
 
 describe('Arr transformations', () => {
   describe(map, () => {
-    const mapped = map([1, 2, 3], (x, i): number => x * x * i);
+    const mapped = map([1, 2, 3], (x, i): number => x ** 2 * i);
 
     expectType<typeof mapped, ArrayOfLength<3, number>>('=');
 
@@ -32,7 +32,9 @@ describe('Arr transformations', () => {
 
     test('should work with empty tuple', () => {
       const empty = [] as const;
+
       const mappedEmpty = map(empty, (x) => String(x));
+
       expectType<typeof mappedEmpty, readonly []>('=');
 
       assert.deepStrictEqual(mappedEmpty, []);
@@ -40,7 +42,9 @@ describe('Arr transformations', () => {
 
     test('should preserve tuple length with different types', () => {
       const mixed = [1, 'hello', true] as const;
+
       const mappedMixed = map(mixed, (x) => typeof x);
+
       expectType<typeof mappedMixed, readonly [string, string, string]>('<=');
 
       assert.deepStrictEqual(mappedMixed, ['number', 'string', 'boolean']);
@@ -48,7 +52,9 @@ describe('Arr transformations', () => {
 
     test('should work with index parameter', () => {
       const tuple = ['a', 'b', 'c'] as const;
+
       const mappedWithIndex = map(tuple, (x, i) => `${i}:${x}`);
+
       expectType<typeof mappedWithIndex, readonly [string, string, string]>(
         '<=',
       );
@@ -60,6 +66,7 @@ describe('Arr transformations', () => {
   describe(scan, () => {
     test('should compute running sum', () => {
       const numbers = [1, 2, 3, 4];
+
       const runningSum = scan(numbers, (acc, curr) => acc + curr, 0);
 
       expectType<typeof runningSum, readonly [number, ...number[]]>('<=');
@@ -69,6 +76,7 @@ describe('Arr transformations', () => {
 
     test('should include initial value as first element', () => {
       const numbers = [10, 20, 30];
+
       const result = scan(numbers, (acc, curr) => acc + curr, 100);
 
       assert.deepStrictEqual(result, [100, 110, 130, 160]);
@@ -80,20 +88,24 @@ describe('Arr transformations', () => {
       const scanSum = scan<number, number>((acc, curr) => acc + curr, 0);
 
       const result1 = scanSum([1, 2, 3]);
+
       const result2 = scanSum([5, 10]);
 
       assert.deepStrictEqual(result1, [0, 1, 3, 6]);
+
       assert.deepStrictEqual(result2, [0, 5, 15]);
     });
 
     test('should provide index to reducer', () => {
       const numbers = [10, 20, 30];
+
       const mut_indices: number[] = [];
 
       scan(
         numbers,
         (acc, curr, index) => {
           mut_indices.push(index);
+
           return acc + curr;
         },
         0,
@@ -104,6 +116,7 @@ describe('Arr transformations', () => {
 
     test('should work with empty array', () => {
       const empty: readonly number[] = [];
+
       const result = scan(empty, (acc, curr) => acc + curr, 42);
 
       assert.deepStrictEqual(result, [42]);
@@ -111,6 +124,7 @@ describe('Arr transformations', () => {
 
     test('should work with different accumulator and element types', () => {
       const strings = ['a', 'b', 'c'];
+
       const result = scan(strings, (acc, curr) => acc + curr.length, 0);
 
       expectType<typeof result, readonly [number, ...number[]]>('<=');
@@ -120,6 +134,7 @@ describe('Arr transformations', () => {
 
     test('should compute running product', () => {
       const numbers = [2, 3, 4];
+
       const runningProduct = scan(numbers, (acc, curr) => acc * curr, 1);
 
       assert.deepStrictEqual(runningProduct, [1, 2, 6, 24]);
@@ -135,6 +150,7 @@ describe('Arr transformations', () => {
 
     test('should preserve all intermediate values', () => {
       const numbers = [1, 2, 3];
+
       const result = scan(numbers, (acc, curr) => acc - curr, 10);
 
       // 10 -> 10-1=9 -> 9-2=7 -> 7-3=4
@@ -145,6 +161,7 @@ describe('Arr transformations', () => {
   describe(toReversed, () => {
     {
       const xs = [1, 2, 3] as const;
+
       const _nativeResult = xs.toReversed();
 
       expectType<typeof _nativeResult, (1 | 2 | 3)[]>('=');
@@ -160,7 +177,9 @@ describe('Arr transformations', () => {
 
     test('should work with empty tuple', () => {
       const empty = [] as const;
+
       const reversed = toReversed(empty);
+
       expectType<typeof reversed, readonly []>('=');
 
       assert.deepStrictEqual(reversed, []);
@@ -168,7 +187,9 @@ describe('Arr transformations', () => {
 
     test('should work with single element', () => {
       const single = [42] as const;
+
       const reversed = toReversed(single);
+
       expectType<typeof reversed, readonly [42]>('=');
 
       assert.deepStrictEqual(reversed, [42]);
@@ -176,7 +197,9 @@ describe('Arr transformations', () => {
 
     test('should preserve mixed types in reverse order', () => {
       const mixed = [1, 'hello', true, null] as const;
+
       const reversed = toReversed(mixed);
+
       expectType<typeof reversed, readonly [null, true, 'hello', 1]>('=');
 
       assert.deepStrictEqual(reversed, [null, true, 'hello', 1]);
@@ -186,6 +209,7 @@ describe('Arr transformations', () => {
   describe(toSorted, () => {
     {
       const xs = [2, 1, 3] as const;
+
       const result = toSorted(xs);
 
       expectType<typeof result, ArrayOfLength<3, 1 | 2 | 3>>('=');
@@ -194,8 +218,10 @@ describe('Arr transformations', () => {
         assert.deepStrictEqual(result, [1, 2, 3]);
       });
     }
+
     {
       const xs = [2, 1, 3] as const;
+
       const result = toSorted(xs, (a, b) => a - b);
 
       expectType<typeof result, ArrayOfLength<3, 1 | 2 | 3>>('=');
@@ -204,8 +230,10 @@ describe('Arr transformations', () => {
         assert.deepStrictEqual(result, [1, 2, 3]);
       });
     }
+
     {
       const xs = [2, 1, 3] as const;
+
       const result = toSorted(xs, (a, b) => b - a);
 
       expectType<typeof result, ArrayOfLength<3, 1 | 2 | 3>>('=');
@@ -219,6 +247,7 @@ describe('Arr transformations', () => {
   describe(toSortedBy, () => {
     {
       const xs = [{ v: 2 }, { v: 1 }, { v: 3 }] as const;
+
       const sorted = toSortedBy(xs, (x) => x.v);
 
       expectType<
@@ -230,8 +259,10 @@ describe('Arr transformations', () => {
         assert.deepStrictEqual(sorted, [{ v: 1 }, { v: 2 }, { v: 3 }]);
       });
     }
+
     {
       const xs = [{ v: 2 }, { v: 1 }, { v: 3 }] as const;
+
       const sorted = toSortedBy(
         xs,
         (x) => x.v,
@@ -254,16 +285,21 @@ describe('Arr transformations', () => {
         { name: 'Bob', age: 20 },
         { name: 'Charlie', age: 25 },
       ];
+
       const result = toSortedBy(people, (person) => person.age);
 
       expect(result).toHaveLength(3);
+
       expect(result[0]?.name).toBe('Bob');
+
       expect(result[1]?.name).toBe('Charlie');
+
       expect(result[2]?.name).toBe('Alice');
     });
 
     test('should work with string sorting', () => {
       const words = ['banana', 'apple', 'cherry'];
+
       const result = toSortedBy(
         words,
         (word: string) => word,
@@ -275,6 +311,7 @@ describe('Arr transformations', () => {
 
     test('should work with custom key extraction', () => {
       const items = ['hello', 'hi', 'welcome', 'bye'];
+
       const result = toSortedBy(items, (item) => item.length);
 
       assert.deepStrictEqual(result, ['hi', 'bye', 'hello', 'welcome']);
@@ -282,6 +319,7 @@ describe('Arr transformations', () => {
 
     test('should work with empty array', () => {
       const empty: readonly { value: number }[] = [];
+
       const result = toSortedBy(empty, (item) => item.value);
 
       assert.deepStrictEqual(result, []);
@@ -289,6 +327,7 @@ describe('Arr transformations', () => {
 
     test('toSortedBy should work with empty array', () => {
       const empty: readonly { value: number }[] = [];
+
       const result = toSortedBy(empty, (item) => item.value);
 
       assert.deepStrictEqual(result, []);
@@ -298,6 +337,7 @@ describe('Arr transformations', () => {
   describe(filter, () => {
     test('should filter array with predicate', () => {
       const numbers = [1, 2, 3, 4, 5];
+
       const evens = filter(numbers, (n) => n % 2 === 0);
 
       assert.deepStrictEqual(evens, [2, 4]);
@@ -311,7 +351,9 @@ describe('Arr transformations', () => {
         'world',
         123,
       ];
+
       const strings = filter(mixed, (x): x is string => typeof x === 'string');
+
       expectType<typeof strings, readonly string[]>('=');
 
       assert.deepStrictEqual(strings, ['hello', 'world']);
@@ -319,7 +361,9 @@ describe('Arr transformations', () => {
 
     test('should work with curried version', () => {
       const isPositive = (n: number): boolean => n > 0;
+
       const filterPositive = filter(isPositive);
+
       const result = filterPositive([-1, 2, -3, 4]);
 
       assert.deepStrictEqual(result, [2, 4]);
@@ -327,8 +371,11 @@ describe('Arr transformations', () => {
 
     test('should work with curried type guards', () => {
       const isString = (x: unknown): x is string => typeof x === 'string';
+
       const filterStrings = filter(isString);
+
       const result = filterStrings(['a', 1, 'b', 2]);
+
       expectType<typeof result, readonly string[]>('=');
 
       assert.deepStrictEqual(result, ['a', 'b']);
@@ -336,7 +383,9 @@ describe('Arr transformations', () => {
 
     test('should preserve array type with generic predicate', () => {
       const tuple = [1, 2, 3] as const;
+
       const filtered = filter(tuple, (x) => x > 1);
+
       expectType<typeof filtered, readonly (1 | 2 | 3)[]>('=');
 
       assert.deepStrictEqual(filtered, [2, 3]);
@@ -344,6 +393,7 @@ describe('Arr transformations', () => {
 
     test('should work with empty array', () => {
       const empty: number[] = [];
+
       const result = filter(empty, (n) => n > 0);
 
       assert.deepStrictEqual(result, []);
@@ -351,6 +401,7 @@ describe('Arr transformations', () => {
 
     test('should pass index to predicate', () => {
       const numbers = [10, 20, 30, 40];
+
       const evenIndexes = filter(numbers, (_, i) => i % 2 === 0);
 
       assert.deepStrictEqual(evenIndexes, [10, 30]);
@@ -359,6 +410,7 @@ describe('Arr transformations', () => {
 
   describe(filterNot, () => {
     const xs = [1, 2, 3] as const;
+
     const filtered = filterNot(xs, (x) => x % 2 === 0);
 
     expectType<typeof filtered, readonly (1 | 2 | 3)[]>('=');
@@ -371,6 +423,7 @@ describe('Arr transformations', () => {
   describe(uniq, () => {
     test('should remove duplicate primitives', () => {
       const array = [1, 2, 2, 3, 1, 4, 3];
+
       const result = uniq(array);
 
       assert.deepStrictEqual(result, [1, 2, 3, 4]);
@@ -378,6 +431,7 @@ describe('Arr transformations', () => {
 
     test('should work with strings', () => {
       const array = ['a', 'b', 'a', 'c', 'b'];
+
       const result = uniq(array);
 
       assert.deepStrictEqual(result, ['a', 'b', 'c']);
@@ -385,6 +439,7 @@ describe('Arr transformations', () => {
 
     test('should work with empty array', () => {
       const array: readonly number[] = [];
+
       const result = uniq(array);
 
       assert.deepStrictEqual(result, []);
@@ -392,6 +447,7 @@ describe('Arr transformations', () => {
 
     test('should preserve order of first occurrence', () => {
       const array = [3, 1, 2, 1, 3, 2];
+
       const result = uniq(array);
 
       assert.deepStrictEqual(result, [3, 1, 2]);
@@ -406,27 +462,35 @@ describe('Arr transformations', () => {
         { id: 1, name: 'Alice Duplicate' },
         { id: 3, name: 'Charlie' },
       ];
+
       const result = uniqBy(array, (item) => item.id);
 
       expect(result).toHaveLength(3);
 
       assert.deepStrictEqual(result[0], { id: 1, name: 'Alice' });
+
       assert.deepStrictEqual(result[1], { id: 2, name: 'Bob' });
+
       assert.deepStrictEqual(result[2], { id: 3, name: 'Charlie' });
     });
 
     test('should work with string key function', () => {
       const words = ['hello', 'world', 'hi', 'welcome'];
+
       const result = uniqBy(words, (word) => word.length);
 
       expect(result).toHaveLength(3);
+
       expect(result).toContain('hello'); // length 5
+
       expect(result).toContain('hi'); // length 2
+
       expect(result).toContain('welcome'); // length 7
     });
 
     test('should work with empty array', () => {
       const empty: readonly { id: number }[] = [];
+
       const result = uniqBy(empty, (item) => item.id);
 
       assert.deepStrictEqual(result, []);
@@ -440,6 +504,7 @@ describe('Arr transformations', () => {
         [3, 4],
         [5, 6],
       ];
+
       const flattened = flat(nested);
 
       assert.deepStrictEqual(flattened, [1, 2, 3, 4, 5, 6]);
@@ -447,15 +512,19 @@ describe('Arr transformations', () => {
 
     test('should flatten with specified depth', () => {
       const deepNested = [1, [2, [3, 4]], 5];
+
       const flat1 = flat(deepNested, 1);
+
       const flat2 = flat(deepNested, 2);
 
       assert.deepStrictEqual(flat1, [1, 2, [3, 4], 5]);
+
       assert.deepStrictEqual(flat2, [1, 2, 3, 4, 5]);
     });
 
     test('should work with curried version', () => {
       const flattenOnce = flat();
+
       const result = flattenOnce([
         [1, 2],
         [3, 4],
@@ -466,6 +535,7 @@ describe('Arr transformations', () => {
 
     test('should work with empty arrays', () => {
       const withEmpties = [[1], [], [2, 3]];
+
       const flattened = flat(withEmpties);
 
       assert.deepStrictEqual(flattened, [1, 2, 3]);
@@ -476,6 +546,7 @@ describe('Arr transformations', () => {
         [1, 2],
         [3, 4],
       ];
+
       const unflattened = flat(nested, 0);
 
       assert.deepStrictEqual(unflattened, [
@@ -486,6 +557,7 @@ describe('Arr transformations', () => {
 
     test('should work with infinite depth', () => {
       const veryDeep = [1, [2, [3, [4, [5]]]]];
+
       const allFlat = flat(veryDeep, SafeUint.MAX_VALUE);
 
       assert.deepStrictEqual(allFlat, [1, 2, 3, 4, 5]);
@@ -495,6 +567,7 @@ describe('Arr transformations', () => {
   describe(flatMap, () => {
     test('should map and flatten results', () => {
       const words = ['hello', 'world'];
+
       const chars = flatMap(words, (word) => word.split(''));
 
       assert.deepStrictEqual(chars, [
@@ -513,6 +586,7 @@ describe('Arr transformations', () => {
 
     test('should work with curried version', () => {
       const splitWords = flatMap((word: string) => word.split(''));
+
       const result = splitWords(['foo', 'bar']);
 
       assert.deepStrictEqual(result, ['f', 'o', 'o', 'b', 'a', 'r']);
@@ -520,6 +594,7 @@ describe('Arr transformations', () => {
 
     test('should work with numbers', () => {
       const numbers = [1, 2, 3];
+
       const doubled = flatMap(numbers, (n) => [n, n * 2]);
 
       assert.deepStrictEqual(doubled, [1, 2, 2, 4, 3, 6]);
@@ -527,6 +602,7 @@ describe('Arr transformations', () => {
 
     test('should pass index to mapping function', () => {
       const numbers = [10, 20];
+
       const result = flatMap(numbers, (n, i) => [n, i]);
 
       assert.deepStrictEqual(result, [10, 0, 20, 1]);
@@ -534,6 +610,7 @@ describe('Arr transformations', () => {
 
     test('should work with empty arrays', () => {
       const empty: string[] = [];
+
       const result = flatMap(empty, (s) => s.split(''));
 
       assert.deepStrictEqual(result, []);
@@ -541,6 +618,7 @@ describe('Arr transformations', () => {
 
     test('should handle mapping to empty arrays', () => {
       const numbers = [1, 2, 3];
+
       const result = flatMap(numbers, (n) => (n % 2 === 0 ? [n] : []));
 
       assert.deepStrictEqual(result, [2]);
@@ -548,6 +626,7 @@ describe('Arr transformations', () => {
 
     test('should work with tuples', () => {
       const tuple = [1, 2] as const;
+
       const result = flatMap(tuple, (n) => [n, n]);
 
       assert.deepStrictEqual(result, [1, 1, 2, 2]);
@@ -650,6 +729,7 @@ describe('Arr transformations', () => {
 
     test('should partition array into chunks', () => {
       const numbers = [1, 2, 3, 4, 5, 6];
+
       const result = partition(numbers, 2);
 
       assert.deepStrictEqual(result, [
@@ -661,6 +741,7 @@ describe('Arr transformations', () => {
 
     test('should handle arrays not evenly divisible by chunk size', () => {
       const numbers = [1, 2, 3, 4, 5];
+
       const result = partition(numbers, 2);
 
       assert.deepStrictEqual(result, [[1, 2], [3, 4], [5]]);
@@ -668,6 +749,7 @@ describe('Arr transformations', () => {
 
     test('should work with chunk size < 2 (returns empty)', () => {
       const numbers = [1, 2, 3];
+
       const result = partition(numbers, 1);
 
       // According to docs, returns empty array if chunkSize < 2
@@ -676,6 +758,7 @@ describe('Arr transformations', () => {
 
     test('should work with chunk size larger than array', () => {
       const numbers = [1, 2];
+
       const result = partition(numbers, 5);
 
       assert.deepStrictEqual(result, [[1, 2]]);
@@ -683,6 +766,7 @@ describe('Arr transformations', () => {
 
     test('partition should work with empty array', () => {
       const empty: readonly number[] = [];
+
       const result = partition(empty, 2);
 
       assert.deepStrictEqual(result, []);
@@ -691,7 +775,9 @@ describe('Arr transformations', () => {
 
   describe(concat, () => {
     const xs = [1, 2, 3] as const;
+
     const ys = [4, 5] as const;
+
     const result = concat(xs, ys);
 
     expectType<typeof result, readonly [1, 2, 3, 4, 5]>('=');
@@ -798,35 +884,43 @@ describe('Arr transformations', () => {
         { type: 'vegetable', name: 'carrot' },
         { type: 'fruit', name: 'banana' },
       ];
+
       const grouped = groupBy(array, (item) => item.type);
 
       expect(grouped.size).toBe(2);
 
       const fruits = grouped.get('fruit');
+
       const vegetables = grouped.get('vegetable');
 
-      expect(Optional.isSome(fruits)).toBe(true);
-      expect(Optional.isSome(vegetables)).toBe(true);
+      assert.isTrue(Optional.isSome(fruits));
+
+      assert.isTrue(Optional.isSome(vegetables));
 
       if (Optional.isSome(fruits)) {
         expect(fruits.value).toHaveLength(2);
+
         expect(fruits.value[0]?.name).toBe('apple');
+
         expect(fruits.value[1]?.name).toBe('banana');
       }
 
       if (Optional.isSome(vegetables)) {
         expect(vegetables.value).toHaveLength(1);
+
         expect(vegetables.value[0]?.name).toBe('carrot');
       }
     });
 
     test('should work with numeric keys', () => {
       const numbers = [1, 2, 3, 4, 5, 6];
+
       const grouped = groupBy(numbers, (n) => n % 2);
 
       expect(grouped.size).toBe(2);
 
       const evens = grouped.get(0);
+
       const odds = grouped.get(1);
 
       if (Optional.isSome(evens)) {
@@ -840,6 +934,7 @@ describe('Arr transformations', () => {
 
     test('should work with empty array', () => {
       const empty: readonly number[] = [];
+
       const grouped = groupBy(empty, (n) => n % 2);
 
       expect(grouped.size).toBe(0);
@@ -847,6 +942,7 @@ describe('Arr transformations', () => {
 
     test('should handle all elements in same group', () => {
       const array = [1, 2, 3, 4];
+
       const grouped = groupBy(array, () => 'all');
 
       expect(grouped.size).toBe(1);
@@ -862,7 +958,9 @@ describe('Arr transformations', () => {
   describe(zip, () => {
     {
       const xs = [1, 2, 3] as const;
+
       const ys = [4, 5, 6] as const;
+
       const zipped = zip(xs, ys);
 
       expectType<
@@ -878,9 +976,12 @@ describe('Arr transformations', () => {
         ]);
       });
     }
+
     {
       const xs: readonly number[] = [1, 2, 3];
+
       const ys: readonly number[] = [4];
+
       const zipped = zip(xs, ys);
 
       expectType<typeof zipped, readonly (readonly [number, number])[]>('=');
@@ -889,9 +990,12 @@ describe('Arr transformations', () => {
         assert.deepStrictEqual(zipped, [[1, 4]]);
       });
     }
+
     {
       const xs = [1] as const;
+
       const ys: readonly number[] = [4, 5, 6];
+
       const zipped = zip(xs, ys);
 
       expectType<typeof zipped, readonly [readonly [1, number]]>('=');
@@ -943,7 +1047,9 @@ describe('Arr transformations', () => {
 
     test('should zip two arrays', () => {
       const arr1 = [1, 2, 3];
+
       const arr2 = ['a', 'b', 'c'];
+
       const result = zip(arr1, arr2);
 
       assert.deepStrictEqual(result, [
@@ -955,7 +1061,9 @@ describe('Arr transformations', () => {
 
     test('should handle arrays of different lengths', () => {
       const arr1 = [1, 2, 3, 4];
+
       const arr2 = ['a', 'b'];
+
       const result = zip(arr1, arr2);
 
       assert.deepStrictEqual(result, [
@@ -966,7 +1074,9 @@ describe('Arr transformations', () => {
 
     test('should work with empty arrays', () => {
       const arr1: readonly number[] = [];
+
       const arr2: readonly string[] = [];
+
       const result = zip(arr1, arr2);
 
       assert.deepStrictEqual(result, []);
@@ -974,7 +1084,9 @@ describe('Arr transformations', () => {
 
     test('should handle one empty array', () => {
       const arr1 = [1, 2, 3];
+
       const arr2: readonly string[] = [];
+
       const result = zip(arr1, arr2);
 
       assert.deepStrictEqual(result, []);