ts-data-forge 2.1.1 → 2.1.3

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';
+// No imports from functional needed anymore
 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)
@@ -560,9 +560,7 @@ class ISetClass<K extends MapSetKeyType> implements ISet<K>, Iterable<K> {
     if (!this.has(key)) {
       if (this.#showNotFoundMessage) {
         const keyStr = unknownToString(key);
-        console.warn(
-          `ISet.delete: key not found: ${Result.isOk(keyStr) ? keyStr.value : '<error converting key to string>'}`,
-        );
+        console.warn(`ISet.delete: key not found: ${keyStr}`);
       }
       return this;
     }

package/src/collections/iset.test.mts

@@ -325,7 +325,7 @@ describe('ISet.map', () => {
     const set = ISet.create([1, 2, 3]);
     const doubled = set.map((x) => x * 2);
 
-    expect([...doubled.toArray()].sort((a, b) => a - b)).toStrictEqual([
+    expect(doubled.toArray().toSorted((a, b) => a - b)).toStrictEqual([
       2, 4, 6,
     ]);
   });
@@ -711,34 +711,35 @@ describe('ISet.forEach', () => {
       (callback: (value: 1 | 2 | 3) => void) => void
     >('<=');
 
-    const result: (1 | 2 | 3)[] = [];
-    s0.forEach((x) => {
-      result.push(x);
-    });
+    const mut_result: (1 | 2 | 3)[] = [];
+    for (const x of s0) {
+      mut_result.push(x);
+    }
 
-    expect(result.sort((a, b) => a - b)).toStrictEqual([1, 2, 3]);
+    expect(mut_result.toSorted((a, b) => a - b)).toStrictEqual([1, 2, 3]);
   });
 
   test('should execute callback for each element', () => {
     const set = ISet.create([1, 2, 3]);
-    const collected: number[] = [];
+    const mut_collected: number[] = [];
 
-    set.forEach((value) => {
-      collected.push(value);
-    });
+    for (const value of set) {
+      mut_collected.push(value);
+    }
 
-    expect(collected.sort((a, b) => a - b)).toStrictEqual([1, 2, 3]);
+    expect(mut_collected.toSorted((a, b) => a - b)).toStrictEqual([1, 2, 3]);
   });
 
   test('should not call callback for empty set', () => {
     const set = ISet.create<number>([]);
-    let callCount = 0;
+    let mut_callCount = 0;
 
+    // eslint-disable-next-line unicorn/no-array-for-each
     set.forEach(() => {
-      callCount += 1;
+      mut_callCount += 1;
     });
 
-    expect(callCount).toBe(0);
+    expect(mut_callCount).toBe(0);
   });
 });
 
@@ -748,12 +749,12 @@ describe('ISet.keys', () => {
 
     expectType<typeof s0.keys, () => IterableIterator<1 | 2 | 3>>('<=');
 
-    const result: (1 | 2 | 3)[] = [];
+    const mut_result: (1 | 2 | 3)[] = [];
     for (const x of s0.keys()) {
-      result.push(x);
+      mut_result.push(x);
     }
 
-    expect(result.sort((a, b) => a - b)).toStrictEqual([1, 2, 3]);
+    expect(mut_result.toSorted((a, b) => a - b)).toStrictEqual([1, 2, 3]);
   });
 });
 
@@ -763,12 +764,12 @@ describe('ISet.values', () => {
 
     expectType<typeof s0.values, () => IterableIterator<1 | 2 | 3>>('<=');
 
-    const result: (1 | 2 | 3)[] = [];
+    const mut_result: (1 | 2 | 3)[] = [];
     for (const x of s0.values()) {
-      result.push(x);
+      mut_result.push(x);
     }
 
-    expect(result.sort((a, b) => a - b)).toStrictEqual([1, 2, 3]);
+    expect(mut_result.toSorted((a, b) => a - b)).toStrictEqual([1, 2, 3]);
   });
 });
 
