ts-data-forge 1.5.2 → 2.0.1

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

@@ -7,7 +7,7 @@ describe('Arr modifications', () => {
     const xs = [1, 2, 3] as const;
     const result = Arr.toUpdated(xs, 1, (x) => x + 2);
 
-    expectType<typeof result, readonly number[]>('=');
+    expectType<typeof result, ArrayOfLength<3, number>>('=');
 
     test('case 1', () => {
       expect(result).toStrictEqual([1, 4, 3]);
@@ -17,112 +17,107 @@ describe('Arr modifications', () => {
   describe('toInserted', () => {
     const xs = [1, 2, 3] as const;
 
-    {
+    test('case 1', () => {
       const result = Arr.toInserted(xs, 1, 5);
 
-      expectType<typeof result, NonEmptyArray<1 | 2 | 3 | 5>>('=');
+      expectType<typeof result, ArrayOfLength<4, 1 | 2 | 3 | 5>>('=');
 
-      test('case 1', () => {
-        expect(result).toStrictEqual([1, 5, 2, 3]);
-      });
-    }
-    {
-      const result = Arr.toInserted(xs, 0, 5);
+      expect(result).toStrictEqual([1, 5, 2, 3]);
+    });
 
-      expectType<typeof result, NonEmptyArray<1 | 2 | 3 | 5>>('=');
+    test('case 2 (insert head)', () => {
+      const result = Arr.toInserted(xs, 0, 5);
 
-      test('case 2 (insert head)', () => {
-        expect(result).toStrictEqual([5, 1, 2, 3]);
-      });
-    }
-    {
-      const result = Arr.toInserted(xs, 3, 5);
+      expectType<typeof result, ArrayOfLength<4, 1 | 2 | 3 | 5>>('=');
 
-      expectType<typeof result, NonEmptyArray<1 | 2 | 3 | 5>>('=');
+      expect(result).toStrictEqual([5, 1, 2, 3]);
+    });
 
-      test('case 3 (insert tail)', () => {
-        expect(result).toStrictEqual([1, 2, 3, 5]);
-      });
-    }
-    {
-      const result = Arr.toInserted(xs, asUint32(999), 5);
+    test('case 3 (insert tail)', () => {
+      const result = Arr.toInserted(['a', 'b', 'c'], asUint32(999), 5);
 
-      expectType<typeof result, NonEmptyArray<1 | 2 | 3 | 5>>('=');
+      expectType<typeof result, NonEmptyArray<string | 5>>('=');
 
-      test('case 4 (insert tail)', () => {
-        expect(result).toStrictEqual([1, 2, 3, 5]);
-      });
-    }
+      expect(result).toStrictEqual(['a', 'b', 'c', 5]);
+    });
   });
 
   describe('toRemoved', () => {
-    const xs = [1, 2, 3] as const;
-
-    {
+    test('case 1', () => {
+      const xs = [1, 2, 3] as const;
       const result = Arr.toRemoved(xs, 1);
 
       expectType<typeof result, readonly (1 | 2 | 3)[]>('=');
 
-      test('case 1', () => {
-        expect(result).toStrictEqual([1, 3]);
-      });
-    }
-    {
+      expect(result).toStrictEqual([1, 3]);
+    });
+
+    test('case 2 (remove head)', () => {
+      const xs = [1, 2, 3] as const;
       const result = Arr.toRemoved(xs, 0);
 
       expectType<typeof result, readonly (1 | 2 | 3)[]>('=');
 
-      test('case 2 (remove head)', () => {
-        expect(result).toStrictEqual([2, 3]);
-      });
-    }
-    {
+      expect(result).toStrictEqual([2, 3]);
+    });
+
+    test('case 3 (remove tail)', () => {
+      const xs = [1, 2, 3] as const;
       const result = Arr.toRemoved(xs, 2);
 
       expectType<typeof result, readonly (1 | 2 | 3)[]>('=');
 
-      test('case 3 (remove tail)', () => {
-        expect(result).toStrictEqual([1, 2]);
-      });
-    }
-    {
-      const result = Arr.toRemoved(xs, 3);
-
-      expectType<typeof result, readonly (1 | 2 | 3)[]>('=');
+      expect(result).toStrictEqual([1, 2]);
+    });
 
-      test('case 3 (noop)', () => {
-        expect(result).toStrictEqual([1, 2, 3]);
-      });
-    }
-    {
+    test('case 4 (number[])', () => {
+      const xs: number[] = [1, 2, 3];
       const result = Arr.toRemoved(xs, 5);
 
-      expectType<typeof result, readonly (1 | 2 | 3)[]>('=');
+      expectType<typeof result, readonly number[]>('=');
 
-      test('case 4 (noop)', () => {
-        expect(result).toStrictEqual([1, 2, 3]);
-      });
-    }
+      expect(result).toStrictEqual([1, 2, 3]);
+    });
   });
 
   describe('toPushed', () => {
-    const xs = [1, 2, 3] as const;
-    const result = Arr.toPushed(xs, 4 as const);
+    test('case 1', () => {
+      const xs = [1, 2, 3] as const;
+      const result = Arr.toPushed(xs, 4 as const);
 
-    expectType<typeof result, readonly [1, 2, 3, 4]>('=');
+      expectType<typeof result, readonly [1, 2, 3, 4]>('=');
+
+      expect(result).toStrictEqual([1, 2, 3, 4]);
+    });
+
+    test('case 2', () => {
+      const xs: number[] = [1, 2, 3];
+      const result = Arr.toPushed(xs, 4 as const);
+
+      expectType<typeof result, readonly [...number[], 4]>('=');
 
-    test('case 1', () => {
       expect(result).toStrictEqual([1, 2, 3, 4]);
     });
   });
 
   describe('toUnshifted', () => {
-    const xs = [1, 2, 3] as const;
-    const result = Arr.toUnshifted(xs, 4 as const);
+    test('case 1', () => {
+      const xs = [1, 2, 3] as const;
 
-    expectType<typeof result, readonly [4, 1, 2, 3]>('=');
+      const result = Arr.toUnshifted(xs, 4 as const);
+
+      expectType<typeof result, readonly [4, 1, 2, 3]>('=');
+
+      expect(result).toStrictEqual([4, 1, 2, 3]);
+    });
+
+    test('case 2', () => {
+      const xs: number[] = [1, 2, 3];
+
+      const result = Arr.toUnshifted(xs, 4 as const);
+
+      expectType<typeof result, readonly [4, ...number[]]>('=');
 
-    test('case 1', () => {
       expect(result).toStrictEqual([4, 1, 2, 3]);
     });
   });
@@ -194,4 +189,35 @@ describe('Arr modifications', () => {
       expect(Arr.toRangeFilled(arr, 0, [1, 2.5])).toStrictEqual([1, 0, 3]);
     });
   });
+
+  describe('set', () => {
+    const result = Arr.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]);
+    });
+
+    test('should work with different value types', () => {
+      const nums = [1, 2, 3] as const;
+      const withString = Arr.set(nums, 1, 'two');
+      expectType<typeof withString, readonly [1 | 'two', 2 | 'two', 3 | 'two']>(
+        '=',
+      );
+      expect(withString).toStrictEqual([1, 'two', 3]);
+    });
+
+    test('should work at index 0', () => {
+      const tuple = ['a', 'b', 'c'] as const;
+      const updated = Arr.set(tuple, 0, 'A');
+      expect(updated).toStrictEqual(['A', 'b', 'c']);
+    });
+
+    test('should work at last index', () => {
+      const tuple = ['a', 'b', 'c'] as const;
+      const updated = Arr.set(tuple, 2, 'C');
+      expect(updated).toStrictEqual(['a', 'b', 'C']);
+    });
+  });
 });

package/src/array/array-utils-overload-type-error.test.mts

@@ -15,7 +15,7 @@ describe('Array overloaded functions - type error validation', () => {
       const _result2 = Arr.findIndex(predicate);
       const _result3 = Arr.findIndex(predicate)(testArray);
 
-      expectType<typeof _result1, SizeType.Arr | -1>('=');
+      expectType<typeof _result1, 0 | 1 | 2 | 3 | 4 | -1>('=');
       expectType<
         typeof _result2,
         (array: readonly number[]) => SizeType.Arr | -1
@@ -113,7 +113,7 @@ describe('Array overloaded functions - type error validation', () => {
       const _result1 = Arr.findIndex(...correctArgs1);
       const _result2 = Arr.findIndex(...correctArgs2);
 
-      expectType<typeof _result1, SizeType.Arr | -1>('<=');
+      expectType<typeof _result1, 0 | 1 | 2 | 3 | 4 | -1>('<=');
       expectType<
         typeof _result2,
         (array: readonly number[]) => SizeType.Arr | -1

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

@@ -87,14 +87,7 @@ describe('Arr reducing value', () => {
   });
 
   describe('minBy', () => {
-    const xs: NonEmptyArray<
-      | Readonly<{ x: 1; y: 2 }>
-      | Readonly<{ x: 2; y: 3 }>
-      | Readonly<{ x: 3; y: 2 }>
-      | Readonly<{ x: 4; y: 1 }>
-      | Readonly<{ x: 5; y: 1 }>
-      | Readonly<{ x: 6; y: 1 }>
-    > = [
+    const xs = [
       { x: 5, y: 1 },
       { x: 4, y: 1 },
       { x: 6, y: 1 },
@@ -108,12 +101,14 @@ describe('Arr reducing value', () => {
     expectType<
       typeof result,
       Optional.Some<
-        | Readonly<{ x: 1; y: 2 }>
-        | Readonly<{ x: 2; y: 3 }>
-        | Readonly<{ x: 3; y: 2 }>
-        | Readonly<{ x: 4; y: 1 }>
-        | Readonly<{ x: 5; y: 1 }>
-        | Readonly<{ x: 6; y: 1 }>
+        Readonly<
+          | { x: 1; y: 2 }
+          | { x: 2; y: 3 }
+          | { x: 3; y: 2 }
+          | { x: 4; y: 1 }
+          | { x: 5; y: 1 }
+          | { x: 6; y: 1 }
+        >
       >
     >('=');
 
@@ -146,10 +141,12 @@ describe('Arr reducing value', () => {
 
       expectType<
         typeof res,
-        Optional<
-          | Readonly<{ name: 'apple'; score: 10 }>
-          | Readonly<{ name: 'banana'; score: 5 }>
-          | Readonly<{ name: 'cherry'; score: 12 }>
+        Optional.Some<
+          Readonly<
+            | { name: 'apple'; score: 10 }
+            | { name: 'banana'; score: 5 }
+            | { name: 'cherry'; score: 12 }
+          >
         >
       >('=');
 
@@ -161,14 +158,7 @@ describe('Arr reducing value', () => {
   });
 
   describe('maxBy', () => {
-    const xs: NonEmptyArray<
-      | Readonly<{ x: 1; y: 2 }>
-      | Readonly<{ x: 2; y: 3 }>
-      | Readonly<{ x: 3; y: 2 }>
-      | Readonly<{ x: 4; y: 1 }>
-      | Readonly<{ x: 5; y: 1 }>
-      | Readonly<{ x: 6; y: 1 }>
-    > = [
+    const xs = [
       { x: 5, y: 1 },
       { x: 4, y: 1 },
       { x: 6, y: 1 },
@@ -182,12 +172,14 @@ describe('Arr reducing value', () => {
     expectType<
       typeof result,
       Optional.Some<
-        | Readonly<{ x: 1; y: 2 }>
-        | Readonly<{ x: 2; y: 3 }>
-        | Readonly<{ x: 3; y: 2 }>
-        | Readonly<{ x: 4; y: 1 }>
-        | Readonly<{ x: 5; y: 1 }>
-        | Readonly<{ x: 6; y: 1 }>
+        Readonly<
+          | { x: 1; y: 2 }
+          | { x: 2; y: 3 }
+          | { x: 3; y: 2 }
+          | { x: 4; y: 1 }
+          | { x: 5; y: 1 }
+          | { x: 6; y: 1 }
+        >
       >
     >('=');
 
@@ -220,10 +212,12 @@ describe('Arr reducing value', () => {
 
       expectType<
         typeof res,
-        Optional<
-          | Readonly<{ name: 'apple'; score: 10 }>
-          | Readonly<{ name: 'banana'; score: 5 }>
-          | Readonly<{ name: 'cherry'; score: 12 }>
+        Optional.Some<
+          Readonly<
+            | { name: 'apple'; score: 10 }
+            | { name: 'banana'; score: 5 }
+            | { name: 'cherry'; score: 12 }
+          >
         >
       >('=');
 
@@ -272,7 +266,7 @@ describe('Arr reducing value', () => {
 
     const result = Arr.countBy(xs, (a) => a.x);
 
-    expectType<typeof result, IMap<1 | 2 | 3, Uint32>>('=');
+    expectType<typeof result, IMap<1 | 2 | 3, 0 | 1 | 2 | 3 | 4 | 5>>('=');
 
     test('case 1', () => {
       expect(result).toStrictEqual(

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

@@ -3,81 +3,105 @@ import { Arr } from './array-utils.mjs';
 
 describe('Arr', () => {
   describe('sliceClamped', () => {
-    const list = [0, 1, 2, 3, 4] as const;
+    {
+      const list: readonly number[] = [0, 1, 2, 3, 4] as const;
 
-    test.each([
-      {
-        start: 0,
-        end: 5,
-        expected: [0, 1, 2, 3, 4],
-      }, // normal
-      {
-        start: 0,
-        end: 6,
-        expected: [0, 1, 2, 3, 4],
-      }, // one side overflow
-      {
-        start: -1,
-        end: 5,
-        expected: [0, 1, 2, 3, 4],
-      }, // one side overflow
-      {
-        start: -1,
-        end: 6,
-        expected: [0, 1, 2, 3, 4],
-      }, // both sides overflow
-      {
-        start: 0,
-        end: 3,
-        expected: [0, 1, 2],
-      }, // normal
-      {
-        start: 1,
-        end: 3,
-        expected: [1, 2],
-      }, // normal
-      {
-        start: -1,
-        end: 3,
-        expected: [0, 1, 2],
-      }, // one side overflow
-      {
-        start: 3,
-        end: 5,
-        expected: [3, 4],
-      }, // normal
-      {
-        start: 3,
-        end: 6,
-        expected: [3, 4],
-      }, // one side overflow
-      {
-        start: 4,
-        end: 3,
-        expected: [],
-      }, // start > end
+      test.each([
+        {
+          start: 0,
+          end: 5,
+          expected: [0, 1, 2, 3, 4],
+        }, // normal
+        {
+          start: 0,
+          end: 5,
+          expected: [0, 1, 2, 3, 4],
+        }, // one side overflow
+        {
+          start: -1,
+          end: 5,
+          expected: [0, 1, 2, 3, 4],
+        }, // one side overflow
+        {
+          start: -1,
+          end: 6,
+          expected: [0, 1, 2, 3, 4],
+        }, // both sides overflow
+        {
+          start: 0,
+          end: 3,
+          expected: [0, 1, 2],
+        }, // normal
+        {
+          start: 1,
+          end: 3,
+          expected: [1, 2],
+        }, // normal
+        {
+          start: -1,
+          end: 3,
+          expected: [0, 1, 2],
+        }, // one side overflow
+        {
+          start: 3,
+          end: 5,
+          expected: [3, 4],
+        }, // normal
+        {
+          start: 4,
+          end: 3,
+          expected: [],
+        }, // start > end
+        {
+          start: 0,
+          end: -1,
+          expected: [],
+        }, // start > end
+        {
+          start: -1,
+          end: -2,
+          expected: [],
+        }, // start > end
+        {
+          start: 6,
+          end: 9,
+          expected: [],
+        },
+        {
+          start: 6,
+          end: 3,
+          expected: [],
+        },
+      ] as const)('sliceClamped($start, $end)', ({ start, end, expected }) => {
+        expect(Arr.sliceClamped(list, start, end)).toStrictEqual(expected);
+      });
+    }
+
+    test('should be type error for index overflow for fixed length array', () => {
       {
-        start: 0,
-        end: -1,
-        expected: [],
-      }, // start > end
+        const array = [1, 2, 3, 4, 5] as const;
+        // @ts-expect-error end index is out of bounds
+        const result = Arr.sliceClamped(array, 0, 6);
+        expect(result).toStrictEqual(array);
+      }
       {
-        start: -1,
-        end: -2,
-        expected: [],
-      }, // start > end
+        const array = [1, 2, 3, 4, 5] as const;
+        // @ts-expect-error end index is out of bounds
+        const result = Arr.sliceClamped(array, 0, -6);
+        expect(result).toStrictEqual([]);
+      }
       {
-        start: 6,
-        end: 9,
-        expected: [],
-      },
+        const array = [1, 2, 3, 4, 5] as const;
+        // @ts-expect-error start index is out of bounds
+        const result = Arr.sliceClamped(array, -6, 5);
+        expect(result).toStrictEqual(array);
+      }
       {
-        start: 6,
-        end: 3,
-        expected: [],
-      },
-    ] as const)('sliceClamped($start, $end)', ({ start, end, expected }) => {
-      expect(Arr.sliceClamped(list, start, end)).toStrictEqual(expected);
+        const array = [1, 2, 3, 4, 5] as const;
+        // @ts-expect-error start index is out of bounds
+        const result = Arr.sliceClamped(array, 6, 5);
+        expect(result).toStrictEqual([]);
+      }
     });
 
     test('should slice with clamped indices', () => {