ts-data-forge 4.1.0 → 5.0.0

package/src/functional/ternary-result.test.mts

@@ -2,7 +2,7 @@ import { expectType } from '../expect-type.mjs';
 import { Optional } from './optional/index.mjs';
 import { TernaryResult } from './ternary-result/index.mjs';
 
-describe('TernaryResult', () => {
+describe('TernaryResult test', () => {
   test('constructors and guards', () => {
     const ok = TernaryResult.ok(1);
     const warn = TernaryResult.warn(1, 'caution');
@@ -64,10 +64,12 @@ describe('TernaryResult', () => {
 
     expect(TernaryResult.unwrapOk(okResult)).toBe(3);
     expect(TernaryResult.isWarn(warnResult)).toBe(true);
+
     if (TernaryResult.isWarn(warnResult)) {
       expect(warnResult.value).toBe(3);
       expect(warnResult.warning).toBe('slow');
     }
+
     expect(TernaryResult.unwrapErr(errResult)).toBe('bad');
   });
 
@@ -93,24 +95,28 @@ describe('TernaryResult', () => {
 
     expect(TernaryResult.unwrapOk(value)).toBe(2);
     expect(TernaryResult.unwrapOk(warn)).toBe(4);
-    expect(TernaryResult.unwrapWarn(warn)).toStrictEqual({
+
+    assert.deepStrictEqual(TernaryResult.unwrapWarn(warn), {
       warning: 'heads up',
     });
-    expect(TernaryResult.unwrapErr(err)).toStrictEqual({ message: 'boom' });
+    assert.deepStrictEqual(TernaryResult.unwrapErr(err), { message: 'boom' });
   });
 
   test('orElse keeps Ok and Warn variants', () => {
     const fallback = TernaryResult.ok('fallback');
 
-    expect(
+    assert.deepStrictEqual(
       TernaryResult.orElse(TernaryResult.ok('value'), fallback),
-    ).toStrictEqual(TernaryResult.ok('value'));
-    expect(
+      TernaryResult.ok('value'),
+    );
+    assert.deepStrictEqual(
       TernaryResult.orElse(TernaryResult.warn('value', 'warn'), fallback),
-    ).toStrictEqual(TernaryResult.warn('value', 'warn'));
-    expect(
+      TernaryResult.warn('value', 'warn'),
+    );
+    assert.deepStrictEqual(
       TernaryResult.orElse(TernaryResult.err('err'), fallback),
-    ).toStrictEqual(fallback);
+      fallback,
+    );
   });
 
   test('unwrap helpers', () => {
@@ -150,26 +156,32 @@ describe('TernaryResult', () => {
     const warn = TernaryResult.warn('warn', 'warned');
     const err = TernaryResult.err('err');
 
-    expect(TernaryResult.zip(ok, TernaryResult.ok(1))).toStrictEqual(
+    assert.deepStrictEqual(
+      TernaryResult.zip(ok, TernaryResult.ok(1)),
       TernaryResult.ok(['x', 1] as const),
     );
-    expect(TernaryResult.zip(ok, warn)).toStrictEqual(
+    assert.deepStrictEqual(
+      TernaryResult.zip(ok, warn),
       TernaryResult.warn(['x', 'warn'] as const, 'warned'),
     );
-    expect(TernaryResult.zip(warn, ok)).toStrictEqual(
+    assert.deepStrictEqual(
+      TernaryResult.zip(warn, ok),
       TernaryResult.warn(['warn', 'x'] as const, 'warned'),
     );
-    expect(TernaryResult.zip(ok, err)).toStrictEqual(err);
-    expect(TernaryResult.zip(err, warn)).toStrictEqual(err);
+    assert.deepStrictEqual(TernaryResult.zip(ok, err), err);
+    assert.deepStrictEqual(TernaryResult.zip(err, warn), err);
   });
 
   test('toOptional keeps only Ok values', () => {
-    expect(TernaryResult.toOptional(TernaryResult.ok(1))).toStrictEqual(
+    assert.deepStrictEqual(
+      TernaryResult.toOptional(TernaryResult.ok(1)),
       Optional.some(1),
     );
-    expect(
+    assert.deepStrictEqual(
       TernaryResult.toOptional(TernaryResult.warn(1, 'warn')),
-    ).toStrictEqual(Optional.some(1));
+      Optional.some(1),
+    );
+
     expect(TernaryResult.toOptional(TernaryResult.err('err'))).toBe(
       Optional.none,
     );
@@ -183,16 +195,20 @@ describe('TernaryResult', () => {
     const rejected = await TernaryResult.fromPromise(
       Promise.reject(new Error('bad')),
     );
+
     expect(TernaryResult.isErr(rejected)).toBe(true);
   });
 
   test('fromThrowable converts thrown values', () => {
-    expect(TernaryResult.fromThrowable(() => 5)).toStrictEqual(
+    assert.deepStrictEqual(
+      TernaryResult.fromThrowable(() => 5),
       TernaryResult.ok(5),
     );
+
     const errorResult = TernaryResult.fromThrowable(() => {
       throw new Error('boom');
     });
+
     expect(TernaryResult.isErr(errorResult)).toBe(true);
   });
 });

package/src/guard/is-non-empty-string.test.mts

@@ -1,7 +1,7 @@
 import { expectType } from '../expect-type.mjs';
 import { isNonEmptyString } from './is-non-empty-string.mjs';
 
-describe('isNonEmptyString', () => {
+describe(isNonEmptyString, () => {
   test('should return true for non-empty strings', () => {
     expect(isNonEmptyString('hello')).toBe(true);
     expect(isNonEmptyString('a')).toBe(true);
@@ -42,6 +42,7 @@ describe('isNonEmptyString', () => {
     // @ts-expect-error Testing non-string types
     if (isNonEmptyString(value)) {
       expectType<typeof value, string>('=');
+
       // TypeScript knows it's a string
       expect(value.length).toBeGreaterThan(0);
       expect(value.charAt(0)).toBe('t');
@@ -53,6 +54,7 @@ describe('isNonEmptyString', () => {
 
     if (isNonEmptyString(maybeString)) {
       expectType<typeof maybeString, string>('=');
+
       expect(maybeString.toUpperCase()).toBe('HELLO');
     }
   });
@@ -71,7 +73,8 @@ describe('isNonEmptyString', () => {
 
     // @ts-expect-error Testing non-string types
     const nonEmptyStrings = mixed.filter(isNonEmptyString);
-    expect(nonEmptyStrings).toStrictEqual(['valid', 'another', 'third']);
+
+    assert.deepStrictEqual(nonEmptyStrings, ['valid', 'another', 'third']);
   });
 
   test('should handle string edge cases', () => {

package/src/guard/is-non-null-object.test.mts

@@ -1,7 +1,7 @@
 import { expectType } from '../expect-type.mjs';
 import { isNonNullObject } from './is-non-null-object.mjs';
 
-describe('isNonNullObject', () => {
+describe(isNonNullObject, () => {
   test('should return true for plain objects', () => {
     expect(isNonNullObject({})).toBe(true);
     expect(isNonNullObject({ a: 1, b: 'test' })).toBe(true);
@@ -57,9 +57,7 @@ describe('isNonNullObject', () => {
     const value: unknown = { test: true };
 
     if (isNonNullObject(value)) {
-      expectType<typeof value, NonNullable<UnknownRecord>>('>=');
-      // Can access object methods
-      expect(typeof value.toString).toBe('function');
+      expectType<typeof value, object>('=');
     }
   });
 
@@ -85,6 +83,6 @@ describe('isNonNullObject', () => {
 
     const objects = mixed.filter(isNonNullObject);
 
-    expect(objects).toStrictEqual([{ a: 1 }, []]);
+    assert.deepStrictEqual(objects, [{ a: 1 }, []]);
   });
 });

package/src/guard/is-primitive.test.mts

@@ -1,7 +1,8 @@
 import { expectType } from '../expect-type.mjs';
 import { isPrimitive } from './is-primitive.mjs';
+import { isSymbol } from './is-type.mjs';
 
-describe('isPrimitive', () => {
+describe(isPrimitive, () => {
   test('should return true for string primitives', () => {
     expect(isPrimitive('hello')).toBe(true);
     expect(isPrimitive('')).toBe(true);
@@ -95,8 +96,9 @@ describe('isPrimitive', () => {
     expect(primitives[2]).toBe(true);
     expect(primitives[3]).toBeNull();
     expect(primitives[4]).toBeUndefined();
-    expect(typeof primitives[5]).toBe('symbol');
 
-    expect(nonPrimitives).toStrictEqual([{}, []]);
+    expect(isSymbol(primitives[5])).toBe(true);
+
+    assert.deepStrictEqual(nonPrimitives, [{}, []]);
   });
 });

package/src/guard/is-record.test.mts

@@ -1,7 +1,7 @@
 import { expectType } from '../expect-type.mjs';
 import { isRecord } from './is-record.mjs';
 
-describe('isRecord', () => {
+describe(isRecord, () => {
   test('{ x: 1 } is a record', () => {
     const obj = { x: 1 } as const;
     const unk: unknown = obj;

package/src/guard/is-type.test.mts

@@ -18,7 +18,7 @@ import {
   isUndefined,
 } from './is-type.mjs';
 
-describe('isUndefined', () => {
+describe(isUndefined, () => {
   test('should return true for undefined', () => {
     expect(isUndefined(undefined)).toBe(true);
   });
@@ -39,7 +39,7 @@ describe('isUndefined', () => {
   });
 });
 
-describe('isNotUndefined', () => {
+describe(isNotUndefined, () => {
   test('should return false for undefined', () => {
     expect(isNotUndefined(undefined)).toBe(false);
   });
@@ -59,7 +59,7 @@ describe('isNotUndefined', () => {
   });
 });
 
-describe('isNull', () => {
+describe(isNull, () => {
   test('should return true for null', () => {
     expect(isNull(null)).toBe(true);
   });
@@ -80,7 +80,7 @@ describe('isNull', () => {
   });
 });
 
-describe('isNotNull', () => {
+describe(isNotNull, () => {
   test('should return false for null', () => {
     expect(isNotNull(null)).toBe(false);
   });
@@ -99,7 +99,7 @@ describe('isNotNull', () => {
   });
 });
 
-describe('isString', () => {
+describe(isString, () => {
   test('should return true for strings', () => {
     expect(isString('')).toBe(true);
     expect(isString('hello')).toBe(true);
@@ -120,12 +120,13 @@ describe('isString', () => {
     const value: unknown = 'test';
     if (isString(value)) {
       expectType<typeof value, string>('=');
+
       expect(value).toHaveLength(4);
     }
   });
 });
 
-describe('isNumber', () => {
+describe(isNumber, () => {
   test('should return true for numbers', () => {
     expect(isNumber(0)).toBe(true);
     expect(isNumber(42)).toBe(true);
@@ -148,12 +149,13 @@ describe('isNumber', () => {
     const value: unknown = 42;
     if (isNumber(value)) {
       expectType<typeof value, number>('=');
+
       expect(value + 1).toBe(43);
     }
   });
 });
 
-describe('isBigint', () => {
+describe(isBigint, () => {
   test('should return true for bigints', () => {
     expect(isBigint(0n)).toBe(true);
     expect(isBigint(123n)).toBe(true);
@@ -171,12 +173,13 @@ describe('isBigint', () => {
     const value: unknown = 123n;
     if (isBigint(value)) {
       expectType<typeof value, bigint>('=');
+
       expect(value + 1n).toBe(124n);
     }
   });
 });
 
-describe('isBoolean', () => {
+describe(isBoolean, () => {
   test('should return true for booleans', () => {
     expect(isBoolean(true)).toBe(true);
     expect(isBoolean(false)).toBe(true);
@@ -195,12 +198,13 @@ describe('isBoolean', () => {
     const value: unknown = true;
     if (isBoolean(value)) {
       expectType<typeof value, boolean>('=');
+
       expect(!value).toBe(false);
     }
   });
 });
 
-describe('isSymbol', () => {
+describe(isSymbol, () => {
   test('should return true for symbols', () => {
     expect(isSymbol(Symbol())).toBe(true);
     expect(isSymbol(Symbol('test'))).toBe(true);
@@ -217,12 +221,13 @@ describe('isSymbol', () => {
     const value: unknown = Symbol('test');
     if (isSymbol(value)) {
       expectType<typeof value, symbol>('=');
+
       expect(value.toString()).toContain('Symbol');
     }
   });
 });
 
-describe('isNotBoolean', () => {
+describe(isNotBoolean, () => {
   test('should return false for boolean values', () => {
     expect(isNotBoolean(true)).toBe(false);
     expect(isNotBoolean(false)).toBe(false);
@@ -243,13 +248,14 @@ describe('isNotBoolean', () => {
     const value: string | number | boolean = 'test';
     if (isNotBoolean(value)) {
       expectType<typeof value, string | number>('<=');
+
       // Should not have boolean methods
       expect(typeof value === 'string' || typeof value === 'number').toBe(true);
     }
   });
 });
 
-describe('isNotNumber', () => {
+describe(isNotNumber, () => {
   test('should return false for number values', () => {
     expect(isNotNumber(0)).toBe(false);
     expect(isNotNumber(42)).toBe(false);
@@ -275,6 +281,7 @@ describe('isNotNumber', () => {
     const value: string | number | boolean = 'test';
     if (isNotNumber(value)) {
       expectType<typeof value, string | boolean>('<=');
+
       expect(typeof value === 'string' || typeof value === 'boolean').toBe(
         true,
       );
@@ -282,7 +289,7 @@ describe('isNotNumber', () => {
   });
 });
 
-describe('isNotBigint', () => {
+describe(isNotBigint, () => {
   test('should return false for bigint values', () => {
     expect(isNotBigint(0n)).toBe(false);
     expect(isNotBigint(123n)).toBe(false);
@@ -304,12 +311,13 @@ describe('isNotBigint', () => {
     const value: number | bigint = 123;
     if (isNotBigint(value)) {
       expectType<typeof value, number>('<=');
-      expect(typeof value).toBe('number');
+
+      expectTypeOf(value).toBeNumber();
     }
   });
 });
 
-describe('isNotString', () => {
+describe(isNotString, () => {
   test('should return false for string values', () => {
     expect(isNotString('')).toBe(false);
     expect(isNotString('hello')).toBe(false);
@@ -333,6 +341,7 @@ describe('isNotString', () => {
     const value: string | number | boolean = 42;
     if (isNotString(value)) {
       expectType<typeof value, number | boolean>('<=');
+
       expect(typeof value === 'number' || typeof value === 'boolean').toBe(
         true,
       );
@@ -340,7 +349,7 @@ describe('isNotString', () => {
   });
 });
 
-describe('isNotSymbol', () => {
+describe(isNotSymbol, () => {
   test('should return false for symbol values', () => {
     expect(isNotSymbol(Symbol())).toBe(false);
     expect(isNotSymbol(Symbol('test'))).toBe(false);
@@ -363,12 +372,13 @@ describe('isNotSymbol', () => {
     const value: string | number | symbol = 'test';
     if (isNotSymbol(value)) {
       expectType<typeof value, string | number>('<=');
+
       expect(typeof value === 'string' || typeof value === 'number').toBe(true);
     }
   });
 });
 
-describe('isNullish', () => {
+describe(isNullish, () => {
   test('should return true for null and undefined', () => {
     expect(isNullish(null)).toBe(true);
     expect(isNullish(undefined)).toBe(true);
@@ -389,6 +399,7 @@ describe('isNullish', () => {
     const value: string | null | undefined = null;
     if (isNullish(value)) {
       expectType<typeof value, null | undefined>('<=');
+
       // Value is guaranteed to be null or undefined in this branch
       expect(true).toBe(true);
     }
@@ -401,7 +412,7 @@ describe('isNullish', () => {
   });
 });
 
-describe('isNonNullish', () => {
+describe(isNonNullish, () => {
   test('should return false for null and undefined', () => {
     expect(isNonNullish(null)).toBe(false);
     expect(isNonNullish(undefined)).toBe(false);
@@ -424,6 +435,7 @@ describe('isNonNullish', () => {
     const value: string | null | undefined = 'test';
     if (isNonNullish(value)) {
       expectType<typeof value, string>('<=');
+
       expect(value).toHaveLength(4);
     }
   });
@@ -441,7 +453,8 @@ describe('isNonNullish', () => {
     expectType<typeof definedItems, string[]>('<=');
 
     expect(definedItems).toHaveLength(3);
-    expect(definedItems).toStrictEqual(['hello', 'world', 'test']);
+
+    assert.deepStrictEqual(definedItems, ['hello', 'world', 'test']);
   });
 
   test('should handle complex union types', () => {
@@ -450,6 +463,7 @@ describe('isNonNullish', () => {
 
     if (isNonNullish(value)) {
       expectType<typeof value, string | number | boolean>('<=');
+
       // Value is guaranteed to be non-nullish in this branch
       expect(true).toBe(true);
     }
@@ -462,7 +476,8 @@ describe('type guard behavior in complex scenarios', () => {
 
     if (isNonNullish(value) && isNotBoolean(value) && isNotNumber(value)) {
       expectType<typeof value, string>('<=');
-      expect(typeof value).toBe('string');
+
+      expectTypeOf(value).toBeString();
     }
   });
 
@@ -487,6 +502,6 @@ describe('type guard behavior in complex scenarios', () => {
     const strings = nonBooleans.filter(isNotNumber);
     expectType<typeof strings, string[]>('<=');
 
-    expect(strings).toStrictEqual(['hello', 'world']);
+    assert.deepStrictEqual(strings, ['hello', 'world']);
   });
 });

package/src/guard/key-is-in.test.mts

@@ -5,7 +5,7 @@ const f = <Key extends string, V, KeySub extends Key>(
   obj: ReadonlyRecord<KeySub, V>,
 ): V | undefined => (keyIsIn(key, obj) ? obj[key] : undefined);
 
-describe('keyIsIn', () => {
+describe(keyIsIn, () => {
   f('a' as 'a' | 'b' | 'c', { a: 0, b: 1 });
 
   test('', () => {

package/src/iterator/range.test.mts

@@ -1,46 +1,52 @@
 import { range } from './range.mjs';
 
-describe('range', () => {
+describe(range, () => {
   test('range(0, 10)', () => {
-    expect(Array.from(range(0, 10))).toStrictEqual([
-      0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
-    ]);
+    assert.deepStrictEqual(
+      Array.from(range(0, 10)),
+      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+    );
   });
 
   test('range(10)', () => {
-    expect(Array.from(range(10))).toStrictEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+    assert.deepStrictEqual(
+      Array.from(range(10)),
+      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+    );
   });
 
   test('range(0)', () => {
-    expect(Array.from(range(0))).toStrictEqual([]);
+    assert.deepStrictEqual(Array.from(range(0)), []);
   });
 
   test('range(-1)', () => {
     // @ts-expect-error negative end is not allowed
-    expect(Array.from(range(-1))).toStrictEqual([]);
+    assert.deepStrictEqual(Array.from(range(-1)), []);
   });
 
   test('range(10, 0, -1)', () => {
-    expect(Array.from(range(10, 0, -1))).toStrictEqual([
-      10, 9, 8, 7, 6, 5, 4, 3, 2, 1,
-    ]);
+    assert.deepStrictEqual(
+      Array.from(range(10, 0, -1)),
+      [10, 9, 8, 7, 6, 5, 4, 3, 2, 1],
+    );
   });
 
   test('range(0, -10, -1)', () => {
-    expect(Array.from(range(0, -10, -1))).toStrictEqual([
-      0, -1, -2, -3, -4, -5, -6, -7, -8, -9,
-    ]);
+    assert.deepStrictEqual(
+      Array.from(range(0, -10, -1)),
+      [0, -1, -2, -3, -4, -5, -6, -7, -8, -9],
+    );
   });
 
   test('range(0, 0)', () => {
-    expect(Array.from(range(0, 0))).toStrictEqual([]);
+    assert.deepStrictEqual(Array.from(range(0, 0)), []);
   });
 
   test('range(0, 11, 2)', () => {
-    expect(Array.from(range(0, 11, 2))).toStrictEqual([0, 2, 4, 6, 8, 10]);
+    assert.deepStrictEqual(Array.from(range(0, 11, 2)), [0, 2, 4, 6, 8, 10]);
   });
 
   test('range(1, 12, 2)', () => {
-    expect(Array.from(range(1, 12, 2))).toStrictEqual([1, 3, 5, 7, 9, 11]);
+    assert.deepStrictEqual(Array.from(range(1, 12, 2)), [1, 3, 5, 7, 9, 11]);
   });
 });

package/src/json/json.mts

@@ -108,6 +108,8 @@ export namespace Json {
    *
    * assert.ok(Result.isOk(filtered));
    * if (Result.isOk(filtered)) {
+   *   assert(isString(filtered.value));
+   *
    *   assert.ok(!filtered.value.includes('age'));
    * }
    * ```
@@ -136,7 +138,7 @@ export namespace Json {
     value: unknown,
     replacer?: (this: unknown, key: string, val: unknown) => unknown,
     space?: UintRangeInclusive<1, 10> | string,
-  ): Result<string, string> => {
+  ): Result<string | undefined, string> => {
     try {
       return Result.ok(JSON.stringify(value, replacer, space));
     } catch (error) {
@@ -170,6 +172,8 @@ export namespace Json {
    *
    * assert.ok(Result.isOk(safeJson));
    * if (Result.isOk(safeJson)) {
+   *   assert(isString(safeJson.value));
+   *
    *   const parsed: unknown = JSON.parse(safeJson.value);
    *   assert.deepStrictEqual(parsed, {
    *     id: 1,
@@ -207,7 +211,7 @@ export namespace Json {
     value: unknown,
     propertiesToBeSelected?: readonly (number | string)[],
     space?: UintRangeInclusive<1, 10> | string,
-  ): Result<string, string> => {
+  ): Result<string | undefined, string> => {
     try {
       return Result.ok(
         JSON.stringify(value, castMutable(propertiesToBeSelected), space),
@@ -257,6 +261,8 @@ export namespace Json {
    * const formatted = Json.stringifySortedKey(unorderedData, 2);
    * assert.ok(Result.isOk(formatted));
    * if (Result.isOk(formatted)) {
+   *   assert(isString(formatted.value));
+   *
    *   // Check that keys are in order (first key should be "apple")
    *   assert.ok(
    *     formatted.value.indexOf('"apple"') < formatted.value.indexOf('"mango"'),
@@ -288,7 +294,7 @@ export namespace Json {
   export const stringifySortedKey = (
     value: UnknownRecord,
     space?: UintRangeInclusive<1, 10> | string,
-  ): Result<string, string> => {
+  ): Result<string | undefined, string> => {
     const allKeys = pipe(keysDeep(value))
       .map((keys) => Arr.uniq(keys))
       .map((ks) => ks.toSorted()).value;