ts-data-forge 5.0.1 → 5.1.1

package/src/collections/imap.test.mts

@@ -27,6 +27,7 @@ describe('IMap[Symbol.iterator]', () => {
       ['a', 1],
       ['b', 2],
     ]);
+
     const mut_collected: (readonly [string, number])[] = [];
 
     for (const entry of map) {
@@ -34,7 +35,9 @@ describe('IMap[Symbol.iterator]', () => {
     }
 
     expect(mut_collected).toHaveLength(2);
+
     expect(mut_collected).toContainEqual(['a', 1]);
+
     expect(mut_collected).toContainEqual(['b', 2]);
   });
 
@@ -43,10 +46,13 @@ describe('IMap[Symbol.iterator]', () => {
       ['a', 1],
       ['b', 2],
     ]);
+
     const entries = Array.from(map);
 
     expect(entries).toHaveLength(2);
+
     expect(entries).toContainEqual(['a', 1]);
+
     expect(entries).toContainEqual(['b', 2]);
   });
 
@@ -55,10 +61,13 @@ describe('IMap[Symbol.iterator]', () => {
       ['a', 1],
       ['b', 2],
     ]);
+
     const entries = Array.from(map);
 
     expect(entries).toHaveLength(2);
+
     expect(entries).toContainEqual(['a', 1]);
+
     expect(entries).toContainEqual(['b', 2]);
   });
 });
@@ -75,10 +84,13 @@ describe('IMap.create', () => {
       ['a', 1],
       ['b', 2],
     ]);
+
     const map = IMap.create(jsMap);
 
     expect(map.size).toBe(2);
+
     expect(Optional.unwrap(map.get('a'))).toBe(1);
+
     expect(Optional.unwrap(map.get('b'))).toBe(2);
   });
 
@@ -87,10 +99,13 @@ describe('IMap.create', () => {
       ['a', 1],
       ['b', 2],
     ]);
+
     const copy = IMap.create(original);
 
     expect(copy.size).toBe(2);
+
     expect(Optional.unwrap(copy.get('a'))).toBe(1);
+
     expect(Optional.unwrap(copy.get('b'))).toBe(2);
   });
 });
@@ -101,12 +116,13 @@ describe('IMap.equal', () => {
       ['a', 1],
       ['b', 2],
     ]);
+
     const map2 = IMap.create([
       ['a', 1],
       ['b', 2],
     ]);
 
-    expect(IMap.equal(map1, map2)).toBe(true);
+    assert.isTrue(IMap.equal(map1, map2));
   });
 
   test('should return true for different creation order', () => {
@@ -114,22 +130,24 @@ describe('IMap.equal', () => {
       ['a', 1],
       ['b', 2],
     ]);
+
     const map2 = IMap.create([
       ['b', 2],
       ['a', 1],
     ]);
 
-    expect(IMap.equal(map1, map2)).toBe(true);
+    assert.isTrue(IMap.equal(map1, map2));
   });
 
   test('should return false for maps with different sizes', () => {
     const map1 = IMap.create<'a' | 'b', number>([['a', 1]]);
+
     const map2 = IMap.create([
       ['a', 1],
       ['b', 2],
     ]);
 
-    expect(IMap.equal(map1, map2)).toBe(false);
+    assert.isFalse(IMap.equal(map1, map2));
   });
 
   test('should return false for maps with different values', () => {
@@ -137,12 +155,13 @@ describe('IMap.equal', () => {
       ['a', 1],
       ['b', 2],
     ]);
+
     const map2 = IMap.create([
       ['a', 1],
       ['b', 3],
     ]);
 
-    expect(IMap.equal(map1, map2)).toBe(false);
+    assert.isFalse(IMap.equal(map1, map2));
   });
 
   test('should return false for maps with different keys', () => {
@@ -150,19 +169,21 @@ describe('IMap.equal', () => {
       ['a', 1],
       ['b', 2],
     ]);
+
     const map2 = IMap.create<'a' | 'b' | 'c', number>([
       ['a', 1],
       ['c', 2],
     ]);
 
-    expect(IMap.equal(map1, map2)).toBe(false);
+    assert.isFalse(IMap.equal(map1, map2));
   });
 
   test('should return true for empty maps', () => {
     const map1 = IMap.create<string, number>([]);
+
     const map2 = IMap.create<string, number>([]);
 
-    expect(IMap.equal(map1, map2)).toBe(true);
+    assert.isTrue(IMap.equal(map1, map2));
   });
 });
 
