ts-fortress 2.2.1 → 2.3.0

package/src/compose/merge-records.mts

@@ -1,10 +1,12 @@
-import { expectType, isRecord, Result } from 'ts-data-forge';
+import { Arr, expectType, isRecord, Result } from 'ts-data-forge';
 import { type Type, type TypeOf } from '../type.mjs';
-import { createAssertFn, createCastFn, createIsFn } from '../utils/index.mjs';
 import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
   type ValidationError,
   type ValidationErrorWithMessage,
-} from '../validation-error.mjs';
+} from '../utils/index.mjs';
 
 export const mergeRecords = <
   const Types extends NonEmptyArray<Type<UnknownRecord>>,
@@ -24,22 +26,23 @@ export const mergeRecords = <
     `Intersection<${types.map((a) => a.typeName).join(', ')}>`;
 
   const validate: Type<T>['validate'] = (a) => {
-    const errors: readonly ValidationError[] = types.flatMap((type) => {
-      const r = type.validate(a);
-      return Result.isErr(r)
-        ? [
-            {
-              path: [],
-              actualValue: a,
-              expectedType: typeNameFilled,
-              message: `The type of value is expected to match all types of { ${types
-                .map((t) => t.typeName)
-                .join(', ')} }`,
-              typeName: typeNameFilled,
-            } satisfies ValidationErrorWithMessage,
-            ...r.value,
-          ]
-        : [];
+    const errors: readonly ValidationError[] = Arr.generate(function* () {
+      for (const type of types) {
+        const res = type.validate(a);
+        if (Result.isErr(res)) {
+          yield {
+            path: [],
+            actualValue: a,
+            expectedType: typeNameFilled,
+            message: `The type of value is expected to match all types of { ${types
+              .map((t) => t.typeName)
+              .join(', ')} }`,
+            typeName: typeNameFilled,
+          } satisfies ValidationErrorWithMessage;
+
+          yield* res.value;
+        }
+      }
     });
 
     if (errors.length > 0) {

package/src/compose/merge-records.test.mts

@@ -5,7 +5,7 @@ import { type TypeOf } from '../type.mjs';
 import {
   type ValidationError,
   validationErrorsToMessages,
-} from '../validation-error.mjs';
+} from '../utils/index.mjs';
 import { mergeRecords } from './merge-records.mjs';
 
 describe('mergeRecords', () => {
@@ -82,6 +82,15 @@ describe('mergeRecords', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input = { x: 0, y: 1, z: 2, w: 3 };
+      const result = targetType.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
     test('falsy case', () => {
       const result = targetType.validate({ x: 0, y: 1 });
       expect(Result.isErr(result)).toBe(true);

package/src/compose/recursion.mts

@@ -0,0 +1,49 @@
+import { type Type } from '../type.mjs';
+import { createAssertFn, createCastFn, createIsFn } from '../utils/index.mjs';
+
+export const recursion = <A,>(
+  typeName: string,
+  definition: () => Type<A>,
+  options?: Partial<
+    Readonly<{
+      defaultValue: A;
+    }>
+  >,
+): Type<A> => {
+  const cache: {
+    innerType: Type<A> | undefined;
+    computedDefaultValue: A | undefined;
+  } = {
+    innerType: undefined as Type<A> | undefined,
+    computedDefaultValue: undefined as A | undefined,
+  };
+
+  const getInnerType = (): Type<A> => {
+    // eslint-disable-next-line functional/immutable-data
+    cache.innerType ??= definition();
+    return cache.innerType;
+  };
+
+  const validate: Type<A>['validate'] = (a) => getInnerType().validate(a);
+
+  const is = createIsFn<A>(validate);
+
+  const fill: Type<A>['fill'] = (a) => getInnerType().fill(a);
+
+  return {
+    typeName,
+    get defaultValue(): A {
+      if (options?.defaultValue !== undefined) {
+        return options.defaultValue;
+      }
+      // eslint-disable-next-line functional/immutable-data
+      cache.computedDefaultValue ??= getInnerType().defaultValue;
+      return cache.computedDefaultValue;
+    },
+    fill,
+    validate,
+    is,
+    assertIs: createAssertFn(validate),
+    cast: createCastFn(validate),
+  };
+};

package/src/compose/recursion.test.mts

@@ -0,0 +1,234 @@
+import { expectType } from 'ts-data-forge';
+import { array } from '../array/index.mjs';
+import { boolean, nullType, number, string } from '../primitives/index.mjs';
+import { keyValueRecord, record } from '../record/index.mjs';
+import { type Type, type TypeOf } from '../type.mjs';
+import { recursion } from './recursion.mjs';
+import { union } from './union.mjs';
+
+describe('recursive', () => {
+  // Define JsonPrimitive type
+  const JsonPrimitive = union([nullType, number(), string(), boolean()]);
+
+  type JsonPrimitive = TypeOf<typeof JsonPrimitive>;
+
+  test('JsonPrimitive.defaultValue', () => {
+    expectType<JsonPrimitive, null | boolean | number | string>('=');
+
+    expect(JsonPrimitive.defaultValue).toBeNull();
+  });
+
+  // Define recursive JsonValue type
+  type JsonValue =
+    | JsonPrimitive
+    | Readonly<{
+        [k: string]: JsonValue;
+      }>
+    | readonly JsonValue[];
+
+  const JsonValue: Type<JsonValue> = recursion('JsonValue', () =>
+    union([
+      JsonPrimitive,
+      keyValueRecord(string(), JsonValue),
+      array(JsonValue),
+    ]),
+  );
+
+  test('JsonValue.defaultValue', () => {
+    expectType<TypeOf<typeof JsonValue>, JsonValue>('=');
+
+    expect(JsonValue.defaultValue).toBeNull();
+  });
+
+  test('JsonValue - primitive values', () => {
+    expect(JsonValue.is(true)).toBe(true);
+    expect(JsonValue.is(false)).toBe(true);
+    expect(JsonValue.is(42)).toBe(true);
+    expect(JsonValue.is(3.14)).toBe(true);
+    expect(JsonValue.is('hello')).toBe(true);
+    expect(JsonValue.is(null)).toBe(true);
+    expect(JsonValue.is(undefined)).toBe(false);
+  });
+
+  test('JsonValue - arrays', () => {
+    expect(JsonValue.is([])).toBe(true);
+    expect(JsonValue.is([1, 2, 3])).toBe(true);
+    expect(JsonValue.is(['a', 'b', 'c'])).toBe(true);
+    expect(JsonValue.is([true, false, null])).toBe(true);
+    expect(JsonValue.is([1, 'a', true, null])).toBe(true);
+  });
+
+  test('JsonValue - objects', () => {
+    expect(JsonValue.is({})).toBe(true);
+    expect(JsonValue.is({ a: 1 })).toBe(true);
+    expect(JsonValue.is({ a: 1, b: 'hello' })).toBe(true);
+    expect(JsonValue.is({ a: 1, b: [1, 2, 3] })).toBe(true);
+  });
+
+  test('JsonValue - nested structures', () => {
+    const nestedData = {
+      name: 'John',
+      age: 30,
+      active: true,
+      address: {
+        street: '123 Main St',
+        city: 'New York',
+        coordinates: {
+          lat: 40.7128,
+          lon: -74.006,
+        },
+      },
+      hobbies: ['reading', 'coding', 'gaming'],
+      scores: [95, 87, 92],
+      metadata: null,
+      tags: [],
+      settings: {
+        theme: 'dark',
+        notifications: {
+          email: true,
+          push: false,
+        },
+      },
+    };
+
+    expect(JsonValue.is(nestedData)).toBe(true);
+  });
+
+  test('JsonValue - deeply nested arrays', () => {
+    const deepArray = [
+      [
+        [1, 2, 3],
+        [4, 5, 6],
+      ],
+      [
+        [7, 8, 9],
+        [10, 11, 12],
+      ],
+    ];
+
+    expect(JsonValue.is(deepArray)).toBe(true);
+  });
+
+  test('JsonValue - mixed nested structure', () => {
+    const mixedData = {
+      users: [
+        {
+          id: 1,
+          name: 'Alice',
+          tasks: [
+            { id: 'task1', completed: true },
+            { id: 'task2', completed: false },
+          ],
+        },
+        {
+          id: 2,
+          name: 'Bob',
+          tasks: [],
+        },
+      ],
+      config: {
+        version: '1.0.0',
+        features: ['feature1', 'feature2'],
+        settings: {
+          debug: false,
+          timeout: 5000,
+        },
+      },
+    };
+
+    expect(JsonValue.is(mixedData)).toBe(true);
+  });
+
+  test('JsonValue - invalid values', () => {
+    expect(JsonValue.is(undefined)).toBe(false);
+    expect(JsonValue.is(Symbol('test'))).toBe(false);
+    expect(JsonValue.is(() => 'function')).toBe(false);
+
+    // Note: keyValueRecord accepts any object with string keys, including Date/Set/Map
+    // This is expected behavior for keyValueRecord, which doesn't distinguish
+    // between plain objects and other object instances
+  });
+
+  test('JsonValue - cast function', () => {
+    const result = JsonValue.cast({ a: 1, b: [2, 3], c: { d: 'hello' } });
+    expect(result).toStrictEqual({ a: 1, b: [2, 3], c: { d: 'hello' } });
+  });
+
+  test('JsonValue - fill function', () => {
+    const result = JsonValue.fill({ a: 1, b: [2, 3] });
+    expect(result).toStrictEqual({ a: 1, b: [2, 3] });
+
+    // Fill with default value for invalid input
+    const defaultResult = JsonValue.fill(undefined);
+    expect(JsonValue.is(defaultResult)).toBe(true);
+  });
+
+  // Test other recursive structures
+  test('Linked list structure', () => {
+    type LinkedList<T> = { value: T; next: LinkedList<T> | null };
+
+    const LinkedListNumber: Type<LinkedList<number>> = recursion(
+      'LinkedList<number>',
+      () =>
+        record({
+          value: number(0),
+          next: union([nullType, LinkedListNumber]),
+        }),
+      { defaultValue: { value: 0, next: null } },
+    );
+
+    const list: LinkedList<number> = {
+      value: 1,
+      next: {
+        value: 2,
+        next: {
+          value: 3,
+          next: null,
+        },
+      },
+    };
+
+    expect(LinkedListNumber.is(list)).toBe(true);
+    expect(LinkedListNumber.is({ value: 1, next: null })).toBe(true);
+    expect(LinkedListNumber.is({ value: 'not a number', next: null })).toBe(
+      false,
+    );
+  });
+
+  test('Tree structure', () => {
+    type TreeNode<T> = Readonly<{
+      value: T;
+      children: readonly TreeNode<T>[];
+    }>;
+
+    const TreeNodeString: Type<TreeNode<string>> = recursion(
+      'TreeNode<string>',
+      () =>
+        record({
+          value: string(),
+          children: array(TreeNodeString),
+        }),
+    );
+
+    const tree: TreeNode<string> = {
+      value: 'root',
+      children: [
+        {
+          value: 'branch1',
+          children: [
+            { value: 'leaf1', children: [] },
+            { value: 'leaf2', children: [] },
+          ],
+        },
+        {
+          value: 'branch2',
+          children: [{ value: 'leaf3', children: [] }],
+        },
+      ],
+    };
+
+    expect(TreeNodeString.is(tree)).toBe(true);
+    expect(TreeNodeString.is({ value: 'node', children: [] })).toBe(true);
+    expect(TreeNodeString.is({ value: 123, children: [] })).toBe(false);
+  });
+});

package/src/compose/union.mts

@@ -1,7 +1,11 @@
 import { Result, expectType } from 'ts-data-forge';
 import { type Type, type TypeOf } from '../type.mjs';
-import { createAssertFn, createCastFn, createIsFn } from '../utils/index.mjs';
-import { type ValidationErrorWithMessage } from '../validation-error.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  type ValidationErrorWithMessage,
+} from '../utils/index.mjs';
 
 export const union = <const Types extends NonEmptyArray<Type<unknown>>>(
   types: Types,

package/src/compose/union.test.mts

@@ -5,7 +5,7 @@ import { type TypeOf } from '../type.mjs';
 import {
   type ValidationError,
   validationErrorsToMessages,
-} from '../validation-error.mjs';
+} from '../utils/index.mjs';
 import { union } from './union.mjs';
 
 describe('union', () => {
@@ -105,6 +105,15 @@ describe('union', () => {
         ]);
       }
     });
+
+    test('validate returns input as-is for OK cases', () => {
+      const input = { x: 10, y: 20 };
+      const result = targetType.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
   });
 
   describe('fill', () => {

package/src/enum/enum.mts

@@ -1,7 +1,11 @@
 import { ISet, Result } from 'ts-data-forge';
 import { type Type } from '../type.mjs';
-import { createAssertFn, createCastFn, createIsFn } from '../utils/index.mjs';
-import { type ValidationErrorWithMessage } from '../validation-error.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  type ValidationErrorWithMessage,
+} from '../utils/index.mjs';
 
 export const enumType = <const Values extends NonEmptyArray<Primitive>>(
   values: Values,

package/src/enum/enum.test.mts

@@ -3,7 +3,7 @@ import { type TypeOf } from '../type.mjs';
 import {
   type ValidationError,
   validationErrorsToMessages,
-} from '../validation-error.mjs';
+} from '../utils/index.mjs';
 import { enumType } from './enum.mjs';
 
 describe('enumType', () => {
@@ -76,6 +76,15 @@ describe('enumType', () => {
         throw new Error('Expected validation to fail');
       }
     });
+
+    test('validate returns input as-is for OK cases', () => {
+      const input = 'a';
+      const result = targetType.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
   });
 
   describe('fill', () => {

package/src/enum/uint-range.mts

@@ -1,7 +1,11 @@
 import { isNumber, Num, Result } from 'ts-data-forge';
 import { type Type } from '../type.mjs';
-import { createAssertFn, createCastFn, createIsFn } from '../utils/index.mjs';
-import { type ValidationErrorWithMessage } from '../validation-error.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  type ValidationErrorWithMessage,
+} from '../utils/index.mjs';
 
 export const uintRange = <
   Start extends Uint8,

package/src/enum/uint-range.test.mts

@@ -3,7 +3,7 @@ import { type TypeOf } from '../type.mjs';
 import {
   type ValidationError,
   validationErrorsToMessages,
-} from '../validation-error.mjs';
+} from '../utils/index.mjs';
 import { uintRange } from './uint-range.mjs';
 
 describe('uintRange', () => {
@@ -57,6 +57,15 @@ describe('uintRange', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input = 5;
+      const result = month.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
     test('falsy case', () => {
       const result = month.validate(13);
       expect(Result.isErr(result)).toBe(true);

package/src/index.mts

@@ -7,4 +7,3 @@ export * from './record/index.mjs';
 export * from './type.mjs';
 export * from './unknown.mjs';
 export * from './utils/index.mjs';
-export * from './validation-error.mjs';

package/src/primitives/bigint.test.mts

@@ -1,6 +1,6 @@
 import { expectType, Result } from 'ts-data-forge';
 import { type TypeOf } from '../type.mjs';
-import { validationErrorsToMessages } from '../validation-error.mjs';
+import { validationErrorsToMessages } from '../utils/index.mjs';
 import { bigint, bigintLiteral } from './bigint.mjs';
 
 describe('bigint', () => {
@@ -68,6 +68,15 @@ describe('bigint', () => {
         ]);
       }
     });
+
+    test('validate returns input as-is for OK cases', () => {
+      const input = 999n;
+      const result = targetType.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
   });
 
   describe('assertIs', () => {
@@ -215,6 +224,15 @@ describe('bigintLiteral', () => {
         ]);
       }
     });
+
+    test('validate returns input as-is for OK cases', () => {
+      const input = 42n;
+      const result = targetType.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
   });
 
   describe('cast', () => {

package/src/primitives/boolean.test.mts

@@ -1,6 +1,6 @@
 import { expectType, Result } from 'ts-data-forge';
 import { type TypeOf } from '../type.mjs';
-import { validationErrorsToMessages } from '../validation-error.mjs';
+import { validationErrorsToMessages } from '../utils/index.mjs';
 import { boolean, booleanLiteral } from './boolean.mjs';
 
 describe('boolean', () => {
@@ -68,6 +68,15 @@ describe('boolean', () => {
         ]);
       }
     });
+
+    test('validate returns input as-is for OK cases', () => {
+      const input = false;
+      const result = targetType.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
   });
 
   describe('assertIs', () => {
@@ -218,6 +227,15 @@ describe('booleanLiteral', () => {
           ]);
         }
       });
+
+      test('validate returns input as-is for OK cases', () => {
+        const input = true;
+        const result = targetType.validate(input);
+        expect(Result.isOk(result)).toBe(true);
+        if (Result.isOk(result)) {
+          expect(result.value).toBe(input); // ✅ same reference
+        }
+      });
     });
 
     describe('cast', () => {
@@ -304,6 +322,15 @@ describe('booleanLiteral', () => {
           ]);
         }
       });
+
+      test('validate returns input as-is for OK cases', () => {
+        const input = false;
+        const result = targetType.validate(input);
+        expect(Result.isOk(result)).toBe(true);
+        if (Result.isOk(result)) {
+          expect(result.value).toBe(input); // ✅ same reference
+        }
+      });
     });
 
     describe('fill', () => {

package/src/primitives/null.test.mts

@@ -166,5 +166,14 @@ describe('nullType', () => {
         ]);
       }
     });
+
+    test('validate returns input as-is for OK cases', () => {
+      const input = null;
+      const result = nullType.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
   });
 });

package/src/primitives/number.test.mts

@@ -174,6 +174,15 @@ describe('number', () => {
         ]);
       }
     });
