ts-fortress 2.2.1 → 2.2.2

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', () => {

package/src/primitives/undefined.test.mts

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

package/src/record/key-value-record.mts

@@ -1,12 +1,14 @@
-import { isRecord, Result } from 'ts-data-forge';
+import { Arr, 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,
   createPrimitiveValidationError,
   prependPathToValidationErrors,
   type ValidationError,
   type ValidationErrorWithMessage,
-} from '../validation-error.mjs';
+} from '../utils/index.mjs';
 
 type RecordResultType<
   K extends Type<string>,
@@ -36,43 +38,39 @@ export const keyValueRecord = <K extends Type<string>, V extends Type<unknown>>(
       ]);
     }
 
-    const errors: readonly ValidationError[] = Object.entries(a).flatMap(
-      ([k, v]) => {
-        const keyErrors = (() => {
+    const errors: readonly ValidationError[] = Arr.generate(function* () {
+      for (const [k, v] of Object.entries(a)) {
+        {
           const res = keyType.validate(k);
-          return Result.isErr(res)
-            ? [
-                {
-                  path: [],
-                  actualValue: k,
-                  expectedType: typeName,
-                  message: `The key of the record is expected to be <${keyType.typeName}>`,
-                  typeName,
-                } satisfies ValidationErrorWithMessage,
-                ...res.value,
-              ]
-            : [];
-        })();
 
-        const valueErrors = (() => {
+          if (Result.isErr(res)) {
+            yield {
+              path: [],
+              actualValue: k,
+              expectedType: typeName,
+              message: `The key of the record is expected to be <${keyType.typeName}>`,
+              typeName,
+            } satisfies ValidationErrorWithMessage;
+
+            yield* res.value;
+          }
+        }
+        {
           const res = valueType.validate(v);
-          return Result.isErr(res)
-            ? [
-                {
-                  path: [],
-                  actualValue: v,
-                  expectedType: typeName,
-                  message: `The value of the record is expected to be <${valueType.typeName}>`,
-                  typeName,
-                } satisfies ValidationErrorWithMessage,
-                ...prependPathToValidationErrors(res.value, k),
-              ]
-            : [];
-        })();
+          if (Result.isErr(res)) {
+            yield {
+              path: [],
+              actualValue: v,
+              expectedType: typeName,
+              message: `The value of the record is expected to be <${valueType.typeName}>`,
+              typeName,
+            } satisfies ValidationErrorWithMessage;
 
-        return [...keyErrors, ...valueErrors];
-      },
-    );
+            yield* prependPathToValidationErrors(res.value, k);
+          }
+        }
+      }
+    });
 
     if (errors.length > 0) {
       return Result.err(errors);

package/src/record/key-value-record.test.mts

@@ -4,7 +4,7 @@ import { type TypeOf } from '../type.mjs';
 import {
   type ValidationError,
   validationErrorsToMessages,
-} from '../validation-error.mjs';
+} from '../utils/index.mjs';
 import { keyValueRecord } from './key-value-record.mjs';
 
 describe('keyValueRecord', () => {
@@ -74,6 +74,19 @@ describe('keyValueRecord', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input: UnknownRecord = {
+        year: 2000,
+        month: 12,
+        date: 25,
+      };
+      const result = strNumRecord.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
     test('falsy case', () => {
       const x: UnknownRecord = {
         year: 2000,

package/src/record/keyof.test.mts

@@ -1,7 +1,7 @@
 import { expectType, Result } from 'ts-data-forge';
 import { number } from '../primitives/index.mjs';
 import { type Type, type TypeOf } from '../type.mjs';
-import { validationErrorsToMessages } from '../validation-error.mjs';
+import { validationErrorsToMessages } from '../utils/index.mjs';
 import { keyof } from './keyof.mjs';
 import { record } from './record.mjs';
 
@@ -61,6 +61,15 @@ describe('keyof', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input = 'year';
+      const result = ymdKey.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
     test('falsy case', () => {
       const x: unknown = 'minutes';
 

package/src/record/omit.mts

@@ -1,7 +1,11 @@
 import { expectType, isRecord, Obj, Result } from 'ts-data-forge';
 import { type Type, type TypeOf } from '../type.mjs';
-import { createAssertFn, createCastFn, createIsFn } from '../utils/index.mjs';
-import { createPrimitiveValidationError } from '../validation-error.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  createPrimitiveValidationError,
+} from '../utils/index.mjs';
 
 /** Creates a record type with keys omitted. */
 export const omit = <
@@ -43,9 +47,8 @@ export const omit = <
 
     const baseValidationResult = recordType.validate(objectFilled);
 
-    return Result.map(baseValidationResult, Obj.omit(keysToOmit)) as ReturnType<
-      Type<V>['validate']
-    >;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return Result.map(baseValidationResult, () => a as V);
   };
 
   const fill: Type<V>['fill'] = (a) => Obj.omit(recordType.fill(a), keysToOmit);

package/src/record/omit.test.mts

@@ -1,7 +1,7 @@
 import { expectType, Result } from 'ts-data-forge';
 import { number } from '../primitives/index.mjs';
 import { type Type, type TypeOf } from '../type.mjs';
-import { validationErrorsToMessages } from '../validation-error.mjs';
+import { validationErrorsToMessages } from '../utils/index.mjs';
 import { omit } from './omit.mjs';
 import { record } from './record.mjs';
 
@@ -73,6 +73,51 @@ describe('omit', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input: UnknownRecord = {
+        year: 2000,
+        month: 12,
+      };
+      const result = ym.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
+    test('truthy case with additional keys', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: 12,
+        aaa: 999,
+      };
+
+      const result = ym.validate(x);
+      expect(Result.isOk(result)).toBe(true);
+
+      if (Result.isOk(result)) {
+        expectType<typeof result.value, Ym>('=');
+        expect(result.value).toStrictEqual({
+          year: 2000,
+          month: 12,
+          aaa: 999,
+        });
+      }
+    });
+
+    test('validate returns input as-is for OK cases with additional keys', () => {
+      const input: UnknownRecord = {
+        year: 2000,
+        month: 12,
+        aaa: 999,
+      };
+      const result = ym.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
     test('falsy case', () => {
       const x: UnknownRecord = {
         year: 2000,

package/src/record/partial.mts

@@ -1,7 +1,11 @@
 import { expectType, ISet, isRecord, Obj, Result } from 'ts-data-forge';
 import { type Type, type TypeOf } from '../type.mjs';
-import { createAssertFn, createCastFn, createIsFn } from '../utils/index.mjs';
-import { createPrimitiveValidationError } from '../validation-error.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  createPrimitiveValidationError,
+} from '../utils/index.mjs';
 
 /**
  * Creates a Partial type. If keysToBeOptional is set, only those keys are
@@ -58,9 +62,7 @@ export const partial = <
     const validationResult = recordType.validate(objectFilled);
 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    return Result.map(validationResult, Obj.pick(Object.keys(a))) as ReturnType<
-      Type<V>['validate']
-    >;
+    return Result.map(validationResult, () => a as V);
   };
 
   const fill: Type<V>['fill'] = (a) => {

package/src/record/partial.test.mts

@@ -4,7 +4,7 @@ import { type Type, type TypeOf } from '../type.mjs';
 import {
   type ValidationError,
   validationErrorsToMessages,
-} from '../validation-error.mjs';
+} from '../utils/index.mjs';
 import { optional } from './optional.mjs';
 import { partial } from './partial.mjs';
 import { record } from './record.mjs';
@@ -88,6 +88,19 @@ describe('partial', () => {
         }
       });
 
+      test('validate returns input as-is for OK cases', () => {
+        const input: UnknownRecord = {
+          year: 2000,
+          month: 12,
+          date: 25,
+        };
+        const result = ymd.validate(input);
+        expect(Result.isOk(result)).toBe(true);
+        if (Result.isOk(result)) {
+          expect(result.value).toBe(input); // ✅ same reference
+        }
+      });
+
       test('truthy case optional keys', () => {
         const x: UnknownRecord = {};
 
@@ -100,6 +113,51 @@ describe('partial', () => {
         }
       });
 
+      test('validate returns input as-is for empty object', () => {
+        const input: UnknownRecord = {};
+        const result = ymd.validate(input);
+        expect(Result.isOk(result)).toBe(true);
+        if (Result.isOk(result)) {
+          expect(result.value).toBe(input); // ✅ same reference
+        }
+      });
+
+      test('truthy case with additional keys', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 12,
+          date: 25,
+          aaa: 999,
+        };
+
+        const result = ymd.validate(x);
+        expectType<typeof result, Result<Ymd, readonly ValidationError[]>>('=');
+        expect(Result.isOk(result)).toBe(true);
+
+        if (Result.isOk(result)) {
+          expect(result.value).toStrictEqual({
+            year: 2000,
+            month: 12,
+            date: 25,
+            aaa: 999,
+          });
+        }
+      });
+
+      test('validate returns input as-is for OK cases with additional keys', () => {
+        const input: UnknownRecord = {
+          year: 2000,
+          month: 12,
+          date: 25,
+          aaa: 999,
+        };
+        const result = ymd.validate(input);
+        expect(Result.isOk(result)).toBe(true);
+        if (Result.isOk(result)) {
+          expect(result.value).toBe(input); // ✅ same reference
+        }
+      });
+
       test('falsy case 1', () => {
         const x: UnknownRecord = {
           year: 2000,
@@ -287,6 +345,18 @@ describe('partial', () => {
         }
       });
 
+      test('partiallyPartialType validate returns input as-is for OK cases', () => {
+        const input: UnknownRecord = {
+          year: 2000,
+          month: 12,
+        };
+        const result = ymd.validate(input);
+        expect(Result.isOk(result)).toBe(true);
+        if (Result.isOk(result)) {
+          expect(result.value).toBe(input); // ✅ same reference
+        }
+      });
+
       test('falsy case', () => {
         const x: UnknownRecord = {
           year: 2000,

package/src/record/pick.mts

@@ -1,7 +1,11 @@
 import { expectType, isRecord, Obj, Result } from 'ts-data-forge';
 import { type Type, type TypeOf } from '../type.mjs';
-import { createAssertFn, createCastFn, createIsFn } from '../utils/index.mjs';
-import { createPrimitiveValidationError } from '../validation-error.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  createPrimitiveValidationError,
+} from '../utils/index.mjs';
 
 /** Creates a record type with keys picked. */
 export const pick = <
@@ -44,9 +48,7 @@ export const pick = <
     const baseValidationResult = recordType.validate(objectFilled);
 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    return Result.map(baseValidationResult, Obj.pick(keysToPick)) as ReturnType<
-      Type<V>['validate']
-    >;
+    return Result.map(baseValidationResult, () => a as V);
   };
 
   const fill: Type<V>['fill'] = (a) =>