@@ -188,7 +209,7 @@ describe('IMap.has', () => {
       [7, 70],
     ] as const);
 
-    expect(m0.has(6)).toBe(true);
+    assert.isTrue(m0.has(6));
   });
 
   test('case 2', () => {
@@ -200,13 +221,13 @@ describe('IMap.has', () => {
       [7, 70],
     ]);
 
-    expect(m0.has(8)).toBe(false);
+    assert.isFalse(m0.has(8));
   });
 
   test('case 3', () => {
     const m0 = IMap.create<number, number>([]);
 
-    expect(m0.has(0)).toBe(false);
+    assert.isFalse(m0.has(0));
   });
 
   test('case 4', () => {
@@ -219,7 +240,7 @@ describe('IMap.has', () => {
       [Number.NaN, 0],
     ] as const);
 
-    expect(m0.has(Number.NaN)).toBe(true);
+    assert.isTrue(m0.has(Number.NaN));
   });
 
   test('should handle boolean keys', () => {
@@ -228,8 +249,9 @@ describe('IMap.has', () => {
       [false, 'no'],
     ]);
 
-    expect(map.has(true)).toBe(true);
-    expect(map.has(false)).toBe(true);
+    assert.isTrue(map.has(true));
+
+    assert.isTrue(map.has(false));
   });
 
   test('should handle string number keys', () => {
@@ -238,8 +260,9 @@ describe('IMap.has', () => {
       ['2', 'two'],
     ]);
 
-    expect(map.has('1')).toBe(true);
-    expect(map.has(String(1))).toBe(true);
+    assert.isTrue(map.has('1'));
+
+    assert.isTrue(map.has(String(1)));
   });
 });
 
@@ -294,6 +317,7 @@ describe('IMap.get', () => {
     ]);
 
     expect(Optional.unwrap(map.get('undef'))).toBeUndefined();
+
     expect(Optional.unwrap(map.get('null'))).toBeNull();
   });
 });
@@ -319,6 +343,7 @@ describe('IMap.set', () => {
         [9, 90],
       ]),
     );
