ts-data-forge 5.1.0 → 5.1.1

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

@@ -51,7 +51,7 @@ describe('ISetMapped.has', () => {
       fromKey,
     );
 
-    expect(s0.has({ v: 3 })).toBe(true);
+    assert.isTrue(s0.has({ v: 3 }));
   });
 
   test('case 2', () => {
@@ -61,7 +61,7 @@ describe('ISetMapped.has', () => {
       fromKey,
     );
 
-    expect(s0.has({ v: 4 })).toBe(false);
+    assert.isFalse(s0.has({ v: 4 }));
   });
 
   test('case 3', () => {
@@ -71,7 +71,7 @@ describe('ISetMapped.has', () => {
       fromKey,
     );
 
-    expect(s0.has({ v: 3 })).toBe(false);
+    assert.isFalse(s0.has({ v: 3 }));
   });
 });
 
@@ -488,9 +488,9 @@ describe('ISetMapped additional functionality with complex types', () => {
 
       expect(set.size).toBe(2);
 
-      expect(set.has({ id: 1, type: 'user' })).toBe(true);
+      assert.isTrue(set.has({ id: 1, type: 'user' }));
 
-      expect(set.has({ id: 2, type: 'admin' })).toBe(true);
+      assert.isTrue(set.has({ id: 2, type: 'admin' }));
     });
 
     test('should handle duplicate elements based on mapping', () => {
@@ -528,7 +528,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(ISetMapped.equal(set1, set2)).toBe(true);
+      assert.isTrue(ISetMapped.equal(set1, set2));
     });
 
     test('should return false for sets with different elements', () => {
@@ -550,7 +550,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(ISetMapped.equal(set1, set2)).toBe(false);
+      assert.isFalse(ISetMapped.equal(set1, set2));
     });
 
     test('should return true for empty sets', () => {
@@ -566,7 +566,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(ISetMapped.equal(set1, set2)).toBe(true);
+      assert.isTrue(ISetMapped.equal(set1, set2));
     });
   });
 
@@ -596,11 +596,11 @@ describe('ISetMapped additional functionality with complex types', () => {
 
       expect(diff.deleted.size).toBe(1);
 
-      expect(diff.deleted.has({ id: 1, type: 'user' })).toBe(true);
+      assert.isTrue(diff.deleted.has({ id: 1, type: 'user' }));
 
       expect(diff.added.size).toBe(1);
 
-      expect(diff.added.has({ id: 4, type: 'user' })).toBe(true);
+      assert.isTrue(diff.added.has({ id: 4, type: 'user' }));
     });
 
     test('should handle no changes', () => {
@@ -656,9 +656,9 @@ describe('ISetMapped additional functionality with complex types', () => {
 
       expect(intersection.size).toBe(2);
 
-      expect(intersection.has({ id: 2, type: 'admin' })).toBe(true);
+      assert.isTrue(intersection.has({ id: 2, type: 'admin' }));
 
-      expect(intersection.has({ id: 3, type: 'guest' })).toBe(true);
+      assert.isTrue(intersection.has({ id: 3, type: 'guest' }));
     });
 
     test('should compute union correctly', () => {
@@ -684,13 +684,13 @@ describe('ISetMapped additional functionality with complex types', () => {
 
       expect(union.size).toBe(4);
 
-      expect(union.has({ id: 1, type: 'user' })).toBe(true);
+      assert.isTrue(union.has({ id: 1, type: 'user' }));
 
-      expect(union.has({ id: 2, type: 'admin' })).toBe(true);
+      assert.isTrue(union.has({ id: 2, type: 'admin' }));
 
-      expect(union.has({ id: 3, type: 'guest' })).toBe(true);
+      assert.isTrue(union.has({ id: 3, type: 'guest' }));
 
-      expect(union.has({ id: 4, type: 'user' })).toBe(true);
+      assert.isTrue(union.has({ id: 4, type: 'user' }));
     });
   });
 
@@ -705,7 +705,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(set.every((el) => el.type === 'user')).toBe(true);
+      assert.isTrue(set.every((el) => el.type === 'user'));
     });
 
     test('should return false when some elements do not satisfy predicate', () => {
@@ -718,7 +718,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(set.every((el) => el.type === 'user')).toBe(false);
+      assert.isFalse(set.every((el) => el.type === 'user'));
     });
   });
 
