ts-data-forge 2.1.1 → 2.1.3

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

@@ -1,6 +1,6 @@
 import { IMap } from '../collections/index.mjs';
 import { expectType } from '../expect-type.mjs';
-import { Optional } from '../functional/optional.mjs';
+import { Optional } from '../functional/index.mjs';
 import { SafeUint } from '../number/index.mjs';
 import { Arr } from './array-utils.mjs';
 
@@ -132,47 +132,7 @@ describe('Arr transformations', () => {
       expect(result).toStrictEqual([[1, 2]]);
     });
 
-    test('should work with empty array', () => {
-      const empty: readonly number[] = [];
-      const result = Arr.partition(empty, 2);
-
-      expect(result).toStrictEqual([]);
-    });
-
-    test('should partition array into chunks', () => {
-      const numbers = [1, 2, 3, 4, 5, 6];
-      const result = Arr.partition(numbers, 2);
-
-      expect(result).toStrictEqual([
-        [1, 2],
-        [3, 4],
-        [5, 6],
-      ]);
-    });
-
-    test('should handle arrays not evenly divisible by chunk size', () => {
-      const numbers = [1, 2, 3, 4, 5];
-      const result = Arr.partition(numbers, 2);
-
-      expect(result).toStrictEqual([[1, 2], [3, 4], [5]]);
-    });
-
-    test('should work with chunk size < 2 (returns empty)', () => {
-      const numbers = [1, 2, 3];
-      const result = Arr.partition(numbers, 1);
-
-      // According to docs, returns empty array if chunkSize < 2
-      expect(result).toStrictEqual([]);
-    });
-
-    test('should work with chunk size larger than array', () => {
-      const numbers = [1, 2];
-      const result = Arr.partition(numbers, 5);
-
-      expect(result).toStrictEqual([[1, 2]]);
-    });
-
-    test('should work with empty array', () => {
+    test('partition should work with empty array', () => {
       const empty: readonly number[] = [];
       const result = Arr.partition(empty, 2);
 
@@ -180,19 +140,6 @@ describe('Arr transformations', () => {
     });
   });
 
-  describe('toReversed', () => {
-    {
-      const xs = [1, 2, 3] as const;
-      const result = xs.toReversed();
-
-      expectType<typeof result, (1 | 2 | 3)[]>('=');
-
-      test('case 1', () => {
-        expect(result).toStrictEqual([3, 2, 1]);
-      });
-    }
-  });
-
   describe('toSorted', () => {
     {
       const xs = [2, 1, 3] as const;
@@ -294,37 +241,7 @@ describe('Arr transformations', () => {
       expect(result).toStrictEqual([]);
     });
 
-    test('should sort by key function', () => {
-      const people = [
-        { name: 'Alice', age: 30 },
-        { name: 'Bob', age: 20 },
-        { name: 'Charlie', age: 25 },
-      ];
-      const result = Arr.toSortedBy(people, (person) => person.age);
-
-      expect(result).toHaveLength(3);
-      expect(result[0]?.name).toBe('Bob');
-      expect(result[1]?.name).toBe('Charlie');
-      expect(result[2]?.name).toBe('Alice');
-    });
-
-    test('should work with string sorting', () => {
-      const words = ['banana', 'apple', 'cherry'];
-      const result = Arr.toSortedBy(
-        words,
-        (word: string) => word,
-        (a: string, b: string) => a.localeCompare(b),
-      );
-      expect(result).toStrictEqual(['apple', 'banana', 'cherry']);
-    });
-
-    test('should work with custom key extraction', () => {
-      const items = ['hello', 'hi', 'welcome', 'bye'];
-      const result = Arr.toSortedBy(items, (item) => item.length);
-      expect(result).toStrictEqual(['hi', 'bye', 'hello', 'welcome']);
-    });
-
-    test('should work with empty array', () => {
+    test('toSortedBy should work with empty array', () => {
       const empty: readonly { value: number }[] = [];
       const result = Arr.toSortedBy(empty, (item) => item.value);
       expect(result).toStrictEqual([]);
@@ -452,68 +369,6 @@ describe('Arr transformations', () => {
         expect(all.value).toStrictEqual([1, 2, 3, 4]);
       }
     });
-
-    test('should group elements by key', () => {
-      const array = [
-        { type: 'fruit', name: 'apple' },
-        { type: 'vegetable', name: 'carrot' },
-        { type: 'fruit', name: 'banana' },
-      ];
-      const grouped = Arr.groupBy(array, (item) => item.type);
-
-      expect(grouped.size).toBe(2);
-      const fruits = grouped.get('fruit');
-      const vegetables = grouped.get('vegetable');
-
-      expect(Optional.isSome(fruits)).toBe(true);
-      expect(Optional.isSome(vegetables)).toBe(true);
-
-      if (Optional.isSome(fruits)) {
-        expect(fruits.value).toHaveLength(2);
-        expect(fruits.value[0]?.name).toBe('apple');
-        expect(fruits.value[1]?.name).toBe('banana');
-      }
-
-      if (Optional.isSome(vegetables)) {
-        expect(vegetables.value).toHaveLength(1);
-        expect(vegetables.value[0]?.name).toBe('carrot');
-      }
-    });
-
-    test('should work with numeric keys', () => {
-      const numbers = [1, 2, 3, 4, 5, 6];
-      const grouped = Arr.groupBy(numbers, (n) => n % 2);
-
-      expect(grouped.size).toBe(2);
-      const evens = grouped.get(0);
-      const odds = grouped.get(1);
-
-      if (Optional.isSome(evens)) {
-        expect(evens.value).toStrictEqual([2, 4, 6]);
-      }
-
-      if (Optional.isSome(odds)) {
-        expect(odds.value).toStrictEqual([1, 3, 5]);
-      }
-    });
-
-    test('should work with empty array', () => {
-      const empty: readonly number[] = [];
-      const grouped = Arr.groupBy(empty, (n) => n % 2);
-      expect(grouped.size).toBe(0);
-    });
-
-    test('should handle all elements in same group', () => {
-      const array = [1, 2, 3, 4];
-      const grouped = Arr.groupBy(array, () => 'all');
-
-      expect(grouped.size).toBe(1);
-      const all = grouped.get('all');
-
-      if (Optional.isSome(all)) {
-        expect(all.value).toStrictEqual([1, 2, 3, 4]);
-      }
-    });
   });
 
   describe('zip', () => {
@@ -632,41 +487,6 @@ describe('Arr transformations', () => {
       const result = Arr.zip(arr1, arr2);
       expect(result).toStrictEqual([]);
     });
-
-    test('should zip two arrays', () => {
-      const arr1 = [1, 2, 3];
-      const arr2 = ['a', 'b', 'c'];
-      const result = Arr.zip(arr1, arr2);
-      expect(result).toStrictEqual([
-        [1, 'a'],
-        [2, 'b'],
-        [3, 'c'],
-      ]);
-    });
-
-    test('should handle arrays of different lengths', () => {
-      const arr1 = [1, 2, 3, 4];
-      const arr2 = ['a', 'b'];
-      const result = Arr.zip(arr1, arr2);
-      expect(result).toStrictEqual([
-        [1, 'a'],
-        [2, 'b'],
-      ]);
-    });
-
-    test('should work with empty arrays', () => {
-      const arr1: readonly number[] = [];
-      const arr2: readonly string[] = [];
-      const result = Arr.zip(arr1, arr2);
-      expect(result).toStrictEqual([]);
-    });
-
-    test('should handle one empty array', () => {
-      const arr1 = [1, 2, 3];
-      const arr2: readonly string[] = [];
-      const result = Arr.zip(arr1, arr2);
-      expect(result).toStrictEqual([]);
-    });
   });
 
   describe('filterNot', () => {
@@ -816,6 +636,11 @@ describe('Arr transformations', () => {
 
   describe('toReversed', () => {
     {
+      const xs = [1, 2, 3] as const;
+      const _nativeResult = xs.toReversed();
+
+      expectType<typeof _nativeResult, (1 | 2 | 3)[]>('=');
+
       const result = Arr.toReversed([1, 2, 3]);
 
       expectType<typeof result, readonly [3, 2, 1]>('=');
@@ -1197,15 +1022,15 @@ describe('Arr transformations', () => {
     test('should search from end to beginning', () => {
       // Verify search order by using side effects
       const numbers = [1, 2, 3, 4, 5];
-      const searchOrder: number[] = [];
+      const mut_searchOrder: number[] = [];
 
       Arr.findLastIndex(numbers, (val, idx) => {
-        searchOrder.push(idx);
+        mut_searchOrder.push(idx);
         return val === 3;
       });
 
       // Should search from end: 4, 3, 2 (stops at 2 when found)
-      expect(searchOrder).toStrictEqual([4, 3, 2]);
+      expect(mut_searchOrder).toStrictEqual([4, 3, 2]);
     });
 
     test('should handle single element array', () => {

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

@@ -19,14 +19,16 @@ describe('Arr validations', () => {
     });
 
     test('should refine union types correctly', () => {
-      function processValue(value: string | readonly number[] | null): number {
+      const processValue = (
+        value: string | readonly number[] | null,
+      ): number => {
         if (Arr.isArray(value)) {
           // value should be typed as number[]
           expectType<typeof value, readonly number[]>('=');
           return value.length;
         }
         return 0;
-      }
+      };
 
       expect(processValue([1, 2, 3])).toBe(3);
       expect(processValue('hello')).toBe(0);
@@ -37,7 +39,7 @@ describe('Arr validations', () => {
       const readonlyArray: readonly number[] = [1, 2, 3];
       if (Arr.isArray(readonlyArray)) {
         expectType<typeof readonlyArray, readonly number[]>('=');
-        expect(readonlyArray.length).toBe(3);
+        expect(readonlyArray).toHaveLength(3);
       }
     });
 
@@ -45,25 +47,25 @@ describe('Arr validations', () => {
       const mutableArray: number[] = [1, 2, 3];
       if (Arr.isArray(mutableArray)) {
         expectType<typeof mutableArray, number[]>('=');
-        expect(mutableArray.length).toBe(3);
+        expect(mutableArray).toHaveLength(3);
       }
     });
 
     test('should exclude impossible array types from unions', () => {
-      function checkUnion(
-        value: string | boolean | readonly number[] | { readonly a: number },
-      ): number {
+      const checkUnion = (
+        value: string | boolean | readonly number[] | Readonly<{ a: number }>,
+      ): number => {
         if (Arr.isArray(value)) {
           // Only number[] should remain
           expectType<typeof value, readonly number[]>('=');
           return value.length;
         }
         // Non-array types
-        expectType<typeof value, string | boolean | { readonly a: number }>(
+        expectType<typeof value, string | boolean | Readonly<{ a: number }>>(
           '=',
         );
         return -1;
-      }
+      };
 
       expect(checkUnion([1, 2])).toBe(2);
       expect(checkUnion('test')).toBe(-1);
@@ -72,17 +74,17 @@ describe('Arr validations', () => {
     });
 
     test('should exclude impossible array types from unions (including unknown)', () => {
-      function checkUnion(
+      const checkUnion = (
         value:
           | string
           | boolean
           | readonly number[]
-          | { readonly a: number }
+          | Readonly<{ a: number }>
           // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
           | unknown
           // eslint-disable-next-line @typescript-eslint/no-restricted-types
           | object,
-      ): number {
+      ): number => {
         if (Arr.isArray(value)) {
           // Only number[] should remain
           expectType<typeof value, readonly unknown[]>('=');
@@ -93,14 +95,14 @@ describe('Arr validations', () => {
           typeof value,
           | string
           | boolean
-          | { readonly a: number }
+          | Readonly<{ a: number }>
           // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
           | unknown
           // eslint-disable-next-line @typescript-eslint/no-restricted-types
           | object
         >('=');
         return -1;
-      }
+      };
 
       expect(checkUnion([1, 2])).toBe(2);
       expect(checkUnion('test')).toBe(-1);
@@ -126,7 +128,7 @@ describe('Arr validations', () => {
       const value: unknown = [1, 2, 3];
       if (Arr.isArray(value)) {
         expectType<typeof value, readonly unknown[]>('=');
-        expect(value.length).toBe(3);
+        expect(value).toHaveLength(3);
       }
     });
 
@@ -186,13 +188,13 @@ describe('Arr validations', () => {
       });
 
       test('should work with generic function', () => {
-        function processGeneric<T>(value: T | readonly number[]): number {
+        const processGeneric = <T,>(value: T | readonly number[]): number => {
           if (Arr.isArray(value)) {
             // Type is narrowed to array type within this block
             return value.length;
           }
           return 0;
-        }
+        };
         expect(processGeneric([1, 2, 3])).toBe(3);
         expect(processGeneric('hello')).toBe(0);
       });
@@ -207,14 +209,14 @@ describe('Arr validations', () => {
 
       test('should work with conditional types', () => {
         type ArrayOrValue<T> = T extends readonly unknown[] ? T : readonly T[];
-        function makeArray<T>(value: T): ArrayOrValue<T> {
+        const makeArray = <T,>(value: T): ArrayOrValue<T> => {
           if (Arr.isArray(value)) {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
             return value as ArrayOrValue<T>;
           }
           // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
           return [value] as ArrayOrValue<T>;
-        }
+        };
         expect(makeArray([1, 2, 3])).toStrictEqual([1, 2, 3]);
         expect(makeArray(5)).toStrictEqual([5]);
       });
@@ -229,9 +231,7 @@ describe('Arr validations', () => {
       });
 
       test('should work with branded types', () => {
-        type BrandedArray = readonly number[] & {
-          readonly __brand: unique symbol;
-        };
+        type BrandedArray = readonly number[] & Readonly<{ __brand: unknown }>;
         // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
         const branded = [1, 2, 3] as unknown as BrandedArray;
         if (Arr.isArray(branded)) {
@@ -248,7 +248,7 @@ describe('Arr validations', () => {
           | null;
 
         // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-        function processComplex(value: ComplexUnion): number {
+        const processComplex = (value: ComplexUnion): number => {
           if (Arr.isArray(value)) {
             expectType<typeof value, readonly number[]>('=');
             return value.length;
@@ -267,7 +267,7 @@ describe('Arr validations', () => {
             | { type: 'object'; data: Record<string, unknown> }
           >('=');
           return -1;
-        }
+        };
 
         expect(processComplex([1, 2, 3])).toBe(3);
         expect(processComplex('test')).toBe(4);
@@ -293,7 +293,7 @@ describe('Arr validations', () => {
         const sym = Symbol('test');
         const arrWithSymbol = Object.assign([1, 2, 3], { [sym]: 'value' });
         if (Arr.isArray(arrWithSymbol)) {
-          expect(arrWithSymbol.length).toBe(3);
+          expect(arrWithSymbol).toHaveLength(3);
         }
       });
     });
@@ -390,7 +390,7 @@ describe('Arr validations', () => {
       const array: readonly number[] = [1, 2, 3];
       if (Arr.isArrayOfLength(array, 3)) {
         expectType<typeof array, ArrayOfLength<3, number>>('=');
-        expect(array.length).toBe(3);
+        expect(array).toHaveLength(3);
       }
     });
   });
@@ -455,7 +455,7 @@ describe('Arr validations', () => {
       const array: readonly number[] = [1, 2, 3];
       if (Arr.isArrayAtLeastLength(array, 2)) {
         expectType<typeof array, ArrayAtLeastLen<2, number>>('=');
-        expect(array.length >= 2).toBe(true);
+        expect(array.length).toBeGreaterThanOrEqual(2);
       }
     });
   });

package/src/array/array-utils.mts

@@ -2133,9 +2133,9 @@ export namespace Arr {
     switch (args.length) {
       case 3: {
         const [array, value, [start, end]] = args;
-        const cp: (E | V)[] = castMutable(copy(array));
-        cp.fill(value, start, end);
-        return cp;
+        const mut_cp: (E | V)[] = castMutable(copy(array));
+        mut_cp.fill(value, start, end);
+        return mut_cp;
       }
       case 2: {
         const [value, fillRange] = args;
@@ -2669,7 +2669,7 @@ export namespace Arr {
         const [array, searchElement] = args;
 
         const index = array.indexOf(searchElement);
-        return index >= 0 ? asUint32(index) : -1;
+        return index !== -1 ? asUint32(index) : -1;
       }
       case 1: {
         const [searchElement] = args;
@@ -2702,7 +2702,7 @@ export namespace Arr {
       case 3: {
         const [array, searchElement, fromIndex] = args;
         const index = array.indexOf(searchElement, fromIndex);
-        return index >= 0 ? asUint32(index) : -1;
+        return index !== -1 ? asUint32(index) : -1;
       }
       case 2: {
         const [searchElement, fromIndex] = args;
@@ -2750,7 +2750,7 @@ export namespace Arr {
       case 2: {
         const [array, searchElement] = args;
         const index = array.lastIndexOf(searchElement);
-        return index >= 0 ? asUint32(index) : -1;
+        return index !== -1 ? asUint32(index) : -1;
       }
       case 1: {
         const [searchElement] = args;
@@ -2785,7 +2785,7 @@ export namespace Arr {
 
         const index = array.lastIndexOf(searchElement, fromIndex);
 
-        return index >= 0 ? asUint32(index) : -1;
+        return index !== -1 ? asUint32(index) : -1;
       }
       case 2: {
         const [searchElement, fromIndex] = args;
@@ -3460,11 +3460,7 @@ export namespace Arr {
       return Result.ok(result);
     } catch (error) {
       return Result.err(
-        error instanceof Error
-          ? error
-          : pipe(unknownToString(error))
-              .map(Result.unwrapOkOr('Failed to join array'))
-              .map((e) => new Error(e)).value,
+        error instanceof Error ? error : new Error(unknownToString(error)),
       );
     }
   };

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

@@ -83,10 +83,12 @@ describe('IMapMapped.create', () => {
 
   test('should handle complex key transformations', () => {
     type ComplexKey = { nested: { id: number }; arr: number[] };
-    const complexKeyToString = (key: {
-      readonly nested: { readonly id: number };
-      readonly arr: readonly number[];
-    }): string => `${key.nested.id}_${key.arr.join(',')}`;
+    const complexKeyToString = (
+      key: DeepReadonly<{
+        nested: { id: number };
+        arr: number[];
+      }>,
+    ): string => `${key.nested.id}_${key.arr.join(',')}`;
     const stringToComplexKey = (str: string): ComplexKey => {
       const [idStr, arrStr] = str.split('_');
       return {
@@ -527,6 +529,7 @@ describe('IMapMapped.some', () => {
       testKeyToString,
       stringToTestKey,
     );
+    // eslint-disable-next-line unicorn/prefer-includes
     expect(map.some((value) => value === 'Alice')).toBe(true);
   });
 
@@ -539,6 +542,7 @@ describe('IMapMapped.some', () => {
       testKeyToString,
       stringToTestKey,
     );
+    // eslint-disable-next-line unicorn/prefer-includes
     expect(map.some((value) => value === 'Charlie')).toBe(false);
   });
 
@@ -704,15 +708,15 @@ describe('IMapMapped.forEach', () => {
       testKeyToString,
       stringToTestKey,
     );
-    const collected: [TestKey, string][] = [];
+    const mut_collected: [TestKey, string][] = [];
 
-    map.forEach((value, key) => {
-      collected.push([key, value]);
-    });
+    for (const [key, value] of map.entries()) {
+      mut_collected.push([key, value]);
+    }
 
-    expect(collected).toHaveLength(2);
-    expect(collected).toContainEqual([{ id: 1, type: 'user' }, 'Alice']);
-    expect(collected).toContainEqual([{ id: 2, type: 'admin' }, 'Bob']);
+    expect(mut_collected).toHaveLength(2);
+    expect(mut_collected).toContainEqual([{ id: 1, type: 'user' }, 'Alice']);
+    expect(mut_collected).toContainEqual([{ id: 2, type: 'admin' }, 'Bob']);
   });
 });
 

package/src/collections/imap.mts

@@ -1,7 +1,6 @@
-import { Optional, Result } from '../functional/index.mjs';
+import { Optional } from '../functional/index.mjs';
 import { asUint32 } from '../number/index.mjs';
-import { tp } from '../others/index.mjs';
-import { unknownToString } from '../others/unknown-to-string.mjs';
+import { tp, unknownToString } from '../others/index.mjs';
 
 /**
  * Interface for an immutable map with O(1) lookup performance and functional programming patterns.
@@ -323,7 +322,7 @@ export namespace IMap {
    *
    * // From custom iterable
    * function* generateEntries(): Generator<[string, number]> {
-   *   for (let i = 0; i < 3; i++) {
+   *   for (const i of range(3)) {
    *     yield [`item${i}`, i * 10];
    *   }
    * }
@@ -488,9 +487,7 @@ class IMapClass<K extends MapSetKeyType, V>
     if (!this.has(key)) {
       if (this.#showNotFoundMessage) {
         const keyStr = unknownToString(key);
-        console.warn(
-          `IMap.delete: key not found: ${Result.isOk(keyStr) ? keyStr.value : '<error converting key to string>'}`,
-        );
+        console.warn(`IMap.delete: key not found: ${keyStr}`);
       }
       return this;
     }
@@ -519,9 +516,7 @@ class IMapClass<K extends MapSetKeyType, V>
     if (Optional.isNone(curr)) {
       if (this.#showNotFoundMessage) {
         const keyStr = unknownToString(key);
-        console.warn(
-          `IMap.update: key not found: ${Result.isOk(keyStr) ? keyStr.value : '<error converting key to string>'}`,
-        );
+        console.warn(`IMap.update: key not found: ${keyStr}`);
       }
       return this;
     }
@@ -561,9 +556,7 @@ class IMapClass<K extends MapSetKeyType, V>
           if (!mut_result.has(key) || curr === undefined) {
             if (this.#showNotFoundMessage) {
               const keyStr = unknownToString(key);
-              console.warn(
-                `IMap.withMutations: key not found: ${Result.isOk(keyStr) ? keyStr.value : '<error converting key to string>'}`,
-              );
+              console.warn(`IMap.withMutations: key not found: ${keyStr}`);
             }
             break;
           }