ts-data-forge 2.1.0 → 2.1.2

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;

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 { 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];
    *   }
    * }

package/src/collections/imap.test.mts

@@ -25,15 +25,15 @@ describe('IMap[Symbol.iterator]', () => {
       ['a', 1],
       ['b', 2],
     ]);
-    const collected: [string, number][] = [];
+    const mut_collected: (readonly [string, number])[] = [];
 
     for (const entry of map) {
-      collected.push([...entry]);
+      mut_collected.push(entry);
     }
 
-    expect(collected).toHaveLength(2);
-    expect(collected).toContainEqual(['a', 1]);
-    expect(collected).toContainEqual(['b', 2]);
+    expect(mut_collected).toHaveLength(2);
+    expect(mut_collected).toContainEqual(['a', 1]);
+    expect(mut_collected).toContainEqual(['b', 2]);
   });
 
   test('should work with spread operator', () => {
@@ -41,7 +41,7 @@ describe('IMap[Symbol.iterator]', () => {
       ['a', 1],
       ['b', 2],
     ]);
-    const entries = [...map];
+    const entries = Array.from(map);
 
     expect(entries).toHaveLength(2);
     expect(entries).toContainEqual(['a', 1]);
@@ -282,8 +282,8 @@ describe('IMap.get', () => {
       ['undef', undefined],
       ['null', null],
     ]);
-    expect(Optional.unwrap(map.get('undef'))).toBe(undefined);
-    expect(Optional.unwrap(map.get('null'))).toBe(null);
+    expect(Optional.unwrap(map.get('undef'))).toBeUndefined();
+    expect(Optional.unwrap(map.get('null'))).toBeNull();
   });
 });
 
@@ -781,27 +781,28 @@ describe('IMap.forEach', () => {
       ['b', 2],
       ['c', 3],
     ]);
-    const collected: [string, number][] = [];
+    const mut_collected: [string, number][] = [];
 
-    map.forEach((value, key) => {
-      collected.push([key, value]);
-    });
+    for (const [key, value] of map.entries()) {
+      mut_collected.push([key, value]);
+    }
 
-    expect(collected).toHaveLength(3);
-    expect(collected).toContainEqual(['a', 1]);
-    expect(collected).toContainEqual(['b', 2]);
-    expect(collected).toContainEqual(['c', 3]);
+    expect(mut_collected).toHaveLength(3);
+    expect(mut_collected).toContainEqual(['a', 1]);
+    expect(mut_collected).toContainEqual(['b', 2]);
+    expect(mut_collected).toContainEqual(['c', 3]);
   });
 
   test('should work with empty map', () => {
     const map = IMap.create<string, number>([]);
-    let called = false;
+    let mut_called = false;
 
+    // eslint-disable-next-line unicorn/no-array-for-each
     map.forEach(() => {
-      called = true;
+      mut_called = true;
     });
 
-    expect(called).toBe(false);
+    expect(mut_called).toBe(false);
   });
 });
 

package/src/collections/iset-mapped.mts