@@ -733,7 +733,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(set.some((el) => el.type === 'admin')).toBe(true);
+      assert.isTrue(set.some((el) => el.type === 'admin'));
     });
 
     test('should return false when no elements satisfy predicate', () => {
@@ -746,7 +746,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(set.some((el) => el.type === 'admin')).toBe(false);
+      assert.isFalse(set.some((el) => el.type === 'admin'));
     });
   });
 
@@ -762,9 +762,9 @@ describe('ISetMapped additional functionality with complex types', () => {
 
       expect(updated.size).toBe(2);
 
-      expect(updated.has({ id: 1, type: 'user' })).toBe(true);
+      assert.isTrue(updated.has({ id: 1, type: 'user' }));
 
-      expect(updated.has({ id: 2, type: 'admin' })).toBe(true);
+      assert.isTrue(updated.has({ id: 2, type: 'admin' }));
     });
 
     test('should return same instance when adding existing element', () => {
@@ -795,9 +795,9 @@ describe('ISetMapped additional functionality with complex types', () => {
 
       expect(updated.size).toBe(1);
 
-      expect(updated.has({ id: 1, type: 'user' })).toBe(false);
+      assert.isFalse(updated.has({ id: 1, type: 'user' }));
 
-      expect(updated.has({ id: 2, type: 'admin' })).toBe(true);
+      assert.isTrue(updated.has({ id: 2, type: 'admin' }));
     });
 
     test('should return same instance when deleting non-existent element', () => {
@@ -829,11 +829,11 @@ describe('ISetMapped additional functionality with complex types', () => {
 
       expect(updated.size).toBe(2);
 
-      expect(updated.has({ id: 1, type: 'user' })).toBe(false);
+      assert.isFalse(updated.has({ id: 1, type: 'user' }));
 
-      expect(updated.has({ id: 2, type: 'admin' })).toBe(true);
+      assert.isTrue(updated.has({ id: 2, type: 'admin' }));
 
-      expect(updated.has({ id: 3, type: 'guest' })).toBe(true);
+      assert.isTrue(updated.has({ id: 3, type: 'guest' }));
     });
 
     test('should handle empty mutations array', () => {
@@ -847,7 +847,7 @@ describe('ISetMapped additional functionality with complex types', () => {
 
       expect(updated.size).toBe(1);
 
-      expect(ISetMapped.equal(set, updated)).toBe(true);
+      assert.isTrue(ISetMapped.equal(set, updated));
     });
   });
 
@@ -869,9 +869,9 @@ describe('ISetMapped additional functionality with complex types', () => {
 
       expect(transformed.size).toBe(2);
 
-      expect(transformed.has({ id: 1, type: 'USER' })).toBe(true);
+      assert.isTrue(transformed.has({ id: 1, type: 'USER' }));
 
-      expect(transformed.has({ id: 2, type: 'ADMIN' })).toBe(true);
+      assert.isTrue(transformed.has({ id: 2, type: 'ADMIN' }));
     });
   });
 
@@ -891,11 +891,11 @@ describe('ISetMapped additional functionality with complex types', () => {
 
       expect(filtered.size).toBe(2);
 
-      expect(filtered.has({ id: 1, type: 'user' })).toBe(true);
+      assert.isTrue(filtered.has({ id: 1, type: 'user' }));
 
-      expect(filtered.has({ id: 3, type: 'user' })).toBe(true);
+      assert.isTrue(filtered.has({ id: 3, type: 'user' }));
 
-      expect(filtered.has({ id: 2, type: 'admin' })).toBe(false);
+      assert.isFalse(filtered.has({ id: 2, type: 'admin' }));
     });
   });
 
@@ -915,11 +915,11 @@ describe('ISetMapped additional functionality with complex types', () => {
 
       expect(filtered.size).toBe(1);
 
-      expect(filtered.has({ id: 2, type: 'admin' })).toBe(true);
+      assert.isTrue(filtered.has({ id: 2, type: 'admin' }));
 
-      expect(filtered.has({ id: 1, type: 'user' })).toBe(false);
+      assert.isFalse(filtered.has({ id: 1, type: 'user' }));
 
-      expect(filtered.has({ id: 3, type: 'user' })).toBe(false);
+      assert.isFalse(filtered.has({ id: 3, type: 'user' }));
     });
   });
 
