ts-data-forge 4.1.0 → 5.0.0

package/src/array/impl/array-utils-reducing-value.test.mts

@@ -15,7 +15,7 @@ import {
 } from './array-utils-reducing-value.mjs';
 
 describe('Arr reducing value', () => {
-  describe('min', () => {
+  describe(min, () => {
     {
       const xs = [3, 5, 4] as const;
       const result = min(xs);
@@ -24,6 +24,7 @@ describe('Arr reducing value', () => {
 
       test('case 1', () => {
         expect(Optional.isSome(result)).toBe(true);
+
         if (Optional.isSome(result)) {
           expect(result.value).toBe(3);
         }
@@ -37,6 +38,7 @@ describe('Arr reducing value', () => {
 
       test('case 2', () => {
         expect(Optional.isSome(result)).toBe(true);
+
         if (Optional.isSome(result)) {
           expect(result.value).toBe(3);
         }
@@ -50,6 +52,7 @@ describe('Arr reducing value', () => {
 
       test('case 3', () => {
         expect(Optional.isSome(result)).toBe(true);
+
         if (Optional.isSome(result)) {
           expect(result.value).toBe(3);
         }
@@ -57,7 +60,7 @@ describe('Arr reducing value', () => {
     }
   });
 
-  describe('max', () => {
+  describe(max, () => {
     const xs = [3, 5, 4] as const;
     const result = max(xs, (a, b) => a - b);
 
@@ -65,6 +68,7 @@ describe('Arr reducing value', () => {
 
     test('case 1', () => {
       expect(Optional.isSome(result)).toBe(true);
+
       if (Optional.isSome(result)) {
         expect(result.value).toBe(5);
       }
@@ -73,7 +77,9 @@ describe('Arr reducing value', () => {
     test('case 2: no comparator', () => {
       const res = max(xs);
       expectType<typeof res, Some<3 | 4 | 5>>('=');
+
       expect(Optional.isSome(res)).toBe(true);
+
       if (Optional.isSome(res)) {
         expect(res.value).toBe(5);
       }
@@ -83,7 +89,9 @@ describe('Arr reducing value', () => {
       const arr: readonly number[] = [1, 5, 2];
       const res = max(arr);
       expectType<typeof res, Optional<number>>('=');
+
       expect(Optional.isSome(res)).toBe(true);
+
       if (Optional.isSome(res)) {
         expect(res.value).toBe(5);
       }
@@ -93,11 +101,12 @@ describe('Arr reducing value', () => {
       const arr: readonly number[] = [];
       const res = max(arr);
       expectType<typeof res, Optional<number>>('=');
+
       expect(Optional.isNone(res)).toBe(true);
     });
   });
 
-  describe('minBy', () => {
+  describe(minBy, () => {
     const xs = [
       { x: 5, y: 1 },
       { x: 4, y: 1 },
@@ -125,8 +134,9 @@ describe('Arr reducing value', () => {
 
     test('case 1', () => {
       expect(Optional.isSome(result)).toBe(true);
+
       if (Optional.isSome(result)) {
-        expect(result.value).toStrictEqual({ x: 1, y: 2 });
+        assert.deepStrictEqual(result.value, { x: 1, y: 2 });
       }
     });
 
@@ -134,6 +144,7 @@ describe('Arr reducing value', () => {
       const arr: readonly { x: number }[] = [];
       const res = minBy(arr, (a) => a.x);
       expectType<typeof res, Optional<{ x: number }>>('=');
+
       expect(Optional.isNone(res)).toBe(true);
     });
 
@@ -162,13 +173,14 @@ describe('Arr reducing value', () => {
       >('=');
 
       expect(Optional.isSome(res)).toBe(true);
+
       if (Optional.isSome(res)) {
-        expect(res.value).toStrictEqual({ name: 'apple', score: 10 });
+        assert.deepStrictEqual(res.value, { name: 'apple', score: 10 });
       }
     });
   });
 
-  describe('maxBy', () => {
+  describe(maxBy, () => {
     const xs = [
       { x: 5, y: 1 },
       { x: 4, y: 1 },
@@ -196,8 +208,9 @@ describe('Arr reducing value', () => {
 
     test('case 1', () => {
       expect(Optional.isSome(result)).toBe(true);
+
       if (Optional.isSome(result)) {
-        expect(result.value).toStrictEqual({ x: 6, y: 1 });
+        assert.deepStrictEqual(result.value, { x: 6, y: 1 });
       }
     });
 
@@ -205,6 +218,7 @@ describe('Arr reducing value', () => {
       const arr: readonly { x: number }[] = [];
       const res = maxBy(arr, (a) => a.x);
       expectType<typeof res, Optional<{ x: number }>>('=');
+
       expect(Optional.isNone(res)).toBe(true);
     });
 
@@ -233,13 +247,14 @@ describe('Arr reducing value', () => {
       >('=');
 
       expect(Optional.isSome(res)).toBe(true);
+
       if (Optional.isSome(res)) {
-        expect(res.value).toStrictEqual({ name: 'cherry', score: 12 });
+        assert.deepStrictEqual(res.value, { name: 'cherry', score: 12 });
       }
     });
   });
 
-  describe('count', () => {
+  describe(count, () => {
     const xs = [
       { x: 1, y: 1 },
       { x: 2, y: 1 },
@@ -261,11 +276,12 @@ describe('Arr reducing value', () => {
       const arr: readonly number[] = [];
       const res = count(arr, (x) => x > 0);
       expectType<typeof res, Uint32>('=');
+
       expect(res).toBe(0);
     });
   });
 
-  describe('countBy', () => {
+  describe(countBy, () => {
     const xs = [
       { x: 1, y: 1 },
       { x: 2, y: 1 },
@@ -280,8 +296,9 @@ describe('Arr reducing value', () => {
     expectType<typeof result, IMap<1 | 2 | 3, 0 | 1 | 2 | 3 | 4 | 5>>('=');
 
     test('case 1', () => {
-      expect(result).toStrictEqual(
-        IMap.create<1 | 2 | 3, number>([
+      assert.deepStrictEqual(
+        result,
+        IMap.create<1 | 2 | 3, 0 | 1 | 2 | 3 | 4 | 5>([
           [1, 3],
           [2, 2],
           [3, 1],
@@ -293,20 +310,23 @@ describe('Arr reducing value', () => {
       const arr: readonly { x: number }[] = [];
       const res = countBy(arr, (a) => a.x);
       expectType<typeof res, IMap<number, Uint32>>('=');
+
       expect(res.size).toBe(0);
     });
   });
 
-  describe('foldl', () => {
+  describe(foldl, () => {
     test('empty array', () => {
       const result = foldl([], (acc, curr: number) => acc + curr, 0);
       expectType<typeof result, number>('=');
+
       expect(result).toBe(0);
     });
 
     test('sum numbers', () => {
       const result = foldl([1, 2, 3] as const, (acc, curr) => acc + curr, 0);
       expectType<typeof result, number>('=');
+
       expect(result).toBe(6);
     });
 
@@ -317,14 +337,16 @@ describe('Arr reducing value', () => {
         '',
       );
       expectType<typeof result, string>('=');
+
       expect(result).toBe('abc');
     });
   });
 
-  describe('foldr', () => {
+  describe(foldr, () => {
     test('empty array', () => {
       const result = foldr([], (acc, curr: number) => acc + curr, 0);
       expectType<typeof result, number>('=');
+
       expect(result).toBe(0);
     });
 
@@ -332,6 +354,7 @@ describe('Arr reducing value', () => {
       // (1 - (2 - (3 - 0))) = 1 - (2 - 3) = 1 - (-1) = 2
       const result = foldr([1, 2, 3] as const, (acc, curr) => curr - acc, 0);
       expectType<typeof result, number>('=');
+
       expect(result).toBe(2); // 3 - (2 - (1 - 0)) = 3 - (2 - 1) = 3 - 1 = 2.  No, this is (acc, curr) => acc - curr.
       // The callback is (previousValue: S, currentValue: A) => S
       // So it's initialValue for S.
@@ -347,6 +370,7 @@ describe('Arr reducing value', () => {
         '',
       );
       expectType<typeof result, string>('=');
+
       expect(result).toBe('abc'); // c + (b + (a + "")) = cba. No, it's curr + acc.
       // Iteration 1: prev = "", curr = "c". Result = "c" + "" = "c".
       // Iteration 2: prev = "c", curr = "b". Result = "b" + "c" = "bc".
@@ -354,38 +378,43 @@ describe('Arr reducing value', () => {
     });
   });
 
-  describe('sum', () => {
+  describe(sum, () => {
     test('empty array', () => {
       const result = sum([]);
       expectType<typeof result, 0>('=');
+
       expect(result).toBe(0);
     });
 
     test('one element array', () => {
       const result = sum([23]);
       expectType<typeof result, 23>('=');
+
       expect(result).toBe(23);
     });
 
     test('positive numbers', () => {
       const result = sum([1, 2, 3, 4, 5] as const);
       expectType<typeof result, number>('=');
+
       expect(result).toBe(15);
     });
 
     test('mixed numbers', () => {
       const result = sum([1, -2, 3, 0, -5] as const);
       expectType<typeof result, number>('=');
+
       expect(result).toBe(-3);
     });
   });
 
-  describe('join', () => {
+  describe(join, () => {
     test('should join array elements', () => {
       const arr = ['Hello', 'World'];
       const result = join(arr, ' ');
 
       expect(Result.isOk(result)).toBe(true);
+
       if (Result.isOk(result)) {
         expect(result.value).toBe('Hello World');
       }
@@ -396,6 +425,7 @@ describe('Arr reducing value', () => {
       const result = join(arr, '');
 
       expect(Result.isOk(result)).toBe(true);
+
       if (Result.isOk(result)) {
         expect(result.value).toBe('abc');
       }
@@ -406,6 +436,7 @@ describe('Arr reducing value', () => {
       const result = join(arr);
 
       expect(Result.isOk(result)).toBe(true);
+
       if (Result.isOk(result)) {
         expect(result.value).toBe('a,b,c');
       }

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

@@ -12,10 +12,11 @@ import {
 } from './array-utils-search.mjs';
 
 describe('Arr search operations', () => {
-  describe('find', () => {
+  describe(find, () => {
     test('should find first element matching predicate', () => {
       const numbers = [1, 2, 3, 4, 5];
       const firstEven = find(numbers, (n) => n % 2 === 0);
+
       expect(Optional.isSome(firstEven)).toBe(true);
       expect(Optional.unwrap(firstEven)).toBe(2);
     });
@@ -23,6 +24,7 @@ describe('Arr search operations', () => {
     test('should return None when no element matches', () => {
       const odds = [1, 3, 5];
       const firstEven = find(odds, (n) => n % 2 === 0);
+
       expect(Optional.isNone(firstEven)).toBe(true);
     });
 
@@ -46,6 +48,7 @@ describe('Arr search operations', () => {
       );
 
       expectType<typeof firstString, Optional<string>>('=');
+
       expect(Optional.isSome(firstString)).toBe(true);
       expect(Optional.unwrap(firstString)).toBe('a');
     });
@@ -54,6 +57,7 @@ describe('Arr search operations', () => {
       const numbers = [10, 20, 30];
       const foundWithIndex = find(numbers, (value, index, arr) => {
         expect(arr).toBe(numbers);
+
         return index === 1 && value === 20;
       });
 
@@ -63,20 +67,23 @@ describe('Arr search operations', () => {
     test('should return first match when multiple elements match', () => {
       const numbers = [2, 4, 6, 8];
       const firstEven = find(numbers, (n) => n % 2 === 0);
+
       expect(Optional.unwrap(firstEven)).toBe(2);
     });
 
     test('should work with empty array', () => {
       const empty: readonly number[] = [];
       const result = find(empty, () => true);
+
       expect(Optional.isNone(result)).toBe(true);
     });
   });
 
-  describe('findLast', () => {
+  describe(findLast, () => {
     test('should find last element matching predicate', () => {
       const numbers = [1, 2, 3, 4, 5];
       const lastEven = findLast(numbers, (n) => n % 2 === 0);
+
       expect(Optional.isSome(lastEven)).toBe(true);
       expect(Optional.unwrap(lastEven)).toBe(4);
     });
@@ -84,6 +91,7 @@ describe('Arr search operations', () => {
     test('should return None when no element matches', () => {
       const odds = [1, 3, 5];
       const lastEven = findLast(odds, (n) => n % 2 === 0);
+
       expect(Optional.isNone(lastEven)).toBe(true);
     });
 
@@ -91,6 +99,7 @@ describe('Arr search operations', () => {
       const isPositive = (n: number): boolean => n > 0;
       const findLastPositive = findLast(isPositive);
       const result = findLastPositive([-1, 2, -3, 4]);
+
       expect(Optional.isSome(result)).toBe(true);
       expect(Optional.unwrap(result)).toBe(4);
     });
@@ -98,6 +107,7 @@ describe('Arr search operations', () => {
     test('should work with empty array', () => {
       const empty: number[] = [];
       const result = findLast(empty, (n) => n > 0);
+
       expect(Optional.isNone(result)).toBe(true);
     });
 
@@ -105,29 +115,35 @@ describe('Arr search operations', () => {
       const numbers = [10, 20, 30, 40];
       const lastWithIndex2 = findLast(numbers, (_, idx, arr) => {
         expect(arr).toBe(numbers);
+
         return idx === 2;
       });
+
       expect(Optional.unwrap(lastWithIndex2)).toBe(30);
     });
 
     test('should find last occurrence', () => {
       const numbers = [1, 2, 2, 3, 2, 4];
       const lastTwo = findLast(numbers, (n) => n === 2);
+
       expect(Optional.unwrap(lastTwo)).toBe(2);
 
       // Verify it's actually the last occurrence by checking behavior
       const index = numbers.lastIndexOf(2);
+
       expect(index).toBe(4); // Last 2 is at index 4
     });
   });
 
-  describe('findIndex', () => {
+  describe(findIndex, () => {
     test('should find index of matching element', () => {
       const arr = ['a', 'b', 'c'];
       const result = findIndex(arr, (x) => x === 'b');
 
       expect(result).toBeGreaterThanOrEqual(0);
+
       expectType<typeof result, SizeType.Arr | -1>('=');
+
       expect(result).toBe(1);
     });
 
@@ -139,16 +155,18 @@ describe('Arr search operations', () => {
     });
   });
 
-  describe('findLastIndex', () => {
+  describe(findLastIndex, () => {
     test('should find last index matching predicate', () => {
       const numbers = [1, 2, 3, 4, 2, 5];
       const lastTwoIndex = findLastIndex(numbers, (n) => n === 2);
+
       expect(lastTwoIndex).toBe(4);
     });
 
     test('should return -1 when no element matches', () => {
       const odds = [1, 3, 5];
       const lastEvenIndex = findLastIndex(odds, (n) => n % 2 === 0);
+
       expect(lastEvenIndex).toBe(-1);
     });
 
@@ -156,12 +174,14 @@ describe('Arr search operations', () => {
       const isPositive = (n: number): boolean => n > 0;
       const findLastPositiveIndex = findLastIndex(isPositive);
       const result = findLastPositiveIndex([-1, 2, -3, 4, -5]);
+
       expect(result).toBe(3); // index of last positive number (4)
     });
 
     test('should work with empty array', () => {
       const empty: number[] = [];
       const result = findLastIndex(empty, (n) => n > 0);
+
       expect(result).toBe(-1);
     });
 
@@ -169,8 +189,10 @@ describe('Arr search operations', () => {
       const numbers = [10, 20, 30, 40];
       const lastWithIndex2OrHigher = findLastIndex(numbers, (_, idx, arr) => {
         expect(arr).toBe(numbers);
+
         return idx >= 2;
       });
+
       expect(lastWithIndex2OrHigher).toBe(3); // last index >= 2
     });
 
@@ -183,12 +205,14 @@ describe('Arr search operations', () => {
         { id: 5, active: true },
       ];
       const lastActiveIndex = findLastIndex(data, (item) => item.active);
+
       expect(lastActiveIndex).toBe(4); // last active item
     });
 
     test('should work with tuples', () => {
       const tuple = [10, 20, 30, 20, 40] as const;
       const lastTwentyIndex = findLastIndex(tuple, (x) => x === 20);
+
       expect(lastTwentyIndex).toBe(3); // last occurrence of 20
     });
 
@@ -203,7 +227,7 @@ describe('Arr search operations', () => {
       });
 
       // Should search from end: 4, 3, 2 (stops at 2 when found)
-      expect(mut_searchOrder).toStrictEqual([4, 3, 2]);
+      assert.deepStrictEqual(mut_searchOrder, [4, 3, 2]);
     });
 
     test('should handle single element array', () => {
@@ -218,18 +242,21 @@ describe('Arr search operations', () => {
     test('should work with string arrays', () => {
       const words = ['hello', 'world', 'test', 'hello', 'end'];
       const lastHelloIndex = findLastIndex(words, (word) => word === 'hello');
+
       expect(lastHelloIndex).toBe(3);
     });
   });
 
-  describe('indexOf', () => {
+  describe(indexOf, () => {
     test('should find index of element', () => {
       const arr = ['a', 'b', 'c', 'b'];
       const result = indexOf(arr, 'b');
 
       expect(result).toBeGreaterThanOrEqual(0);
+
       if (result !== -1) {
         expectType<typeof result, SizeType.Arr>('=');
+
         expect(result).toBe(1);
       }
     });
@@ -242,14 +269,16 @@ describe('Arr search operations', () => {
     });
   });
 
-  describe('indexOfFrom', () => {
+  describe(indexOfFrom, () => {
     test('should find index of element from specified index', () => {
       const arr = ['a', 'b', 'c', 'b'];
       const result = indexOfFrom(arr, 'b', 2);
 
       expect(result).toBeGreaterThanOrEqual(0);
+
       if (result !== -1) {
         expectType<typeof result, SizeType.Arr>('=');
+
         expect(result).toBe(3);
       }
     });
@@ -283,14 +312,16 @@ describe('Arr search operations', () => {
     });
   });
 
-  describe('lastIndexOf', () => {
+  describe(lastIndexOf, () => {
     test('should find last index of element', () => {
       const arr = ['a', 'b', 'c', 'b'];
       const result = lastIndexOf(arr, 'b');
 
       expect(result).toBeGreaterThanOrEqual(0);
+
       if (result !== -1) {
         expectType<typeof result, SizeType.Arr>('=');
+
         expect(result).toBe(3);
       }
     });
@@ -303,14 +334,16 @@ describe('Arr search operations', () => {
     });
   });
 
-  describe('lastIndexOfFrom', () => {
+  describe(lastIndexOfFrom, () => {
     test('should find last index of element from specified index', () => {
       const arr = ['a', 'b', 'c', 'b', 'e'];
       const result = lastIndexOfFrom(arr, 'b', 2);
 
       expect(result).toBeGreaterThanOrEqual(0);
+
       if (result !== -1) {
         expectType<typeof result, SizeType.Arr>('=');
+
         expect(result).toBe(1);
       }
     });