ts-data-forge 5.1.0 → 6.0.0

package/src/collections/queue.mts

@@ -44,17 +44,17 @@ export type Queue<T> = Readonly<{
    * ```ts
    * const queue = createQueue<number>();
    *
-   * assert.ok(queue.isEmpty);
+   * assert.isTrue(queue.isEmpty);
    *
-   * assert(queue.size === 0);
+   * assert.isTrue(queue.size === 0);
    *
    * queue.enqueue(1);
    *
    * queue.enqueue(2);
    *
-   * assert.notOk(queue.isEmpty);
+   * assert.isFalse(queue.isEmpty);
    *
-   * assert(queue.size === 2);
+   * assert.isTrue(queue.size === 2);
    *
    * assert.deepStrictEqual(queue.dequeue(), Optional.some(1));
    *
@@ -64,7 +64,7 @@ export type Queue<T> = Readonly<{
    *
    * const seededQueue = createQueue(['first', 'second']);
    *
-   * assert(seededQueue.size === 2);
+   * assert.isTrue(seededQueue.size === 2);
    *
    * assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('first'));
    *
@@ -81,17 +81,17 @@ export type Queue<T> = Readonly<{
    * ```ts
    * const queue = createQueue<number>();
    *
-   * assert.ok(queue.isEmpty);
+   * assert.isTrue(queue.isEmpty);
    *
-   * assert(queue.size === 0);
+   * assert.isTrue(queue.size === 0);
    *
    * queue.enqueue(1);
    *
    * queue.enqueue(2);
    *
-   * assert.notOk(queue.isEmpty);
+   * assert.isFalse(queue.isEmpty);
    *
-   * assert(queue.size === 2);
+   * assert.isTrue(queue.size === 2);
    *
    * assert.deepStrictEqual(queue.dequeue(), Optional.some(1));
    *
@@ -101,7 +101,7 @@ export type Queue<T> = Readonly<{
    *
    * const seededQueue = createQueue(['first', 'second']);
    *
-   * assert(seededQueue.size === 2);
+   * assert.isTrue(seededQueue.size === 2);
    *
    * assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('first'));
    *
@@ -118,17 +118,17 @@ export type Queue<T> = Readonly<{
    * ```ts
    * const queue = createQueue<number>();
    *
-   * assert.ok(queue.isEmpty);
+   * assert.isTrue(queue.isEmpty);
    *
-   * assert(queue.size === 0);
+   * assert.isTrue(queue.size === 0);
    *
    * queue.enqueue(1);
    *
    * queue.enqueue(2);
    *
-   * assert.notOk(queue.isEmpty);
+   * assert.isFalse(queue.isEmpty);
    *
-   * assert(queue.size === 2);
+   * assert.isTrue(queue.size === 2);
    *
    * assert.deepStrictEqual(queue.dequeue(), Optional.some(1));
    *
@@ -138,7 +138,7 @@ export type Queue<T> = Readonly<{
    *
    * const seededQueue = createQueue(['first', 'second']);
    *
-   * assert(seededQueue.size === 2);
+   * assert.isTrue(seededQueue.size === 2);
    *
    * assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('first'));
    *
@@ -158,17 +158,17 @@ export type Queue<T> = Readonly<{
    * ```ts
    * const queue = createQueue<number>();
    *
-   * assert.ok(queue.isEmpty);
+   * assert.isTrue(queue.isEmpty);
    *
-   * assert(queue.size === 0);
+   * assert.isTrue(queue.size === 0);
    *
    * queue.enqueue(1);
    *
    * queue.enqueue(2);
    *
-   * assert.notOk(queue.isEmpty);
+   * assert.isFalse(queue.isEmpty);
    *
-   * assert(queue.size === 2);
+   * assert.isTrue(queue.size === 2);
    *
    * assert.deepStrictEqual(queue.dequeue(), Optional.some(1));
    *
@@ -178,7 +178,7 @@ export type Queue<T> = Readonly<{
    *
    * const seededQueue = createQueue(['first', 'second']);
    *
-   * assert(seededQueue.size === 2);
+   * assert.isTrue(seededQueue.size === 2);
    *
    * assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('first'));
    *
@@ -381,17 +381,17 @@ class QueueClass<T> implements Queue<T> {
  * ```ts
  * const queue = createQueue<number>();
  *
- * assert.ok(queue.isEmpty);
+ * assert.isTrue(queue.isEmpty);
  *
- * assert(queue.size === 0);
+ * assert.isTrue(queue.size === 0);
  *
  * queue.enqueue(1);
  *
  * queue.enqueue(2);
  *
- * assert.notOk(queue.isEmpty);
+ * assert.isFalse(queue.isEmpty);
  *
- * assert(queue.size === 2);
+ * assert.isTrue(queue.size === 2);
  *
  * assert.deepStrictEqual(queue.dequeue(), Optional.some(1));
  *
@@ -401,7 +401,7 @@ class QueueClass<T> implements Queue<T> {
  *
  * const seededQueue = createQueue(['first', 'second']);
  *
- * assert(seededQueue.size === 2);
+ * assert.isTrue(seededQueue.size === 2);
  *
  * assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('first'));
  *

package/src/collections/queue.test.mts

@@ -9,7 +9,7 @@ describe('Queue test', () => {
     test('should be empty if initialized without values', () => {
       const q = createQueue();
 
-      expect(q.isEmpty).toBe(true);
+      assert.isTrue(q.isEmpty);
 
       expect(q.size).toBe(0);
     });
@@ -17,7 +17,7 @@ describe('Queue test', () => {
     test('should not be empty if initialized with values', () => {
       const q = createQueue([1, 2, 3]);
 
-      expect(q.isEmpty).toBe(false);
+      assert.isFalse(q.isEmpty);
 
       expect(q.size).toBe(3);
     });
@@ -34,7 +34,7 @@ describe('Queue test', () => {
     test('should increase size and not be empty after enqueueing to an empty queue', () => {
       mut_q.enqueue(1);
 
-      expect(mut_q.isEmpty).toBe(false);
+      assert.isFalse(mut_q.isEmpty);
 
       expect(mut_q.size).toBe(1);
     });
@@ -54,9 +54,9 @@ describe('Queue test', () => {
 
       const result = q.dequeue();
 
-      expect(Optional.isNone(result)).toBe(true);
+      assert.isTrue(Optional.isNone(result));
 
-      expect(q.isEmpty).toBe(true);
+      assert.isTrue(q.isEmpty);
 
       expect(q.size).toBe(0);
     });
@@ -68,7 +68,7 @@ describe('Queue test', () => {
 
       const result1 = q.dequeue(); // Dequeues 1 (first element)
 
-      expect(Optional.isSome(result1)).toBe(true);
+      assert.isTrue(Optional.isSome(result1));
 
       if (Optional.isSome(result1)) {
         expect(result1.value).toBe(1);
@@ -78,7 +78,7 @@ describe('Queue test', () => {
 
       const result2 = q.dequeue(); // Dequeues 2
 
-      expect(Optional.isSome(result2)).toBe(true);
+      assert.isTrue(Optional.isSome(result2));
 
       if (Optional.isSome(result2)) {
         expect(result2.value).toBe(2);
@@ -94,13 +94,13 @@ describe('Queue test', () => {
 
       q.dequeue(); // Dequeues 2
 
-      expect(q.isEmpty).toBe(true);
+      assert.isTrue(q.isEmpty);
 
       expect(q.size).toBe(0);
 
       const result = q.dequeue(); // Dequeue from empty
 
-      expect(Optional.isNone(result)).toBe(true);
+      assert.isTrue(Optional.isNone(result));
     });
   });
 
@@ -118,27 +118,27 @@ describe('Queue test', () => {
 
       let mut_result = q.dequeue(); // Dequeues 1 (first in)
 
-      expect(Optional.isSome(mut_result) && mut_result.value === 1).toBe(true);
+      assert.isTrue(Optional.isSome(mut_result) && mut_result.value === 1);
 
       expect(q.size).toBe(2);
 
       mut_result = q.dequeue(); // Dequeues 2
 
-      expect(Optional.isSome(mut_result) && mut_result.value === 2).toBe(true);
+      assert.isTrue(Optional.isSome(mut_result) && mut_result.value === 2);
 
       expect(q.size).toBe(1);
 
       mut_result = q.dequeue(); // Dequeues 3
 
-      expect(Optional.isSome(mut_result) && mut_result.value === 3).toBe(true);
+      assert.isTrue(Optional.isSome(mut_result) && mut_result.value === 3);
 
       expect(q.size).toBe(0);
 
-      expect(q.isEmpty).toBe(true);
+      assert.isTrue(q.isEmpty);
 
       mut_result = q.dequeue();
 
-      expect(Optional.isNone(mut_result)).toBe(true);
+      assert.isTrue(Optional.isNone(mut_result));
     });
 
     test('initial values are dequeued in the same order (FIFO)', () => {
@@ -148,17 +148,17 @@ describe('Queue test', () => {
 
       const result1 = q.dequeue(); // Dequeues 1 (first element)
 
-      expect(Optional.isSome(result1) && result1.value === 1).toBe(true);
+      assert.isTrue(Optional.isSome(result1) && result1.value === 1);
 
       const result2 = q.dequeue(); // Dequeues 2
 
-      expect(Optional.isSome(result2) && result2.value === 2).toBe(true);
+      assert.isTrue(Optional.isSome(result2) && result2.value === 2);
 
       const result3 = q.dequeue(); // Dequeues 3
 
-      expect(Optional.isSome(result3) && result3.value === 3).toBe(true);
+      assert.isTrue(Optional.isSome(result3) && result3.value === 3);
 
-      expect(q.isEmpty).toBe(true);
+      assert.isTrue(q.isEmpty);
     });
 
     test('mixed enqueue and dequeue operations maintain FIFO order', () => {
@@ -170,7 +170,7 @@ describe('Queue test', () => {
 
       const result1 = q.dequeue();
 
-      expect(Optional.isSome(result1) && result1.value === 'A').toBe(true);
+      assert.isTrue(Optional.isSome(result1) && result1.value === 'A');
 
       q.enqueue('C');
 
@@ -178,17 +178,17 @@ describe('Queue test', () => {
 
       const result2 = q.dequeue();
 
-      expect(Optional.isSome(result2) && result2.value === 'B').toBe(true);
+      assert.isTrue(Optional.isSome(result2) && result2.value === 'B');
 
       const result3 = q.dequeue();
 
-      expect(Optional.isSome(result3) && result3.value === 'C').toBe(true);
+      assert.isTrue(Optional.isSome(result3) && result3.value === 'C');
 
       const result4 = q.dequeue();
 
-      expect(Optional.isSome(result4) && result4.value === 'D').toBe(true);
+      assert.isTrue(Optional.isSome(result4) && result4.value === 'D');
 
-      expect(q.isEmpty).toBe(true);
+      assert.isTrue(q.isEmpty);
     });
   });
 
@@ -226,7 +226,7 @@ describe('Queue test', () => {
 
       expect(Optional.unwrap(q.dequeue())).toBe(8);
 
-      expect(q.isEmpty).toBe(true);
+      assert.isTrue(q.isEmpty);
     });
 
     test('should automatically resize when buffer becomes full', () => {
@@ -243,10 +243,10 @@ describe('Queue test', () => {
       for (const i of range(1, 21)) {
         const result = q.dequeue();
 
-        expect(Optional.isSome(result) && result.value === i).toBe(true);
+        assert.isTrue(Optional.isSome(result) && result.value === i);
       }
 
-      expect(q.isEmpty).toBe(true);
+      assert.isTrue(q.isEmpty);
     });
 
     test('should handle multiple resize operations', () => {
@@ -280,7 +280,7 @@ describe('Queue test', () => {
         expect(Optional.unwrap(q.dequeue())).toBe(i);
       }
 
-      expect(q.isEmpty).toBe(true);
+      assert.isTrue(q.isEmpty);
     });
 
     test('should handle edge case of single element operations', () => {
@@ -294,11 +294,9 @@ describe('Queue test', () => {
 
         const result = q.dequeue();
 
-        expect(Optional.isSome(result) && result.value === `item-${i}`).toBe(
-          true,
-        );
+        assert.isTrue(Optional.isSome(result) && result.value === `item-${i}`);
 
-        expect(q.isEmpty).toBe(true);
+        assert.isTrue(q.isEmpty);
       }
     });
 
@@ -314,7 +312,7 @@ describe('Queue test', () => {
         expect(Optional.unwrap(q.dequeue())).toBe(i);
       }
 
-      expect(q.isEmpty).toBe(true);
+      assert.isTrue(q.isEmpty);
     });
 
     test('should properly clean up references for garbage collection', () => {
@@ -331,17 +329,17 @@ describe('Queue test', () => {
       for (const i of range(0, 5)) {
         const result = q.dequeue();
 
-        expect(Optional.isSome(result) && result.value.id === i).toBe(true);
+        assert.isTrue(Optional.isSome(result) && result.value.id === i);
       }
 
       // Remaining objects should still be accessible
       for (const i of range(5, 10)) {
         const result = q.dequeue();
 
-        expect(Optional.isSome(result) && result.value.id === i).toBe(true);
+        assert.isTrue(Optional.isSome(result) && result.value.id === i);
       }
 
-      expect(q.isEmpty).toBe(true);
+      assert.isTrue(q.isEmpty);
     });
   });
 });

package/src/collections/stack.mts

@@ -44,18 +44,18 @@ export type Stack<T> = Readonly<{
    * ```ts
    * const stack = createStack<string>();
    *
-   * assert.ok(stack.isEmpty);
+   * assert.isTrue(stack.isEmpty);
    *
-   * assert(stack.size === 0);
+   * assert.isTrue(stack.size === 0);
    *
    * stack.push('first');
    *
    * // eslint-disable-next-line unicorn/prefer-single-call
    * stack.push('second');
    *
-   * assert.notOk(stack.isEmpty);
+   * assert.isFalse(stack.isEmpty);
    *
-   * assert(stack.size === 2);
+   * assert.isTrue(stack.size === 2);
    *
    * assert.deepStrictEqual(stack.pop(), Optional.some('second'));
    *
@@ -65,7 +65,7 @@ export type Stack<T> = Readonly<{
    *
    * const seededStack = createStack([10, 20, 30]);
    *
-   * assert(seededStack.size === 3);
+   * assert.isTrue(seededStack.size === 3);
    *
    * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));
    * ```
@@ -80,18 +80,18 @@ export type Stack<T> = Readonly<{
    * ```ts
    * const stack = createStack<string>();
    *
-   * assert.ok(stack.isEmpty);
+   * assert.isTrue(stack.isEmpty);
    *
-   * assert(stack.size === 0);
+   * assert.isTrue(stack.size === 0);
    *
    * stack.push('first');
    *
    * // eslint-disable-next-line unicorn/prefer-single-call
    * stack.push('second');
    *
-   * assert.notOk(stack.isEmpty);
+   * assert.isFalse(stack.isEmpty);
    *
-   * assert(stack.size === 2);
+   * assert.isTrue(stack.size === 2);
    *
    * assert.deepStrictEqual(stack.pop(), Optional.some('second'));
    *
@@ -101,7 +101,7 @@ export type Stack<T> = Readonly<{
    *
    * const seededStack = createStack([10, 20, 30]);
    *
-   * assert(seededStack.size === 3);
+   * assert.isTrue(seededStack.size === 3);
    *
    * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));
    * ```
@@ -116,18 +116,18 @@ export type Stack<T> = Readonly<{
    * ```ts
    * const stack = createStack<string>();
    *
-   * assert.ok(stack.isEmpty);
+   * assert.isTrue(stack.isEmpty);
    *
-   * assert(stack.size === 0);
+   * assert.isTrue(stack.size === 0);
    *
    * stack.push('first');
    *
    * // eslint-disable-next-line unicorn/prefer-single-call
    * stack.push('second');
    *
-   * assert.notOk(stack.isEmpty);
+   * assert.isFalse(stack.isEmpty);
    *
-   * assert(stack.size === 2);
+   * assert.isTrue(stack.size === 2);
    *
    * assert.deepStrictEqual(stack.pop(), Optional.some('second'));
    *
@@ -137,7 +137,7 @@ export type Stack<T> = Readonly<{
    *
    * const seededStack = createStack([10, 20, 30]);
    *
-   * assert(seededStack.size === 3);
+   * assert.isTrue(seededStack.size === 3);
    *
    * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));
    * ```
@@ -155,18 +155,18 @@ export type Stack<T> = Readonly<{
    * ```ts
    * const stack = createStack<string>();
    *
