ts-data-forge 4.0.0 → 5.0.0

package/src/array/impl/array-utils-set-op.test.mts

@@ -9,12 +9,13 @@ import {
 } from './array-utils-set-op.mjs';
 
 describe('Arr set operations', () => {
-  describe('eq', () => {
+  describe(eq, () => {
     {
       const xs = [1, 2, 3] as const;
       const ys = [1, 2, 3] as const;
       const result = eq(xs, ys);
       expectType<typeof result, boolean>('=');
+
       test('should return true for equal arrays of numbers', () => {
         expect(result).toBe(true);
       });
@@ -24,6 +25,7 @@ describe('Arr set operations', () => {
       const ys = [1, 2, 4] as const;
       const result = eq(xs, ys);
       expectType<typeof result, boolean>('=');
+
       test('should return false for different arrays of numbers', () => {
         expect(result).toBe(false);
       });
@@ -33,6 +35,7 @@ describe('Arr set operations', () => {
       const ys = [1, 2] as const;
       const result = eq(xs, ys);
       expectType<typeof result, boolean>('=');
+
       test('should return false for arrays of different lengths', () => {
         expect(result).toBe(false);
       });
@@ -42,6 +45,7 @@ describe('Arr set operations', () => {
       const ys = ['a', 'b'] as const;
       const result = eq(xs, ys);
       expectType<typeof result, boolean>('=');
+
       test('should return true for equal arrays of strings', () => {
         expect(result).toBe(true);
       });
@@ -51,6 +55,7 @@ describe('Arr set operations', () => {
       const ys = [] as const;
       const result = eq(xs, ys);
       expectType<typeof result, boolean>('=');
+
       test('should return true for empty arrays', () => {
         expect(result).toBe(true);
       });
@@ -61,6 +66,7 @@ describe('Arr set operations', () => {
       // Default eq uses reference equality for objects
       const result = eq(xs, ys);
       expectType<typeof result, boolean>('=');
+
       test('should return false for arrays of objects with default equality (reference check)', () => {
         expect(result).toBe(false);
       });
@@ -72,6 +78,7 @@ describe('Arr set operations', () => {
       const ys = [objA, objB] as const;
       const result = eq(xs, ys);
       expectType<typeof result, boolean>('=');
+
       test('should return true for arrays of same object references', () => {
         expect(result).toBe(true);
       });
@@ -85,13 +92,14 @@ describe('Arr set operations', () => {
         (o1, o2) => JSON.stringify(o1) === JSON.stringify(o2),
       );
       expectType<typeof result, boolean>('=');
+
       test('should return true for arrays of objects with custom equality function', () => {
         expect(result).toBe(true);
       });
     }
   });
 
-  describe('isSubset', () => {
+  describe(isSubset, () => {
     {
       const xs = [1, 2, 3] as const;
       const ys = [3, 2] as const;
@@ -118,7 +126,7 @@ describe('Arr set operations', () => {
     }
   });
 
-  describe('isSuperset', () => {
+  describe(isSuperset, () => {
     {
       const xs = [1, 2, 3] as const;
       const ys = [3, 2] as const;
@@ -151,14 +159,15 @@ describe('Arr set operations', () => {
     }
   });
 
-  describe('setIntersection', () => {
+  describe(setIntersection, () => {
     {
       const xs = [1, 2, 3] as const;
       const ys = [2, 3, 4] as const;
       const result = setIntersection(xs, ys);
       expectType<typeof result, readonly (2 | 3)[]>('=');
+
       test('should return the intersection of two number arrays', () => {
-        expect(result).toStrictEqual([2, 3]);
+        assert.deepStrictEqual(result, [2, 3]);
       });
     }
     {
@@ -166,8 +175,9 @@ describe('Arr set operations', () => {
       const ys = ['b', 'c', 'd'] as const;
       const result = setIntersection(xs, ys);
       expectType<typeof result, readonly ('b' | 'c')[]>('=');
+
       test('should return the intersection of two string arrays', () => {
-        expect(result).toStrictEqual(['b', 'c']);
+        assert.deepStrictEqual(result, ['b', 'c']);
       });
     }
     {
@@ -175,8 +185,9 @@ describe('Arr set operations', () => {
       const ys = [4, 5, 6] as const;
       const result = setIntersection(xs, ys);
       expectType<typeof result, readonly never[]>('=');
+
       test('should return an empty array if there is no intersection', () => {
-        expect(result).toStrictEqual([]);
+        assert.deepStrictEqual(result, []);
       });
     }
     {
@@ -184,8 +195,9 @@ describe('Arr set operations', () => {
       const ys = [] as const;
       const result = setIntersection(xs, ys);
       expectType<typeof result, readonly never[]>('=');
+
       test('should return an empty array if one array is empty', () => {
-        expect(result).toStrictEqual([]);
+        assert.deepStrictEqual(result, []);
       });
     }
     {
@@ -193,20 +205,22 @@ describe('Arr set operations', () => {
       const ys = [1, 2, 3] as const;
       const result = setIntersection(xs, ys);
       expectType<typeof result, readonly never[]>('=');
+
       test('should return an empty array if the first array is empty', () => {
-        expect(result).toStrictEqual([]);
+        assert.deepStrictEqual(result, []);
       });
     }
   });
 
-  describe('setDifference', () => {
+  describe(setDifference, () => {
     {
       const xs = [1, 2, 3] as const;
       const ys = [2, 3, 4] as const;
       const result = setDifference(xs, ys);
       expectType<typeof result, readonly (1 | 2 | 3 | 4)[]>('=');
+
       test('should return the difference xs - ys for number arrays', () => {
-        expect(result).toStrictEqual([1]);
+        assert.deepStrictEqual(result, [1]);
       });
     }
     {
@@ -214,8 +228,9 @@ describe('Arr set operations', () => {
       const ys = ['b', 'c', 'd'] as const;
       const result = setDifference(xs, ys);
       expectType<typeof result, readonly ('a' | 'b' | 'c' | 'd')[]>('=');
+
       test('should return the difference xs - ys for string arrays', () => {
-        expect(result).toStrictEqual(['a']);
+        assert.deepStrictEqual(result, ['a']);
       });
     }
     {
@@ -223,8 +238,9 @@ describe('Arr set operations', () => {
       const ys = [1, 2, 3] as const;
       const result = setDifference(xs, ys);
       expectType<typeof result, readonly (1 | 2 | 3)[]>('=');
+
       test('should return an empty array if xs is a subset of ys', () => {
-        expect(result).toStrictEqual([]);
+        assert.deepStrictEqual(result, []);
       });
     }
     {
@@ -232,8 +248,9 @@ describe('Arr set operations', () => {
       const ys = [4, 5, 6] as const;
       const result = setDifference(xs, ys);
       expectType<typeof result, readonly (1 | 2 | 3 | 4 | 5 | 6)[]>('=');
+
       test('should return xs if there is no intersection', () => {
-        expect(result).toStrictEqual([1, 2, 3]);
+        assert.deepStrictEqual(result, [1, 2, 3]);
       });
     }
     {
@@ -241,8 +258,9 @@ describe('Arr set operations', () => {
       const ys = [] as const;
       const result = setDifference(xs, ys);
       expectType<typeof result, readonly (1 | 2 | 3)[]>('=');
+
       test('should return xs if ys is empty', () => {
-        expect(result).toStrictEqual([1, 2, 3]);
+        assert.deepStrictEqual(result, [1, 2, 3]);
       });
     }
     {
@@ -250,20 +268,22 @@ describe('Arr set operations', () => {
       const ys = [1, 2, 3] as const;
       const result = setDifference(xs, ys);
       expectType<typeof result, readonly (1 | 2 | 3)[]>('=');
+
       test('should return an empty array if xs is empty', () => {
-        expect(result).toStrictEqual([]);
+        assert.deepStrictEqual(result, []);
       });
     }
   });
 
-  describe('sortedNumSetDifference', () => {
+  describe(sortedNumSetDifference, () => {
     {
       const xs = [1, 2, 3, 5] as const;
       const ys = [2, 3, 4] as const;
       const result = sortedNumSetDifference(xs, ys);
       expectType<typeof result, readonly (1 | 2 | 3 | 4 | 5)[]>('=');
+
       test('should return the difference for sorted number arrays (xs - ys)', () => {
-        expect(result).toStrictEqual([1, 5]);
+        assert.deepStrictEqual(result, [1, 5]);
       });
     }
     {
@@ -271,8 +291,9 @@ describe('Arr set operations', () => {
       const ys = [1, 2, 3] as const;
       const result = sortedNumSetDifference(xs, ys);
       expectType<typeof result, readonly (1 | 2 | 3)[]>('=');
+
       test('should return an empty array if sets are equal', () => {
-        expect(result).toStrictEqual([]);
+        assert.deepStrictEqual(result, []);
       });
     }
     {
@@ -280,8 +301,9 @@ describe('Arr set operations', () => {
       const ys = [4, 5, 6] as const;
       const result = sortedNumSetDifference(xs, ys);
       expectType<typeof result, readonly (1 | 2 | 3 | 4 | 5 | 6)[]>('=');
+
       test('should return xs if no common elements', () => {
-        expect(result).toStrictEqual([1, 2, 3]);
+        assert.deepStrictEqual(result, [1, 2, 3]);
       });
     }
     {
@@ -289,8 +311,9 @@ describe('Arr set operations', () => {
       const ys = [1, 2, 3] as const;
       const result = sortedNumSetDifference(xs, ys);
       expectType<typeof result, readonly (1 | 2 | 3 | 4 | 5 | 6)[]>('=');
+
       test('should return xs if no common elements (ys < xs)', () => {
-        expect(result).toStrictEqual([4, 5, 6]);
+        assert.deepStrictEqual(result, [4, 5, 6]);
       });
     }
     {
@@ -298,8 +321,9 @@ describe('Arr set operations', () => {
       const ys = [2, 4] as const;
       const result = sortedNumSetDifference(xs, ys);
       expectType<typeof result, readonly (1 | 2 | 3 | 4 | 5)[]>('=');
+
       test('should return correct difference when ys is subset of xs', () => {
-        expect(result).toStrictEqual([1, 3, 5]);
+        assert.deepStrictEqual(result, [1, 3, 5]);
       });
     }
     {
@@ -307,8 +331,9 @@ describe('Arr set operations', () => {
       const ys = [1, 2, 3, 4, 5] as const;
       const result = sortedNumSetDifference(xs, ys);
       expectType<typeof result, readonly (1 | 2 | 3 | 4 | 5)[]>('=');
+
       test('should return empty array when xs is subset of ys', () => {
-        expect(result).toStrictEqual([]);
+        assert.deepStrictEqual(result, []);
       });
     }
     {
@@ -316,8 +341,9 @@ describe('Arr set operations', () => {
       const ys = [1, 2, 3] as const;
       const result = sortedNumSetDifference(xs, ys);
       expectType<typeof result, readonly (1 | 2 | 3)[]>('='); // Type is `readonly number[]` due to `ys`
+
       test('should return an empty array if xs is empty', () => {
-        expect(result).toStrictEqual([]);
+        assert.deepStrictEqual(result, []);
       });
     }
     {
@@ -325,8 +351,9 @@ describe('Arr set operations', () => {
       const ys = [] as const;
       const result = sortedNumSetDifference(xs, ys);
       expectType<typeof result, readonly (1 | 2 | 3)[]>('=');
+
       test('should return xs if ys is empty', () => {
-        expect(result).toStrictEqual([1, 2, 3]);
+        assert.deepStrictEqual(result, [1, 2, 3]);
       });
     }
     {
@@ -334,8 +361,9 @@ describe('Arr set operations', () => {
       const ys = [] as const;
       const result = sortedNumSetDifference(xs, ys);
       expectType<typeof result, readonly never[]>('='); // Type is `readonly number[]`
+
       test('should return an empty array if both are empty', () => {
-        expect(result).toStrictEqual([]);
+        assert.deepStrictEqual(result, []);
       });
     }
   });

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

@@ -3,6 +3,7 @@ import { length, size } from './array-utils-size.mjs';
 describe('size/length', () => {
   test('size should return the array length', () => {
     const array = [1, 2, 3];
+
     expect(size(array)).toBe(array.length);
     expect(length(array)).toBe(3);
   });

package/src/array/impl/array-utils-slice-clamped.test.mts

@@ -2,7 +2,7 @@ import { asInt32, asUint32 } from '../../number/index.mjs';
 import { sliceClamped } from './array-utils-slice-clamped.mjs';
 
 describe('Arr', () => {
-  describe('sliceClamped', () => {
+  describe(sliceClamped, () => {
     {
       const list: readonly number[] = [0, 1, 2, 3, 4] as const;
 
@@ -73,7 +73,7 @@ describe('Arr', () => {
           expected: [],
         },
       ] as const)('sliceClamped($start, $end)', ({ end, expected, start }) => {
-        expect(sliceClamped(list, start, end)).toStrictEqual(expected);
+        assert.deepStrictEqual(sliceClamped(list, start, end), expected);
       });
     }
 
@@ -82,56 +82,65 @@ describe('Arr', () => {
         const array = [1, 2, 3, 4, 5] as const;
         // @ts-expect-error end index is out of bounds
         const result = sliceClamped(array, 0, 6);
-        expect(result).toStrictEqual(array);
+
+        assert.deepStrictEqual(result, array);
       }
       {
         const array = [1, 2, 3, 4, 5] as const;
         // @ts-expect-error end index is out of bounds
         const result = sliceClamped(array, 0, -6);
-        expect(result).toStrictEqual([]);
+
+        assert.deepStrictEqual(result, []);
       }
       {
         const array = [1, 2, 3, 4, 5] as const;
         // @ts-expect-error start index is out of bounds
         const result = sliceClamped(array, -6, 5);
-        expect(result).toStrictEqual(array);
+
+        assert.deepStrictEqual(result, array);
       }
       {
         const array = [1, 2, 3, 4, 5] as const;
         // @ts-expect-error start index is out of bounds
         const result = sliceClamped(array, 6, 5);
-        expect(result).toStrictEqual([]);
+
+        assert.deepStrictEqual(result, []);
       }
     });
 
     test('should slice with clamped indices', () => {
       const array = [1, 2, 3, 4, 5];
       const result = sliceClamped(array, 1, 3);
-      expect(result).toStrictEqual([2, 3]);
+
+      assert.deepStrictEqual(result, [2, 3]);
     });
 
     test('should clamp start index below 0', () => {
       const array = [1, 2, 3, 4, 5];
       const result = sliceClamped(array, -10, 3);
-      expect(result).toStrictEqual([1, 2, 3]);
+
+      assert.deepStrictEqual(result, [1, 2, 3]);
     });
 
     test('should clamp end index above length', () => {
       const array = [1, 2, 3, 4, 5];
       const result = sliceClamped(array, asUint32(2), asUint32(100));
-      expect(result).toStrictEqual([3, 4, 5]);
+
+      assert.deepStrictEqual(result, [3, 4, 5]);
     });
 
     test('should work with both indices out of range', () => {
       const array = [1, 2, 3];
       const result = sliceClamped(array, asInt32(-10), asUint32(100));
-      expect(result).toStrictEqual([1, 2, 3]);
+
+      assert.deepStrictEqual(result, [1, 2, 3]);
     });
 
     test('should work with empty array', () => {
       const array: readonly number[] = [];
       const result = sliceClamped(array, 0, 5);
-      expect(result).toStrictEqual([]);
+
+      assert.deepStrictEqual(result, []);
     });
   });
 });

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

@@ -9,62 +9,68 @@ import {
 } from './array-utils-slicing.mjs';
 
 describe('Arr slicing', () => {
-  describe('tail', () => {
+  describe(tail, () => {
     test('should return all elements except the first', () => {
       const array = [1, 2, 3, 4] as const;
       const result = tail(array);
       expectType<typeof result, readonly [2, 3, 4]>('=');
-      expect(result).toStrictEqual([2, 3, 4]);
+
+      assert.deepStrictEqual(result, [2, 3, 4]);
     });
 
     test('should work with single element array', () => {
       const array = [1] as const;
       const result = tail(array);
       expectType<typeof result, readonly []>('=');
-      expect(result).toStrictEqual([]);
+
+      assert.deepStrictEqual(result, []);
     });
 
     test('should work with empty array', () => {
       const array = [] as const;
       const result = tail(array);
       expectType<typeof result, readonly []>('=');
-      expect(result).toStrictEqual([]);
+
+      assert.deepStrictEqual(result, []);
     });
   });
 
-  describe('butLast', () => {
+  describe(butLast, () => {
     test('readonly number[] type', () => {
       const xs: readonly number[] = [1, 2, 3];
       const bl = butLast(xs);
 
       expectType<typeof bl, readonly number[]>('=');
 
-      expect(bl).toStrictEqual([1, 2]);
+      assert.deepStrictEqual(bl, [1, 2]);
     });
 
     test('should return all elements except the last', () => {
       const array = [1, 2, 3, 4] as const;
       const result = butLast(array);
       expectType<typeof result, readonly [1, 2, 3]>('=');
-      expect(result).toStrictEqual([1, 2, 3]);
+
+      assert.deepStrictEqual(result, [1, 2, 3]);
     });
 
     test('should work with single element array', () => {
       const array = [1] as const;
       const result = butLast(array);
       expectType<typeof result, readonly []>('=');
-      expect(result).toStrictEqual([]);
+
+      assert.deepStrictEqual(result, []);
     });
 
     test('should work with empty array', () => {
       const array = [] as const;
       const result = butLast(array);
       expectType<typeof result, readonly []>('=');
-      expect(result).toStrictEqual([]);
+
+      assert.deepStrictEqual(result, []);
     });
   });
 
-  describe('take', () => {
+  describe(take, () => {
     {
       const xs = [1, 2, 3] as const;
       const t = take(xs, 2);
@@ -72,7 +78,7 @@ describe('Arr slicing', () => {
       expectType<typeof t, readonly [1, 2]>('=');
 
       test('case 1', () => {
-        expect(t).toStrictEqual([1, 2]);
+        assert.deepStrictEqual(t, [1, 2]);
       });
     }
     {
@@ -82,12 +88,12 @@ describe('Arr slicing', () => {
       expectType<typeof t, readonly number[]>('=');
 
       test('case 2', () => {
-        expect(t).toStrictEqual([1, 2]);
+        assert.deepStrictEqual(t, [1, 2]);
       });
     }
   });
 
-  describe('takeLast', () => {
+  describe(takeLast, () => {
     {
       const xs = [1, 2, 3] as const;
       const t = takeLast(xs, 2);
@@ -95,7 +101,7 @@ describe('Arr slicing', () => {
       expectType<typeof t, readonly [2, 3]>('=');
 
       test('case 1', () => {
-        expect(t).toStrictEqual([2, 3]);
+        assert.deepStrictEqual(t, [2, 3]);
       });
     }
     {
@@ -105,12 +111,12 @@ describe('Arr slicing', () => {
       expectType<typeof t, readonly number[]>('=');
 
       test('case 2', () => {
-        expect(t).toStrictEqual([2, 3]);
+        assert.deepStrictEqual(t, [2, 3]);
       });
     }
   });
 
-  describe('skip', () => {
+  describe(skip, () => {
     {
       const xs = [1, 2, 3] as const;
       const t = skip(xs, 2);
@@ -118,7 +124,7 @@ describe('Arr slicing', () => {
       expectType<typeof t, readonly [3]>('=');
 
       test('case 1', () => {
-        expect(t).toStrictEqual([3]);
+        assert.deepStrictEqual(t, [3]);
       });
     }
     {
@@ -128,12 +134,12 @@ describe('Arr slicing', () => {
       expectType<typeof t, readonly number[]>('=');
 
       test('case 2', () => {
-        expect(t).toStrictEqual([3]);
+        assert.deepStrictEqual(t, [3]);
       });
     }
   });
 
-  describe('skipLast', () => {
+  describe(skipLast, () => {
     {
       const xs = [1, 2, 3] as const;
       const t = skipLast(xs, 2);
@@ -141,7 +147,7 @@ describe('Arr slicing', () => {
       expectType<typeof t, readonly [1]>('=');
 
       test('case 1', () => {
-        expect(t).toStrictEqual([1]);
+        assert.deepStrictEqual(t, [1]);
       });
     }
     {
@@ -151,7 +157,7 @@ describe('Arr slicing', () => {
       expectType<typeof t, readonly number[]>('=');
 
       test('case 2', () => {
-        expect(t).toStrictEqual([1]);
+        assert.deepStrictEqual(t, [1]);
       });
     }
   });