+
+    test('validate returns input as-is for OK cases', () => {
+      const input = 123.456;
+      const result = num.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
   });
 });
 
@@ -280,5 +289,14 @@ describe('numberLiteral', () => {
         ]);
       }
     });
+
+    test('validate returns input as-is for OK cases', () => {
+      const input = 42;
+      const result = literal42.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
   });
 });

package/src/primitives/string.test.mts

@@ -187,6 +187,15 @@ describe('string', () => {
         ]);
       }
     });
+
+    test('validate returns input as-is for OK cases', () => {
+      const input = 'hello world';
+      const result = str.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
   });
 });
 
@@ -302,6 +311,15 @@ describe('stringLiteral', () => {
         ]);
       }
     });
+
+    test('validate returns input as-is for OK cases', () => {
+      const input = 'hello';
+      const result = hello.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
   });
 
   describe('cast', () => {

package/src/primitives/symbol.test.mts

@@ -1,6 +1,6 @@
 import { expectType, Result } from 'ts-data-forge';
 import { type TypeOf } from '../type.mjs';
-import { validationErrorsToMessages } from '../validation-error.mjs';
+import { validationErrorsToMessages } from '../utils/index.mjs';
 import { symbol } from './symbol.mjs';
 
 describe('symbol', () => {
@@ -70,6 +70,15 @@ describe('symbol', () => {
         ]);
       }
     });
+
+    test('validate returns input as-is for OK cases', () => {
+      const input = Symbol('my-symbol');
+      const result = targetType.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
   });
 
   describe('assertIs', () => {