ts-fortress 2.2.0 → 2.2.2

package/src/branded/number/int.test.mts

@@ -1,6 +1,6 @@
 import { asInt, 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 { int } from './int.mjs';
 
 describe('int', () => {
@@ -102,6 +102,15 @@ describe('int', () => {
         ]);
       }
     });
+
+    test('validate returns input as-is for OK cases', () => {
+      const input = 123;
+      const result = targetType.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
   });
 
   describe('assertIs', () => {

package/src/branded/number/int16.test.mts

@@ -1,6 +1,6 @@
 import { asInt16, expectType, isInt16, Result } from 'ts-data-forge';
 import { type TypeOf } from '../../type.mjs';
-import { validationErrorsToMessages } from '../../validation-error.mjs';
+import { validationErrorsToMessages } from '../../utils/index.mjs';
 import { int16 } from './int16.mjs';
 
 describe('int16', () => {
@@ -61,6 +61,15 @@ describe('int16', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input = 15000;
+      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 - out of range', () => {
       const result = targetType.validate(50000);
       expect(Result.isErr(result)).toBe(true);

package/src/branded/number/int32.test.mts

@@ -1,6 +1,6 @@
 import { asInt32, expectType, isInt32, Result } from 'ts-data-forge';
 import { type TypeOf } from '../../type.mjs';
-import { validationErrorsToMessages } from '../../validation-error.mjs';
+import { validationErrorsToMessages } from '../../utils/index.mjs';
 import { int32 } from './int32.mjs';
 
 describe('int32', () => {
@@ -55,6 +55,15 @@ describe('int32', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input = 1000000;
+      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 - out of range', () => {
       const result = targetType.validate(3000000000);
       expect(Result.isErr(result)).toBe(true);

package/src/branded/number/non-negative-finite-number.test.mts

@@ -5,7 +5,7 @@ import {
   Result,
 } from 'ts-data-forge';
 import { type TypeOf } from '../../type.mjs';
-import { validationErrorsToMessages } from '../../validation-error.mjs';
+import { validationErrorsToMessages } from '../../utils/index.mjs';
 import { nonNegativeFiniteNumber } from './non-negative-finite-number.mjs';
 
 describe('nonNegativeFiniteNumber', () => {
@@ -72,6 +72,15 @@ describe('nonNegativeFiniteNumber', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input = 123.456;
+      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 - negative', () => {
       const result = targetType.validate(-5.5);
       expect(Result.isErr(result)).toBe(true);

package/src/branded/number/non-zero-finite-number.test.mts

@@ -1,6 +1,6 @@
 import { expectType, isNonZeroFiniteNumber, Result } from 'ts-data-forge';
 import { type TypeOf } from '../../type.mjs';
-import { validationErrorsToMessages } from '../../validation-error.mjs';
+import { validationErrorsToMessages } from '../../utils/index.mjs';
 import { nonZeroFiniteNumber } from './non-zero-finite-number.mjs';
 
 describe('nonZeroFiniteNumber', () => {
@@ -68,6 +68,15 @@ describe('nonZeroFiniteNumber', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input = 123.456;
+      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 - zero', () => {
       const result = targetType.validate(0);
       expect(Result.isErr(result)).toBe(true);

package/src/branded/number/non-zero-int.test.mts

@@ -1,6 +1,6 @@
 import { asNonZeroInt, expectType, isNonZeroInt, Result } from 'ts-data-forge';
 import { type TypeOf } from '../../type.mjs';
-import { validationErrorsToMessages } from '../../validation-error.mjs';
+import { validationErrorsToMessages } from '../../utils/index.mjs';
 import { nonZeroInt } from './non-zero-int.mjs';
 
 describe('nonZeroInt', () => {
@@ -61,6 +61,15 @@ describe('nonZeroInt', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input = 123;
+      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 - zero', () => {
       const result = targetType.validate(0);
       expect(Result.isErr(result)).toBe(true);

package/src/branded/number/non-zero-safe-int.test.mts

@@ -1,6 +1,6 @@
 import { expectType, isNonZeroSafeInt, Result } from 'ts-data-forge';
 import { type TypeOf } from '../../type.mjs';
-import { validationErrorsToMessages } from '../../validation-error.mjs';
+import { validationErrorsToMessages } from '../../utils/index.mjs';
 import { nonZeroSafeInt } from './non-zero-safe-int.mjs';
 
 describe('nonZeroSafeInt', () => {
@@ -68,6 +68,15 @@ describe('nonZeroSafeInt', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input = 123;
+      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 - zero', () => {
       const result = targetType.validate(0);
       expect(Result.isErr(result)).toBe(true);

package/src/branded/number/positive-finite-number.test.mts

@@ -1,6 +1,6 @@
 import { expectType, isPositiveFiniteNumber, Result } from 'ts-data-forge';
 import { type TypeOf } from '../../type.mjs';
-import { validationErrorsToMessages } from '../../validation-error.mjs';
+import { validationErrorsToMessages } from '../../utils/index.mjs';
 import { positiveFiniteNumber } from './positive-finite-number.mjs';
 
 describe('positiveFiniteNumber', () => {
@@ -68,6 +68,15 @@ describe('positiveFiniteNumber', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input = 123.456;
+      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 - zero', () => {
       const result = targetType.validate(0);
       expect(Result.isErr(result)).toBe(true);

package/src/branded/number/positive-int.test.mts

@@ -5,7 +5,7 @@ import {
   Result,
 } from 'ts-data-forge';
 import { type TypeOf } from '../../type.mjs';
-import { validationErrorsToMessages } from '../../validation-error.mjs';
+import { validationErrorsToMessages } from '../../utils/index.mjs';
 import { positiveInt } from './positive-int.mjs';
 
 describe('positiveInt', () => {
@@ -78,6 +78,15 @@ describe('positiveInt', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input = 123;
+      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 - negative', () => {
       const result = targetType.validate(-5);
       expect(Result.isErr(result)).toBe(true);

package/src/branded/number/positive-safe-int.test.mts

@@ -5,7 +5,7 @@ import {
   Result,
 } from 'ts-data-forge';
 import { type TypeOf } from '../../type.mjs';
-import { validationErrorsToMessages } from '../../validation-error.mjs';
+import { validationErrorsToMessages } from '../../utils/index.mjs';
 import { positiveSafeInt } from './positive-safe-int.mjs';
 
 describe('positiveSafeInt', () => {
@@ -72,6 +72,15 @@ describe('positiveSafeInt', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input = 123456;
+      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 - zero', () => {
       const result = targetType.validate(0);
       expect(Result.isErr(result)).toBe(true);

package/src/branded/number/safe-int.test.mts

@@ -1,6 +1,6 @@
 import { asSafeInt, 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 { safeInt } from './safe-int.mjs';
 
 describe('safeInt', () => {
@@ -60,6 +60,15 @@ describe('safeInt', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input = 123;
+      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 - unsafe integer', () => {
       const result = targetType.validate(Number.MAX_SAFE_INTEGER + 1);
       expect(Result.isErr(result)).toBe(true);

package/src/branded/number/safe-uint.test.mts

@@ -1,6 +1,6 @@
 import { asSafeUint, expectType, isSafeUint, Result } from 'ts-data-forge';
 import { type TypeOf } from '../../type.mjs';
-import { validationErrorsToMessages } from '../../validation-error.mjs';
+import { validationErrorsToMessages } from '../../utils/index.mjs';
 import { safeUint } from './safe-uint.mjs';
 
 describe('safeUint', () => {
@@ -67,6 +67,15 @@ describe('safeUint', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input = 123456;
+      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 - negative', () => {
       const result = targetType.validate(-5);
       expect(Result.isErr(result)).toBe(true);

package/src/branded/number/uint.test.mts

@@ -1,6 +1,6 @@
 import { asUint, expectType, isUint, Result } from 'ts-data-forge';
 import { type TypeOf } from '../../type.mjs';
-import { validationErrorsToMessages } from '../../validation-error.mjs';
+import { validationErrorsToMessages } from '../../utils/index.mjs';
 import { uint } from './uint.mjs';
 
 describe('uint', () => {
@@ -73,6 +73,15 @@ describe('uint', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input = 123;
+      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 - negative', () => {
       const result = targetType.validate(-5);
       expect(Result.isErr(result)).toBe(true);

package/src/branded/number/uint16.test.mts

@@ -1,6 +1,6 @@
 import { asUint16, expectType, isUint16, Result } from 'ts-data-forge';
 import { type TypeOf } from '../../type.mjs';
-import { validationErrorsToMessages } from '../../validation-error.mjs';
+import { validationErrorsToMessages } from '../../utils/index.mjs';
 import { uint16 } from './uint16.mjs';
 
 describe('uint16', () => {
@@ -67,6 +67,15 @@ describe('uint16', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input = 30000;
+      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 - negative', () => {
       const result = targetType.validate(-5);
       expect(Result.isErr(result)).toBe(true);

package/src/branded/number/uint32.test.mts

@@ -1,6 +1,6 @@
 import { asUint32, expectType, isUint32, Result } from 'ts-data-forge';
 import { type TypeOf } from '../../type.mjs';
-import { validationErrorsToMessages } from '../../validation-error.mjs';
+import { validationErrorsToMessages } from '../../utils/index.mjs';
 import { uint32 } from './uint32.mjs';
 
 describe('uint32', () => {
@@ -67,6 +67,15 @@ describe('uint32', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input = 2000000000;
+      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 - negative', () => {
       const result = targetType.validate(-5);
       expect(Result.isErr(result)).toBe(true);

package/src/branded/simple-branded-number.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 { simpleBrandedNumber } from './simple-branded-number.mjs';
 
 describe('simpleBrandedNumber', () => {
@@ -36,6 +36,15 @@ describe('simpleBrandedNumber', () => {
     });
 
     describe('validate', () => {
+      test('validate returns input as-is for OK cases', () => {
+        const input = 42;
+        const result = userIdType.validate(input);
+        expect(Result.isOk(result)).toBe(true);
+        if (Result.isOk(result)) {
+          expect(result.value).toBe(input); // ✅ same reference
+        }
+      });
+
       test('succeeds for valid numbers', () => {
         const result = userIdType.validate(42);
         expect(Result.isOk(result)).toBe(true);
@@ -100,6 +109,15 @@ describe('simpleBrandedNumber', () => {
     });
 
     describe('validate', () => {
+      test('validate returns input as-is for OK cases', () => {
+        const input = 85;
+        const result = scoreType.validate(input);
+        expect(Result.isOk(result)).toBe(true);
+        if (Result.isOk(result)) {
+          expect(result.value).toBe(input); // ✅ same reference
+        }
+      });
+
       test('succeeds for valid numbers', () => {
         const result = scoreType.validate(85);
         expect(Result.isOk(result)).toBe(true);

package/src/branded/simple-branded-string.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 { simpleBrandedString } from './simple-branded-string.mjs';
 
 describe('simpleBrandedString', () => {
@@ -37,6 +37,15 @@ describe('simpleBrandedString', () => {
     });
 
     describe('validate', () => {
+      test('validate returns input as-is for OK cases', () => {
+        const input = 'john_doe';
+        const result = userNameType.validate(input);
+        expect(Result.isOk(result)).toBe(true);
+        if (Result.isOk(result)) {
+          expect(result.value).toBe(input); // ✅ same reference
+        }
+      });
+
       test('succeeds for valid strings', () => {
         const result = userNameType.validate('john_doe');
         expect(Result.isOk(result)).toBe(true);
@@ -101,6 +110,15 @@ describe('simpleBrandedString', () => {
     });
 
     describe('validate', () => {
+      test('validate returns input as-is for OK cases', () => {
+        const input = 'technology';
+        const result = categoryType.validate(input);
+        expect(Result.isOk(result)).toBe(true);
+        if (Result.isOk(result)) {
+          expect(result.value).toBe(input); // ✅ same reference
+        }
+      });
+
       test('succeeds for valid strings', () => {
         const result = categoryType.validate('technology');
         expect(Result.isOk(result)).toBe(true);

package/src/compose/intersection.mts

@@ -1,10 +1,12 @@
-import { expectType, Result } from 'ts-data-forge';
+import { Arr, expectType, 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 intersection = <const Types extends NonEmptyArray<Type<unknown>>>(
   types: Types,
@@ -22,22 +24,24 @@ export const intersection = <const Types extends NonEmptyArray<Type<unknown>>>(
     `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/intersection.test.mts

@@ -6,7 +6,7 @@ import { type TypeOf } from '../type.mjs';
 import {
   type ValidationError,
   validationErrorsToMessages,
-} from '../validation-error.mjs';
+} from '../utils/index.mjs';
 import { intersection } from './intersection.mjs';
 
 describe('intersection', () => {
@@ -90,6 +90,15 @@ describe('intersection', () => {
         }
       });
 
+      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);
@@ -194,6 +203,15 @@ describe('intersection', () => {
         }
       });
 
+      test('validate returns input as-is for OK cases', () => {
+        const input = 0;
+        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('aaa');
         expect(Result.isErr(result)).toBe(true);
@@ -320,6 +338,15 @@ describe('intersection', () => {
         }
       });
 
+      test('validate returns input as-is for OK cases', () => {
+        const input = 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(7);
         expect(Result.isErr(result)).toBe(true);

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/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,