+
     assert.deepStrictEqual(
       m0,
       IMap.create([
@@ -350,6 +375,7 @@ describe('IMap.set', () => {
         [7, 70],
       ]),
     );
+
     assert.deepStrictEqual(
       m0,
       IMap.create([
@@ -366,35 +392,46 @@ describe('IMap.set', () => {
     const m0 = IMap.create<number, number>([]);
 
     assert.deepStrictEqual(m0.set(1, 10), IMap.create([[1, 10]]));
+
     assert.deepStrictEqual(m0, IMap.create<number, number>([]));
   });
 
   test('should not create new instance when setting the same value', () => {
     const map = IMap.create([['a', 1]]);
+
     const updated = map.set('a', 1);
 
     expect(updated).toBe(map);
+
     expect(Optional.unwrap(updated.get('a'))).toBe(1);
   });
 
   test('should not create new instance even with same value', () => {
     const map = IMap.create([['a', 1]]);
+
     const curr = map.get('a');
-    assert(Optional.isSome(curr));
+
+    assert.isTrue(Optional.isSome(curr));
+
     const updated = map.set('a', curr.value);
 
     expect(updated).toBe(map);
+
     expect(Optional.unwrap(updated.get('a'))).toBe(1);
   });
 
   test('should not modify original map when setting', () => {
     const original = IMap.create<string, number>([['a', 1]]);
+
     const modified = original.set('b', 2);
 
     expect(original.size).toBe(1);
+
     expect(modified.size).toBe(2);
-    expect(original.has('b')).toBe(false);
-    expect(modified.has('b')).toBe(true);
+
+    assert.isFalse(original.has('b'));
+
+    assert.isTrue(modified.has('b'));
   });
 });
 
@@ -418,6 +455,7 @@ describe('IMap.update', () => {
         [7, 70],
       ]),
     );
+
     assert.deepStrictEqual(
       m0,
       IMap.create([
@@ -449,6 +487,7 @@ describe('IMap.update', () => {
         [7, 70],
       ]),
     );
+
     assert.deepStrictEqual(
       m0,
       IMap.create([
@@ -468,14 +507,17 @@ describe('IMap.update', () => {
       m0.update(1, (x) => 2 * x),
       IMap.create([]),
     );
+
     assert.deepStrictEqual(m0, IMap.create<number, number>([]));
   });
 
   test('should not modify original map when updating', () => {
     const original = IMap.create([['a', 1]]);
+
     const modified = original.update('a', (x) => x * 2);
 
     expect(Optional.unwrap(original.get('a'))).toBe(1);
+
     expect(Optional.unwrap(modified.get('a'))).toBe(2);
   });
 });
@@ -500,6 +542,7 @@ describe('IMap.delete', () => {
         [7, 70],
       ]),
     );
+
     assert.deepStrictEqual(
       m0,
       IMap.create([
@@ -530,6 +573,7 @@ describe('IMap.delete', () => {
         [7, 70],
       ]),
     );
+
     assert.deepStrictEqual(
       m0,
       IMap.create([
@@ -546,6 +590,7 @@ describe('IMap.delete', () => {
     const m0 = IMap.create<number, number>([]);
 
     assert.deepStrictEqual(m0.delete(1), IMap.create([]));
+
     assert.deepStrictEqual(m0, IMap.create<number, number>([]));
   });
 
@@ -554,12 +599,16 @@ describe('IMap.delete', () => {
       ['a', 1],
       ['b', 2],
     ]);
+
     const modified = original.delete('a');
 
     expect(original.size).toBe(2);
+
     expect(modified.size).toBe(1);
-    expect(original.has('a')).toBe(true);
-    expect(modified.has('a')).toBe(false);
+
+    assert.isTrue(original.has('a'));
+
+    assert.isFalse(modified.has('a'));
   });
 });
 
@@ -571,7 +620,7 @@ describe('IMap.every', () => {
       ['c', 6],
     ]);
 
-    expect(map.every((value) => value % 2 === 0)).toBe(true);
+    assert.isTrue(map.every((value) => value % 2 === 0));
   });
 
   test('should return false when some elements do not satisfy predicate', () => {
@@ -581,13 +630,13 @@ describe('IMap.every', () => {
       ['c', 4],
     ]);
 
-    expect(map.every((value) => value % 2 === 0)).toBe(false);
+    assert.isFalse(map.every((value) => value % 2 === 0));
   });
 
   test('should return true for empty map', () => {
     const map = IMap.create<string, number>([]);
 
-    expect(map.every((value) => value > 0)).toBe(true);
+    assert.isTrue(map.every((value) => value > 0));
   });
 
   test('should work with key parameter', () => {
@@ -597,7 +646,7 @@ describe('IMap.every', () => {
       ['cc', 3],
     ]);
 
-    expect(map.every((_value, key) => key.length === 2)).toBe(true);
+    assert.isTrue(map.every((_value, key) => key.length === 2));
   });
 
   test('should work as type guard', () => {
@@ -605,11 +654,12 @@ describe('IMap.every', () => {
       ['a', 'hello'],
       ['b', 'world'],
     ]);
+
     if (map.every((value): value is string => typeof value === 'string')) {
       // Type should be narrowed to IMap<string, string>
       const firstValue = Optional.unwrap(map.get('a'));
 
-      expect(isString(firstValue)).toBe(true);
+      assert.isTrue(isString(firstValue));
     }
   });
 });
@@ -622,7 +672,7 @@ describe('IMap.some', () => {
       ['c', 3],
     ]);
 
-    expect(map.some((value) => value % 2 === 0)).toBe(true);
+    assert.isTrue(map.some((value) => value % 2 === 0));
   });
 
   test('should return false when no elements satisfy predicate', () => {
@@ -632,13 +682,13 @@ describe('IMap.some', () => {
       ['c', 5],
     ]);
 
-    expect(map.some((value) => value % 2 === 0)).toBe(false);
+    assert.isFalse(map.some((value) => value % 2 === 0));
   });
 
   test('should return false for empty map', () => {
     const map = IMap.create<string, number>([]);
 
-    expect(map.some((value) => value > 0)).toBe(false);
+    assert.isFalse(map.some((value) => value > 0));
   });
 
   test('should work with key parameter', () => {
@@ -648,7 +698,7 @@ describe('IMap.some', () => {
       ['c', 3],
     ]);
 
-    expect(map.some((_value, key) => key.length > 1)).toBe(true);
+    assert.isTrue(map.some((_value, key) => key.length > 1));
   });
 });
 
