ts-data-forge 4.1.0 → 5.0.1

package/src/array/impl/array-utils-element-access.test.mts

@@ -4,30 +4,34 @@ import { asInt32, asUint32 } from '../../number/index.mjs';
 import { at, head, last } from './array-utils-element-access.mjs';
 
 describe('Arr element access', () => {
-  describe('at', () => {
+  describe(at, () => {
     test('should handle very large positive indices', () => {
       const array = [1, 2, 3];
       const result = at(array, asUint32(1000));
+
       expect(Optional.isNone(result)).toBe(true);
     });
 
     test('should handle very large negative indices', () => {
       const array = [1, 2, 3];
       const result = at(array, asInt32(-1000));
+
       expect(Optional.isNone(result)).toBe(true);
     });
 
     test('should work with valid indices', () => {
       const array = [10, 20, 30];
       const result = at(array, 1);
+
       expect(Optional.isSome(result)).toBe(true);
+
       if (Optional.isSome(result)) {
         expect(result.value).toBe(20);
       }
     });
   });
 
-  describe('head', () => {
+  describe(head, () => {
     test('case 1', () => {
       const xs = [1, 2, 3] as const;
       const h = head(xs);
@@ -35,6 +39,7 @@ describe('Arr element access', () => {
       expectType<typeof h, Some<1>>('=');
 
       expect(Optional.isSome(h)).toBe(true);
+
       if (Optional.isSome(h)) {
         expect(h.value).toBe(1);
       }
@@ -47,6 +52,7 @@ describe('Arr element access', () => {
       expectType<typeof h, Some<number>>('=');
 
       expect(Optional.isSome(h)).toBe(true);
+
       if (Optional.isSome(h)) {
         expect(h.value).toBe(1);
       }
@@ -59,6 +65,7 @@ describe('Arr element access', () => {
       expectType<typeof h, Optional<number>>('=');
 
       expect(Optional.isSome(h)).toBe(true);
+
       if (Optional.isSome(h)) {
         expect(h.value).toBe(1);
       }
@@ -76,19 +83,22 @@ describe('Arr element access', () => {
 
     test('should return none for empty array', () => {
       const result = head([]);
+
       expect(Optional.isNone(result)).toBe(true);
     });
 
     test('should work with single element array', () => {
       const result = head([42]);
+
       expect(Optional.isSome(result)).toBe(true);
+
       if (Optional.isSome(result)) {
         expect(result.value).toBe(42);
       }
     });
   });
 
-  describe('last', () => {
+  describe(last, () => {
     test('case 1', () => {
       const xs = [1, 2, 3] as const;
       const l = last(xs);
@@ -96,6 +106,7 @@ describe('Arr element access', () => {
       expectType<typeof l, Some<3>>('=');
 
       expect(Optional.isSome(l)).toBe(true);
+
       if (Optional.isSome(l)) {
         expect(l.value).toBe(3);
       }
@@ -108,6 +119,7 @@ describe('Arr element access', () => {
       expectType<typeof l, Some<number>>('=');
 
       expect(Optional.isSome(l)).toBe(true);
+
       if (Optional.isSome(l)) {
         expect(l.value).toBe(3);
       }
@@ -120,6 +132,7 @@ describe('Arr element access', () => {
       expectType<typeof l, Optional<number>>('=');
 
       expect(Optional.isSome(l)).toBe(true);
+
       if (Optional.isSome(l)) {
         expect(l.value).toBe(3);
       }
@@ -137,12 +150,15 @@ describe('Arr element access', () => {
 
     test('should return none for empty array', () => {
       const result = last([]);
+
       expect(Optional.isNone(result)).toBe(true);
     });
 
     test('should work with single element array', () => {
       const result = last([42]);
+
       expect(Optional.isSome(result)).toBe(true);
+
       if (Optional.isSome(result)) {
         expect(result.value).toBe(42);
       }

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

@@ -1,14 +1,16 @@
 import { expectType } from '../../expect-type.mjs';
+import { asUint32 } from '../../number/index.mjs';
 import { entries, indices, values } from './array-utils-iterators.mjs';
 
-describe('entries', () => {
+describe(entries, () => {
   test('should return array of index-value pairs', () => {
     const fruits = ['apple', 'banana', 'cherry'];
     const es = Array.from(entries(fruits));
-    expect(es).toStrictEqual([
-      [0, 'apple'],
-      [1, 'banana'],
-      [2, 'cherry'],
+
+    assert.deepStrictEqual(es, [
+      [asUint32(0), 'apple'],
+      [asUint32(1), 'banana'],
+      [asUint32(2), 'cherry'],
     ]);
   });
 
@@ -16,36 +18,41 @@ describe('entries', () => {
     const tuple = [10, 20, 30] as const;
     const es = Array.from(entries(tuple));
     expectType<typeof es, (readonly [Uint32, 10 | 20 | 30])[]>('=');
-    expect(es).toStrictEqual([
-      [0, 10],
-      [1, 20],
-      [2, 30],
+
+    assert.deepStrictEqual(es, [
+      [asUint32(0), 10],
+      [asUint32(1), 20],
+      [asUint32(2), 30],
     ]);
   });
 
   test('should work with empty array', () => {
     const empty: string[] = [];
     const es = Array.from(entries(empty));
-    expect(es).toStrictEqual([]);
+
+    assert.deepStrictEqual(es, []);
   });
 
   test('should preserve mixed types', () => {
     const mixed = [1, 'hello', true] as const;
     const es = Array.from(entries(mixed));
     expectType<typeof es, (readonly [Uint32, 1 | 'hello' | true])[]>('=');
-    expect(es).toStrictEqual([
-      [0, 1],
-      [1, 'hello'],
-      [2, true],
+
+    assert.deepStrictEqual(es, [
+      [asUint32(0), 1],
+      [asUint32(1), 'hello'],
+      [asUint32(2), true],
     ]);
   });
 });
 
-describe('values', () => {
+describe(values, () => {
   test('should return copy of array values', () => {
     const numbers = [1, 2, 3];
     const vs = Array.from(values(numbers));
-    expect(vs).toStrictEqual([1, 2, 3]);
+
+    assert.deepStrictEqual(vs, [1, 2, 3]);
+
     expect(vs).not.toBe(numbers); // Should be a copy
   });
 
@@ -53,46 +60,59 @@ describe('values', () => {
     const tuple = ['a', 'b', 'c'] as const;
     const vs = Array.from(values(tuple));
     expectType<typeof vs, ('a' | 'b' | 'c')[]>('=');
-    expect(vs).toStrictEqual(['a', 'b', 'c']);
+
+    assert.deepStrictEqual(vs, ['a', 'b', 'c']);
   });
 
   test('should work with empty array', () => {
     const empty: number[] = [];
     const vs = Array.from(values(empty));
-    expect(vs).toStrictEqual([]);
+
+    assert.deepStrictEqual(vs, []);
   });
 
   test('should preserve mixed types', () => {
     const mixed = [1, 'hello', null] as const;
     const vs = Array.from(values(mixed));
     expectType<typeof vs, (1 | 'hello' | null)[]>('=');
-    expect(vs).toStrictEqual([1, 'hello', null]);
+
+    assert.deepStrictEqual(vs, [1, 'hello', null]);
   });
 });
 
-describe('indices', () => {
+describe(indices, () => {
   test('should return array of indices', () => {
     const fruits = ['apple', 'banana', 'cherry'];
     const ks = Array.from(indices(fruits));
-    expect(ks).toStrictEqual([0, 1, 2]);
+
+    assert.deepStrictEqual(ks, [asUint32(0), asUint32(1), asUint32(2)]);
   });
 
   test('should work with tuples', () => {
     const tuple = ['a', 'b'] as const;
     const ks = Array.from(indices(tuple));
     expectType<typeof ks, Uint32[]>('=');
-    expect(ks).toStrictEqual([0, 1]);
+
+    assert.deepStrictEqual(ks, [asUint32(0), asUint32(1)]);
   });
 
   test('should work with empty array', () => {
     const empty: string[] = [];
     const ks = Array.from(indices(empty));
-    expect(ks).toStrictEqual([]);
+
+    assert.deepStrictEqual(ks, []);
   });
 
   test('should work with larger arrays', () => {
     const large = Array.from({ length: 5 }, () => 'x');
     const ks = Array.from(indices(large));
-    expect(ks).toStrictEqual([0, 1, 2, 3, 4]);
+
+    assert.deepStrictEqual(ks, [
+      asUint32(0),
+      asUint32(1),
+      asUint32(2),
+      asUint32(3),
+      asUint32(4),
+    ]);
   });
 });

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

@@ -12,18 +12,18 @@ import {
 } from './array-utils-modification.mjs';
 
 describe('Arr modifications', () => {
-  describe('toUpdated', () => {
+  describe(toUpdated, () => {
     const xs = [1, 2, 3] as const;
     const result = toUpdated(xs, 1, (x) => x + 2);
 
     expectType<typeof result, ArrayOfLength<3, number>>('=');
 
     test('case 1', () => {
-      expect(result).toStrictEqual([1, 4, 3]);
+      assert.deepStrictEqual(result, [1, 4, 3]);
     });
   });
 
-  describe('toInserted', () => {
+  describe(toInserted, () => {
     const xs = [1, 2, 3] as const;
 
     test('case 1', () => {
@@ -31,7 +31,7 @@ describe('Arr modifications', () => {
 
       expectType<typeof result, ArrayOfLength<4, 1 | 2 | 3 | 5>>('=');
 
-      expect(result).toStrictEqual([1, 5, 2, 3]);
+      assert.deepStrictEqual(result, [1, 5, 2, 3]);
     });
 
     test('case 2 (insert head)', () => {
@@ -39,7 +39,7 @@ describe('Arr modifications', () => {
 
       expectType<typeof result, ArrayOfLength<4, 1 | 2 | 3 | 5>>('=');
 
-      expect(result).toStrictEqual([5, 1, 2, 3]);
+      assert.deepStrictEqual(result, [5, 1, 2, 3]);
     });
 
     test('case 3 (insert tail)', () => {
@@ -51,18 +51,18 @@ describe('Arr modifications', () => {
 
       expectType<typeof result, NonEmptyArray<string | 5>>('=');
 
-      expect(result).toStrictEqual(['a', 'b', 'c', 5]);
+      assert.deepStrictEqual(result, ['a', 'b', 'c', 5]);
     });
   });
 
-  describe('toRemoved', () => {
+  describe(toRemoved, () => {
     test('case 1', () => {
       const xs = [1, 2, 3] as const;
       const result = toRemoved(xs, 1);
 
       expectType<typeof result, readonly (1 | 2 | 3)[]>('=');
 
-      expect(result).toStrictEqual([1, 3]);
+      assert.deepStrictEqual(result, [1, 3]);
     });
 
     test('case 2 (remove head)', () => {
@@ -71,7 +71,7 @@ describe('Arr modifications', () => {
 
       expectType<typeof result, readonly (1 | 2 | 3)[]>('=');
 
-      expect(result).toStrictEqual([2, 3]);
+      assert.deepStrictEqual(result, [2, 3]);
     });
 
     test('case 3 (remove tail)', () => {
@@ -80,7 +80,7 @@ describe('Arr modifications', () => {
 
       expectType<typeof result, readonly (1 | 2 | 3)[]>('=');
 
-      expect(result).toStrictEqual([1, 2]);
+      assert.deepStrictEqual(result, [1, 2]);
     });
 
     test('case 4 (number[])', () => {
@@ -89,18 +89,18 @@ describe('Arr modifications', () => {
 
       expectType<typeof result, readonly number[]>('=');
 
-      expect(result).toStrictEqual([1, 2, 3]);
+      assert.deepStrictEqual(result, [1, 2, 3]);
     });
   });
 
-  describe('toPushed', () => {
+  describe(toPushed, () => {
     test('case 1', () => {
       const xs = [1, 2, 3] as const;
       const result = toPushed(xs, 4 as const);
 
       expectType<typeof result, readonly [1, 2, 3, 4]>('=');
 
-      expect(result).toStrictEqual([1, 2, 3, 4]);
+      assert.deepStrictEqual(result, [1, 2, 3, 4]);
     });
 
     test('case 2', () => {
@@ -109,11 +109,11 @@ describe('Arr modifications', () => {
 
       expectType<typeof result, readonly [...number[], 4]>('=');
 
-      expect(result).toStrictEqual([1, 2, 3, 4]);
+      assert.deepStrictEqual(result, [1, 2, 3, 4]);
     });
   });
 
-  describe('toUnshifted', () => {
+  describe(toUnshifted, () => {
     test('case 1', () => {
       const xs = [1, 2, 3] as const;
 
@@ -121,7 +121,7 @@ describe('Arr modifications', () => {
 
       expectType<typeof result, readonly [4, 1, 2, 3]>('=');
 
-      expect(result).toStrictEqual([4, 1, 2, 3]);
+      assert.deepStrictEqual(result, [4, 1, 2, 3]);
     });
 
     test('case 2', () => {
@@ -131,16 +131,16 @@ describe('Arr modifications', () => {
 
       expectType<typeof result, readonly [4, ...number[]]>('=');
 
-      expect(result).toStrictEqual([4, 1, 2, 3]);
+      assert.deepStrictEqual(result, [4, 1, 2, 3]);
     });
   });
 
-  describe('toFilled', () => {
+  describe(toFilled, () => {
     test('should fill entire array with value', () => {
       const arr = [1, 2, 3, 4, 5];
       const result = toFilled(arr, 0);
 
-      expect(result).toStrictEqual([0, 0, 0, 0, 0]);
+      assert.deepStrictEqual(result, [0, 0, 0, 0, 0]);
     });
 
     test('should work with curried version', () => {
@@ -148,68 +148,68 @@ describe('Arr modifications', () => {
       const arr = [1, 2, 3];
       const result = fillWithZero(arr);
 
-      expect(result).toStrictEqual([0, 0, 0]);
+      assert.deepStrictEqual(result, [0, 0, 0]);
     });
   });
 
-  describe('toRangeFilled', () => {
+  describe(toRangeFilled, () => {
     test('should fill array with range', () => {
       const arr = [1, 2, 3, 4, 5];
       const result = toRangeFilled(arr, 0, [1, 4]);
 
-      expect(result).toStrictEqual([1, 0, 0, 0, 5]);
+      assert.deepStrictEqual(result, [1, 0, 0, 0, 5]);
     });
 
     test('should fill with range starting from 0', () => {
       const arr = [1, 2, 3, 4, 5];
       const result = toRangeFilled(arr, 9, [0, 3]);
 
-      expect(result).toStrictEqual([9, 9, 9, 4, 5]);
+      assert.deepStrictEqual(result, [9, 9, 9, 4, 5]);
     });
 
     test('should handle empty range', () => {
       const arr = [1, 2, 3];
       const result = toRangeFilled(arr, 0, [2, 2]);
 
-      expect(result).toStrictEqual([1, 2, 3]);
+      assert.deepStrictEqual(result, [1, 2, 3]);
     });
 
     test('should clamp range to array bounds', () => {
       const arr = [1, 2, 3];
       const result = toRangeFilled(arr, 0, [1, 10]);
 
-      expect(result).toStrictEqual([1, 0, 0]);
+      assert.deepStrictEqual(result, [1, 0, 0]);
     });
 
     test('should handle negative start (clamped to 0)', () => {
       const arr = [1, 2, 3];
       const result = toRangeFilled(arr, 9, [-5, 2]);
 
-      expect(result).toStrictEqual([9, 9, 3]);
+      assert.deepStrictEqual(result, [9, 9, 3]);
     });
 
     test('A non-integer starting value should result in a type error', () => {
       const arr = [1, 2, 3];
 
       // @ts-expect-error start must be an integer
-      expect(toRangeFilled(arr, 0, [1.5, 3])).toStrictEqual([1, 0, 0]);
+      assert.deepStrictEqual(toRangeFilled(arr, 0, [1.5, 3]), [1, 0, 0]);
     });
 
     test('A non-integer ending value should result in a type error', () => {
       const arr = [1, 2, 3];
 
       // @ts-expect-error end must be an integer
-      expect(toRangeFilled(arr, 0, [1, 2.5])).toStrictEqual([1, 0, 3]);
+      assert.deepStrictEqual(toRangeFilled(arr, 0, [1, 2.5]), [1, 0, 3]);
     });
   });
 
-  describe('set', () => {
+  describe(set, () => {
     const result = set([1, 2, 3], 1, 4);
 
     expectType<typeof result, readonly [1 | 4, 2 | 4, 3 | 4]>('=');
 
     test('case 1', () => {
-      expect(result).toStrictEqual([1, 4, 3]);
+      assert.deepStrictEqual(result, [1, 4, 3]);
     });
 
     test('should work with different value types', () => {
@@ -218,19 +218,22 @@ describe('Arr modifications', () => {
       expectType<typeof withString, readonly [1 | 'two', 2 | 'two', 3 | 'two']>(
         '=',
       );
-      expect(withString).toStrictEqual([1, 'two', 3]);
+
+      assert.deepStrictEqual(withString, [1, 'two', 3]);
     });
 
     test('should work at index 0', () => {
       const tuple = ['a', 'b', 'c'] as const;
       const updated = set(tuple, 0, 'A');
-      expect(updated).toStrictEqual(['A', 'b', 'c']);
+
+      assert.deepStrictEqual(updated, ['A', 'b', 'c']);
     });
 
     test('should work at last index', () => {
       const tuple = ['a', 'b', 'c'] as const;
       const updated = set(tuple, 2, 'C');
-      expect(updated).toStrictEqual(['a', 'b', 'C']);
+
+      assert.deepStrictEqual(updated, ['a', 'b', 'C']);
     });
   });
 });

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

@@ -1,3 +1,4 @@
+import { isError } from '@sindresorhus/is';
 import { IMap } from '../../collections/index.mjs';
 import { Optional, Result } from '../../functional/index.mjs';
 import { isString, isUndefined } from '../../guard/index.mjs';
@@ -515,7 +516,7 @@ const joinImpl = <E,>(
     return Result.ok(result);
   } catch (error) {
     return Result.err(
-      Error.isError(error) ? error : new Error(unknownToString(error)),
+      isError(error) ? error : new Error(unknownToString(error)),
     );
   }
 };