ts-data-forge 4.1.0 → 5.0.1

package/src/collections/queue.test.mts

@@ -4,16 +4,18 @@ import { range } from '../iterator/index.mjs';
 import { asUint32 } from '../number/index.mjs';
 import { createQueue, type Queue } from './queue.mjs';
 
-describe('Queue', () => {
+describe('Queue test', () => {
   describe('initialization', () => {
     test('should be empty if initialized without values', () => {
       const q = createQueue();
+
       expect(q.isEmpty).toBe(true);
       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);
       expect(q.size).toBe(3);
     });
@@ -29,6 +31,7 @@ describe('Queue', () => {
 
     test('should increase size and not be empty after enqueueing to an empty queue', () => {
       mut_q.enqueue(1);
+
       expect(mut_q.isEmpty).toBe(false);
       expect(mut_q.size).toBe(1);
     });
@@ -36,6 +39,7 @@ describe('Queue', () => {
     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);
     });
   });
@@ -44,6 +48,7 @@ describe('Queue', () => {
     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);
       expect(q.size).toBe(0);
@@ -54,17 +59,23 @@ describe('Queue', () => {
       const initialSize = q.size;
 
       const result1 = q.dequeue(); // Dequeues 1 (first element)
+
       expect(Optional.isSome(result1)).toBe(true);
+
       if (Optional.isSome(result1)) {
         expect(result1.value).toBe(1);
       }
+
       expect(q.size).toBe(initialSize - 1);
 
       const result2 = q.dequeue(); // Dequeues 2
+
       expect(Optional.isSome(result2)).toBe(true);
+
       if (Optional.isSome(result2)) {
         expect(result2.value).toBe(2);
       }
+
       expect(q.size).toBe(initialSize - 2);
     });
 
@@ -72,9 +83,12 @@ describe('Queue', () => {
       const q = createQueue([1, 2]); // Internal: [1, 2]
       q.dequeue(); // Dequeues 1
       q.dequeue(); // Dequeues 2
+
       expect(q.isEmpty).toBe(true);
       expect(q.size).toBe(0);
+
       const result = q.dequeue(); // Dequeue from empty
+
       expect(Optional.isNone(result)).toBe(true);
     });
   });
@@ -89,33 +103,41 @@ describe('Queue', () => {
       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);
       expect(q.size).toBe(2);
 
       mut_result = q.dequeue(); // Dequeues 2
+
       expect(Optional.isSome(mut_result) && mut_result.value === 2).toBe(true);
       expect(q.size).toBe(1);
 
       mut_result = q.dequeue(); // Dequeues 3
+
       expect(Optional.isSome(mut_result) && mut_result.value === 3).toBe(true);
       expect(q.size).toBe(0);
       expect(q.isEmpty).toBe(true);
 
       mut_result = q.dequeue();
+
       expect(Optional.isNone(mut_result)).toBe(true);
     });
 
     test('initial values are dequeued in the same order (FIFO)', () => {
       const q = createQueue([1, 2, 3]); // Internal: [1, 2, 3]
+
       expect(q.size).toBe(3);
 
       const result1 = q.dequeue(); // Dequeues 1 (first element)
+
       expect(Optional.isSome(result1) && result1.value === 1).toBe(true);
 
       const result2 = q.dequeue(); // Dequeues 2
+
       expect(Optional.isSome(result2) && result2.value === 2).toBe(true);
 
       const result3 = q.dequeue(); // Dequeues 3
+
       expect(Optional.isSome(result3) && result3.value === 3).toBe(true);
 
       expect(q.isEmpty).toBe(true);
@@ -128,18 +150,22 @@ describe('Queue', () => {
       q.enqueue('B');
 
       const result1 = q.dequeue();
+
       expect(Optional.isSome(result1) && result1.value === 'A').toBe(true);
 
       q.enqueue('C');
       q.enqueue('D');
 
       const result2 = q.dequeue();
+
       expect(Optional.isSome(result2) && result2.value === 'B').toBe(true);
 
       const result3 = q.dequeue();
+
       expect(Optional.isSome(result3) && result3.value === 'C').toBe(true);
 
       const result4 = q.dequeue();
+
       expect(Optional.isSome(result4) && result4.value === 'D').toBe(true);
 
       expect(q.isEmpty).toBe(true);
@@ -188,6 +214,7 @@ describe('Queue', () => {
       // Verify all elements can be dequeued in correct order
       for (const i of range(1, 21)) {
         const result = q.dequeue();
+
         expect(Optional.isSome(result) && result.value === i).toBe(true);
       }
 
@@ -233,9 +260,11 @@ describe('Queue', () => {
       // Test single element enqueue/dequeue cycles
       for (const i of range(10)) {
         q.enqueue(`item-${i}`);
+
         expect(q.size).toBe(1);
 
         const result = q.dequeue();
+
         expect(Optional.isSome(result) && result.value === `item-${i}`).toBe(
           true,
         );
@@ -269,12 +298,14 @@ describe('Queue', () => {
       // Remove first 5 objects
       for (const i of range(0, 5)) {
         const result = q.dequeue();
+
         expect(Optional.isSome(result) && result.value.id === i).toBe(true);
       }
 
       // 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);
       }
 

package/src/collections/stack.test.mts

@@ -4,7 +4,7 @@ import { range } from '../iterator/index.mjs';
 import { asPositiveSafeInt, asSafeInt } from '../number/index.mjs';
 import { createStack, type Stack } from './stack.mjs';
 
-describe('Stack', () => {
+describe('Stack test', () => {
   test('should have correct type definitions', () => {
     const stack = createStack<number>();
 
@@ -15,10 +15,10 @@ describe('Stack', () => {
     expectType<typeof stack.push, (value: number) => void>('=');
 
     // Verify the type checking works at runtime too
-    expect(typeof stack.isEmpty).toBe('boolean');
-    expect(typeof stack.size).toBe('number');
-    expect(typeof stack.pop).toBe('function');
-    expect(typeof stack.push).toBe('function');
+    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', () => {
@@ -66,6 +66,7 @@ describe('Stack', () => {
     const stack = createStack<number>();
 
     const result = stack.pop();
+
     expect(Optional.isNone(result)).toBe(true);
     expect(stack.isEmpty).toBe(true);
     expect(stack.size).toBe(0);
@@ -77,21 +78,27 @@ describe('Stack', () => {
     expect(stack.size).toBe(0);
 
     stack.push(1);
+
     expect(stack.size).toBe(1);
 
     stack.push(2);
+
     expect(stack.size).toBe(2);
 
     stack.push(3);
+
     expect(stack.size).toBe(3);
 
     Optional.unwrap(stack.pop());
+
     expect(stack.size).toBe(2);
 
     Optional.unwrap(stack.pop());
+
     expect(stack.size).toBe(1);
 
     Optional.unwrap(stack.pop());
+
     expect(stack.size).toBe(0);
     expect(stack.isEmpty).toBe(true);
   });
@@ -102,11 +109,13 @@ describe('Stack', () => {
     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');
@@ -125,8 +134,9 @@ describe('Stack', () => {
     // eslint-disable-next-line unicorn/prefer-single-call
     stack.push(item2);
 
-    expect(Optional.unwrap(stack.pop())).toStrictEqual(item2);
-    expect(Optional.unwrap(stack.pop())).toStrictEqual(item1);
+    assert.deepStrictEqual(Optional.unwrap(stack.pop()), item2);
+    assert.deepStrictEqual(Optional.unwrap(stack.pop()), item1);
+
     expect(stack.isEmpty).toBe(true);
   });
 
@@ -145,6 +155,7 @@ describe('Stack', () => {
     // 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);
       expect(Optional.unwrap(result)).toBe(i);
     }
@@ -165,7 +176,8 @@ describe('Stack', () => {
 
     // Original array should be unchanged
     expect(initialValues).toHaveLength(originalLength);
-    expect(initialValues).toStrictEqual([1, 2, 3]);
+
+    assert.deepStrictEqual(initialValues, [1, 2, 3]);
   });
 
   test('should work with undefined and null values', () => {
@@ -217,6 +229,7 @@ describe('Stack', () => {
       if (i % 2 === 1) {
         // Pop every other time
         const result = stack.pop();
+
         expect(Optional.unwrap(result)).toBe(i);
       }
     }
@@ -227,6 +240,7 @@ describe('Stack', () => {
     // Verify elements are in correct LIFO order
     for (const i of range(98, -1, -2)) {
       const result = stack.pop();
+
       expect(Optional.unwrap(result)).toBe(i);
     }
 

package/src/functional/match.test.mts

@@ -1,7 +1,7 @@
 import { expectType } from '../expect-type.mjs';
 import { match } from './match.mjs';
 
-describe('match', () => {
+describe(match, () => {
   type Direction = 'E' | 'N' | 'S' | 'W';
   const direction: Direction = 'N' as Direction;
 

package/src/functional/optional.test.mts

@@ -2,7 +2,7 @@ import { expectType } from '../expect-type.mjs';
 import { Optional } from './optional/index.mjs';
 import { pipe } from './pipe.mjs';
 
-describe('Optional', () => {
+describe('Optional test', () => {
   describe('isOptional', () => {
     test('should return true for Some values', () => {
       expect(Optional.isOptional(Optional.some(42))).toBe(true);
@@ -28,16 +28,20 @@ describe('Optional', () => {
   describe('some', () => {
     test('should create a Some variant with the provided value', () => {
       const someNumber = Optional.some(42);
+
       expect(Optional.isSome(someNumber)).toBe(true);
       expect(Optional.unwrap(someNumber)).toBe(42);
 
       const someString = Optional.some('hello');
+
       expect(Optional.isSome(someString)).toBe(true);
       expect(Optional.unwrap(someString)).toBe('hello');
 
       const someObject = Optional.some({ name: 'Alice', age: 30 });
+
       expect(Optional.isSome(someObject)).toBe(true);
-      expect(Optional.unwrap(someObject)).toStrictEqual({
+
+      assert.deepStrictEqual(Optional.unwrap(someObject), {
         name: 'Alice',
         age: 30,
       });
@@ -66,12 +70,14 @@ describe('Optional', () => {
   describe('isSome and isNone', () => {
     test('should correctly identify Some values', () => {
       const some = Optional.some(42);
+
       expect(Optional.isSome(some)).toBe(true);
       expect(Optional.isNone(some)).toBe(false);
     });
 
     test('should correctly identify None values', () => {
       const none = Optional.none;
+
       expect(Optional.isSome(none)).toBe(false);
       expect(Optional.isNone(none)).toBe(true);
     });
@@ -95,6 +101,7 @@ describe('Optional', () => {
       const mapped = Optional.map(some, (x) => x * 2);
 
       expect(Optional.isSome(mapped)).toBe(true);
+
       if (Optional.isSome(mapped)) {
         expect(Optional.unwrap(mapped)).toBe(10);
       }
@@ -120,6 +127,7 @@ describe('Optional', () => {
 
     test('should preserve types correctly', () => {
       const some = Optional.some(42);
+
       expectTypeOf(Optional.map(some, (x) => x.toString())).toEqualTypeOf<
         Optional<string>
       >();
@@ -132,12 +140,14 @@ describe('Optional', () => {
       const mapped = doubler(some);
 
       expect(Optional.isSome(mapped)).toBe(true);
+
       if (Optional.isSome(mapped)) {
         expect(Optional.unwrap(mapped)).toBe(10);
       }
 
       const none = Optional.none;
       const mappedNone = doubler(none);
+
       expect(Optional.isNone(mappedNone)).toBe(true);
     });
 
@@ -148,6 +158,7 @@ describe('Optional', () => {
       const result = pipe(Optional.some(5)).map(doubler).map(toStringFn).value;
 
       expect(Optional.isSome(result)).toBe(true);
+
       if (Optional.isSome(result)) {
         expect(Optional.unwrap(result)).toBe('10');
       }
@@ -168,9 +179,11 @@ describe('Optional', () => {
 
     test('should have correct return types', () => {
       const someNumber = Optional.some(42);
+
       expectTypeOf(Optional.unwrap(someNumber)).toExtend<number | undefined>();
 
       const none = Optional.none;
+
       // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
       expectTypeOf(Optional.unwrapOr(none, undefined)).toExtend<undefined>();
     });
@@ -190,6 +203,7 @@ describe('Optional', () => {
 
     test('should have correct return types', () => {
       const someNumber = Optional.some(42);
+
       expectTypeOf(Optional.unwrapThrow(someNumber)).toExtend<number>();
     });
   });
@@ -209,6 +223,7 @@ describe('Optional', () => {
 
     test('should have correct return types', () => {
       const someNumber = Optional.some(42);
+
       expectTypeOf(Optional.unwrapOr(someNumber, 0)).toExtend<number>();
 
       expectTypeOf(Optional.unwrapOr(someNumber, 'default')).toExtend<
@@ -216,6 +231,7 @@ describe('Optional', () => {
       >();
 
       const none = Optional.none;
+
       expectTypeOf(Optional.unwrapOr(none, 'default')).toExtend<string>();
     });
 
@@ -224,10 +240,12 @@ describe('Optional', () => {
 
       const someValue = Optional.some(100);
       const result = unwrapWithDefault(someValue);
+
       expect(result).toBe(100);
 
       const noneValue = Optional.none;
       const defaultResult = unwrapWithDefault(noneValue);
+
       expect(defaultResult).toBe(42);
     });
 
@@ -237,9 +255,11 @@ describe('Optional', () => {
       const someResult = pipe(Optional.some('hello')).map(
         unwrapWithDefault,
       ).value;
+
       expect(someResult).toBe('hello');
 
       const noneResult = pipe(Optional.none).map(unwrapWithDefault).value;
+
       expect(noneResult).toBe('default');
     });
   });
@@ -247,11 +267,13 @@ describe('Optional', () => {
   describe('expectToBe', () => {
     test('should return the value for Some', () => {
       const expectNumber = Optional.expectToBe<number>('Expected a number');
+
       expect(expectNumber(Optional.some(42))).toBe(42);
     });
 
     test('should throw with custom message for None', () => {
       const expectNumber = Optional.expectToBe<number>('Expected a number');
+
       expect(() => expectNumber(Optional.none)).toThrow('Expected a number');
     });
 
@@ -270,9 +292,11 @@ describe('Optional', () => {
 
       const someValue = Optional.some('important data');
       const result = getValue(someValue);
+
       expect(result).toBe('important data');
 
       const noneValue = Optional.none;
+
       expect(() => getValue(noneValue)).toThrow('Value must exist');
     });
 
@@ -282,7 +306,8 @@ describe('Optional', () => {
       const someResult = pipe(Optional.some({ name: 'Alice', age: 30 })).map(
         expectUser,
       ).value;
-      expect(someResult).toStrictEqual({ name: 'Alice', age: 30 });
+
+      assert.deepStrictEqual(someResult, { name: 'Alice', age: 30 });
 
       expect(() => pipe(Optional.none).map(expectUser).value).toThrow(
         'User not found',
@@ -324,6 +349,7 @@ describe('Optional', () => {
       }
 
       const invalid = Optional.flatMap(Optional.some('abc'), parseNumber);
+
       expect(Optional.isNone(invalid)).toBe(true);
     });
 
@@ -331,6 +357,7 @@ describe('Optional', () => {
       const result = Optional.flatMap(Optional.none, (_: never) =>
         Optional.some(42),
       );
+
       expect(Optional.isNone(result)).toBe(true);
     });
 
@@ -364,15 +391,19 @@ describe('Optional', () => {
       const parser = Optional.flatMap(parseNumber);
 
       const result = parser(Optional.some('42'));
+
       expect(Optional.isSome(result)).toBe(true);
+
       if (Optional.isSome(result)) {
         expect(Optional.unwrap(result)).toBe(42);
       }
 
       const invalid = parser(Optional.some('abc'));
+
       expect(Optional.isNone(invalid)).toBe(true);
 
       const noneResult = parser(Optional.none);
+
       expect(Optional.isNone(noneResult)).toBe(true);
     });
 
@@ -391,6 +422,7 @@ describe('Optional', () => {
       const result = pipe(Optional.some('42')).map(parser).map(doubler).value;
 
       expect(Optional.isSome(result)).toBe(true);
+
       if (Optional.isSome(result)) {
         expect(Optional.unwrap(result)).toBe(84);
       }
@@ -409,11 +441,13 @@ describe('Optional', () => {
     test('should return None for Some values that do not match predicate', () => {
       const someOdd = Optional.some(5);
       const filtered = Optional.filter(someOdd, (x) => x % 2 === 0);
+
       expect(Optional.isNone(filtered)).toBe(true);
     });
 
     test('should return None if input is None', () => {
       const filtered = Optional.filter(Optional.none, (_: never) => true);
+
       expect(Optional.isNone(filtered)).toBe(true);
     });
 
@@ -422,16 +456,20 @@ describe('Optional', () => {
 
       const someEven = Optional.some(4);
       const filtered = evenFilter(someEven);
+
       expect(Optional.isSome(filtered)).toBe(true);
+
       if (Optional.isSome(filtered)) {
         expect(Optional.unwrap(filtered)).toBe(4);
       }
 
       const someOdd = Optional.some(5);
       const filteredOdd = evenFilter(someOdd);
+
       expect(Optional.isNone(filteredOdd)).toBe(true);
 
       const noneResult = evenFilter(Optional.none);
+
       expect(Optional.isNone(noneResult)).toBe(true);
     });
 
@@ -444,6 +482,7 @@ describe('Optional', () => {
         .map(positiveFilter).value;
 
       expect(Optional.isSome(result)).toBe(true);
+
       if (Optional.isSome(result)) {
         expect(Optional.unwrap(result)).toBe(4);
       }
@@ -475,6 +514,7 @@ describe('Optional', () => {
 
     test('should return None if both are None', () => {
       const result = Optional.orElse(Optional.none, Optional.none);
+
       expect(Optional.isNone(result)).toBe(true);
     });
 
@@ -483,14 +523,18 @@ describe('Optional', () => {
 
       const someValue = Optional.some('primary');
       const result = fallbackTo(someValue);
+
       expect(Optional.isSome(result)).toBe(true);
+
       if (Optional.isSome(result)) {
         expect(Optional.unwrap(result)).toBe('primary');
       }
 
       const noneValue = Optional.none;
       const fallbackResult = fallbackTo(noneValue);
+
       expect(Optional.isSome(fallbackResult)).toBe(true);
+
       if (Optional.isSome(fallbackResult)) {
         expect(Optional.unwrap(fallbackResult)).toBe('fallback');
       }
@@ -500,13 +544,17 @@ describe('Optional', () => {
       const fallbackTo = Optional.orElse(Optional.some('backup'));
 
       const someResult = pipe(Optional.some('original')).map(fallbackTo).value;
+
       expect(Optional.isSome(someResult)).toBe(true);
+
       if (Optional.isSome(someResult)) {
         expect(Optional.unwrap(someResult)).toBe('original');
       }
 
       const noneResult = pipe(Optional.none).map(fallbackTo).value;
+
       expect(Optional.isSome(noneResult)).toBe(true);
+
       if (Optional.isSome(noneResult)) {
         expect(Optional.unwrap(noneResult)).toBe('backup');
       }
@@ -519,7 +567,7 @@ describe('Optional', () => {
       const b = Optional.some('hello');
       const zipped = Optional.zip(a, b);
       if (Optional.isSome(zipped)) {
-        expect(Optional.unwrap(zipped)).toStrictEqual([1, 'hello']);
+        assert.deepStrictEqual(Optional.unwrap(zipped), [1, 'hello']);
       }
     });
 
@@ -527,6 +575,7 @@ describe('Optional', () => {
       const a = Optional.none;
       const b = Optional.some('hello');
       const zipped = Optional.zip(a, b);
+
       expect(Optional.isNone(zipped)).toBe(true);
     });
 
@@ -534,11 +583,13 @@ describe('Optional', () => {
       const a = Optional.some(1);
       const b = Optional.none;
       const zipped = Optional.zip(a, b);
+
       expect(Optional.isNone(zipped)).toBe(true);
     });
 
     test('should return None if both are None', () => {
       const zipped = Optional.zip(Optional.none, Optional.none);
+
       expect(Optional.isNone(zipped)).toBe(true);
     });
   });
@@ -573,6 +624,7 @@ describe('Optional', () => {
 
     test('should work with union types', () => {
       const value: string | null = 'test';
+
       expectTypeOf(Optional.fromNullable(value)).toExtend<Optional<string>>();
     });
   });
@@ -591,6 +643,7 @@ describe('Optional', () => {
 
     test('should have correct return type', () => {
       const some = Optional.some(42);
+
       expectTypeOf(Optional.toNullable(some)).toExtend<number | undefined>();
     });
   });
@@ -598,6 +651,7 @@ describe('Optional', () => {
   describe('edge cases', () => {
     test('should handle undefined as a Some value', () => {
       const someUndefined = Optional.some(undefined);
+
       expect(Optional.isSome(someUndefined)).toBe(true);
       // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
       expect(Optional.unwrap(someUndefined)).toBeUndefined();
@@ -608,15 +662,18 @@ describe('Optional', () => {
 
     test('should handle null as a Some value', () => {
       const someNull = Optional.some(null);
+
       expect(Optional.isSome(someNull)).toBe(true);
       expect(Optional.unwrap(someNull)).toBeNull();
     });
 
     test('should handle nested Optionals', () => {
       const nested = Optional.some(Optional.some(42));
+
       expect(Optional.isSome(nested)).toBe(true);
 
       const inner = Optional.unwrap(nested);
+
       expect(Optional.isOptional(inner)).toBe(true);
       expect(Optional.unwrap(inner)).toBe(42);
     });