@@ -666,9 +716,12 @@ describe('IMap.withMutations', () => {
     ]);
 
     expect(updated.size).toBe(2);
+
     expect(Optional.unwrap(updated.get('a'))).toBe(2);
+
     expect(Optional.unwrap(updated.get('c'))).toBe(3);
-    expect(Optional.isNone(updated.get('b'))).toBe(true);
+
+    assert.isTrue(Optional.isNone(updated.get('b')));
   });
 
   test('should handle empty mutations array', () => {
@@ -676,25 +729,31 @@ describe('IMap.withMutations', () => {
       ['a', 1],
       ['b', 2],
     ]);
+
     const updated = map.withMutations([]);
 
     expect(updated.size).toBe(map.size);
+
     expect(Optional.unwrap(updated.get('a'))).toBe(1);
+
     expect(Optional.unwrap(updated.get('b'))).toBe(2);
   });
 
   test('should handle update on non-existent key', () => {
     const map = IMap.create<string, number>([['a', 1]]);
+
     const updated = map.withMutations([
       { type: 'update', key: 'nonexistent', updater: (x: number) => x * 2 },
     ]);
 
     expect(updated.size).toBe(map.size);
-    expect(Optional.isNone(updated.get('nonexistent'))).toBe(true);
+
+    assert.isTrue(Optional.isNone(updated.get('nonexistent')));
   });
 
   test('should handle mixed operations', () => {
     const map = IMap.create([['a', 1]]);
+
     const updated = map.withMutations([
       { type: 'set', key: 'a', value: 10 },
       { type: 'update', key: 'a', updater: (x: number) => x + 5 },
@@ -711,10 +770,13 @@ describe('IMap.map', () => {
       ['b', 2],
       ['c', 3],
     ]);
+
     const doubled = map.map((value) => value * 2);
 
     expect(Optional.unwrap(doubled.get('a'))).toBe(2);
+
     expect(Optional.unwrap(doubled.get('b'))).toBe(4);
+
     expect(Optional.unwrap(doubled.get('c'))).toBe(6);
   });
 
@@ -723,9 +785,11 @@ describe('IMap.map', () => {
       ['a', 1],
       ['b', 2],
     ]);
+
     const mapped = map.map((value, key) => `${key}-${value}`);
 
     expect(Optional.unwrap(mapped.get('a'))).toBe('a-1');
+
     expect(Optional.unwrap(mapped.get('b'))).toBe('b-2');
   });
 
@@ -734,9 +798,11 @@ describe('IMap.map', () => {
       ['a', 1],
       ['b', 2],
     ]);
+
     const stringified = map.map((value) => value.toString());
 
     expect(Optional.unwrap(stringified.get('a'))).toBe('1');
+
     expect(Optional.unwrap(stringified.get('b'))).toBe('2');
   });
 });
@@ -747,10 +813,13 @@ describe('IMap.mapKeys', () => {
       ['a', 1],
       ['b', 2],
     ]);
+
     const mapped = map.mapKeys((key) => key.toUpperCase());
 
-    expect(Optional.isNone(mapped.get('a'))).toBe(true);
+    assert.isTrue(Optional.isNone(mapped.get('a')));
+
     expect(Optional.unwrap(mapped.get('A'))).toBe(1);
+
     expect(Optional.unwrap(mapped.get('B'))).toBe(2);
   });
 
@@ -759,9 +828,11 @@ describe('IMap.mapKeys', () => {
       ['1', 'one'],
       ['2', 'two'],
     ]);
+
     const mapped = map.mapKeys((key) => Number.parseInt(key, 10));
 
     expect(Optional.unwrap(mapped.get(1))).toBe('one');
+
     expect(Optional.unwrap(mapped.get(2))).toBe('two');
   });
 });
@@ -772,12 +843,14 @@ describe('IMap.mapEntries', () => {
       ['a', 1],
       ['b', 2],
     ]);