-   * assert.ok(stack.isEmpty);
+   * assert.isTrue(stack.isEmpty);
    *
-   * assert(stack.size === 0);
+   * assert.isTrue(stack.size === 0);
    *
    * stack.push('first');
    *
    * // eslint-disable-next-line unicorn/prefer-single-call
    * stack.push('second');
    *
-   * assert.notOk(stack.isEmpty);
+   * assert.isFalse(stack.isEmpty);
    *
-   * assert(stack.size === 2);
+   * assert.isTrue(stack.size === 2);
    *
    * assert.deepStrictEqual(stack.pop(), Optional.some('second'));
    *
@@ -176,7 +176,7 @@ export type Stack<T> = Readonly<{
    *
    * const seededStack = createStack([10, 20, 30]);
    *
-   * assert(seededStack.size === 3);
+   * assert.isTrue(seededStack.size === 3);
    *
    * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));
    * ```
@@ -356,18 +356,18 @@ class StackClass<T> implements Stack<T> {
  * ```ts
  * const stack = createStack<string>();
  *
- * assert.ok(stack.isEmpty);
+ * assert.isTrue(stack.isEmpty);
  *
- * assert(stack.size === 0);
+ * assert.isTrue(stack.size === 0);
  *
  * stack.push('first');
  *
  * // eslint-disable-next-line unicorn/prefer-single-call
  * stack.push('second');
  *
