ts-data-forge 5.1.0 → 6.0.0

package/src/array/impl/array-utils-set-op.mts

@@ -10,9 +10,9 @@
  *
  * const differentNumbers = [1, 2, 4] as const;
  *
- * assert.ok(Arr.eq(numbers, sameNumbers));
+ * assert.isTrue(Arr.eq(numbers, sameNumbers));
  *
- * assert.notOk(Arr.eq(numbers, differentNumbers));
+ * assert.isFalse(Arr.eq(numbers, differentNumbers));
  * ```
  */
 export const eq = <E,>(
@@ -43,9 +43,9 @@ export const equal = eq;
  *
  * const notSubset = [2, 4] as const;
  *
- * assert.ok(Arr.isSubset(subset, superset));
+ * assert.isTrue(Arr.isSubset(subset, superset));
  *
- * assert.notOk(Arr.isSubset(notSubset, superset));
+ * assert.isFalse(Arr.isSubset(notSubset, superset));
  * ```
  */
 export const isSubset = <E1 extends Primitive, E2 extends Primitive = E1>(
@@ -69,11 +69,11 @@ export const isSubset = <E1 extends Primitive, E2 extends Primitive = E1>(
  *
  * const notSuperset = ['a', 'd'] as const;
  *
- * assert.ok(Arr.isSuperset(potentialSuperset, subset));
+ * assert.isTrue(Arr.isSuperset(potentialSuperset, subset));
  *
- * assert.notOk(Arr.isSuperset(subset, potentialSuperset));
+ * assert.isFalse(Arr.isSuperset(subset, potentialSuperset));
  *
- * assert.notOk(Arr.isSuperset(potentialSuperset, notSuperset));
+ * assert.isFalse(Arr.isSuperset(potentialSuperset, notSuperset));
  * ```
  */
 export const isSuperset = <E1 extends Primitive, E2 extends Primitive = E1>(

package/src/array/impl/array-utils-set-op.test.mts

@@ -20,7 +20,7 @@ describe('Arr set operations', () => {
       expectType<typeof result, boolean>('=');
 
       test('should return true for equal arrays of numbers', () => {
-        expect(result).toBe(true);
+        assert.isTrue(result);
       });
     }
 
@@ -34,7 +34,7 @@ describe('Arr set operations', () => {
       expectType<typeof result, boolean>('=');
 
       test('should return false for different arrays of numbers', () => {
-        expect(result).toBe(false);
+        assert.isFalse(result);
       });
     }
 
@@ -48,7 +48,7 @@ describe('Arr set operations', () => {
       expectType<typeof result, boolean>('=');
 
       test('should return false for arrays of different lengths', () => {
-        expect(result).toBe(false);
+        assert.isFalse(result);
       });
     }
 
@@ -62,7 +62,7 @@ describe('Arr set operations', () => {
       expectType<typeof result, boolean>('=');
 
       test('should return true for equal arrays of strings', () => {
-        expect(result).toBe(true);
+        assert.isTrue(result);
       });
     }
 
@@ -76,7 +76,7 @@ describe('Arr set operations', () => {
       expectType<typeof result, boolean>('=');
 
       test('should return true for empty arrays', () => {
-        expect(result).toBe(true);
+        assert.isTrue(result);
       });
     }
 
@@ -91,7 +91,7 @@ describe('Arr set operations', () => {
       expectType<typeof result, boolean>('=');
 
       test('should return false for arrays of objects with default equality (reference check)', () => {
-        expect(result).toBe(false);
+        assert.isFalse(result);
       });
     }
 
@@ -109,7 +109,7 @@ describe('Arr set operations', () => {
       expectType<typeof result, boolean>('=');
 
       test('should return true for arrays of same object references', () => {
-        expect(result).toBe(true);
+        assert.isTrue(result);
       });
     }
 
@@ -127,7 +127,7 @@ describe('Arr set operations', () => {
       expectType<typeof result, boolean>('=');
 
       test('should return true for arrays of objects with custom equality function', () => {
-        expect(result).toBe(true);
+        assert.isTrue(result);
       });
     }
   });
@@ -143,7 +143,7 @@ describe('Arr set operations', () => {
       expectType<typeof result, boolean>('=');
 
       test('case 1', () => {
-        expect(result).toBe(true);
+        assert.isTrue(result);
       });
     }
 
@@ -157,7 +157,7 @@ describe('Arr set operations', () => {
       expectType<typeof result, boolean>('=');
 
       test('case 2', () => {
-        expect(result).toBe(false);
+        assert.isFalse(result);
       });
     }
   });
@@ -173,13 +173,13 @@ describe('Arr set operations', () => {
       expectType<typeof result, boolean>('=');
 
       test('case 1', () => {
-        expect(result).toBe(false);
+        assert.isFalse(result);
       });
 
       const result2 = isSuperset(xs, ys);
 
       test('case 2', () => {
-        expect(result2).toBe(true);
+        assert.isTrue(result2);
       });
     }
 
@@ -193,7 +193,7 @@ describe('Arr set operations', () => {
       expectType<typeof result, boolean>('=');
 
       test('case 3', () => {
-        expect(result).toBe(false);
+        assert.isFalse(result);
       });
     }
   });

package/src/array/impl/array-utils-size.mts

@@ -12,9 +12,9 @@
  *
  * const sizeOfLetters = Arr.size(letters);
  *
- * assert(sizeOfNumbers === 3);
+ * assert.isTrue(sizeOfNumbers === 3);
  *
- * assert(sizeOfLetters === 0);
+ * assert.isTrue(sizeOfLetters === 0);
  * ```
  */
 export const size = <const Ar extends readonly unknown[]>(

package/src/array/impl/array-utils-slicing.mts

@@ -16,7 +16,7 @@ import { isEmpty } from './array-utils-validation.mjs';
  *
  *   assert.deepStrictEqual(remainder, ['Grace', 'Katherine']);
  *
- *   assert(remainder.length === 2);
+ *   assert.isTrue(remainder.length === 2);
  * }
  *
  * {
@@ -50,7 +50,7 @@ export const tail = <const Ar extends readonly unknown[]>(
  *
  * assert.deepStrictEqual(withoutLast, ['task-1', 'task-2']);
  *
- * assert(withoutLast.length === 2);
+ * assert.isTrue(withoutLast.length === 2);
  * ```
  */
 export const butLast = <const Ar extends readonly unknown[]>(

package/src/array/impl/array-utils-transformation.test.mts

@@ -893,9 +893,9 @@ describe('Arr transformations', () => {
 
       const vegetables = grouped.get('vegetable');
 
-      expect(Optional.isSome(fruits)).toBe(true);
+      assert.isTrue(Optional.isSome(fruits));
 
-      expect(Optional.isSome(vegetables)).toBe(true);
+      assert.isTrue(Optional.isSome(vegetables));
 
       if (Optional.isSome(fruits)) {
         expect(fruits.value).toHaveLength(2);

package/src/array/impl/array-utils-validation.mts

@@ -10,9 +10,9 @@ import { asUint32, Num } from '../../number/index.mjs';
  *
  * const maybeValue: unknown = 'Ada';
  *
- * assert.ok(Arr.isArray(maybeArray));
+ * assert.isTrue(Arr.isArray(maybeArray));
  *
- * assert.notOk(Arr.isArray(maybeValue));
+ * assert.isFalse(Arr.isArray(maybeValue));
  *
  * if (Arr.isArray(maybeArray)) {
  *   assert.deepStrictEqual(maybeArray, [1, 2, 3]);
@@ -45,9 +45,9 @@ type Cast<A, B> = A extends B ? A : never;
  *
  * const words = ['Ada', 'Lovelace'] as const;
  *
- * assert.ok(Arr.isEmpty(emptyNumbers));
+ * assert.isTrue(Arr.isEmpty(emptyNumbers));
  *
- * assert.notOk(Arr.isEmpty(words));
+ * assert.isFalse(Arr.isEmpty(words));
  *
  * if (Arr.isEmpty(emptyNumbers)) {
  *   assert.deepStrictEqual(emptyNumbers, []);
@@ -67,9 +67,9 @@ export const isEmpty = <E,>(array: readonly E[]): array is readonly [] =>
  *
  * const emptyUsers: readonly { id: number }[] = [];
  *
- * assert.ok(Arr.isNonEmpty(users));
+ * assert.isTrue(Arr.isNonEmpty(users));
  *
- * assert.notOk(Arr.isNonEmpty(emptyUsers));
+ * assert.isFalse(Arr.isNonEmpty(emptyUsers));
  *
  * if (Arr.isNonEmpty(users)) {
  *   assert.deepStrictEqual(users[0], { id: 1 });
@@ -90,9 +90,9 @@ export const isNonEmpty = <E,>(
  *
  * const triple: readonly number[] = [1, 2, 3];
  *
- * assert.ok(Arr.isArrayOfLength(pair, 2));
+ * assert.isTrue(Arr.isArrayOfLength(pair, 2));
  *
- * assert.notOk(Arr.isArrayOfLength(triple, 2));
+ * assert.isFalse(Arr.isArrayOfLength(triple, 2));
  *
  * if (Arr.isArrayOfLength(pair, 2)) {
  *   assert.deepStrictEqual(pair, [1, 2]);
@@ -114,12 +114,12 @@ export const isArrayOfLength = <E, N extends SizeType.ArgArr>(
  *
  * const emptyQueue: readonly string[] = [];
  *
- * assert.ok(Arr.isArrayAtLeastLength(queue, 1));
+ * assert.isTrue(Arr.isArrayAtLeastLength(queue, 1));
  *
- * assert.notOk(Arr.isArrayAtLeastLength(emptyQueue, 1));
+ * assert.isFalse(Arr.isArrayAtLeastLength(emptyQueue, 1));
  *
  * if (Arr.isArrayAtLeastLength(queue, 1)) {
- *   assert(queue[0] === 'task-1');
+ *   assert.isTrue(queue[0] === 'task-1');
  * }
  * ```
  */
@@ -142,9 +142,9 @@ export const isArrayAtLeastLength = <E, N extends SizeType.ArgArr>(
  *
  * const allStartWithA = Arr.every(words, (value) => value.startsWith('A'));
  *
- * assert.ok(allEven);
+ * assert.isTrue(allEven);
  *
- * assert.notOk(allStartWithA);
+ * assert.isFalse(allStartWithA);
  * ```
  */
 // Type guard overloads - narrow the entire array type
@@ -204,9 +204,9 @@ export function every<E>(
  *
  * const hasShortName = Arr.some(words, (value) => value.length <= 3);
  *
- * assert.notOk(hasEven);
+ * assert.isFalse(hasEven);
  *
- * assert.ok(hasShortName);
+ * assert.isTrue(hasShortName);
  * ```
  */
 export function some<const Ar extends readonly unknown[]>(
@@ -249,12 +249,12 @@ export function some<E>(
  * ```ts
  * const items = ['Ada', 'Grace', 'Katherine'] as const;
  *
- * assert.ok(Arr.indexIsInRange(items, 1));
+ * assert.isTrue(Arr.indexIsInRange(items, 1));
  *
- * assert.notOk(Arr.indexIsInRange(items, 3));
+ * assert.isFalse(Arr.indexIsInRange(items, 3));
  *
  * if (Arr.indexIsInRange(items, 2)) {
- *   assert(items[2] === 'Katherine');
+ *   assert.isTrue(items[2] === 'Katherine');
  * }
  * ```
  */