ts-data-forge 5.0.1 → 5.1.0

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);
+
     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'],
@@ -172,6 +190,7 @@ describe('IMapMapped.equal', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const map2 = IMapMapped.create(
       [
         [{ id: 1, type: 'user' }, 'Alice'],
@@ -190,6 +209,7 @@ describe('IMapMapped.equal', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const map2 = IMapMapped.create<TestKey, string, string>(
       [],
       testKeyToString,
@@ -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,11 +431,13 @@ 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);
   });
 });
@@ -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
   });
 });
@@ -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,17 @@ 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,
     );
+
     expect(Optional.unwrap(transformed.get({ id: 10, type: 'user' }))).toBe(
       'Alice',
     );
+
     expect(Optional.unwrap(transformed.get({ id: 20, type: 'admin' }))).toBe(
       'Bob',
     );
@@ -705,6 +748,7 @@ describe('IMapMapped.mapEntries', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const transformed = map.mapEntries(([key, value]) => [
       { ...key, id: key.id * 10 },
       value.toUpperCase(),
@@ -713,6 +757,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 +775,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 +796,7 @@ describe('IMapMapped.forEach', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const mut_collected: [TestKey, string][] = [];
 
     for (const [key, value] of map.entries()) {
@@ -755,7 +804,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 +822,7 @@ describe('IMapMapped.keys', () => {
       toKey,
       fromKey,
     );
+
     const keys = [{ v: 1 }, { v: 2 }, { v: 3 }];
 
     for (const k of s0.keys()) {
@@ -790,6 +842,7 @@ describe('IMapMapped.values', () => {
       toKey,
       fromKey,
     );
+
     const values = ['1', '2', '3'];
 
     for (const v of s0.values()) {
@@ -809,11 +862,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 +885,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 +906,13 @@ describe('IMapMapped.toValuesArray', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const values = map.toValuesArray();
 
     expect(values).toHaveLength(2);
+
     expect(values).toContain('Alice');
+
     expect(values).toContain('Bob');
   });
 });
@@ -865,10 +927,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 +948,9 @@ describe('IMapMapped.toArray', () => {
       testKeyToString,
       stringToTestKey,
     );
+
     const entries = map.toArray();
+
     const entriesArray = map.toEntriesArray();
 
     assert.deepStrictEqual(entries, entriesArray);
@@ -900,10 +967,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');
   });
 });

package/src/collections/imap.mts

@@ -62,6 +62,7 @@ type IMapInterface<K extends MapSetKeyType, V> = Readonly<{
    * ]);
    *
    * assert.ok(map.has('id'));
+   *
    * assert.notOk(map.has('missing'));
    * ```
    *
@@ -79,6 +80,7 @@ type IMapInterface<K extends MapSetKeyType, V> = Readonly<{
    * const map = IMap.create([['user', { id: 1 }]]);
    *
    * assert.deepStrictEqual(map.get('user'), Optional.some({ id: 1 }));
+   *
    * assert.deepStrictEqual(map.get('missing'), Optional.none);
    * ```
    *
@@ -102,9 +104,11 @@ type IMapInterface<K extends MapSetKeyType, V> = Readonly<{
    * ]);
    *
    * const allEven = map.every((value) => value % 2 === 0);
+   *
    * const isNarrowed = map.every((value): value is 2 | 4 => value % 2 === 0);
    *
    * assert.ok(allEven);
+   *
    * assert.ok(isNarrowed);
    * ```
    *
@@ -139,6 +143,7 @@ type IMapInterface<K extends MapSetKeyType, V> = Readonly<{
    * const map = IMap.create(entries);
    *
    * assert.ok(map.some((value) => value > 4));
+   *
    * assert.notOk(map.some((value) => value > 10));
    * ```
    *
@@ -164,8 +169,11 @@ type IMapInterface<K extends MapSetKeyType, V> = Readonly<{
    * const withoutB = original.delete('b');
    *
    * assert.deepStrictEqual(original.get('b'), Optional.some(2));
+   *
    * assert.deepStrictEqual(withoutB.get('b'), Optional.none);
+   *
    * assert(original.size === 2);
+   *
    * assert(withoutB.size === 1);
    * ```
    *
@@ -188,10 +196,13 @@ type IMapInterface<K extends MapSetKeyType, V> = Readonly<{
    * const base = IMap.create<'count' | 'status', number | string>(entries);
    *
    * const updated = base.set('count', 2);
+   *
    * const extended = base.set('status', 'ok');
    *
    * assert.deepStrictEqual(base.get('count'), Optional.some(1));
+   *
    * assert.deepStrictEqual(updated.get('count'), Optional.some(2));
+   *
    * assert.deepStrictEqual(extended.get('status'), Optional.some('ok'));
    * ```
    *
@@ -215,10 +226,13 @@ type IMapInterface<K extends MapSetKeyType, V> = Readonly<{
    * const scores = IMap.create<'alice' | 'bob' | 'charlie', number>(entries);
    *
    * const boosted = scores.update('alice', (value) => value + 5);
+   *
    * const unchanged = scores.update('charlie', (value) => value + 1);
    *
    * assert.deepStrictEqual(boosted.get('alice'), Optional.some(15));
+   *
    * assert.deepStrictEqual(scores.get('alice'), Optional.some(10));
+   *
    * assert(unchanged === scores);
    * ```
    *
@@ -255,8 +269,11 @@ type IMapInterface<K extends MapSetKeyType, V> = Readonly<{
    * const mutated = base.withMutations(actions);
    *
    * assert.deepStrictEqual(mutated.get('c'), Optional.some(3));
+   *
    * assert.deepStrictEqual(mutated.get('b'), Optional.some(20));
+   *
    * assert.deepStrictEqual(mutated.get('a'), Optional.none);
+   *
    * assert.deepStrictEqual(base.get('b'), Optional.some(2));
    * ```
    *
@@ -559,6 +576,7 @@ type IMapInterface<K extends MapSetKeyType, V> = Readonly<{
    * const raw = map.toRawMap();
    *
    * assert.ok(is.map(raw));
+   *
    * assert(raw.get('key') === 1);
    * ```
    *
@@ -616,6 +634,7 @@ export namespace IMap {
    * ]);
    *
    * assert(map.size === 2);
+   *
    * assert.deepStrictEqual(map.get('status'), Optional.some('active'));
    * ```
    *
@@ -658,6 +677,7 @@ export namespace IMap {
    * ]);
    *
    * assert.ok(IMap.equal(first, second));
+   *
    * assert.notOk(IMap.equal(first, third));
    * ```
    *
@@ -719,6 +739,7 @@ class IMapClass<K extends MapSetKeyType, V>
     showNotFoundMessage: boolean = false,
   ) {
     this.#map = new Map(iterable);
+
     this.#showNotFoundMessage = showNotFoundMessage;
   }
 
@@ -736,6 +757,7 @@ class IMapClass<K extends MapSetKeyType, V>
   /** @inheritdoc */
   get(key: K | (WidenLiteral<K> & {})): Optional<V> {
     if (!this.has(key)) return Optional.none;
+
     // eslint-disable-next-line total-functions/no-unsafe-type-assertion, @typescript-eslint/no-non-null-assertion
     return Optional.some(this.#map.get(key as K)!);
   }
@@ -771,8 +793,10 @@ class IMapClass<K extends MapSetKeyType, V>
     if (!this.has(key)) {
       if (this.#showNotFoundMessage) {
         const keyStr = unknownToString(key);
+
         console.warn(`IMap.delete: key not found: ${keyStr}`);
       }
+
       return this;
     }
 
@@ -784,7 +808,9 @@ class IMapClass<K extends MapSetKeyType, V>
   /** @inheritdoc */
   set(key: K, value: V): IMap<K, V> {
     const curr = this.get(key);
+
     if (Optional.isSome(curr) && value === curr.value) return this; // has no changes
+
     if (!this.has(key)) {
       return IMap.create([...this.#map, tp(key, value)]);
     } else {
@@ -801,8 +827,10 @@ class IMapClass<K extends MapSetKeyType, V>
     if (Optional.isNone(curr)) {
       if (this.#showNotFoundMessage) {
         const keyStr = unknownToString(key);
+
         console.warn(`IMap.update: key not found: ${keyStr}`);
       }
+
       return this;
     }
 
@@ -827,10 +855,12 @@ class IMapClass<K extends MapSetKeyType, V>
       switch (action.type) {
         case 'delete':
           mut_result.delete(action.key);
+
           break;
 
         case 'set':
           mut_result.set(action.key, action.value);
+
           break;
 
         case 'update': {
@@ -841,8 +871,10 @@ 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: ${keyStr}`);
             }
+
             break;
           }