@@ -965,7 +965,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(subset.isSubsetOf(superset)).toBe(true);
+      assert.isTrue(subset.isSubsetOf(superset));
     });
 
     test('should return false for non-subset', () => {
@@ -987,7 +987,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(set1.isSubsetOf(set2)).toBe(false);
+      assert.isFalse(set1.isSubsetOf(set2));
     });
   });
 
@@ -1008,7 +1008,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(superset.isSupersetOf(subset)).toBe(true);
+      assert.isTrue(superset.isSupersetOf(subset));
     });
 
     test('should return false for non-superset', () => {
@@ -1030,7 +1030,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(set1.isSupersetOf(set2)).toBe(false);
+      assert.isFalse(set1.isSupersetOf(set2));
     });
   });
 
@@ -1059,11 +1059,11 @@ describe('ISetMapped additional functionality with complex types', () => {
 
       expect(result.size).toBe(2);
 
-      expect(result.has({ id: 1, type: 'user' })).toBe(true);
+      assert.isTrue(result.has({ id: 1, type: 'user' }));
 
-      expect(result.has({ id: 3, type: 'guest' })).toBe(true);
+      assert.isTrue(result.has({ id: 3, type: 'guest' }));
 
-      expect(result.has({ id: 2, type: 'admin' })).toBe(false);
+      assert.isFalse(result.has({ id: 2, type: 'admin' }));
     });
   });
 
@@ -1093,11 +1093,11 @@ describe('ISetMapped additional functionality with complex types', () => {
 
       expect(result.size).toBe(2);
 
-      expect(result.has({ id: 2, type: 'admin' })).toBe(true);
+      assert.isTrue(result.has({ id: 2, type: 'admin' }));
 
-      expect(result.has({ id: 3, type: 'guest' })).toBe(true);
+      assert.isTrue(result.has({ id: 3, type: 'guest' }));
 
-      expect(result.has({ id: 1, type: 'user' })).toBe(false);
+      assert.isFalse(result.has({ id: 1, type: 'user' }));
     });
   });
 
@@ -1125,13 +1125,13 @@ describe('ISetMapped additional functionality with complex types', () => {
 
       expect(result.size).toBe(4);
 
-      expect(result.has({ id: 1, type: 'user' })).toBe(true);
+      assert.isTrue(result.has({ id: 1, type: 'user' }));
 
-      expect(result.has({ id: 2, type: 'admin' })).toBe(true);
+      assert.isTrue(result.has({ id: 2, type: 'admin' }));
 
-      expect(result.has({ id: 3, type: 'guest' })).toBe(true);
+      assert.isTrue(result.has({ id: 3, type: 'guest' }));
 
-      expect(result.has({ id: 4, type: 'user' })).toBe(true);
+      assert.isTrue(result.has({ id: 4, type: 'user' }));
     });
   });
 
@@ -1251,9 +1251,9 @@ describe('ISetMapped additional functionality with complex types', () => {
 
       expect(rawSet.size).toBe(2);
 
-      expect(rawSet.has('user_1')).toBe(true);
+      assert.isTrue(rawSet.has('user_1'));
 
-      expect(rawSet.has('admin_2')).toBe(true);
+      assert.isTrue(rawSet.has('admin_2'));
     });
   });
 });

package/src/collections/iset.mts

