ts-data-forge 5.0.1 → 5.1.1

package/src/collections/queue.mts

@@ -44,22 +44,30 @@ export type Queue<T> = Readonly<{
    * ```ts
    * const queue = createQueue<number>();
    *
-   * assert.ok(queue.isEmpty);
-   * assert(queue.size === 0);
+   * assert.isTrue(queue.isEmpty);
+   *
+   * assert.isTrue(queue.size === 0);
    *
    * queue.enqueue(1);
+   *
    * queue.enqueue(2);
    *
-   * assert.notOk(queue.isEmpty);
-   * assert(queue.size === 2);
+   * assert.isFalse(queue.isEmpty);
+   *
+   * assert.isTrue(queue.size === 2);
+   *
    * assert.deepStrictEqual(queue.dequeue(), Optional.some(1));
+   *
    * assert.deepStrictEqual(queue.dequeue(), Optional.some(2));
+   *
    * assert.deepStrictEqual(queue.dequeue(), Optional.none);
    *
    * const seededQueue = createQueue(['first', 'second']);
    *
-   * assert(seededQueue.size === 2);
+   * assert.isTrue(seededQueue.size === 2);
+   *
    * assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('first'));
+   *
    * assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('second'));
    * ```
    */
@@ -73,22 +81,30 @@ export type Queue<T> = Readonly<{
    * ```ts
    * const queue = createQueue<number>();
    *
-   * assert.ok(queue.isEmpty);
-   * assert(queue.size === 0);
+   * assert.isTrue(queue.isEmpty);
+   *
+   * assert.isTrue(queue.size === 0);
    *
    * queue.enqueue(1);
+   *
    * queue.enqueue(2);
    *
-   * assert.notOk(queue.isEmpty);
-   * assert(queue.size === 2);
+   * assert.isFalse(queue.isEmpty);
+   *
+   * assert.isTrue(queue.size === 2);
+   *
    * assert.deepStrictEqual(queue.dequeue(), Optional.some(1));
+   *
    * assert.deepStrictEqual(queue.dequeue(), Optional.some(2));
+   *
    * assert.deepStrictEqual(queue.dequeue(), Optional.none);
    *
    * const seededQueue = createQueue(['first', 'second']);
    *
-   * assert(seededQueue.size === 2);
+   * assert.isTrue(seededQueue.size === 2);
+   *
    * assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('first'));
+   *
    * assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('second'));
    * ```
    */
@@ -102,22 +118,30 @@ export type Queue<T> = Readonly<{
    * ```ts
    * const queue = createQueue<number>();
    *
-   * assert.ok(queue.isEmpty);
-   * assert(queue.size === 0);
+   * assert.isTrue(queue.isEmpty);
+   *
+   * assert.isTrue(queue.size === 0);
    *
    * queue.enqueue(1);
+   *
    * queue.enqueue(2);
    *
-   * assert.notOk(queue.isEmpty);
-   * assert(queue.size === 2);
+   * assert.isFalse(queue.isEmpty);
+   *
+   * assert.isTrue(queue.size === 2);
+   *
    * assert.deepStrictEqual(queue.dequeue(), Optional.some(1));
+   *
    * assert.deepStrictEqual(queue.dequeue(), Optional.some(2));
+   *
    * assert.deepStrictEqual(queue.dequeue(), Optional.none);
    *
    * const seededQueue = createQueue(['first', 'second']);
    *
-   * assert(seededQueue.size === 2);
+   * assert.isTrue(seededQueue.size === 2);
+   *
    * assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('first'));
+   *
    * assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('second'));
    * ```
    *
@@ -134,22 +158,30 @@ export type Queue<T> = Readonly<{
    * ```ts
    * const queue = createQueue<number>();
    *
-   * assert.ok(queue.isEmpty);
-   * assert(queue.size === 0);
+   * assert.isTrue(queue.isEmpty);
+   *
+   * assert.isTrue(queue.size === 0);
    *
    * queue.enqueue(1);
+   *
    * queue.enqueue(2);
    *
-   * assert.notOk(queue.isEmpty);
-   * assert(queue.size === 2);
+   * assert.isFalse(queue.isEmpty);
+   *
+   * assert.isTrue(queue.size === 2);
+   *
    * assert.deepStrictEqual(queue.dequeue(), Optional.some(1));
+   *
    * assert.deepStrictEqual(queue.dequeue(), Optional.some(2));
+   *
    * assert.deepStrictEqual(queue.dequeue(), Optional.none);
    *
    * const seededQueue = createQueue(['first', 'second']);
    *
-   * assert(seededQueue.size === 2);
+   * assert.isTrue(seededQueue.size === 2);
+   *
    * assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('first'));
+   *
    * assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('second'));
    * ```
    *
@@ -206,8 +238,11 @@ class QueueClass<T> implements Queue<T> {
     );
 
     this.#head = 0;
+
     this.#tail = 0;
+
     this.#mut_size = 0;
+
     this.#capacity = initialCapacity;
 
     // Add initial values
@@ -247,8 +282,11 @@ class QueueClass<T> implements Queue<T> {
 
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const element = this.#buffer[this.#head]!;
+
     this.#buffer[this.#head] = undefined; // Clear reference for garbage collection
+
     this.#head = (this.#head + 1) % this.#capacity;
+
     this.#mut_size -= 1;
 
     return Optional.some(element);
@@ -278,7 +316,9 @@ class QueueClass<T> implements Queue<T> {
     }
 
     this.#buffer[this.#tail] = value;
+
     this.#tail = (this.#tail + 1) % this.#capacity;
+
     this.#mut_size += 1;
   }
 
@@ -289,6 +329,7 @@ class QueueClass<T> implements Queue<T> {
    */
   #resize(): void {
     const newCapacity = asUint32(this.#capacity * 2);
+
     const newBuffer = Array.from<unknown, T | undefined>(
       { length: newCapacity },
       () => undefined,
@@ -297,12 +338,16 @@ class QueueClass<T> implements Queue<T> {
     // Copy elements in order from head to tail
     for (const i of range(asSafeUint(this.#mut_size))) {
       const sourceIndex = (this.#head + i) % this.#capacity;
+
       newBuffer[i] = this.#buffer[sourceIndex];
     }
 
     this.#buffer = newBuffer;
+
     this.#head = 0;
+
     this.#tail = this.#mut_size;
+
     this.#capacity = newCapacity;
   }
 }
@@ -336,22 +381,30 @@ class QueueClass<T> implements Queue<T> {
  * ```ts
  * const queue = createQueue<number>();
  *
- * assert.ok(queue.isEmpty);
- * assert(queue.size === 0);
+ * assert.isTrue(queue.isEmpty);
+ *
+ * assert.isTrue(queue.size === 0);
  *
  * queue.enqueue(1);
+ *
  * queue.enqueue(2);
  *
- * assert.notOk(queue.isEmpty);
- * assert(queue.size === 2);
+ * assert.isFalse(queue.isEmpty);
+ *
+ * assert.isTrue(queue.size === 2);
+ *
  * assert.deepStrictEqual(queue.dequeue(), Optional.some(1));
+ *
  * assert.deepStrictEqual(queue.dequeue(), Optional.some(2));
+ *
  * assert.deepStrictEqual(queue.dequeue(), Optional.none);
  *
  * const seededQueue = createQueue(['first', 'second']);
  *
- * assert(seededQueue.size === 2);
+ * assert.isTrue(seededQueue.size === 2);
+ *
  * assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('first'));
+ *
  * assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('second'));
  * ```
  *

package/src/collections/queue.test.mts

@@ -9,14 +9,16 @@ 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);
     });
 
     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);
     });
   });
@@ -32,12 +34,14 @@ 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);
     });
 
     test('should increase size when enqueueing to a non-empty queue', () => {
       mut_q.enqueue(1);
+
       mut_q.enqueue(2);
 
       expect(mut_q.size).toBe(2);
@@ -47,20 +51,24 @@ describe('Queue test', () => {
   describe('dequeue', () => {
     test('should return Optional.none and size should be 0 when dequeuing from an empty queue', () => {
       const q = createQueue<number>();
+
       const result = q.dequeue();
 
-      expect(Optional.isNone(result)).toBe(true);
-      expect(q.isEmpty).toBe(true);
+      assert.isTrue(Optional.isNone(result));
+
+      assert.isTrue(q.isEmpty);
+
       expect(q.size).toBe(0);
     });
 
     test('should decrease size and return the dequeued element for a non-empty queue', () => {
       const q = createQueue([1, 2, 3]); // FIFO: elements are in order [1, 2, 3]
+
       const initialSize = q.size;
 
       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);
@@ -70,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);
@@ -81,46 +89,56 @@ describe('Queue test', () => {
 
     test('should become empty after dequeuing all elements', () => {
       const q = createQueue([1, 2]); // Internal: [1, 2]
+
       q.dequeue(); // Dequeues 1
+
       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));
     });
   });
 
   describe('FIFO behavior', () => {
     test('elements should be dequeued in first-in, first-out order', () => {
       const q = createQueue<number>();
+
       q.enqueue(1); // internal: [1]
+
       q.enqueue(2); // internal: [1, 2]
+
       q.enqueue(3); // internal: [1, 2, 3]
 
       expect(q.size).toBe(3);
 
       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)', () => {
@@ -130,45 +148,47 @@ 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', () => {
       const q = createQueue<string>();
 
       q.enqueue('A');
+
       q.enqueue('B');
 
       const result1 = q.dequeue();
 
-      expect(Optional.isSome(result1) && result1.value === 'A').toBe(true);
+      assert.isTrue(Optional.isSome(result1) && result1.value === 'A');
 
       q.enqueue('C');
+
       q.enqueue('D');
 
       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);
     });
   });
 
@@ -183,22 +203,30 @@ describe('Queue test', () => {
 
       // Remove first 3 elements
       expect(Optional.unwrap(q.dequeue())).toBe(1);
+
       expect(Optional.unwrap(q.dequeue())).toBe(2);
+
       expect(Optional.unwrap(q.dequeue())).toBe(3);
 
       // Add more elements (this should wrap around in the buffer)
       q.enqueue(6);
+
       q.enqueue(7);
+
       q.enqueue(8);
 
       // Verify FIFO order is maintained
       expect(Optional.unwrap(q.dequeue())).toBe(4);
+
       expect(Optional.unwrap(q.dequeue())).toBe(5);
+
       expect(Optional.unwrap(q.dequeue())).toBe(6);
+
       expect(Optional.unwrap(q.dequeue())).toBe(7);
+
       expect(Optional.unwrap(q.dequeue())).toBe(8);
 
-      expect(q.isEmpty).toBe(true);
+      assert.isTrue(q.isEmpty);
     });
 
     test('should automatically resize when buffer becomes full', () => {
@@ -215,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', () => {
@@ -247,11 +275,12 @@ describe('Queue test', () => {
       for (const i of range(51, 101)) {
         expect(Optional.unwrap(q.dequeue())).toBe(i);
       }
+
       for (const i of range(101, 151)) {
         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', () => {
@@ -265,15 +294,15 @@ describe('Queue test', () => {
 
         const result = q.dequeue();
 
-        expect(Optional.isSome(result) && result.value === `item-${i}`).toBe(
-          true,
-        );
-        expect(q.isEmpty).toBe(true);
+        assert.isTrue(Optional.isSome(result) && result.value === `item-${i}`);
+
+        assert.isTrue(q.isEmpty);
       }
     });
 
     test('should handle large initial values array', () => {
       const largeArray = Arr.range(1, asUint32(51));
+
       const q = createQueue(largeArray);
 
       expect(q.size).toBe(50);
@@ -283,11 +312,12 @@ 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', () => {
       const q = createQueue<{ id: number }>();
+
       const objects = Arr.seq(10).map((i) => ({ id: i }));
 
       // Add all objects
@@ -299,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);
     });
   });
 });