ts-data-forge 6.3.0 → 6.4.0

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

@@ -20,6 +20,7 @@ describe(entries, () => {
 
     const es = Array.from(entries(tuple));
 
+    // transformer-ignore-next-line
     expectType<typeof es, (readonly [Uint32, 10 | 20 | 30])[]>('=');
 
     assert.deepStrictEqual(es, [
@@ -30,7 +31,7 @@ describe(entries, () => {
   });
 
   test('should work with empty array', () => {
-    const empty: string[] = [];
+    const empty: readonly string[] = [];
 
     const es = Array.from(entries(empty));
 
@@ -42,6 +43,7 @@ describe(entries, () => {
 
     const es = Array.from(entries(mixed));
 
+    // transformer-ignore-next-line
     expectType<typeof es, (readonly [Uint32, 1 | 'hello' | true])[]>('=');
 
     assert.deepStrictEqual(es, [
@@ -68,13 +70,14 @@ describe(values, () => {
 
     const vs = Array.from(values(tuple));
 
+    // transformer-ignore-next-line
     expectType<typeof vs, ('a' | 'b' | 'c')[]>('=');
 
     assert.deepStrictEqual(vs, ['a', 'b', 'c']);
   });
 
   test('should work with empty array', () => {
-    const empty: number[] = [];
+    const empty: readonly number[] = [];
 
     const vs = Array.from(values(empty));
 
@@ -86,6 +89,7 @@ describe(values, () => {
 
     const vs = Array.from(values(mixed));
 
+    // transformer-ignore-next-line
     expectType<typeof vs, (1 | 'hello' | null)[]>('=');
 
     assert.deepStrictEqual(vs, [1, 'hello', null]);
@@ -106,13 +110,14 @@ describe(indices, () => {
 
     const ks = Array.from(indices(tuple));
 
+    // transformer-ignore-next-line
     expectType<typeof ks, Uint32[]>('=');
 
     assert.deepStrictEqual(ks, [asUint32(0), asUint32(1)]);
   });
 
   test('should work with empty array', () => {
-    const empty: string[] = [];
+    const empty: readonly string[] = [];
 
     const ks = Array.from(indices(empty));
 

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

@@ -8,7 +8,7 @@ import { copy, create } from './array-utils-creation.mjs';
  * @example
  *
  * ```ts
- * const scores: number[] = [10, 20, 30];
+ * const scores: readonly number[] = [10, 20, 30];
  *
  * const updated = Arr.set(scores, 1, 25);
  *
@@ -46,8 +46,7 @@ export function set<E, const V = E>(
     case 3: {
       const [array, index, newValue] = args;
 
-      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-      return (array as (E | V)[]).with(index, newValue);
+      return (array as readonly (E | V)[]).with(index, newValue);
     }
 
     case 2: {
@@ -64,7 +63,7 @@ export function set<E, const V = E>(
  * @example
  *
  * ```ts
- * const temperatures: number[] = [20, 21, 22];
+ * const temperatures: readonly number[] = [20, 21, 22];
  *
  * const increased = Arr.toUpdated(temperatures, 1, (value) => value + 5);
  *
@@ -116,8 +115,8 @@ export function toUpdated<E, V = E>(
     case 3: {
       const [array, index, updater] = args;
 
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion, total-functions/no-unsafe-type-assertion
-      return (array as (E | V)[]).with(index, updater(array[index]!));
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      return (array as readonly (E | V)[]).with(index, updater(array[index]!));
     }
 
     case 2: {

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

@@ -104,7 +104,7 @@ describe('Arr modifications', () => {
     });
 
     test('case 4 (number[])', () => {
-      const xs: number[] = [1, 2, 3];
+      const xs: readonly number[] = [1, 2, 3];
 
       const result = toRemoved(xs, 5);
 
@@ -134,7 +134,7 @@ describe('Arr modifications', () => {
     });
 
     test('case 2', () => {
-      const xs: number[] = [1, 2, 3];
+      const xs: readonly number[] = [1, 2, 3];
 
       const result = toPushed(xs, 4 as const);
 
@@ -164,7 +164,7 @@ describe('Arr modifications', () => {
     });
 
     test('case 2', () => {
-      const xs: number[] = [1, 2, 3];
+      const xs: readonly number[] = [1, 2, 3];
 
       const result = toUnshifted(xs, 4 as const);
 

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

@@ -145,7 +145,7 @@ describe('Array overloaded functions - type error validation', () => {
     });
 
     test('spread with incorrect types should cause errors', () => {
-      const invalidArgs: [string[], (x: string) => number] = [
+      const invalidArgs: readonly [readonly string[], (x: string) => number] = [
         ['a'],
         (x) => x.length,
       ];

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

@@ -152,11 +152,11 @@ describe('Arr reducing value', () => {
     });
 
     test('case 2: empty array', () => {
-      const arr: readonly { x: number }[] = [];
+      const arr: readonly Readonly<{ x: number }>[] = [];
 
       const res = minBy(arr, (a) => a.x);
 
-      expectType<typeof res, Optional<{ x: number }>>('=');
+      expectType<typeof res, Optional<Readonly<{ x: number }>>>('=');
 
       assert.isTrue(Optional.isNone(res));
     });
@@ -228,11 +228,11 @@ describe('Arr reducing value', () => {
     });
 
     test('case 2: empty array', () => {
-      const arr: readonly { x: number }[] = [];
+      const arr: readonly Readonly<{ x: number }>[] = [];
 
       const res = maxBy(arr, (a) => a.x);
 
-      expectType<typeof res, Optional<{ x: number }>>('=');
+      expectType<typeof res, Optional<Readonly<{ x: number }>>>('=');
 
       assert.isTrue(Optional.isNone(res));
     });
@@ -332,7 +332,7 @@ describe('Arr reducing value', () => {
     });
 
     test('case 2: empty array', () => {
-      const arr: readonly { x: number }[] = [];
+      const arr: readonly Readonly<{ x: number }>[] = [];
 
       const res = countBy(arr, (a) => a.x);
 

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

@@ -15,7 +15,9 @@ import { asUint32 } from '../../number/index.mjs';
  *
  * const found = Arr.find(users, (user) => user.id === 2);
  *
- * const missing = Arr.find<{ id: number }>((user) => user.id === 3)(users);
+ * const missing = Arr.find<Readonly<{ id: number }>>((user) => user.id === 3)(
+ *   users,
+ * );
  *
  * assert.deepStrictEqual(found, Optional.some({ id: 2, name: 'Grace' }));
  *
@@ -225,7 +227,7 @@ export function findIndex<E>(
           arr: readonly E[],
         ) => boolean,
       ]
-): SizeType.Arr | -1 | ((array: readonly E[]) => SizeType.Arr | -1) {
+): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {
   switch (args.length) {
     case 2: {
       const [array, predicate] = args;
@@ -292,7 +294,7 @@ export function findLastIndex<E>(
           arr: readonly E[],
         ) => boolean,
       ]
-): SizeType.Arr | -1 | ((array: readonly E[]) => SizeType.Arr | -1) {
+): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {
   switch (args.length) {
     case 2: {
       const [array, predicate] = args;
@@ -350,7 +352,7 @@ export function indexOf<E>(
   ...args:
     | readonly [array: readonly E[], searchElement: E]
     | readonly [searchElement: E]
-): SizeType.Arr | -1 | ((array: readonly E[]) => SizeType.Arr | -1) {
+): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {
   switch (args.length) {
     case 2: {
       const [array, searchElement] = args;
@@ -418,7 +420,7 @@ export function indexOfFrom<E>(
         fromIndex: SizeType.ArgArrWithNegative,
       ]
     | readonly [searchElement: E, fromIndex: SizeType.ArgArrWithNegative]
-): SizeType.Arr | -1 | ((array: readonly E[]) => SizeType.Arr | -1) {
+): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {
   switch (args.length) {
     case 3: {
       const [array, searchElement, fromIndex] = args;
@@ -477,7 +479,7 @@ export function lastIndexOf<E>(
   ...args:
     | readonly [array: readonly E[], searchElement: E]
     | readonly [searchElement: E]
-): SizeType.Arr | -1 | ((array: readonly E[]) => SizeType.Arr | -1) {
+): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {
   switch (args.length) {
     case 2: {
       const [array, searchElement] = args;
@@ -545,7 +547,7 @@ export function lastIndexOfFrom<E>(
         fromIndex: SizeType.ArgArrWithNegative,
       ]
     | readonly [searchElement: E, fromIndex: SizeType.ArgArrWithNegative]
-): SizeType.Arr | -1 | ((array: readonly E[]) => SizeType.Arr | -1) {
+): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {
   switch (args.length) {
     case 3: {
       const [array, searchElement, fromIndex] = args;

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

@@ -123,7 +123,7 @@ describe('Arr search operations', () => {
     });
 
     test('should work with empty array', () => {
-      const empty: number[] = [];
+      const empty: readonly number[] = [];
 
       const result = findLast(empty, (n) => n > 0);
 
@@ -206,7 +206,7 @@ describe('Arr search operations', () => {
     });
 
     test('should work with empty array', () => {
-      const empty: number[] = [];
+      const empty: readonly number[] = [];
 
       const result = findLastIndex(empty, (n) => n > 0);
 

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

@@ -103,8 +103,9 @@ export const setIntersection = <
   array1: readonly E1[],
   array2: readonly E2[],
 ): readonly (E1 & E2)[] =>
+  // transformer-ignore-next-line
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  array1.filter((e) => array2.includes(e as E1 & E2)) as (E1 & E2)[];
+  (array1 as readonly (E1 & E2)[]).filter((e) => array2.includes(e));
 
 /**
  * Returns the set difference of two arrays (elements in first but not in second).

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

@@ -6,7 +6,7 @@
  * ```ts
  * const numbers = [1, 2, 3] as const;
  *
- * const letters: string[] = [];
+ * const letters: readonly string[] = [];
  *
  * const sizeOfNumbers = Arr.size(numbers);
  *

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

@@ -164,6 +164,7 @@ describe('Arr transformations', () => {
 
       const _nativeResult = xs.toReversed();
 
+      // transformer-ignore-next-line
       expectType<typeof _nativeResult, (1 | 2 | 3)[]>('=');
 
       const result = toReversed([1, 2, 3]);
@@ -318,7 +319,7 @@ describe('Arr transformations', () => {
     });
 
     test('should work with empty array', () => {
-      const empty: readonly { value: number }[] = [];
+      const empty: readonly Readonly<{ value: number }>[] = [];
 
       const result = toSortedBy(empty, (item) => item.value);
 
@@ -326,7 +327,7 @@ describe('Arr transformations', () => {
     });
 
     test('toSortedBy should work with empty array', () => {
-      const empty: readonly { value: number }[] = [];
+      const empty: readonly Readonly<{ value: number }>[] = [];
 
       const result = toSortedBy(empty, (item) => item.value);
 
@@ -344,7 +345,7 @@ describe('Arr transformations', () => {
     });
 
     test('should work with type guards', () => {
-      const mixed: (string | number | null)[] = [
+      const mixed: readonly (string | number | null)[] = [
         'hello',
         42,
         null,
@@ -392,7 +393,7 @@ describe('Arr transformations', () => {
     });
 
     test('should work with empty array', () => {
-      const empty: number[] = [];
+      const empty: readonly number[] = [];
 
       const result = filter(empty, (n) => n > 0);
 
@@ -489,7 +490,7 @@ describe('Arr transformations', () => {
     });
 
     test('should work with empty array', () => {
-      const empty: readonly { id: number }[] = [];
+      const empty: readonly Readonly<{ id: number }>[] = [];
 
       const result = uniqBy(empty, (item) => item.id);
 
@@ -609,7 +610,7 @@ describe('Arr transformations', () => {
     });
 
     test('should work with empty arrays', () => {
-      const empty: string[] = [];
+      const empty: readonly string[] = [];
 
       const result = flatMap(empty, (s) => s.split(''));
 
@@ -833,14 +834,14 @@ describe('Arr transformations', () => {
       typeof result,
       IMap<
         1 | 2 | 3,
-        readonly (
-          | Readonly<{ x: 1; y: 1 }>
-          | Readonly<{ x: 1; y: 2 }>
-          | Readonly<{ x: 1; y: 3 }>
-          | Readonly<{ x: 2; y: 1 }>
-          | Readonly<{ x: 2; y: 2 }>
-          | Readonly<{ x: 3; y: 1 }>
-        )[]
+        readonly Readonly<
+          | { x: 1; y: 1 }
+          | { x: 1; y: 2 }
+          | { x: 1; y: 3 }
+          | { x: 2; y: 1 }
+          | { x: 2; y: 2 }
+          | { x: 3; y: 1 }
+        >[]
       >
     >('=');
 
@@ -849,14 +850,14 @@ describe('Arr transformations', () => {
         result,
         IMap.create<
           1 | 2 | 3,
-          readonly (
-            | Readonly<{ x: 1; y: 1 }>
-            | Readonly<{ x: 1; y: 2 }>
-            | Readonly<{ x: 1; y: 3 }>
-            | Readonly<{ x: 2; y: 1 }>
-            | Readonly<{ x: 2; y: 2 }>
-            | Readonly<{ x: 3; y: 1 }>
-          )[]
+          readonly Readonly<
+            | { x: 1; y: 1 }
+            | { x: 1; y: 2 }
+            | { x: 1; y: 3 }
+            | { x: 2; y: 1 }
+            | { x: 2; y: 2 }
+            | { x: 3; y: 1 }
+          >[]
         >([
           [
             1,

package/src/array/impl/array-utils-validation.mts

@@ -63,9 +63,9 @@ export const isEmpty = <E,>(array: readonly E[]): array is readonly [] =>
  * @example
  *
  * ```ts
- * const users: readonly { id: number }[] = [{ id: 1 }];
+ * const users: readonly Readonly<{ id: number }>[] = [{ id: 1 }];
  *
- * const emptyUsers: readonly { id: number }[] = [];
+ * const emptyUsers: readonly Readonly<{ id: number }>[] = [];
  *
  * assert.isTrue(Arr.isNonEmpty(users));
  *

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

@@ -36,7 +36,7 @@ describe('Arr validations', () => {
 
     test('should refine union types correctly', () => {
       const processValue = (
-        value: string | readonly number[] | null,
+        value: string | null | readonly number[],
       ): number => {
         if (isArray(value)) {
           // value should be typed as number[]
@@ -66,10 +66,10 @@ describe('Arr validations', () => {
     });
 
     test('should work with mutable arrays', () => {
-      const mutableArray: number[] = [1, 2, 3];
+      const mutableArray: readonly number[] = [1, 2, 3];
 
       if (isArray(mutableArray)) {
-        expectType<typeof mutableArray, number[]>('=');
+        expectType<typeof mutableArray, readonly number[]>('=');
 
         expect(mutableArray).toHaveLength(3);
       }
@@ -108,10 +108,10 @@ describe('Arr validations', () => {
         value:
           | string
           | boolean
-          | readonly number[]
-          | Readonly<{ a: number }>
           | unknown
-          | object,
+          | object
+          | readonly number[]
+          | Readonly<{ a: number }>,
       ): number => {
         if (isArray(value)) {
           // Only number[] should remain
@@ -123,7 +123,7 @@ describe('Arr validations', () => {
         // Non-array types
         expectType<
           typeof value,
-          string | boolean | Readonly<{ a: number }> | unknown | object
+          string | boolean | unknown | object | Readonly<{ a: number }>
         >('=');
 
         return -1;
@@ -273,7 +273,7 @@ describe('Arr validations', () => {
       });
 
       test('should handle intersection types', () => {
-        type TaggedArray = readonly number[] & { tag: string };
+        type TaggedArray = readonly number[] & Readonly<{ tag: string }>;
 
         const tagged = Object.assign([1, 2, 3], { tag: 'test' }) as TaggedArray;
 
@@ -297,8 +297,10 @@ describe('Arr validations', () => {
 
       test('should handle complex union discrimination', () => {
         type ComplexUnion =
-          | { type: 'array'; data: readonly string[] }
-          | { type: 'object'; data: Record<string, unknown> }
+          | Readonly<
+              | { type: 'array'; data: readonly string[] }
+              | { type: 'object'; data: Record<string, unknown> }
+            >
           | readonly number[]
           | string
           | null;
@@ -325,8 +327,10 @@ describe('Arr validations', () => {
 
           expectType<
             typeof value,
-            | { type: 'array'; data: readonly string[] }
-            | { type: 'object'; data: Record<string, unknown> }
+            Readonly<
+              | { type: 'array'; data: readonly string[] }
+              | { type: 'object'; data: Record<string, unknown> }
+            >
           >('=');
 
           return -1;
@@ -435,15 +439,16 @@ describe('Arr validations', () => {
     });
 
     test('should work with unknown array type', () => {
-      const arr: number[] = [1, 2];
+      const mut_arr: number[] = [1, 2];
 
-      assert.isTrue(isArrayOfLength(arr, 2));
+      assert.isTrue(isArrayOfLength(mut_arr, 2));
 
-      if (isArrayOfLength(arr, 2)) {
-        expectType<typeof arr, number[] & ArrayOfLength<2, number>>('=');
+      if (isArrayOfLength(mut_arr, 2)) {
+        // transformer-ignore-next-line
+        expectType<typeof mut_arr, number[] & ArrayOfLength<2, number>>('=');
       }
 
-      assert.isFalse(isArrayOfLength(arr, 3));
+      assert.isFalse(isArrayOfLength(mut_arr, 3));
     });
 
     test('should work with unknown readonly array type', () => {
@@ -525,23 +530,25 @@ describe('Arr validations', () => {
     });
 
     test('should work with unknown array type', () => {
-      const arr: number[] = [1, 2];
+      const mut_arr: number[] = [1, 2];
 
-      assert.isTrue(isArrayAtLeastLength(arr, 2));
+      assert.isTrue(isArrayAtLeastLength(mut_arr, 2));
 
-      expectType<typeof arr, number[] & ArrayAtLeastLen<2, number>>('=');
+      // transformer-ignore-next-line
+      expectType<typeof mut_arr, number[] & ArrayAtLeastLen<2, number>>('=');
 
-      assert.isFalse(isArrayAtLeastLength(arr, 3));
+      assert.isFalse(isArrayAtLeastLength(mut_arr, 3));
     });
 
     test('should work with unknown array type 2', () => {
-      const arr: number[] = [1, 2];
+      const mut_arr: number[] = [1, 2];
 
-      assert.isTrue(isArrayAtLeastLength(arr, 1));
+      assert.isTrue(isArrayAtLeastLength(mut_arr, 1));
 
-      expectType<typeof arr, number[] & ArrayAtLeastLen<1, number>>('=');
+      // transformer-ignore-next-line
+      expectType<typeof mut_arr, number[] & ArrayAtLeastLen<1, number>>('=');
 
-      assert.isFalse(isArrayAtLeastLength(arr, 3));
+      assert.isFalse(isArrayAtLeastLength(mut_arr, 3));
     });
 
     test('should return true for arrays of at least specified length (additional)', () => {
@@ -589,7 +596,7 @@ describe('Arr validations', () => {
     });
 
     test('should work as type guard', () => {
-      const mixed: (string | number)[] = ['hello', 'world'];
+      const mixed: readonly (string | number)[] = ['hello', 'world'];
 
       if (every(mixed, (x): x is string => typeof x === 'string')) {
         // TypeScript narrows mixed to readonly string[] here
@@ -612,7 +619,7 @@ describe('Arr validations', () => {
 
       const allStrings = every(isString);
 
-      const data: unknown[] = ['a', 'b', 'c'];
+      const data: readonly unknown[] = ['a', 'b', 'c'];
 
       if (allStrings(data)) {
         // TypeScript narrows data to readonly string[] here
@@ -621,7 +628,7 @@ describe('Arr validations', () => {
     });
 
     test('should return true for empty array', () => {
-      const empty: number[] = [];
+      const empty: readonly number[] = [];
 
       const result = every(empty, (n) => n > 0);
 
@@ -665,7 +672,7 @@ describe('Arr validations', () => {
     });
 
     test('should return false for empty array', () => {
-      const empty: number[] = [];
+      const empty: readonly number[] = [];
 
       const result = some(empty, (n) => n > 0);
 

package/src/array/impl/array.test.mts

@@ -37,6 +37,7 @@ describe('Array.flat', () => {
 
   expectType<
     typeof result,
+    // transformer-ignore-next-line
     (readonly [5, 6, readonly [7, 8]] | 1 | 2 | 3 | 4)[]
   >('=');
 
@@ -137,6 +138,7 @@ describe('Array.filter', () => {
 
     const filtered = xs.filter((x): x is 1 | 3 => x % 2 === 1);
 
+    // transformer-ignore-next-line
     expectType<typeof filtered, (1 | 3)[]>('=');
 
     test('case 1', () => {
@@ -149,6 +151,7 @@ describe('Array.filter', () => {
 
     const filtered = xs.filter((x) => x % 2 === 1);
 
+    // transformer-ignore-next-line
     expectType<typeof filtered, (1 | 2 | 3)[]>('=');
 
     test('case 2', () => {

package/src/collections/imap-mapped.test.mts

@@ -5,7 +5,7 @@ const toKey = (a: Readonly<{ v: number }>): number => a.v;
 
 const fromKey = (k: number): Readonly<{ v: number }> => ({ v: k });
 
-type TestKey = { id: number; type: string };
+type TestKey = Readonly<{ id: number; type: string }>;
 
 const testKeyToString = (key: Readonly<TestKey>): string =>
   `${key.type}_${key.id}`;
@@ -95,7 +95,10 @@ describe('IMapMapped.create', () => {
   });
 
   test('should handle complex key transformations', () => {
-    type ComplexKey = { nested: { id: number }; arr: number[] };
+    type ComplexKey = Readonly<{
+      nested: Readonly<{ id: number }>;
+      arr: readonly number[];
+    }>;
 
     const complexKeyToString = (
       key: DeepReadonly<{

package/src/collections/imap.mts

@@ -389,13 +389,13 @@ type IMapInterface<K extends MapSetKeyType, V> = Readonly<{
    *   ['b', 2],
    * ]);
    *
-   * const entries: (readonly [string, number])[] = [];
+   * const mut_entries: (readonly [string, number])[] = [];
    *
    * for (const [key, value] of map.entries()) {
-   *   entries.push([key, value]);
+   *   mut_entries.push([key, value]);
    * }
    *
-   * assert.deepStrictEqual(entries, [
+   * assert.deepStrictEqual(mut_entries, [
    *   ['a', 1],
    *   ['b', 2],
    * ]);

package/src/collections/iset-mapped.mts

@@ -472,13 +472,13 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    *   fromKey,
    * );
    *
-   * const collected: Point[] = [];
+   * const mut_collected: Point[] = [];
    *
    * for (const point of set) {
-   *   collected.push(point);
+   *   mut_collected.push(point);
    * }
    *
-   * assert.deepStrictEqual(collected, [
+   * assert.deepStrictEqual(mut_collected, [
    *   { x: 1, tag: 'a' },
    *   { x: 2, tag: 'b' },
    * ]);

package/src/collections/iset-mapped.test.mts

@@ -5,7 +5,7 @@ const toKey = (a: Readonly<{ v: number }>): number => a.v;
 const fromKey = (k: number): Readonly<{ v: number }> => ({ v: k });
 
 // Test types for additional functionality
-type TestElement = { id: number; type: string };
+type TestElement = Readonly<{ id: number; type: string }>;
 
 const testElementToString = (el: Readonly<TestElement>): string =>
   `${el.type}_${el.id}`;