@@ -781,12 +782,12 @@ describe('ISet.entries', () => {
       () => IterableIterator<readonly [1 | 2 | 3, 1 | 2 | 3]>
     >('<=');
 
-    const result: [1 | 2 | 3, 1 | 2 | 3][] = [];
+    const mut_result: [1 | 2 | 3, 1 | 2 | 3][] = [];
     for (const x of s0.entries()) {
-      result.push([x[0], x[1]]);
+      mut_result.push([x[0], x[1]]);
     }
 
-    expect(result.sort((a, b) => a[0] - b[0])).toStrictEqual([
+    expect(mut_result.toSorted((a, b) => a[0] - b[0])).toStrictEqual([
       [1, 1],
       [2, 2],
       [3, 3],
@@ -799,7 +800,9 @@ describe('ISet.toArray', () => {
     const s0 = ISet.create([1, 2, 3] as const);
 
     expectType<typeof s0.toArray, () => readonly (1 | 2 | 3)[]>('<=');
-    expect([...s0.toArray()].sort((a, b) => a - b)).toStrictEqual([1, 2, 3]);
+    expect(Array.from(s0.toArray()).toSorted((a, b) => a - b)).toStrictEqual([
+      1, 2, 3,
+    ]);
   });
 
   test('case 2', () => {
@@ -812,8 +815,10 @@ describe('ISet.toArray', () => {
     const set = ISet.create([1, 3, 2]);
     const array = set.toArray();
 
-    expect(array.length).toBe(3);
-    expect([...array].sort((a, b) => a - b)).toStrictEqual([1, 2, 3]);
+    expect(array).toHaveLength(3);
+    expect(Array.from(array).toSorted((a, b) => a - b)).toStrictEqual([
+      1, 2, 3,
+    ]);
   });
 });
 
@@ -961,34 +966,38 @@ describe('ISet.withMutations', () => {
 describe('iterable functionality', () => {
   test('should work with for-of loops', () => {
     const set = ISet.create([1, 2, 3]);
-    const collected: number[] = [];
+    const mut_collected: number[] = [];
 
     for (const value of set) {
-      collected.push(value);
+      mut_collected.push(value);
     }
 
-    expect(collected.sort((a, b) => a - b)).toStrictEqual([1, 2, 3]);
+    expect(mut_collected.toSorted((a, b) => a - b)).toStrictEqual([1, 2, 3]);
   });
 
   test('should work with spread operator', () => {
     const set = ISet.create([1, 2, 3]);
-    const array = [...set];
+    const array = Array.from(set);
 
-    expect([...array].sort((a, b) => a - b)).toStrictEqual([1, 2, 3]);
+    expect(Array.from(array).toSorted((a, b) => a - b)).toStrictEqual([
+      1, 2, 3,
+    ]);
   });
 
   test('should work with Array.from', () => {
     const set = ISet.create([1, 2, 3]);
     const array = Array.from(set);
 
-    expect([...array].sort((a, b) => a - b)).toStrictEqual([1, 2, 3]);
+    expect(Array.from(array).toSorted((a, b) => a - b)).toStrictEqual([
+      1, 2, 3,
+    ]);
   });
 
   test('should work with destructuring', () => {
     const set = ISet.create([1, 2]);
-    const values = [...set];
+    const values = Array.from(set);
 
-    expect(values.sort((a, b) => a - b)).toStrictEqual([1, 2]);
+    expect(values.toSorted((a, b) => a - b)).toStrictEqual([1, 2]);
   });
 });
 

package/src/collections/queue.mts

@@ -1,7 +1,6 @@
-import { Arr } from '../array/index.mjs';
 import { Optional } from '../functional/index.mjs';
-import { asUint32 } from '../number/index.mjs';
-import { castMutable } from '../others/index.mjs';
+import { range } from '../iterator/index.mjs';
+import { asSafeUint, asUint32 } from '../number/index.mjs';
 
 /**
  * Interface for a high-performance queue with FIFO (First-In, First-Out) behavior.
@@ -123,9 +122,11 @@ class QueueClass<T> implements Queue<T> {
       Math.max(QueueClass.#INITIAL_CAPACITY, initialValues.length * 2),
     );
 
-    this.#buffer = castMutable(
-      Arr.create<T | undefined, Uint32>(initialCapacity, undefined),
+    this.#buffer = Array.from<unknown, T | undefined>(
+      { length: initialCapacity },
+      () => undefined,
     );
+
     this.#head = 0;
     this.#tail = 0;
     this.#mut_size = 0;
@@ -234,7 +235,7 @@ class QueueClass<T> implements Queue<T> {
    * // High-volume enqueueing (demonstrates amortized O(1) performance)
    * const dataQueue = createQueue<number>();
    *
-   * for (let i = 0; i < 1000000; i++) {
+   * for (const i of range(1000000)) {
    *   dataQueue.enqueue(i); // Each operation is O(1) amortized
    * }
    *
@@ -259,12 +260,13 @@ class QueueClass<T> implements Queue<T> {
    */
   #resize(): void {
     const newCapacity = asUint32(this.#capacity * 2);
-    const newBuffer = castMutable(
-      Arr.create<T | undefined, Uint32>(newCapacity, undefined),
+    const newBuffer = Array.from<unknown, T | undefined>(
+      { length: newCapacity },
+      () => undefined,
     );
 
     // Copy elements in order from head to tail
-    for (let i = 0; i < this.#mut_size; i++) {
+    for (const i of range(asSafeUint(this.#mut_size))) {
       const sourceIndex = (this.#head + i) % this.#capacity;
       newBuffer[i] = this.#buffer[sourceIndex];
     }
@@ -329,7 +331,7 @@ class QueueClass<T> implements Queue<T> {
  * const eventQueue = createQueue<Event>();
  *
  * // Simulate high-volume event ingestion
- * for (let i = 0; i < 10000; i++) {
+ * for (const i of range(10000)) {
  *   eventQueue.enqueue({
  *     timestamp: Date.now(),
  *     type: `event-${i % 5}`,