@@ -39,7 +39,7 @@ type ISetInterface<K extends MapSetKeyType> = Readonly<{
    * ```ts
    * const set = ISet.create([1, 2, 3]);
    *
-   * assert(set.size === 3);
+   * assert.isTrue(set.size === 3);
    * ```
    */
   size: SizeType.Arr;
@@ -54,9 +54,9 @@ type ISetInterface<K extends MapSetKeyType> = Readonly<{
    *
    * const filledSet = ISet.create([1, 2]);
    *
-   * assert.ok(emptySet.isEmpty);
+   * assert.isTrue(emptySet.isEmpty);
    *
-   * assert.notOk(filledSet.isEmpty);
+   * assert.isFalse(filledSet.isEmpty);
    * ```
    */
   isEmpty: boolean;
@@ -70,9 +70,9 @@ type ISetInterface<K extends MapSetKeyType> = Readonly<{
    * ```ts
    * const set = ISet.create(['apple', 'banana']);
    *
-   * assert.ok(set.has('apple'));
+   * assert.isTrue(set.has('apple'));
    *
-   * assert.notOk(set.has('cherry'));
+   * assert.isFalse(set.has('cherry'));
    * ```
    *
    * @param key The element to check.
@@ -94,9 +94,9 @@ type ISetInterface<K extends MapSetKeyType> = Readonly<{
    *
    * const narrowed = numbers.every((value): value is 2 | 4 | 6 => value % 2 === 0);
    *
-   * assert.ok(allEven);
+   * assert.isTrue(allEven);
    *
-   * assert.ok(narrowed);
+   * assert.isTrue(narrowed);
    * ```
    *
    * @param predicate A function to test each element.
@@ -122,9 +122,9 @@ type ISetInterface<K extends MapSetKeyType> = Readonly<{
    * ```ts
    * const numbers = ISet.create([1, 3, 5]);
    *
-   * assert.ok(numbers.some((value) => value > 4));
+   * assert.isTrue(numbers.some((value) => value > 4));
    *
-   * assert.notOk(numbers.some((value) => value > 10));
+   * assert.isFalse(numbers.some((value) => value > 10));
    * ```
    *
    * @param predicate A function to test each element.
@@ -149,7 +149,7 @@ type ISetInterface<K extends MapSetKeyType> = Readonly<{
    *
    * assert.deepStrictEqual(Array.from(withThree), [1, 2, 3]);
    *
-   * assert(unchanged === base);
+   * assert.isTrue(unchanged === base);
    * ```
    *
    * @param key The element to add.
@@ -171,7 +171,7 @@ type ISetInterface<K extends MapSetKeyType> = Readonly<{
    *
    * assert.deepStrictEqual(Array.from(withoutTwo), [1, 3]);
    *
-   * assert(unchanged === base);
+   * assert.isTrue(unchanged === base);
    * ```
    *
    * @param key The element to delete.
@@ -296,9 +296,9 @@ type ISetInterface<K extends MapSetKeyType> = Readonly<{
    *
    * const superset = ISet.create<number>([1, 2, 3]);
    *
-   * assert.ok(subset.isSubsetOf(superset));
+   * assert.isTrue(subset.isSubsetOf(superset));
    *
-   * assert.notOk(superset.isSubsetOf(subset));
+   * assert.isFalse(superset.isSubsetOf(subset));
    * ```
    *
    * @param set The other set.
@@ -317,9 +317,9 @@ type ISetInterface<K extends MapSetKeyType> = Readonly<{
    *
    * const subset = ISet.create<string>(['a', 'c']);
    *
-   * assert.ok(superset.isSupersetOf(subset));
+   * assert.isTrue(superset.isSupersetOf(subset));
    *
-   * assert.notOk(subset.isSupersetOf(superset));
+   * assert.isFalse(subset.isSupersetOf(superset));
    * ```
    *
    * @param set The other set.
@@ -497,9 +497,9 @@ type ISetInterface<K extends MapSetKeyType> = Readonly<{
    *
    * const raw = set.toRawSet();
    *
-   * assert.ok(is.set(raw));
+   * assert.isTrue(is.set(raw));
    *
-   * assert.ok(raw.has('alpha'));
+   * assert.isTrue(raw.has('alpha'));
    * ```
    *
    * @returns The raw ReadonlySet instance.
@@ -584,9 +584,9 @@ export namespace ISet {
    *
    * const third = ISet.create<number>([1, 3]);
    *
-   * assert.ok(ISet.equal(first, second));
+   * assert.isTrue(ISet.equal(first, second));
    *
-   * assert.notOk(ISet.equal(first, third));
+   * assert.isFalse(ISet.equal(first, third));
    * ```
    *
    * @template K The type of the elements.