- * assert.notOk(stack.isEmpty);
+ * assert.isFalse(stack.isEmpty);
  *
- * assert(stack.size === 2);
+ * assert.isTrue(stack.size === 2);
  *
  * assert.deepStrictEqual(stack.pop(), Optional.some('second'));
  *
@@ -377,7 +377,7 @@ class StackClass<T> implements Stack<T> {
  *
  * const seededStack = createStack([10, 20, 30]);
  *
- * assert(seededStack.size === 3);
+ * assert.isTrue(seededStack.size === 3);
  *
  * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));
  * ```

package/src/collections/stack.test.mts

@@ -31,7 +31,7 @@ describe('Stack test', () => {
   test('should be empty when created without initial values', () => {
     const stack = createStack<string>();
 
-    expect(stack.isEmpty).toBe(true);
+    assert.isTrue(stack.isEmpty);
 
     expect(stack.size).toBe(0);
   });
@@ -39,7 +39,7 @@ describe('Stack test', () => {
   test('should create with initial values', () => {
     const stack = createStack<number>([1, 2, 3]);
 
-    expect(stack.isEmpty).toBe(false);
+    assert.isFalse(stack.isEmpty);
 
     expect(stack.size).toBe(3);
 
@@ -50,7 +50,7 @@ describe('Stack test', () => {
 
     expect(Optional.unwrap(stack.pop())).toBe(1);
 
-    expect(stack.isEmpty).toBe(true);
+    assert.isTrue(stack.isEmpty);
   });
 
   test('should implement LIFO behavior correctly', () => {
@@ -66,7 +66,7 @@ describe('Stack test', () => {
 
     expect(stack.size).toBe(3);
 
-    expect(stack.isEmpty).toBe(false);
+    assert.isFalse(stack.isEmpty);
 
     // LIFO: Last In, First Out
     expect(Optional.unwrap(stack.pop())).toBe('third');
@@ -75,7 +75,7 @@ describe('Stack test', () => {
 
     expect(Optional.unwrap(stack.pop())).toBe('first');
 
-    expect(stack.isEmpty).toBe(true);
+    assert.isTrue(stack.isEmpty);
 
     expect(stack.size).toBe(0);
   });
@@ -85,9 +85,9 @@ describe('Stack test', () => {
 
     const result = stack.pop();
 
-    expect(Optional.isNone(result)).toBe(true);
+    assert.isTrue(Optional.isNone(result));
 
-    expect(stack.isEmpty).toBe(true);
+    assert.isTrue(stack.isEmpty);
 
     expect(stack.size).toBe(0);
   });
@@ -121,7 +121,7 @@ describe('Stack test', () => {
 
     expect(stack.size).toBe(0);
 
-    expect(stack.isEmpty).toBe(true);
+    assert.isTrue(stack.isEmpty);
   });
 
   test('should handle mixed push and pop operations', () => {
@@ -145,7 +145,7 @@ describe('Stack test', () => {
 
     expect(Optional.unwrap(stack.pop())).toBe('a');
 
-    expect(stack.isEmpty).toBe(true);
+    assert.isTrue(stack.isEmpty);
   });
 
   test('should work with object types', () => {
@@ -166,7 +166,7 @@ describe('Stack test', () => {
 
     assert.deepStrictEqual(Optional.unwrap(stack.pop()), item1);
 
-    expect(stack.isEmpty).toBe(true);
+    assert.isTrue(stack.isEmpty);
   });
 
   test('should handle large number of operations efficiently', () => {
@@ -181,18 +181,18 @@ describe('Stack test', () => {
 
     expect(stack.size).toBe(n);
 
-    expect(stack.isEmpty).toBe(false);
+    assert.isFalse(stack.isEmpty);
 
     // Pop all elements and verify LIFO order
     for (const i of range(asSafeInt(n - 1), -1, -1)) {
       const result = stack.pop();
 
-      expect(Optional.isSome(result)).toBe(true);
+      assert.isTrue(Optional.isSome(result));
 
       expect(Optional.unwrap(result)).toBe(i);
     }
 
-    expect(stack.isEmpty).toBe(true);
+    assert.isTrue(stack.isEmpty);
 
     expect(stack.size).toBe(0);
   });
@@ -237,7 +237,7 @@ describe('Stack test', () => {
 
     expect(Optional.unwrap(stack.pop())).toBe('value');
 
-    expect(stack.isEmpty).toBe(true);
+    assert.isTrue(stack.isEmpty);
   });
 
   test('should maintain performance characteristics', () => {
@@ -288,6 +288,6 @@ describe('Stack test', () => {
       expect(Optional.unwrap(result)).toBe(i);
     }
 
-    expect(stack.isEmpty).toBe(true);
+    assert.isTrue(stack.isEmpty);
   });
 });

package/src/functional/match.mts

@@ -34,7 +34,7 @@ import { keyIsIn } from '../guard/index.mjs';
  *   published: 'Complete',
  * });
  *
- * assert(message === 'Work in progress');
+ * assert.isTrue(message === 'Work in progress');
  * ```
  *
  * @param target - The value to match against

package/src/functional/optional/impl/optional-expect-to-be.mts

@@ -11,13 +11,13 @@ import { type Unwrap } from './types.mjs';
  * ```ts
  * const optionalValue = Optional.some('data');
  *
- * assert(Optional.expectToBe(optionalValue, 'value expected') === 'data');
+ * assert.isTrue(Optional.expectToBe(optionalValue, 'value expected') === 'data');
  *
  * const expectValue = Optional.expectToBe<string>('missing optional');
  *
  * assert.throws(() => expectValue(Optional.none), /missing optional/u);
  *
- * assert(expectValue(Optional.some('present')) === 'present');
+ * assert.isTrue(expectValue(Optional.some('present')) === 'present');
  * ```
  *
  * @template O The `UnknownOptional` type to unwrap.

package/src/functional/optional/impl/optional-is-none.mts

@@ -11,7 +11,7 @@ import { type NarrowToNone } from './types.mjs';
  *
  * if (Optional.isNone(optionalValue)) {
  *   // Type narrowed to None
- *   assert.ok(true); // optionalValue is None
+ *   assert.isTrue(true); // optionalValue is None
  * }
  * ```
  *