ts-data-forge 5.0.1 → 5.1.1

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

@@ -10,11 +10,11 @@ describe('Array.every', () => {
   }
 
   test('case 1', () => {
-    expect(xs.every((x): x is 1 => x === 1)).toBe(false);
+    assert.isFalse(xs.every((x): x is 1 => x === 1));
   });
 
   test('case 2', () => {
-    expect(xs.every((x) => 1 <= x && x <= 3)).toBe(true);
+    assert.isTrue(xs.every((x) => 1 <= x && x <= 3));
   });
 });
 
@@ -22,16 +22,17 @@ describe('Array.some', () => {
   const xs = [1, 2, 3] as const;
 
   test('case 1', () => {
-    expect(xs.some((x): x is 1 => x === 1)).toBe(true);
+    assert.isTrue(xs.some((x): x is 1 => x === 1));
   });
 
   test('case 2', () => {
-    expect(xs.some((x) => x <= 1 && 3 <= x)).toBe(false);
+    assert.isFalse(xs.some((x) => x <= 1 && 3 <= x));
   });
 });
 
 describe('Array.flat', () => {
   const xs = [1, 2, [3, 4, [5, 6, [7, 8]]]] as const;
+
   const result = xs.flat();
 
   expectType<
@@ -47,22 +48,25 @@ describe('Array.flat', () => {
 describe('Array.includes', () => {
   {
     const xs = [2, 1, 3] as const;
+
     const result = xs.includes(2);
 
     expectType<typeof result, boolean>('=');
 
     test('case 1', () => {
-      expect(result).toBe(true);
+      assert.isTrue(result);
     });
   }
+
   {
     const xs: readonly number[] = [2, 1, 3];
+
     const result = xs.includes(4);
 
     expectType<typeof result, boolean>('=');
 
     test('case 2', () => {
-      expect(result).toBe(false);
+      assert.isFalse(result);
     });
   }
 });
@@ -70,6 +74,7 @@ describe('Array.includes', () => {
 describe('Array.find', () => {
   {
     const xs = [{ v: 2 }, { v: 1 }, { v: 3 }] as const;
+
     const result = xs.find((x) => x.v === 1);
 
     expectType<typeof result, Readonly<{ v: 1 }> | undefined>('=');
@@ -78,12 +83,14 @@ describe('Array.find', () => {
       assert.deepStrictEqual(result, { v: 1 });
     });
   }
+
   {
     const xs: readonly Readonly<{ v: 1 | 2 | 3 }>[] = [
       { v: 2 },
       { v: 1 },
       { v: 3 },
     ] as const;
+
     const result = xs.find((x) => x.v === 1);
 
     expectType<typeof result, Readonly<{ v: 1 | 2 | 3 }> | undefined>('=');
@@ -97,6 +104,7 @@ describe('Array.find', () => {
 describe('Array.findIndex', () => {
   {
     const xs = [{ v: 2 }, { v: 1 }, { v: 3 }] as const;
+
     const result = xs.findIndex((x) => x.v === 1);
 
     expectType<typeof result, number>('=');
@@ -105,12 +113,14 @@ describe('Array.findIndex', () => {
       expect(result).toBe(1);
     });
   }
+
   {
     const xs: readonly Readonly<{ v: 1 | 2 | 3 }>[] = [
       { v: 2 },
       { v: 1 },
       { v: 3 },
     ] as const;
+
     const result = xs.findIndex((x) => x.v === 1);
 
     expectType<typeof result, number>('=');
@@ -124,6 +134,7 @@ describe('Array.findIndex', () => {
 describe('Array.filter', () => {
   {
     const xs = [1, 2, 3] as const;
+
     const filtered = xs.filter((x): x is 1 | 3 => x % 2 === 1);
 
     expectType<typeof filtered, (1 | 3)[]>('=');
@@ -135,6 +146,7 @@ describe('Array.filter', () => {
 
   {
     const xs = [1, 2, 3] as const;
+
     const filtered = xs.filter((x) => x % 2 === 1);
 
     expectType<typeof filtered, (1 | 2 | 3)[]>('=');

package/src/collections/imap-mapped.mts

@@ -373,8 +373,11 @@ class IMapMappedClass<K, V, KM extends MapSetKeyType>
     showNotFoundMessage: boolean = false,
   ) {
     this.#map = new Map(Array.from(iterable, ([k, v]) => [toKey(k), v]));
+
     this.#toKey = toKey;
+
     this.#fromKey = fromKey;
+
     this.#showNotFoundMessage = showNotFoundMessage;
   }
 
@@ -391,6 +394,7 @@ class IMapMappedClass<K, V, KM extends MapSetKeyType>
   /** @inheritdoc */
   get(key: K): Optional<V> {
     if (!this.has(key)) return Optional.none;
+
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     return Optional.some(this.#map.get(this.#toKey(key))!);
   }
@@ -429,8 +433,10 @@ class IMapMappedClass<K, V, KM extends MapSetKeyType>
           `IMapMapped.delete: key not found: ${String(this.#toKey(key))}`,
         );
       }
+
       return this;
     }
+
     const keyMapped = this.#toKey(key);
 
     return IMapMapped.create(
@@ -445,6 +451,7 @@ class IMapMappedClass<K, V, KM extends MapSetKeyType>
   /** @inheritdoc */
   set(key: K, value: V): IMapMapped<K, V, KM> {
     if (value === this.get(key)) return this; // has no changes
+
     const keyMapped = this.#toKey(key);
 
     if (!this.has(key)) {
@@ -476,6 +483,7 @@ class IMapMappedClass<K, V, KM extends MapSetKeyType>
           `IMapMapped.update: key not found: ${String(this.#toKey(key))}`,
         );
       }
+
       return this;
     }
 
@@ -512,10 +520,12 @@ class IMapMappedClass<K, V, KM extends MapSetKeyType>
       switch (action.type) {
         case 'delete':
           mut_result.delete(key);
+
           break;
 
         case 'set':
           mut_result.set(key, action.value);
+
           break;
 
         case 'update': {
@@ -527,6 +537,7 @@ class IMapMappedClass<K, V, KM extends MapSetKeyType>
                 `IMapMapped.withMutations::update: key not found: ${String(key)}`,
               );
             }
+
             break;
           }
 

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

@@ -2,13 +2,17 @@ import { Optional } from '../functional/index.mjs';
 import { IMapMapped } from './imap-mapped.mjs';
 
 const toKey = (a: Readonly<{ v: number }>): number => a.v;
+
 const fromKey = (k: number): Readonly<{ v: number }> => ({ v: k });
 
 type TestKey = { id: number; type: string };
+
 const testKeyToString = (key: Readonly<TestKey>): string =>
   `${key.type}_${key.id}`;
+
 const stringToTestKey = (str: string): TestKey => {
   const [type, idStr] = str.split('_');
+
   return { type: type ?? '', id: Number(idStr ?? '0') };
 };
 
@@ -65,7 +69,9 @@ describe('IMapMapped.create', () => {
     );
 
     expect(map.size).toBe(2);
+
     expect(Optional.unwrap(map.get({ id: 1, type: 'user' }))).toBe('Alice');
+
     expect(Optional.unwrap(map.get({ id: 2, type: 'admin' }))).toBe('Bob');
   });
 
@@ -78,23 +84,29 @@ describe('IMapMapped.create', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const copy = IMapMapped.create(original, testKeyToString, stringToTestKey);
 
     expect(copy.size).toBe(2);
+
     expect(Optional.unwrap(copy.get({ id: 1, type: 'user' }))).toBe('Alice');
+
     expect(Optional.unwrap(copy.get({ id: 2, type: 'admin' }))).toBe('Bob');
   });
 
   test('should handle complex key transformations', () => {
     type ComplexKey = { nested: { id: number }; arr: number[] };
+
     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 {
         nested: { id: Number(idStr ?? '0') },
         arr: (arrStr ?? '').split(',').map(Number),
@@ -108,6 +120,7 @@ describe('IMapMapped.create', () => {
     );
 
     expect(map.size).toBe(1);
+
     expect(
       Optional.unwrap(map.get({ nested: { id: 1 }, arr: [1, 2, 3] })),
     ).toBe('test');
@@ -124,6 +137,7 @@ describe('IMapMapped.equal', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const map2 = IMapMapped.create(
       [
         [{ id: 1, type: 'user' }, 'Alice'],
@@ -135,8 +149,11 @@ describe('IMapMapped.equal', () => {
 
     // Test structural equality, not reference equality
     expect(map1.size).toBe(map2.size);
-    expect(map1.has({ id: 1, type: 'user' })).toBe(true);
-    expect(map2.has({ id: 1, type: 'user' })).toBe(true);
+
+    assert.isTrue(map1.has({ id: 1, type: 'user' }));
+
+    assert.isTrue(map2.has({ id: 1, type: 'user' }));
+
     expect(Optional.unwrap(map1.get({ id: 1, type: 'user' }))).toBe(
       Optional.unwrap(map2.get({ id: 1, type: 'user' })),
     );
@@ -151,6 +168,7 @@ describe('IMapMapped.equal', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const map2 = IMapMapped.create(
       [
         [{ id: 1, type: 'user' }, 'Alice'],
@@ -160,7 +178,7 @@ describe('IMapMapped.equal', () => {
       stringToTestKey,
     );
 
-    expect(IMapMapped.equal(map1, map2)).toBe(false);
+    assert.isFalse(IMapMapped.equal(map1, map2));
   });
 
   test('should return false for maps with different keys', () => {
@@ -172,6 +190,7 @@ describe('IMapMapped.equal', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const map2 = IMapMapped.create(
       [
         [{ id: 1, type: 'user' }, 'Alice'],
@@ -181,7 +200,7 @@ describe('IMapMapped.equal', () => {
       stringToTestKey,
     );
 
-    expect(IMapMapped.equal(map1, map2)).toBe(false);
+    assert.isFalse(IMapMapped.equal(map1, map2));
   });
 
   test('should return true for empty maps', () => {
@@ -190,13 +209,14 @@ describe('IMapMapped.equal', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const map2 = IMapMapped.create<TestKey, string, string>(
       [],
       testKeyToString,
       stringToTestKey,
     );
 
-    expect(IMapMapped.equal(map1, map2)).toBe(true);
+    assert.isTrue(IMapMapped.equal(map1, map2));
   });
 });
 
@@ -228,7 +248,7 @@ describe('IMapMapped.has', () => {
       fromKey,
     );
 
-    expect(s0.has({ v: 3 })).toBe(true);
+    assert.isTrue(s0.has({ v: 3 }));
   });
 
   test('case 2', () => {
@@ -242,7 +262,7 @@ describe('IMapMapped.has', () => {
       fromKey,
     );
 
-    expect(s0.has({ v: 4 })).toBe(false);
+    assert.isFalse(s0.has({ v: 4 }));
   });
 
   test('case 3', () => {
@@ -252,7 +272,7 @@ describe('IMapMapped.has', () => {
       fromKey,
     );
 
-    expect(s0.has({ v: 3 })).toBe(false);
+    assert.isFalse(s0.has({ v: 3 }));
   });
 });
 
@@ -321,6 +341,7 @@ describe('IMapMapped.set', () => {
         fromKey,
       ),
     );
+
     assert.deepStrictEqual(
       s0,
       IMapMapped.create(
@@ -358,6 +379,7 @@ describe('IMapMapped.set', () => {
         fromKey,
       ),
     );
+
     assert.deepStrictEqual(
       s0,
       IMapMapped.create(
@@ -383,6 +405,7 @@ describe('IMapMapped.set', () => {
       s0.set({ v: 1 }, '1'),
       IMapMapped.create([[{ v: 1 }, '1']], toKey, fromKey),
     );
+
     assert.deepStrictEqual(s0, IMapMapped.create([], toKey, fromKey));
   });
 });
@@ -394,6 +417,7 @@ describe('IMapMapped.update', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const updated = map.update({ id: 1, type: 'user' }, (name) =>
       name.toUpperCase(),
     );
@@ -407,12 +431,14 @@ describe('IMapMapped.update', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const updated = map.update({ id: 2, type: 'user' }, (name) =>
       name.toUpperCase(),
     );
 
     expect(updated).toBe(map);
-    expect(Optional.isNone(updated.get({ id: 2, type: 'user' }))).toBe(true);
+
+    assert.isTrue(Optional.isNone(updated.get({ id: 2, type: 'user' })));
   });
 });
 
@@ -440,6 +466,7 @@ describe('IMapMapped.delete', () => {
         fromKey,
       ),
     );
+
     assert.deepStrictEqual(
       s0,
       IMapMapped.create(
@@ -476,6 +503,7 @@ describe('IMapMapped.delete', () => {
         fromKey,
       ),
     );
+
     assert.deepStrictEqual(
       s0,
       IMapMapped.create(
@@ -497,6 +525,7 @@ describe('IMapMapped.delete', () => {
       s0.delete({ v: 1 }),
       IMapMapped.create([], toKey, fromKey),
     );
+
     assert.deepStrictEqual(s0, IMapMapped.create([], toKey, fromKey));
   });
 
@@ -509,10 +538,13 @@ describe('IMapMapped.delete', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const updated = map.delete({ id: 2, type: 'admin' });
 
     expect(updated).not.toBe(map); // Should return new instance
+
     expect(updated.size).toBe(1);
+
     expect(map.size).toBe(2); // Original unchanged
   });
 });
@@ -528,7 +560,7 @@ describe('IMapMapped.every', () => {
       stringToTestKey,
     );
 
-    expect(map.every((value) => typeof value === 'string')).toBe(true);
+    assert.isTrue(map.every((value) => typeof value === 'string'));
   });
 
   test('should return false when some values do not satisfy predicate', () => {
@@ -541,7 +573,7 @@ describe('IMapMapped.every', () => {
       stringToTestKey,
     );
 
-    expect(map.every((value) => value.length > 5)).toBe(false);
+    assert.isFalse(map.every((value) => value.length > 5));
   });
 
   test('should return true for empty map', () => {
@@ -551,7 +583,7 @@ describe('IMapMapped.every', () => {
       stringToTestKey,
     );
 
-    expect(map.every((value) => value.length > 0)).toBe(true);
+    assert.isTrue(map.every((value) => value.length > 0));
   });
 });
 
@@ -567,7 +599,7 @@ describe('IMapMapped.some', () => {
     );
 
     // eslint-disable-next-line unicorn/prefer-includes
-    expect(map.some((value) => value === 'Alice')).toBe(true);
+    assert.isTrue(map.some((value) => value === 'Alice'));
   });
 
   test('should return false when no values satisfy predicate', () => {
@@ -581,7 +613,7 @@ describe('IMapMapped.some', () => {
     );
 
     // eslint-disable-next-line unicorn/prefer-includes
-    expect(map.some((value) => value === 'Charlie')).toBe(false);
+    assert.isFalse(map.some((value) => value === 'Charlie'));
   });
 
   test('should return false for empty map', () => {
@@ -591,7 +623,7 @@ describe('IMapMapped.some', () => {
       stringToTestKey,
     );
 
-    expect(map.some((value) => value.length > 0)).toBe(false);
+    assert.isFalse(map.some((value) => value.length > 0));
   });
 });
 
@@ -614,7 +646,9 @@ describe('IMapMapped.withMutations', () => {
     ]);
 
     expect(updated.size).toBe(2);
+
     expect(Optional.unwrap(updated.get({ id: 1, type: 'user' }))).toBe('ALICE');
+
     expect(Optional.unwrap(updated.get({ id: 2, type: 'admin' }))).toBe('Bob');
   });
 
@@ -624,9 +658,11 @@ describe('IMapMapped.withMutations', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const updated = map.withMutations([]);
 
     expect(updated.size).toBe(1);
+
     expect(Optional.unwrap(updated.get({ id: 1, type: 'user' }))).toBe('Alice');
   });
 });
@@ -641,11 +677,13 @@ describe('IMapMapped.map', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const transformed = map.map((value) => value.toUpperCase());
 
     expect(Optional.unwrap(transformed.get({ id: 1, type: 'user' }))).toBe(
       'ALICE',
     );
+
     expect(Optional.unwrap(transformed.get({ id: 2, type: 'admin' }))).toBe(
       'BOB',
     );
@@ -660,11 +698,13 @@ describe('IMapMapped.map', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const transformed = map.map((value, key) => `${key.type}:${value}`);
 
     expect(Optional.unwrap(transformed.get({ id: 1, type: 'user' }))).toBe(
       'user:Alice',
     );
+
     expect(Optional.unwrap(transformed.get({ id: 2, type: 'admin' }))).toBe(
       'admin:Bob',
     );
@@ -681,14 +721,15 @@ describe('IMapMapped.mapKeys', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const transformed = map.mapKeys((key) => ({ ...key, id: key.id * 10 }));
 
-    expect(Optional.isNone(transformed.get({ id: 1, type: 'user' }))).toBe(
-      true,
-    );
+    assert.isTrue(Optional.isNone(transformed.get({ id: 1, type: 'user' })));
+
     expect(Optional.unwrap(transformed.get({ id: 10, type: 'user' }))).toBe(
       'Alice',
     );
+
     expect(Optional.unwrap(transformed.get({ id: 20, type: 'admin' }))).toBe(
       'Bob',
     );
@@ -705,6 +746,7 @@ describe('IMapMapped.mapEntries', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const transformed = map.mapEntries(([key, value]) => [
       { ...key, id: key.id * 10 },
       value.toUpperCase(),
@@ -713,6 +755,7 @@ describe('IMapMapped.mapEntries', () => {
     expect(Optional.unwrap(transformed.get({ id: 10, type: 'user' }))).toBe(
       'ALICE',
     );
+
     expect(Optional.unwrap(transformed.get({ id: 20, type: 'admin' }))).toBe(
       'BOB',
     );
@@ -730,11 +773,14 @@ describe('IMapMapped.forEach', () => {
       toKey,
       fromKey,
     );
+
     const keys = [{ v: 1 }, { v: 2 }, { v: 3 }];
+
     const values = ['1', '2', '3'];
 
     for (const [key, value] of s0.entries()) {
       expect(keys).toContainEqual(key);
+
       expect(values).toContainEqual(value);
     }
   });
@@ -748,6 +794,7 @@ describe('IMapMapped.forEach', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const mut_collected: [TestKey, string][] = [];
 
     for (const [key, value] of map.entries()) {
@@ -755,7 +802,9 @@ describe('IMapMapped.forEach', () => {
     }
 
     expect(mut_collected).toHaveLength(2);
+
     expect(mut_collected).toContainEqual([{ id: 1, type: 'user' }, 'Alice']);
+
     expect(mut_collected).toContainEqual([{ id: 2, type: 'admin' }, 'Bob']);
   });
 });
@@ -771,6 +820,7 @@ describe('IMapMapped.keys', () => {
       toKey,
       fromKey,
     );
+
     const keys = [{ v: 1 }, { v: 2 }, { v: 3 }];
 
     for (const k of s0.keys()) {
@@ -790,6 +840,7 @@ describe('IMapMapped.values', () => {
       toKey,
       fromKey,
     );
+
     const values = ['1', '2', '3'];
 
     for (const v of s0.values()) {
@@ -809,11 +860,14 @@ describe('IMapMapped.entries', () => {
       toKey,
       fromKey,
     );
+
     const keys = [{ v: 1 }, { v: 2 }, { v: 3 }];
+
     const values = ['1', '2', '3'];
 
     for (const [k, v] of s0.entries()) {
       expect(keys).toContainEqual(k);
+
       expect(values).toContainEqual(v);
     }
   });
@@ -829,10 +883,13 @@ describe('IMapMapped.toKeysArray', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const keys = map.toKeysArray();
 
     expect(keys).toHaveLength(2);
+
     expect(keys).toContainEqual({ id: 1, type: 'user' });
+
     expect(keys).toContainEqual({ id: 2, type: 'admin' });
   });
 });
@@ -847,10 +904,13 @@ describe('IMapMapped.toValuesArray', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const values = map.toValuesArray();
 
     expect(values).toHaveLength(2);
+
     expect(values).toContain('Alice');
+
     expect(values).toContain('Bob');
   });
 });
@@ -865,10 +925,13 @@ describe('IMapMapped.toEntriesArray', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const entries = map.toEntriesArray();
 
     expect(entries).toHaveLength(2);
+
     expect(entries).toContainEqual([{ id: 1, type: 'user' }, 'Alice']);
+
     expect(entries).toContainEqual([{ id: 2, type: 'admin' }, 'Bob']);
   });
 });
@@ -883,7 +946,9 @@ describe('IMapMapped.toArray', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const entries = map.toArray();
+
     const entriesArray = map.toEntriesArray();
 
     assert.deepStrictEqual(entries, entriesArray);
@@ -900,10 +965,13 @@ describe('IMapMapped.toRawMap', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const rawMap = map.toRawMap();
 
     expect(rawMap.size).toBe(2);
+
     expect(rawMap.get('user_1')).toBe('Alice');
+
     expect(rawMap.get('admin_2')).toBe('Bob');
   });
 });