@@ -611,7 +611,7 @@ export namespace ISetMapped {
    *
    * const combinedFlags = ISetMapped.union(setA, setB);
    * // The order might vary as sets are unordered internally.
-   * console.log(combinedFlags.toArray().map(f => f.flagName).sort());
+   * console.log(combinedFlags.toArray().map(f => f.flagName).toSorted());
    * // Output: ["betaFeature", "darkMode", "newUI"]
    * ```
    */

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

@@ -212,96 +212,6 @@ describe('ISetMapped.entries', () => {
   });
 });
 
-describe('ISetMapped.union', () => {
-  test('case 1', () => {
-    const s0 = ISetMapped.create(
-      [{ v: 1 }, { v: 2 }, { v: 3 }],
-      toKey,
-      fromKey,
-    );
-    const s1 = ISetMapped.create(
-      [{ v: 3 }, { v: 4 }, { v: 5 }],
-      toKey,
-      fromKey,
-    );
-
-    expect(s0.union(s1)).toStrictEqual(
-      ISetMapped.create(
-        [{ v: 1 }, { v: 2 }, { v: 3 }, { v: 4 }, { v: 5 }],
-        toKey,
-        fromKey,
-      ),
-    );
-  });
-  test('case 2', () => {
-    const s0 = ISetMapped.create(
-      [{ v: 1 }, { v: 2 }, { v: 3 }],
-      toKey,
-      fromKey,
-    );
-    const s1 = ISetMapped.create([], toKey, fromKey);
-
-    expect(s0.union(s1)).toStrictEqual(
-      ISetMapped.create([{ v: 1 }, { v: 2 }, { v: 3 }], toKey, fromKey),
-    );
-  });
-  test('case 3', () => {
-    const s0 = ISetMapped.create([], toKey, fromKey);
-    const s1 = ISetMapped.create(
-      [{ v: 1 }, { v: 2 }, { v: 3 }],
-      toKey,
-      fromKey,
-    );
-
-    expect(s0.union(s1)).toStrictEqual(
-      ISetMapped.create([{ v: 1 }, { v: 2 }, { v: 3 }], toKey, fromKey),
-    );
-  });
-});
-
-describe('ISetMapped.intersect', () => {
-  test('case 1', () => {
-    const s0 = ISetMapped.create(
-      [{ v: 1 }, { v: 2 }, { v: 3 }],
-      toKey,
-      fromKey,
-    );
-    const s1 = ISetMapped.create(
-      [{ v: 2 }, { v: 3 }, { v: 4 }],
-      toKey,
-      fromKey,
-    );
-
-    expect(s0.intersect(s1)).toStrictEqual(
-      ISetMapped.create([{ v: 2 }, { v: 3 }], toKey, fromKey),
-    );
-  });
-  test('case 2', () => {
-    const s0 = ISetMapped.create(
-      [{ v: 1 }, { v: 2 }, { v: 3 }],
-      toKey,
-      fromKey,
-    );
-    const s1 = ISetMapped.create([], toKey, fromKey);
-
-    expect(s0.intersect(s1)).toStrictEqual(
-      ISetMapped.create([], toKey, fromKey),
-    );
-  });
-  test('case 3', () => {
-    const s0 = ISetMapped.create([], toKey, fromKey);
-    const s1 = ISetMapped.create(
-      [{ v: 1 }, { v: 2 }, { v: 3 }],
-      toKey,
-      fromKey,
-    );
-
-    expect(s0.intersect(s1)).toStrictEqual(
-      ISetMapped.create([], toKey, fromKey),
-    );
-  });
-});
-
 describe('ISetMapped.subtract', () => {
   test('case 1', () => {
     const s0 = ISetMapped.create(
@@ -901,15 +811,15 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
-      const collected: TestElement[] = [];
+      const mut_collected: TestElement[] = [];
 
-      set.forEach((el) => {
-        collected.push(el);
-      });
+      for (const el of set) {
+        mut_collected.push(el);
+      }
 
-      expect(collected).toHaveLength(2);
-      expect(collected).toContainEqual({ id: 1, type: 'user' });
-      expect(collected).toContainEqual({ id: 2, type: 'admin' });
+      expect(mut_collected).toHaveLength(2);
+      expect(mut_collected).toContainEqual({ id: 1, type: 'user' });
+      expect(mut_collected).toContainEqual({ id: 2, type: 'admin' });
     });
   });
 
@@ -1125,9 +1035,9 @@ describe('ISetMapped additional functionality with complex types', () => {
       const entries = Array.from(set.entries());
 
       expect(entries).toHaveLength(2);
-      entries.forEach(([key, value]) => {
+      for (const [key, value] of entries) {
         expect(key).toStrictEqual(value);
-      });
+      }
     });
 
     test('should work with for-of loop', () => {
@@ -1139,15 +1049,15 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
-      const collected: TestElement[] = [];
+      const mut_collected: TestElement[] = [];
 
       for (const element of set) {
-        collected.push(element);
+        mut_collected.push(element);
       }
 
-      expect(collected).toHaveLength(2);
-      expect(collected).toContainEqual({ id: 1, type: 'user' });
-      expect(collected).toContainEqual({ id: 2, type: 'admin' });
+      expect(mut_collected).toHaveLength(2);
+      expect(mut_collected).toContainEqual({ id: 1, type: 'user' });
+      expect(mut_collected).toContainEqual({ id: 2, type: 'admin' });
     });
   });
 

package/src/collections/iset.mts

@@ -1,6 +1,6 @@
 import { Result } from '../functional/index.mjs';
 import { asUint32 } from '../number/index.mjs';
-import { unknownToString } from '../others/unknown-to-string.mjs';
+import { unknownToString } from '../others/index.mjs';
 
 /**
  * Interface for an immutable set with O(1) lookup performance and set operation support.
@@ -258,7 +258,7 @@ export namespace ISet {
    *   .filter(x => x % 2 === 0)  // Keep even numbers: 2, 4
    *   .add(6)                    // Add 6: 2, 4, 6
    *   .delete(2);                // Remove 2: 4, 6
-   * console.log(processedNumbers.toArray().sort()); // Output: [4, 6]
+   * console.log(processedNumbers.toArray().toSorted()); // Output: [4, 6]
    *
    * // From generator function
    * function* generatePrimes(): Generator<number> {
@@ -445,7 +445,7 @@ export namespace ISet {
    * const rolePermissions = ISet.create(["write", "execute", "admin"]);
    *
    * const allPermissions = ISet.union(userPermissions, rolePermissions);
-   * console.log(allPermissions.toArray().sort());
+   * console.log(allPermissions.toArray().toSorted());
    * // Output: ["admin", "execute", "read", "write"]
    *
    * // Union with different types (type widening)