ts-data-forge 5.0.1 → 5.1.1

package/src/collections/stack.mts

@@ -44,22 +44,29 @@ export type Stack<T> = Readonly<{
    * ```ts
    * const stack = createStack<string>();
    *
-   * assert.ok(stack.isEmpty);
-   * assert(stack.size === 0);
+   * assert.isTrue(stack.isEmpty);
+   *
+   * assert.isTrue(stack.size === 0);
    *
    * stack.push('first');
+   *
    * // eslint-disable-next-line unicorn/prefer-single-call
    * stack.push('second');
    *
-   * assert.notOk(stack.isEmpty);
-   * assert(stack.size === 2);
+   * assert.isFalse(stack.isEmpty);
+   *
+   * assert.isTrue(stack.size === 2);
+   *
    * assert.deepStrictEqual(stack.pop(), Optional.some('second'));
+   *
    * assert.deepStrictEqual(stack.pop(), Optional.some('first'));
+   *
    * assert.deepStrictEqual(stack.pop(), Optional.none);
    *
    * const seededStack = createStack([10, 20, 30]);
    *
-   * assert(seededStack.size === 3);
+   * assert.isTrue(seededStack.size === 3);
+   *
    * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));
    * ```
    */
@@ -73,22 +80,29 @@ export type Stack<T> = Readonly<{
    * ```ts
    * const stack = createStack<string>();
    *
-   * assert.ok(stack.isEmpty);
-   * assert(stack.size === 0);
+   * assert.isTrue(stack.isEmpty);
+   *
+   * assert.isTrue(stack.size === 0);
    *
    * stack.push('first');
+   *
    * // eslint-disable-next-line unicorn/prefer-single-call
    * stack.push('second');
    *
-   * assert.notOk(stack.isEmpty);
-   * assert(stack.size === 2);
+   * assert.isFalse(stack.isEmpty);
+   *
+   * assert.isTrue(stack.size === 2);
+   *
    * assert.deepStrictEqual(stack.pop(), Optional.some('second'));
+   *
    * assert.deepStrictEqual(stack.pop(), Optional.some('first'));
+   *
    * assert.deepStrictEqual(stack.pop(), Optional.none);
    *
    * const seededStack = createStack([10, 20, 30]);
    *
-   * assert(seededStack.size === 3);
+   * assert.isTrue(seededStack.size === 3);
+   *
    * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));
    * ```
    */
@@ -102,22 +116,29 @@ export type Stack<T> = Readonly<{
    * ```ts
    * const stack = createStack<string>();
    *
-   * assert.ok(stack.isEmpty);
-   * assert(stack.size === 0);
+   * assert.isTrue(stack.isEmpty);
+   *
+   * assert.isTrue(stack.size === 0);
    *
    * stack.push('first');
+   *
    * // eslint-disable-next-line unicorn/prefer-single-call
    * stack.push('second');
    *
-   * assert.notOk(stack.isEmpty);
-   * assert(stack.size === 2);
+   * assert.isFalse(stack.isEmpty);
+   *
+   * assert.isTrue(stack.size === 2);
+   *
    * assert.deepStrictEqual(stack.pop(), Optional.some('second'));
+   *
    * assert.deepStrictEqual(stack.pop(), Optional.some('first'));
+   *
    * assert.deepStrictEqual(stack.pop(), Optional.none);
    *
    * const seededStack = createStack([10, 20, 30]);
    *
-   * assert(seededStack.size === 3);
+   * assert.isTrue(seededStack.size === 3);
+   *
    * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));
    * ```
    *
@@ -134,22 +155,29 @@ export type Stack<T> = Readonly<{
    * ```ts
    * const stack = createStack<string>();
    *
-   * assert.ok(stack.isEmpty);
-   * assert(stack.size === 0);
+   * assert.isTrue(stack.isEmpty);
+   *
+   * assert.isTrue(stack.size === 0);
    *
    * stack.push('first');
+   *
    * // eslint-disable-next-line unicorn/prefer-single-call
    * stack.push('second');
    *
-   * assert.notOk(stack.isEmpty);
-   * assert(stack.size === 2);
+   * assert.isFalse(stack.isEmpty);
+   *
+   * assert.isTrue(stack.size === 2);
+   *
    * assert.deepStrictEqual(stack.pop(), Optional.some('second'));
+   *
    * assert.deepStrictEqual(stack.pop(), Optional.some('first'));
+   *
    * assert.deepStrictEqual(stack.pop(), Optional.none);
    *
    * const seededStack = createStack([10, 20, 30]);
    *
-   * assert(seededStack.size === 3);
+   * assert.isTrue(seededStack.size === 3);
+   *
    * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));
    * ```
    *
@@ -197,7 +225,9 @@ class StackClass<T> implements Stack<T> {
       { length: initialCapacity },
       () => undefined,
     );
+
     this.#mut_size = asUint32(0);
+
     this.#capacity = initialCapacity;
 
     // Add initial values
@@ -236,8 +266,10 @@ class StackClass<T> implements Stack<T> {
     }
 
     this.#mut_size = Uint32.sub(this.#mut_size, 1);
+
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const element = this.#buffer[this.#mut_size]!;
+
     this.#buffer[this.#mut_size] = undefined; // Clear reference for garbage collection
 
     return Optional.some(element);
@@ -267,6 +299,7 @@ class StackClass<T> implements Stack<T> {
     }
 
     this.#buffer[this.#mut_size] = value;
+
     this.#mut_size = Uint32.add(this.#mut_size, 1);
   }
 
@@ -277,6 +310,7 @@ class StackClass<T> implements Stack<T> {
    */
   #resize(): void {
     const newCapacity = asUint32(this.#capacity * 2);
+
     const newBuffer = Array.from<unknown, T | undefined>(
       { length: newCapacity },
       () => undefined,
@@ -288,6 +322,7 @@ class StackClass<T> implements Stack<T> {
     }
 
     this.#buffer = newBuffer;
+
     this.#capacity = newCapacity;
   }
 }
@@ -321,22 +356,29 @@ class StackClass<T> implements Stack<T> {
  * ```ts
  * const stack = createStack<string>();
  *
- * assert.ok(stack.isEmpty);
- * assert(stack.size === 0);
+ * assert.isTrue(stack.isEmpty);
+ *
+ * assert.isTrue(stack.size === 0);
  *
  * stack.push('first');
+ *
  * // eslint-disable-next-line unicorn/prefer-single-call
  * stack.push('second');
  *
- * assert.notOk(stack.isEmpty);
- * assert(stack.size === 2);
+ * assert.isFalse(stack.isEmpty);
+ *
+ * assert.isTrue(stack.size === 2);
+ *
  * assert.deepStrictEqual(stack.pop(), Optional.some('second'));
+ *
  * assert.deepStrictEqual(stack.pop(), Optional.some('first'));
+ *
  * assert.deepStrictEqual(stack.pop(), Optional.none);
  *
  * 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

@@ -9,56 +9,74 @@ describe('Stack test', () => {
     const stack = createStack<number>();
 
     expectType<typeof stack, Stack<number>>('=');
+
     expectType<typeof stack.isEmpty, boolean>('=');
+
     expectType<typeof stack.size, SizeType.Arr>('=');
+
     expectType<typeof stack.pop, () => Optional<number>>('=');
+
     expectType<typeof stack.push, (value: number) => void>('=');
 
     // Verify the type checking works at runtime too
     expectTypeOf(stack.isEmpty).toBeBoolean();
+
     expectTypeOf(stack.size).toBeNumber();
+
     expectTypeOf(stack.pop).toBeFunction();
+
     expectTypeOf(stack.push).toBeFunction();
   });
 
   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);
   });
 
   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);
 
     // Last element should be on top (LIFO)
     expect(Optional.unwrap(stack.pop())).toBe(3);
+
     expect(Optional.unwrap(stack.pop())).toBe(2);
+
     expect(Optional.unwrap(stack.pop())).toBe(1);
-    expect(stack.isEmpty).toBe(true);
+
+    assert.isTrue(stack.isEmpty);
   });
 
   test('should implement LIFO behavior correctly', () => {
     const stack = createStack<string>();
 
     stack.push('first');
+
     // eslint-disable-next-line unicorn/prefer-single-call
     stack.push('second');
+
     // eslint-disable-next-line unicorn/prefer-single-call
     stack.push('third');
 
     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');
+
     expect(Optional.unwrap(stack.pop())).toBe('second');
+
     expect(Optional.unwrap(stack.pop())).toBe('first');
 
-    expect(stack.isEmpty).toBe(true);
+    assert.isTrue(stack.isEmpty);
+
     expect(stack.size).toBe(0);
   });
 
@@ -67,8 +85,10 @@ describe('Stack test', () => {
 
     const result = stack.pop();
 
-    expect(Optional.isNone(result)).toBe(true);
-    expect(stack.isEmpty).toBe(true);
+    assert.isTrue(Optional.isNone(result));
+
+    assert.isTrue(stack.isEmpty);
+
     expect(stack.size).toBe(0);
   });
 
@@ -100,48 +120,58 @@ describe('Stack test', () => {
     Optional.unwrap(stack.pop());
 
     expect(stack.size).toBe(0);
-    expect(stack.isEmpty).toBe(true);
+
+    assert.isTrue(stack.isEmpty);
   });
 
   test('should handle mixed push and pop operations', () => {
     const stack = createStack<string>();
 
     stack.push('a');
+
     // eslint-disable-next-line unicorn/prefer-single-call
     stack.push('b');
 
     expect(Optional.unwrap(stack.pop())).toBe('b');
 
     stack.push('c');
+
     // eslint-disable-next-line unicorn/prefer-single-call
     stack.push('d');
 
     expect(Optional.unwrap(stack.pop())).toBe('d');
+
     expect(Optional.unwrap(stack.pop())).toBe('c');
+
     expect(Optional.unwrap(stack.pop())).toBe('a');
 
-    expect(stack.isEmpty).toBe(true);
+    assert.isTrue(stack.isEmpty);
   });
 
   test('should work with object types', () => {
     type Item = Readonly<{ id: number; name: string }>;
+
     const stack = createStack<Item>();
 
     const item1: Item = { id: 1, name: 'first' };
+
     const item2: Item = { id: 2, name: 'second' };
 
     stack.push(item1);
+
     // eslint-disable-next-line unicorn/prefer-single-call
     stack.push(item2);
 
     assert.deepStrictEqual(Optional.unwrap(stack.pop()), item2);
+
     assert.deepStrictEqual(Optional.unwrap(stack.pop()), item1);
 
-    expect(stack.isEmpty).toBe(true);
+    assert.isTrue(stack.isEmpty);
   });
 
   test('should handle large number of operations efficiently', () => {
     const stack = createStack<number>();
+
     const n = asPositiveSafeInt(10_000);
 
     // Push many elements
@@ -150,28 +180,33 @@ 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);
   });
 
   test('should not mutate initial values array', () => {
     const initialValues = [1, 2, 3];
+
     const originalLength = initialValues.length;
 
     const stack = createStack(initialValues);
 
     // Modify stack
     stack.push(4);
+
     Optional.unwrap(stack.pop());
 
     // Original array should be unchanged
@@ -184,18 +219,25 @@ describe('Stack test', () => {
     const stack = createStack<string | null | undefined>();
 
     stack.push('value');
+
     // eslint-disable-next-line unicorn/prefer-single-call
     stack.push(null);
+
     // eslint-disable-next-line unicorn/prefer-single-call
     stack.push(undefined);
+
     // eslint-disable-next-line unicorn/prefer-single-call
     stack.push('another');
 
     expect(Optional.unwrap(stack.pop())).toBe('another');
+
     expect(Optional.unwrap(stack.pop())).toBeUndefined();
+
     expect(Optional.unwrap(stack.pop())).toBeNull();
+
     expect(Optional.unwrap(stack.pop())).toBe('value');
-    expect(stack.isEmpty).toBe(true);
+
+    assert.isTrue(stack.isEmpty);
   });
 
   test('should maintain performance characteristics', () => {
@@ -215,6 +257,7 @@ describe('Stack test', () => {
     }
 
     const endTime = performance.now();
+
     const duration = endTime - startTime;
 
     // Should complete in reasonable time (much less than 100ms for 512 operations)
@@ -226,6 +269,7 @@ describe('Stack test', () => {
 
     for (const i of range(100)) {
       stack.push(i);
+
       if (i % 2 === 1) {
         // Pop every other time
         const result = stack.pop();
@@ -244,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
@@ -70,10 +70,13 @@ export function match<
   switch (args.length) {
     case 2: {
       const [target, cases] = args;
+
       return cases[target];
     }
+
     case 3: {
       const [target, cases, defaultValue] = args;
+
       return keyIsIn(target, cases) ? cases[target] : defaultValue;
     }
   }
@@ -102,8 +105,11 @@ type AllCasesCovered<Case extends PropertyKey, R> =
   TypeEq<Case, keyof R> extends true ? true : false;
 
 expectType<AllCasesCovered<'a' | 'b', { a: 1; b: 2 }>, true>('=');
+
 expectType<AllCasesCovered<'a' | 'b' | 'c', { a: 1; b: 2 }>, false>('=');
+
 expectType<AllCasesCovered<'a' | 'b', { a: 1; b: 2; c: 3 }>, false>('=');
+
 expectType<AllCasesCovered<string, Record<string, string>>, true>('=');
 
 /**
@@ -121,15 +127,19 @@ type IsLiteralUnionFullyCovered<
     : false;
 
 expectType<IsLiteralUnionFullyCovered<'a' | 'b', { a: 1; b: 2 }>, true>('=');
+
 expectType<IsLiteralUnionFullyCovered<'a' | 'b' | 'c', { a: 1; b: 2 }>, false>(
   '=',
 );
+
 expectType<IsLiteralUnionFullyCovered<'a' | 'b', { a: 1; b: 2; c: 3 }>, false>(
   '=',
 );
+
 expectType<IsLiteralUnionFullyCovered<string, Record<string, string>>, false>(
   '=',
 );
+
 expectType<
   // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
   IsLiteralUnionFullyCovered<'a' | 'b' | string, { a: 1; b: 2 }>,
@@ -152,9 +162,15 @@ type IsLiteralType<T extends PropertyKey> = string extends T
       : true;
 
 expectType<IsLiteralType<'a' | 'b'>, true>('=');
+
 expectType<IsLiteralType<'a'>, true>('=');
+
 expectType<IsLiteralType<string>, false>('=');
+
 expectType<IsLiteralType<number>, false>('=');
+
 expectType<IsLiteralType<1>, true>('=');
+
 expectType<IsLiteralType<number | 'aa'>, false>('=');
+
 expectType<IsLiteralType<'aa' | 32>, true>('=');

package/src/functional/match.test.mts

@@ -3,6 +3,7 @@ import { match } from './match.mjs';
 
 describe(match, () => {
   type Direction = 'E' | 'N' | 'S' | 'W';
+
   const direction: Direction = 'N' as Direction;
 
   test('literal union', () => {
@@ -159,6 +160,7 @@ describe(match, () => {
 
   test('with default case - string key missing', () => {
     const unknownDirection = 'X' as string;
+
     const res = match(
       unknownDirection,
       {

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

@@ -11,12 +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.
@@ -41,12 +42,14 @@ export function expectToBe<O extends UnknownOptional>(
   switch (args.length) {
     case 2: {
       const [optional, message] = args;
+
       return expectToBeImpl(optional, message);
     }
 
     case 1: {
       // Curried version: first argument is message
       const [message] = args;
+
       return (optional: Optional<Unwrap<O>>): Unwrap<O> =>
         expectToBeImpl(optional, message);
     }

package/src/functional/optional/impl/optional-filter.mts

@@ -13,14 +13,17 @@ import { type Unwrap } from './types.mjs';
  *
  * ```ts
  * const even = Optional.filter(Optional.some(4), (value) => value % 2 === 0);
+ *
  * const odd = Optional.filter(Optional.some(3), (value) => value % 2 === 0);
  *
  * assert.deepStrictEqual(even, Optional.some(4));
+ *
  * assert.deepStrictEqual(odd, Optional.none);
  *
  * const filterEven = Optional.filter((value: number) => value % 2 === 0);
  *
  * assert.deepStrictEqual(filterEven(Optional.some(6)), Optional.some(6));
+ *
  * assert.deepStrictEqual(filterEven(Optional.some(5)), Optional.none);
  * ```
  *
@@ -47,12 +50,14 @@ export function filter<O extends UnknownOptional>(
   switch (args.length) {
     case 2: {
       const [optional, predicate] = args;
+
       return filterImpl(optional, predicate);
     }
 
     case 1: {
       // Curried version: first argument is predicate function
       const [predicate] = args;
+
       return (optional: O) => filterImpl(optional, predicate);
     }
   }
@@ -64,6 +69,7 @@ const filterImpl = <O extends UnknownOptional>(
 ): Optional<Unwrap<O>> => {
   if (isSome(optional)) {
     const value = unwrap(optional);
+
     return predicate(value) ? some(value) : none;
   }
 

package/src/functional/optional/impl/optional-flat-map.mts

@@ -13,6 +13,7 @@ import { type Unwrap } from './types.mjs';
  * ```ts
  * const parseNumber = (input: string): Optional<number> => {
  *   const num = Number.parseInt(input, 10);
+ *
  *   return Number.isNaN(num) ? Optional.none : Optional.some(num);
  * };
  *
@@ -23,6 +24,7 @@ import { type Unwrap } from './types.mjs';
  * const flatMapParse = Optional.flatMap(parseNumber);
  *
  * assert.deepStrictEqual(flatMapParse(Optional.some('5')), Optional.some(5));
+ *
  * assert.deepStrictEqual(flatMapParse(Optional.some('invalid')), Optional.none);
  * ```
  *
@@ -50,12 +52,14 @@ export function flatMap<O extends UnknownOptional, S2>(
   switch (args.length) {
     case 2: {
       const [optional, flatMapFn] = args;
+
       return flatMapImpl(optional, flatMapFn);
     }
 
     case 1: {
       // Curried version
       const [flatMapFn] = args;
+
       return (optional: O) => flatMapImpl(optional, flatMapFn);
     }
   }

package/src/functional/optional/impl/optional-from-nullable.mts

@@ -12,9 +12,11 @@ import { some } from './optional-some.mjs';
  *
  * ```ts
  * const present = Optional.fromNullable('hello');
+ *
  * const absent = Optional.fromNullable<string | null>(null);
  *
  * assert.deepStrictEqual(present, Optional.some('hello'));
+ *
  * assert.deepStrictEqual(absent, Optional.none);
  * ```
  *

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
  * }
  * ```
  *

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

@@ -8,10 +8,12 @@ import { NoneTypeTagName, SomeTypeTagName } from './tag.mjs';
  *
  * ```ts
  * const maybeOptional = Optional.some('value');
+ *
  * const notOptional = { $$tag: 'ts-data-forge::Optional.some' };
  *
- * assert.ok(Optional.isOptional(maybeOptional));
- * assert.notOk(Optional.isOptional(notOptional));
+ * assert.isTrue(Optional.isOptional(maybeOptional));
+ *
+ * assert.isFalse(Optional.isOptional(notOptional));
  * ```
  *
  * @param maybeOptional The value to check.

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

@@ -11,7 +11,8 @@ import { type NarrowToSome } from './types.mjs';
  *
  * if (Optional.isSome(optionalNumber)) {
  *   const value: number = optionalNumber.value;
- *   assert(value === 42);
+ *
+ *   assert.isTrue(value === 42);
  * }
  * ```
  *