+
     const mapped = map.mapEntries(([key, value]) => [
       key.toUpperCase(),
       value * 2,
     ]);
 
     expect(Optional.unwrap(mapped.get('A'))).toBe(2);
+
     expect(Optional.unwrap(mapped.get('B'))).toBe(4);
   });
 
@@ -786,9 +859,11 @@ describe('IMap.mapEntries', () => {
       ['a', 1],
       ['b', 2],
     ]);
+
     const mapped = map.mapEntries(([key, value]) => [value, key]);
 
     expect(Optional.unwrap(mapped.get(1))).toBe('a');
+
     expect(Optional.unwrap(mapped.get(2))).toBe('b');
   });
 });
@@ -802,11 +877,14 @@ describe('IMap.forEach', () => {
       [6, 60],
       [7, 70],
     ] as const);
+
     const keys = [1, 3, 5, 6, 7];
+
     const values = [10, 30, 50, 60, 70];
 
     for (const [key, value] of m0.entries()) {
       expect(keys).toContain(key);
+
       expect(values).toContain(value);
     }
   });
@@ -817,6 +895,7 @@ describe('IMap.forEach', () => {
       ['b', 2],
       ['c', 3],
     ]);
+
     const mut_collected: [string, number][] = [];
 
     for (const [key, value] of map.entries()) {
@@ -824,13 +903,17 @@ describe('IMap.forEach', () => {
     }
 
     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 mut_called = false;
 
     // eslint-disable-next-line unicorn/no-array-for-each
@@ -851,6 +934,7 @@ describe('IMap.keys', () => {
       [6, 60],
       [7, 70],
     ] as const);
+
     const keys = [1, 3, 5, 6, 7];
 
     for (const k of m0.keys()) {
@@ -868,6 +952,7 @@ describe('IMap.values', () => {
       [6, 60],
       [7, 70],
     ]);
+
     const values = [10, 30, 50, 60, 70];
 
     for (const v of m0.values()) {
@@ -885,11 +970,14 @@ describe('IMap.entries', () => {
       [6, 60],
       [7, 70],
     ]);
+
     const keys = [1, 3, 5, 6, 7];
+
     const values = [10, 30, 50, 60, 70];
 
     for (const [k, v] of m0.entries()) {
       expect(keys).toContain(k);
+
       expect(values).toContain(v);
     }
   });
@@ -902,11 +990,15 @@ describe('IMap.toKeysArray', () => {
       ['b', 2],
       ['c', 3],
     ]);
+
     const keys = map.toKeysArray();
 
     expect(keys).toHaveLength(3);
+
     expect(keys).toContain('a');
+
     expect(keys).toContain('b');
+
     expect(keys).toContain('c');
   });
 });
@@ -918,11 +1010,15 @@ describe('IMap.toValuesArray', () => {
       ['b', 2],
       ['c', 3],
     ]);
+
     const values = map.toValuesArray();
 
     expect(values).toHaveLength(3);
+
     expect(values).toContain(1);
+
     expect(values).toContain(2);
+
     expect(values).toContain(3);
   });
 });
@@ -934,11 +1030,15 @@ describe('IMap.toEntriesArray', () => {
       ['b', 2],
       ['c', 3],
     ]);
+
     const entries = map.toEntriesArray();
 
     expect(entries).toHaveLength(3);
+
     expect(entries).toContainEqual(['a', 1]);
+
     expect(entries).toContainEqual(['b', 2]);
+
     expect(entries).toContainEqual(['c', 3]);
   });
 });
@@ -950,7 +1050,9 @@ describe('IMap.toArray', () => {
       ['b', 2],
       ['c', 3],
     ]);
+
     const entries = map.toArray();
+
     const entriesArray = map.toEntriesArray();
 
     assert.deepStrictEqual(entries, entriesArray);
@@ -964,11 +1066,15 @@ describe('IMap.toRawMap', () => {
       ['b', 2],
       ['c', 3],
     ]);
+
     const rawMap = map.toRawMap();
 
     expect(rawMap.size).toBe(3);
+
     expect(rawMap.get('a')).toBe(1);
+
     expect(rawMap.get('b')).toBe(2);
+
     expect(rawMap.get('c')).toBe(3);
   });
 });