valdex 1.0.1 → 1.0.3

package/README.md

@@ -1,6 +1,30 @@
 # valdex
 
-Runtime type validation with TypeScript type inference.
+**Runtime type validation with TypeScript type inference**
+
+Validate unknown data at runtime and get automatic TypeScript type narrowing—without separate schema objects or class instances.
+
+## Why valdex?
+
+Runtime validation libraries typically require you to define schemas separately and instantiate them before use. This creates distance between where you validate and where you consume the data.
+
+Valdex takes a different approach: validate inline, exactly where you need it. No jumping between schema definitions and usage points. No maintaining separate DTO classes or validator instances.
+
+```typescript
+// Traditional approach - schema defined elsewhere
+const userSchema = z.object({ name: z.string(), age: z.number() });
+const user = userSchema.parse(data);
+
+// valdex - validate at point of use
+validate(data, { name: String, age: Number });
+// data is now typed as { name: string, age: number }
+```
+
+This is particularly useful when working with:
+- Database query results (mysql2, pg, etc.)
+- External API responses (axios, fetch)
+- Message queue payloads
+- Any `unknown` or `any` typed data that needs runtime verification
 
 ## Installation
 
@@ -10,11 +34,11 @@ npm install valdex
 
 ## Features
 
-- Runtime type validation for unknown data
-- Automatic TypeScript type inference from schema
-- Support for nested objects and arrays
-- Optional and nullable field modifiers
-- Zero dependencies
+- **Zero dependencies**: No external dependencies
+- **Type inference**: Automatic TypeScript type narrowing after validation
+- **Inline validation**: Validate where you use, not where you define
+- **Nested structures**: Full support for nested objects and arrays
+- **Optional/Nullable**: Flexible handling of optional and nullable fields
 
 ## Usage
 
@@ -26,9 +50,9 @@ import { validate } from 'valdex';
 const data: unknown = await fetchData();
 
 validate(data, {
-    name: String,
-    age: Number,
-    active: Boolean
+  name: String,
+  age: Number,
+  active: Boolean
 });
 
 // TypeScript now knows the exact type of data
@@ -41,13 +65,13 @@ data.active // boolean
 
 ```typescript
 validate(data, {
-    user: {
-        id: Number,
-        profile: {
-            name: String,
-            email: String
-        }
+  user: {
+    id: Number,
+    profile: {
+      name: String,
+      email: String
     }
+  }
 });
 
 data.user.profile.name // string
@@ -57,11 +81,11 @@ data.user.profile.name // string
 
 ```typescript
 validate(data, {
-    tags: [String],           // string[]
-    items: [{                 // { id: number, name: string }[]
-        id: Number,
-        name: String
-    }]
+  tags: [String],  // string[]
+  items: [{        // { id: number, name: string }[]
+    id: Number,
+    name: String
+  }]
 });
 
 data.tags[0]       // string
@@ -76,12 +100,12 @@ Use `Optional()` to allow `undefined` values:
 import { validate, Optional } from 'valdex';
 
 validate(data, {
-    required: String,
-    optional: Optional(String),      // string | undefined
-    optionalObject: Optional({       // { id: number } | undefined
-        id: Number
-    }),
-    optionalArray: Optional([Number]) // number[] | undefined
+  required: String,
+  optional: Optional(String),  // string | undefined
+  optionalObject: Optional({   // { id: number } | undefined
+    id: Number
+  }),
+  optionalArray: Optional([Number]) // number[] | undefined
 });
 ```
 
@@ -93,11 +117,11 @@ Use `Nullable()` to allow `null` values:
 import { validate, Nullable } from 'valdex';
 
 validate(data, {
-    required: String,
-    nullable: Nullable(String),      // string | null
-    nullableObject: Nullable({       // { id: number } | null
-        id: Number
-    })
+  required: String,
+  nullable: Nullable(String),  // string | null
+  nullableObject: Nullable({   // { id: number } | null
+    id: Number
+  })
 });
 ```
 
@@ -107,7 +131,7 @@ validate(data, {
 import { validate, Optional, Nullable } from 'valdex';
 
 validate(data, {
-    field: Optional(Nullable(String)) // string | undefined | null
+  field: Optional(Nullable(String)) // string | undefined | null
 });
 ```
 
@@ -130,12 +154,12 @@ When validation fails, a `RuntimeTypeError` is thrown:
 import { validate, RuntimeTypeError } from 'valdex';
 
 try {
-    validate(data, { count: Number });
+  validate(data, { count: Number });
 } catch (error) {
-    if (error instanceof RuntimeTypeError) {
-        console.error(error.message);
-        // "count must be Number, but got String. Actual value: hello"
-    }
+  if (error instanceof RuntimeTypeError) {
+    console.error(error.message);
+    // "count must be Number, but got String. Actual value: hello"
+  }
 }
 ```
 

package/dist/index.d.mts

@@ -4,19 +4,20 @@ type OptionalMarker = {
 type NullableMarker = {
     __nullable: true;
 };
+type MarkerKeys = '__optional' | '__nullable' | '__type';
 type ArraySchema = [PrimitiveType | Expression];
 type Expression = {
-    [key: string | number]: PrimitiveType | (PrimitiveType & OptionalMarker) | (PrimitiveType & NullableMarker) | (PrimitiveType & OptionalMarker & NullableMarker) | Expression | (Expression & OptionalMarker) | (Expression & NullableMarker) | (Expression & OptionalMarker & NullableMarker) | ArraySchema | (ArraySchema & OptionalMarker) | (ArraySchema & NullableMarker) | (ArraySchema & OptionalMarker & NullableMarker);
+    [key: string | number]: PrimitiveType | Expression | ArraySchema | (PrimitiveType & OptionalMarker) | (PrimitiveType & NullableMarker) | (PrimitiveType & OptionalMarker & NullableMarker) | (Expression & OptionalMarker) | (Expression & NullableMarker) | (Expression & OptionalMarker & NullableMarker) | (ArraySchema & OptionalMarker) | (ArraySchema & NullableMarker) | (ArraySchema & OptionalMarker & NullableMarker) | true;
 };
 type PrimitiveType = NumberConstructor | StringConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor | DateConstructor;
 type InferPrimitiveType<T> = T extends NumberConstructor ? number : T extends StringConstructor ? string : T extends BooleanConstructor ? boolean : T extends ArrayConstructor ? any[] : T extends ObjectConstructor ? object : T extends DateConstructor ? Date : never;
-type InferType<T> = T extends PrimitiveType & OptionalMarker & NullableMarker ? InferPrimitiveType<T> | undefined | null : T extends PrimitiveType & OptionalMarker ? InferPrimitiveType<T> | undefined : T extends PrimitiveType & NullableMarker ? InferPrimitiveType<T> | null : T extends PrimitiveType ? InferPrimitiveType<T> : T extends Expression & OptionalMarker & NullableMarker ? {
-    [K in keyof T]: InferType<T[K]>;
-} | undefined | null : T extends Expression & OptionalMarker ? {
-    [K in keyof T]: InferType<T[K]>;
-} | undefined : T extends Expression & NullableMarker ? {
-    [K in keyof T]: InferType<T[K]>;
-} | null : T extends ArraySchema & OptionalMarker & NullableMarker ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | undefined | null : T extends ArraySchema & OptionalMarker ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | undefined : T extends ArraySchema & NullableMarker ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | null : T extends [infer U] ? U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never : T extends Expression ? {
+type InferType<T> = T extends PrimitiveType & OptionalMarker & NullableMarker ? InferPrimitiveType<T> | undefined | null : T extends PrimitiveType & OptionalMarker ? InferPrimitiveType<T> | undefined : T extends PrimitiveType & NullableMarker ? InferPrimitiveType<T> | null : T extends PrimitiveType ? InferPrimitiveType<T> : T extends ArraySchema & OptionalMarker & NullableMarker ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | undefined | null : T extends ArraySchema & OptionalMarker ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | undefined : T extends ArraySchema & NullableMarker ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | null : T extends [infer U] ? U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never : T extends OptionalMarker & NullableMarker ? {
+    [K in keyof T as K extends MarkerKeys ? never : K]: InferType<T[K]>;
+} | undefined | null : T extends OptionalMarker ? {
+    [K in keyof T as K extends MarkerKeys ? never : K]: InferType<T[K]>;
+} | undefined : T extends NullableMarker ? {
+    [K in keyof T as K extends MarkerKeys ? never : K]: InferType<T[K]>;
+} | null : T extends Expression ? {
     [K in keyof T]: InferType<T[K]>;
 } : never;
 /**

package/dist/index.d.ts

@@ -4,19 +4,20 @@ type OptionalMarker = {
 type NullableMarker = {
     __nullable: true;
 };
+type MarkerKeys = '__optional' | '__nullable' | '__type';
 type ArraySchema = [PrimitiveType | Expression];
 type Expression = {
-    [key: string | number]: PrimitiveType | (PrimitiveType & OptionalMarker) | (PrimitiveType & NullableMarker) | (PrimitiveType & OptionalMarker & NullableMarker) | Expression | (Expression & OptionalMarker) | (Expression & NullableMarker) | (Expression & OptionalMarker & NullableMarker) | ArraySchema | (ArraySchema & OptionalMarker) | (ArraySchema & NullableMarker) | (ArraySchema & OptionalMarker & NullableMarker);
+    [key: string | number]: PrimitiveType | Expression | ArraySchema | (PrimitiveType & OptionalMarker) | (PrimitiveType & NullableMarker) | (PrimitiveType & OptionalMarker & NullableMarker) | (Expression & OptionalMarker) | (Expression & NullableMarker) | (Expression & OptionalMarker & NullableMarker) | (ArraySchema & OptionalMarker) | (ArraySchema & NullableMarker) | (ArraySchema & OptionalMarker & NullableMarker) | true;
 };
 type PrimitiveType = NumberConstructor | StringConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor | DateConstructor;
 type InferPrimitiveType<T> = T extends NumberConstructor ? number : T extends StringConstructor ? string : T extends BooleanConstructor ? boolean : T extends ArrayConstructor ? any[] : T extends ObjectConstructor ? object : T extends DateConstructor ? Date : never;
-type InferType<T> = T extends PrimitiveType & OptionalMarker & NullableMarker ? InferPrimitiveType<T> | undefined | null : T extends PrimitiveType & OptionalMarker ? InferPrimitiveType<T> | undefined : T extends PrimitiveType & NullableMarker ? InferPrimitiveType<T> | null : T extends PrimitiveType ? InferPrimitiveType<T> : T extends Expression & OptionalMarker & NullableMarker ? {
-    [K in keyof T]: InferType<T[K]>;
-} | undefined | null : T extends Expression & OptionalMarker ? {
-    [K in keyof T]: InferType<T[K]>;
-} | undefined : T extends Expression & NullableMarker ? {
-    [K in keyof T]: InferType<T[K]>;
-} | null : T extends ArraySchema & OptionalMarker & NullableMarker ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | undefined | null : T extends ArraySchema & OptionalMarker ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | undefined : T extends ArraySchema & NullableMarker ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | null : T extends [infer U] ? U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never : T extends Expression ? {
+type InferType<T> = T extends PrimitiveType & OptionalMarker & NullableMarker ? InferPrimitiveType<T> | undefined | null : T extends PrimitiveType & OptionalMarker ? InferPrimitiveType<T> | undefined : T extends PrimitiveType & NullableMarker ? InferPrimitiveType<T> | null : T extends PrimitiveType ? InferPrimitiveType<T> : T extends ArraySchema & OptionalMarker & NullableMarker ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | undefined | null : T extends ArraySchema & OptionalMarker ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | undefined : T extends ArraySchema & NullableMarker ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | null : T extends [infer U] ? U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never : T extends OptionalMarker & NullableMarker ? {
+    [K in keyof T as K extends MarkerKeys ? never : K]: InferType<T[K]>;
+} | undefined | null : T extends OptionalMarker ? {
+    [K in keyof T as K extends MarkerKeys ? never : K]: InferType<T[K]>;
+} | undefined : T extends NullableMarker ? {
+    [K in keyof T as K extends MarkerKeys ? never : K]: InferType<T[K]>;
+} | null : T extends Expression ? {
     [K in keyof T]: InferType<T[K]>;
 } : never;
 /**

package/dist/index.js

@@ -55,14 +55,14 @@ function getTypeName(value) {
   const type = typeof value;
   return type.charAt(0).toUpperCase() + type.slice(1);
 }
-var TYPE_VALIDATORS = {
-  Number: (value) => typeof value === "number" && !Number.isNaN(value),
-  String: (value) => typeof value === "string",
-  Boolean: (value) => typeof value === "boolean",
-  Array: (value) => Array.isArray(value),
-  Object: (value) => typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date),
-  Date: (value) => value instanceof Date && !Number.isNaN(value.getTime())
-};
+var TYPE_VALIDATORS = /* @__PURE__ */ new Map([
+  [Number, (value) => typeof value === "number" && !Number.isNaN(value)],
+  [String, (value) => typeof value === "string"],
+  [Boolean, (value) => typeof value === "boolean"],
+  [Array, (value) => Array.isArray(value)],
+  [Object, (value) => typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date)],
+  [Date, (value) => value instanceof Date && !Number.isNaN(value.getTime())]
+]);
 function isValidateExpression(ctor) {
   return typeof ctor === "object" && !Array.isArray(ctor);
 }
@@ -79,33 +79,42 @@ function isBothOptionalAndNullable(ctor) {
   return ctor.__optional === true && ctor.__nullable === true;
 }
 function unwrapOptionalNullable(ctor) {
-  if (!ctor || typeof ctor !== "object") {
-    return ctor;
-  }
-  if (Array.isArray(ctor)) {
-    return ctor;
-  }
-  if (ctor.__type) {
-    return ctor.__type;
-  }
-  const unwrapped = {};
-  for (const key in ctor) {
-    if (key !== "__optional" && key !== "__nullable" && key !== "__type") {
-      unwrapped[key] = ctor[key];
-    }
-  }
-  if (Object.keys(unwrapped).length === 0 && (ctor.__optional || ctor.__nullable)) {
-    return ctor;
+  while (ctor && typeof ctor === "object" && !Array.isArray(ctor) && ctor.__type) {
+    ctor = ctor.__type;
   }
-  return unwrapped;
+  return ctor;
 }
 function assertType(key, expectedType, value, isValid) {
   if (!isValid) {
     throw new RuntimeTypeError(key, expectedType, getTypeName(value), value);
   }
 }
+function validateArrayElement(item, schema, path) {
+  if (isArraySchema(schema)) {
+    assertType(path, "Array", item, Array.isArray(item));
+    const innerSchema = schema[0];
+    const arr = item;
+    for (let i = 0; i < arr.length; i++) {
+      validateArrayElement(arr[i], innerSchema, `${path}[${i}]`);
+    }
+  } else if (isValidateExpression(schema)) {
+    const objectValidator = TYPE_VALIDATORS.get(Object);
+    assertType(path, "Object", item, objectValidator?.(item) ?? false);
+    validate(item, schema, path);
+  } else if (typeof schema === "function") {
+    const validator = TYPE_VALIDATORS.get(schema);
+    if (!validator) {
+      throw new Error("Invalid array element expression.");
+    }
+    assertType(path, schema.name, item, validator(item));
+  } else {
+    throw new Error("Invalid array element expression.");
+  }
+}
 function validate(target, expression, path = "") {
-  for (const [key, ctor] of Object.entries(expression)) {
+  for (const key in expression) {
+    if (!Object.prototype.hasOwnProperty.call(expression, key)) continue;
+    const ctor = expression[key];
     const value = target[key];
     const currentPath = path ? `${path}.${key}` : key;
     if (isBothOptionalAndNullable(ctor)) {
@@ -123,33 +132,20 @@ function validate(target, expression, path = "") {
     if (isArraySchema(unwrappedCtor)) {
       assertType(currentPath, "Array", value, Array.isArray(value));
       const elementSchema = unwrappedCtor[0];
-      value.forEach((item, index) => {
-        const arrayPath = `${currentPath}[${index}]`;
-        if (isValidateExpression(elementSchema)) {
-          const objectValidator = TYPE_VALIDATORS["Object"];
-          assertType(arrayPath, "Object", item, objectValidator?.(item) ?? false);
-          validate(item, elementSchema, arrayPath);
-        } else {
-          const validator = TYPE_VALIDATORS[elementSchema.name];
-          if (!validator) {
-            throw new Error("Invalid array element expression.");
-          }
-          assertType(arrayPath, elementSchema.name, item, validator(item));
-        }
-      });
+      const arr = value;
+      for (let i = 0; i < arr.length; i++) {
+        validateArrayElement(arr[i], elementSchema, `${currentPath}[${i}]`);
+      }
       continue;
     }
     if (typeof unwrappedCtor === "function") {
-      const validator = TYPE_VALIDATORS[unwrappedCtor.name];
+      const validator = TYPE_VALIDATORS.get(unwrappedCtor);
       if (!validator) {
         throw new Error("Invalid expression. Use 'Number' or 'String' or 'Boolean' or 'Array' or 'Object'.");
       }
       assertType(currentPath, unwrappedCtor.name, value, validator(value));
     } else if (isValidateExpression(unwrappedCtor)) {
-      const objectValidator = TYPE_VALIDATORS["Object"];
-      if (!objectValidator) {
-        throw new Error("Object validator not found");
-      }
+      const objectValidator = TYPE_VALIDATORS.get(Object);
       assertType(currentPath, "Object", value, objectValidator(value));
       validate(value, unwrappedCtor, currentPath);
     } else {

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["type OptionalMarker = { __optional: true };\ntype NullableMarker = { __nullable: true };\n\ntype ArraySchema = [PrimitiveType | Expression];\n\ntype Expression = {\n    [key: string | number]: PrimitiveType | (PrimitiveType & OptionalMarker) | (PrimitiveType & NullableMarker) | (PrimitiveType & OptionalMarker & NullableMarker) | Expression | (Expression & OptionalMarker) | (Expression & NullableMarker) | (Expression & OptionalMarker & NullableMarker) | ArraySchema | (ArraySchema & OptionalMarker) | (ArraySchema & NullableMarker) | (ArraySchema & OptionalMarker & NullableMarker)\n}\n\ntype PrimitiveType = NumberConstructor | StringConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor | DateConstructor;\n\ntype InferPrimitiveType<T> =\n    T extends NumberConstructor ? number :\n        T extends StringConstructor ? string :\n            T extends BooleanConstructor ? boolean :\n                T extends ArrayConstructor ? any[] :\n                    T extends ObjectConstructor ? object :\n                        T extends DateConstructor ? Date :\n                            never;\n\ntype InferType<T> =\n    T extends PrimitiveType & OptionalMarker & NullableMarker\n        ? InferPrimitiveType<T> | undefined | null\n        : T extends PrimitiveType & OptionalMarker\n            ? InferPrimitiveType<T> | undefined\n            : T extends PrimitiveType & NullableMarker\n                ? InferPrimitiveType<T> | null\n                : T extends PrimitiveType\n                    ? InferPrimitiveType<T>\n                    : T extends Expression & OptionalMarker & NullableMarker\n                        ? { [K in keyof T]: InferType<T[K]> } | undefined | null\n                        : T extends Expression & OptionalMarker\n                            ? { [K in keyof T]: InferType<T[K]> } | undefined\n                            : T extends Expression & NullableMarker\n                                ? { [K in keyof T]: InferType<T[K]> } | null\n                                : T extends ArraySchema & OptionalMarker & NullableMarker\n                                    ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | undefined | null\n                                    : T extends ArraySchema & OptionalMarker\n                                        ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | undefined\n                                        : T extends ArraySchema & NullableMarker\n                                            ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | null\n                                            : T extends [infer U]\n                                                ? U extends Expression\n                                                    ? InferType<U>[]\n                                                    : U extends PrimitiveType\n                                                        ? InferPrimitiveType<U>[]\n                                                        : never\n                                                : T extends Expression\n                                                    ? { [K in keyof T]: InferType<T[K]> }\n                                                    : never;\n\n/**\n * Marks a field as optional.\n * Optional fields pass validation even if they are undefined.\n * The type is inferred as T | undefined.\n * @example\n * ```ts\n * validate(data, {\n *     required_field: String,           // string (required)\n *     optional_field: Optional(String), // string | undefined\n *     optional_object: Optional({       // { id: string } | undefined\n *         id: String\n *     }),\n *     optional_array: Optional([String]) // string[] | undefined\n * });\n * ```\n */\nexport function Optional<T extends PrimitiveType | Expression | ArraySchema>(ctor: T): T & OptionalMarker {\n    return {\n        ...ctor as any,\n        __optional: true,\n        __type: ctor\n    } as T & OptionalMarker;\n}\n\n/**\n * Marks a field as nullable.\n * Nullable fields pass validation even if they are null.\n * The type is inferred as T | null.\n * @example\n * ```ts\n * validate(data, {\n *     required_field: String,           // string (required)\n *     nullable_field: Nullable(String), // string | null\n *     nullable_object: Nullable({       // { id: string } | null\n *         id: String\n *     }),\n *     nullable_array: Nullable([String]) // string[] | null\n * });\n * ```\n */\nexport function Nullable<T extends PrimitiveType | Expression | ArraySchema>(ctor: T): T & NullableMarker {\n    return {\n        ...ctor as any,\n        __nullable: true,\n        __type: ctor\n    } as T & NullableMarker;\n}\n\nexport class RuntimeTypeError extends Error {\n    constructor(\n        key: string,\n        requiredType: string,\n        actualType: string,\n        actualValue: any,\n        message?: string\n    ) {\n        if (message) message += \": \"\n        super(`${message || \"\"}${key} must be ${requiredType}, but got ${actualType}. Actual value: ${actualValue}`);\n    }\n}\n\nfunction getTypeName(value: any): string {\n    if (value === null) return 'null';\n    if (value === undefined) return 'undefined';\n    if (Array.isArray(value)) return 'Array';\n    if (typeof value === 'number' && Number.isNaN(value)) return 'NaN';\n    if (typeof value === 'object') return 'Object';\n\n    const type = typeof value;\n    return type.charAt(0).toUpperCase() + type.slice(1);\n}\n\nconst TYPE_VALIDATORS: Record<string, (value: any) => boolean> = {\n    Number: (value) => typeof value === 'number' && !Number.isNaN(value),\n    String: (value) => typeof value === 'string',\n    Boolean: (value) => typeof value === 'boolean',\n    Array: (value) => Array.isArray(value),\n    Object: (value) => typeof value === 'object' && value !== null && !Array.isArray(value) && !(value instanceof Date),\n    Date: (value) => value instanceof Date && !Number.isNaN(value.getTime())\n};\n\nfunction isValidateExpression(ctor: any): ctor is Expression {\n    return typeof ctor === 'object' && !Array.isArray(ctor);\n}\n\nfunction isArraySchema(ctor: any): ctor is [PrimitiveType | Expression] {\n    return Array.isArray(ctor) && ctor.length === 1;\n}\n\nfunction isOptional(ctor: any): boolean {\n    return ctor.__optional === true;\n}\n\nfunction isNullable(ctor: any): boolean {\n    return ctor.__nullable === true;\n}\n\nfunction isBothOptionalAndNullable(ctor: any): boolean {\n    return ctor.__optional === true && ctor.__nullable === true;\n}\n\nfunction unwrapOptionalNullable(ctor: any): any {\n    if (!ctor || typeof ctor !== 'object') {\n        return ctor;\n    }\n    \n    if (Array.isArray(ctor)) {\n        return ctor;\n    }\n    \n    if (ctor.__type) {\n        return ctor.__type;\n    }\n    \n    const unwrapped: any = {};\n    for (const key in ctor) {\n        if (key !== '__optional' && key !== '__nullable' && key !== '__type') {\n            unwrapped[key] = ctor[key];\n        }\n    }\n    \n    if (Object.keys(unwrapped).length === 0 && (ctor.__optional || ctor.__nullable)) {\n        return ctor;\n    }\n    \n    return unwrapped;\n}\n\nfunction assertType(key: string, expectedType: string, value: any, isValid: boolean): void {\n    if (!isValid) {\n        throw new RuntimeTypeError(key, expectedType, getTypeName(value), value);\n    }\n}\n\n/**\n * Asserts the type of target according to the expression schema.\n * The expression should be represented using primitive type constructors.\n * Supports nested types and array element type validation.\n *\n * Fields not declared in the expression but present in target are ignored.\n *\n * Fields declared in the expression do not allow undefined or null by default.\n * Wrap with Optional() to allow undefined.\n * Wrap with Nullable() to allow null.\n *\n * @param target - The value to validate\n * @param expression - The schema expression to validate against\n * @throws {RuntimeTypeError} When type mismatch occurs\n * @throws {RuntimeTypeError} When value is undefined or null (unless optional/nullable)\n * @example\n * ```ts\n * const data: unknown = getData();\n *\n * validate(data, {\n *     \"a\": Boolean,\n *     \"b\": {\n *         \"c\": Number,\n *         \"d\": Optional(String),  // string | undefined\n *         \"e\": Nullable(String)   // string | null\n *     },\n *     \"items\": [{\n *         \"name\": String,\n *         \"value\": Number\n *     }]\n * });\n *\n * // From this point, data is type-asserted\n * data.a // boolean\n * data.b.c // number\n * data.b.d // string | undefined\n * data.b.e // string | null\n * data.items[0].name // string\n * ```\n */\nexport function validate<T extends Expression>(\n    target: any,\n    expression: T,\n    path: string = \"\"\n): asserts target is InferType<T> {\n    for (const [key, ctor] of Object.entries(expression)) {\n        const value = target[key];\n        const currentPath = path ? `${path}.${key}` : key;\n\n        if (isBothOptionalAndNullable(ctor)) {\n            if (value === undefined || value === null) {\n                continue\n            }\n        } else if (value === undefined && isOptional(ctor)) {\n            continue;\n        } else if (value === null && isNullable(ctor)) {\n            continue;\n        } else {\n            assertType(currentPath, \"not undefined or null\", value, value !== undefined && value !== null);\n        }\n\n        const unwrappedCtor = unwrapOptionalNullable(ctor);\n\n        if (isArraySchema(unwrappedCtor)) {\n            assertType(currentPath, \"Array\", value, Array.isArray(value));\n            const elementSchema = unwrappedCtor[0];\n\n            (value as any[]).forEach((item, index) => {\n                const arrayPath = `${currentPath}[${index}]`;\n                if (isValidateExpression(elementSchema)) {\n                    const objectValidator = TYPE_VALIDATORS['Object'];\n                    assertType(arrayPath, \"Object\", item, objectValidator?.(item) ?? false);\n                    validate(item, elementSchema, arrayPath);\n                } else {\n                    const validator = TYPE_VALIDATORS[elementSchema.name];\n                    if (!validator) {\n                        throw new Error(\"Invalid array element expression.\");\n                    }\n                    assertType(arrayPath, elementSchema.name, item, validator(item));\n                }\n            });\n            continue;\n        }\n\n        if (typeof unwrappedCtor === 'function') {\n            const validator = TYPE_VALIDATORS[unwrappedCtor.name];\n            if (!validator) {\n                throw new Error(\"Invalid expression. Use 'Number' or 'String' or 'Boolean' or 'Array' or 'Object'.\");\n            }\n            assertType(currentPath, unwrappedCtor.name, value, validator(value));\n        } else if (isValidateExpression(unwrappedCtor)) {\n            const objectValidator = TYPE_VALIDATORS['Object'];\n            if (!objectValidator) {\n                throw new Error(\"Object validator not found\");\n            }\n            assertType(currentPath, \"Object\", value, objectValidator(value));\n            validate(value, unwrappedCtor, currentPath);\n        } else {\n            throw new Error(\"Invalid expression. Use 'Number' or 'String' or 'Boolean' or 'Array' or 'Object'.\");\n        }\n    }\n}"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["type OptionalMarker = { __optional: true };\ntype NullableMarker = { __nullable: true };\ntype MarkerKeys = '__optional' | '__nullable' | '__type';\n\ntype ArraySchema = [PrimitiveType | Expression];\n\ntype Expression = {\n    [key: string | number]: PrimitiveType | Expression | ArraySchema | (PrimitiveType & OptionalMarker) | (PrimitiveType & NullableMarker) | (PrimitiveType & OptionalMarker & NullableMarker) | (Expression & OptionalMarker) | (Expression & NullableMarker) | (Expression & OptionalMarker & NullableMarker) | (ArraySchema & OptionalMarker) | (ArraySchema & NullableMarker) | (ArraySchema & OptionalMarker & NullableMarker) | true\n}\n\ntype PrimitiveType = NumberConstructor | StringConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor | DateConstructor;\n\ntype InferPrimitiveType<T> =\n    T extends NumberConstructor ? number :\n        T extends StringConstructor ? string :\n            T extends BooleanConstructor ? boolean :\n                T extends ArrayConstructor ? any[] :\n                    T extends ObjectConstructor ? object :\n                        T extends DateConstructor ? Date :\n                            never;\n\ntype InferType<T> =\n    T extends PrimitiveType & OptionalMarker & NullableMarker\n        ? InferPrimitiveType<T> | undefined | null\n        : T extends PrimitiveType & OptionalMarker\n            ? InferPrimitiveType<T> | undefined\n            : T extends PrimitiveType & NullableMarker\n                ? InferPrimitiveType<T> | null\n                : T extends PrimitiveType\n                    ? InferPrimitiveType<T>\n                    : T extends ArraySchema & OptionalMarker & NullableMarker\n                        ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | undefined | null\n                        : T extends ArraySchema & OptionalMarker\n                            ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | undefined\n                            : T extends ArraySchema & NullableMarker\n                                ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | null\n                                : T extends [infer U]\n                                    ? U extends Expression\n                                        ? InferType<U>[]\n                                        : U extends PrimitiveType\n                                            ? InferPrimitiveType<U>[]\n                                            : never\n                                    : T extends OptionalMarker & NullableMarker\n                                        ? { [K in keyof T as K extends MarkerKeys ? never : K]: InferType<T[K]> } | undefined | null\n                                        : T extends OptionalMarker\n                                            ? { [K in keyof T as K extends MarkerKeys ? never : K]: InferType<T[K]> } | undefined\n                                            : T extends NullableMarker\n                                                ? { [K in keyof T as K extends MarkerKeys ? never : K]: InferType<T[K]> } | null\n                                                : T extends Expression\n                                                    ? { [K in keyof T]: InferType<T[K]> }\n                                                    : never;\n\n/**\n * Marks a field as optional.\n * Optional fields pass validation even if they are undefined.\n * The type is inferred as T | undefined.\n * @example\n * ```ts\n * validate(data, {\n *     required_field: String,           // string (required)\n *     optional_field: Optional(String), // string | undefined\n *     optional_object: Optional({       // { id: string } | undefined\n *         id: String\n *     }),\n *     optional_array: Optional([String]) // string[] | undefined\n * });\n * ```\n */\nexport function Optional<T extends PrimitiveType | Expression | ArraySchema>(ctor: T): T & OptionalMarker {\n    return {\n        ...ctor as any,\n        __optional: true,\n        __type: ctor\n    } as T & OptionalMarker;\n}\n\n/**\n * Marks a field as nullable.\n * Nullable fields pass validation even if they are null.\n * The type is inferred as T | null.\n * @example\n * ```ts\n * validate(data, {\n *     required_field: String,           // string (required)\n *     nullable_field: Nullable(String), // string | null\n *     nullable_object: Nullable({       // { id: string } | null\n *         id: String\n *     }),\n *     nullable_array: Nullable([String]) // string[] | null\n * });\n * ```\n */\nexport function Nullable<T extends PrimitiveType | Expression | ArraySchema>(ctor: T): T & NullableMarker {\n    return {\n        ...ctor as any,\n        __nullable: true,\n        __type: ctor\n    } as T & NullableMarker;\n}\n\nexport class RuntimeTypeError extends Error {\n    constructor(\n        key: string,\n        requiredType: string,\n        actualType: string,\n        actualValue: any,\n        message?: string\n    ) {\n        if (message) message += \": \"\n        super(`${message || \"\"}${key} must be ${requiredType}, but got ${actualType}. Actual value: ${actualValue}`);\n    }\n}\n\nfunction getTypeName(value: any): string {\n    if (value === null) return 'null';\n    if (value === undefined) return 'undefined';\n    if (Array.isArray(value)) return 'Array';\n    if (typeof value === 'number' && Number.isNaN(value)) return 'NaN';\n    if (typeof value === 'object') return 'Object';\n\n    const type = typeof value;\n    return type.charAt(0).toUpperCase() + type.slice(1);\n}\n\nconst TYPE_VALIDATORS = new Map<Function, (value: any) => boolean>([\n    [Number, (value) => typeof value === 'number' && !Number.isNaN(value)],\n    [String, (value) => typeof value === 'string'],\n    [Boolean, (value) => typeof value === 'boolean'],\n    [Array, (value) => Array.isArray(value)],\n    [Object, (value) => typeof value === 'object' && value !== null && !Array.isArray(value) && !(value instanceof Date)],\n    [Date, (value) => value instanceof Date && !Number.isNaN(value.getTime())]\n]);\n\nfunction isValidateExpression(ctor: any): ctor is Expression {\n    return typeof ctor === 'object' && !Array.isArray(ctor);\n}\n\nfunction isArraySchema(ctor: any): ctor is [PrimitiveType | Expression] {\n    return Array.isArray(ctor) && ctor.length === 1;\n}\n\nfunction isOptional(ctor: any): boolean {\n    return ctor.__optional === true;\n}\n\nfunction isNullable(ctor: any): boolean {\n    return ctor.__nullable === true;\n}\n\nfunction isBothOptionalAndNullable(ctor: any): boolean {\n    return ctor.__optional === true && ctor.__nullable === true;\n}\n\nfunction unwrapOptionalNullable(ctor: any): any {\n    while (ctor && typeof ctor === 'object' && !Array.isArray(ctor) && ctor.__type) {\n        ctor = ctor.__type;\n    }\n    return ctor;\n}\n\nfunction assertType(key: string, expectedType: string, value: any, isValid: boolean): void {\n    if (!isValid) {\n        throw new RuntimeTypeError(key, expectedType, getTypeName(value), value);\n    }\n}\n\nfunction validateArrayElement(item: any, schema: any, path: string): void {\n    if (isArraySchema(schema)) {\n        assertType(path, \"Array\", item, Array.isArray(item));\n        const innerSchema = schema[0];\n        const arr = item as any[];\n        for (let i = 0; i < arr.length; i++) {\n            validateArrayElement(arr[i], innerSchema, `${path}[${i}]`);\n        }\n    } else if (isValidateExpression(schema)) {\n        const objectValidator = TYPE_VALIDATORS.get(Object);\n        assertType(path, \"Object\", item, objectValidator?.(item) ?? false);\n        validate(item, schema, path);\n    } else if (typeof schema === 'function') {\n        const validator = TYPE_VALIDATORS.get(schema);\n        if (!validator) {\n            throw new Error(\"Invalid array element expression.\");\n        }\n        assertType(path, schema.name, item, validator(item));\n    } else {\n        throw new Error(\"Invalid array element expression.\");\n    }\n}\n\n/**\n * Asserts the type of target according to the expression schema.\n * The expression should be represented using primitive type constructors.\n * Supports nested types and array element type validation.\n *\n * Fields not declared in the expression but present in target are ignored.\n *\n * Fields declared in the expression do not allow undefined or null by default.\n * Wrap with Optional() to allow undefined.\n * Wrap with Nullable() to allow null.\n *\n * @param target - The value to validate\n * @param expression - The schema expression to validate against\n * @throws {RuntimeTypeError} When type mismatch occurs\n * @throws {RuntimeTypeError} When value is undefined or null (unless optional/nullable)\n * @example\n * ```ts\n * const data: unknown = getData();\n *\n * validate(data, {\n *     \"a\": Boolean,\n *     \"b\": {\n *         \"c\": Number,\n *         \"d\": Optional(String),  // string | undefined\n *         \"e\": Nullable(String)   // string | null\n *     },\n *     \"items\": [{\n *         \"name\": String,\n *         \"value\": Number\n *     }]\n * });\n *\n * // From this point, data is type-asserted\n * data.a // boolean\n * data.b.c // number\n * data.b.d // string | undefined\n * data.b.e // string | null\n * data.items[0].name // string\n * ```\n */\nexport function validate<T extends Expression>(\n    target: any,\n    expression: T,\n    path: string = \"\"\n): asserts target is InferType<T> {\n    for (const key in expression) {\n        if (!Object.prototype.hasOwnProperty.call(expression, key)) continue;\n\n        const ctor = expression[key];\n        const value = target[key];\n        const currentPath = path ? `${path}.${key}` : key;\n\n        if (isBothOptionalAndNullable(ctor)) {\n            if (value === undefined || value === null) {\n                continue\n            }\n        } else if (value === undefined && isOptional(ctor)) {\n            continue;\n        } else if (value === null && isNullable(ctor)) {\n            continue;\n        } else {\n            assertType(currentPath, \"not undefined or null\", value, value !== undefined && value !== null);\n        }\n\n        const unwrappedCtor = unwrapOptionalNullable(ctor);\n\n        if (isArraySchema(unwrappedCtor)) {\n            assertType(currentPath, \"Array\", value, Array.isArray(value));\n            const elementSchema = unwrappedCtor[0];\n            const arr = value as any[];\n\n            for (let i = 0; i < arr.length; i++) {\n                validateArrayElement(arr[i], elementSchema, `${currentPath}[${i}]`);\n            }\n            continue;\n        }\n\n        if (typeof unwrappedCtor === 'function') {\n            const validator = TYPE_VALIDATORS.get(unwrappedCtor);\n            if (!validator) {\n                throw new Error(\"Invalid expression. Use 'Number' or 'String' or 'Boolean' or 'Array' or 'Object'.\");\n            }\n            assertType(currentPath, unwrappedCtor.name, value, validator(value));\n        } else if (isValidateExpression(unwrappedCtor)) {\n            const objectValidator = TYPE_VALIDATORS.get(Object)!;\n            assertType(currentPath, \"Object\", value, objectValidator(value));\n            validate(value, unwrappedCtor, currentPath);\n        } else {\n            throw new Error(\"Invalid expression. Use 'Number' or 'String' or 'Boolean' or 'Array' or 'Object'.\");\n        }\n    }\n}"],"mappings":"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","names":[]}

package/dist/index.mjs

@@ -28,14 +28,14 @@ function getTypeName(value) {
   const type = typeof value;
   return type.charAt(0).toUpperCase() + type.slice(1);
 }
-var TYPE_VALIDATORS = {
-  Number: (value) => typeof value === "number" && !Number.isNaN(value),
-  String: (value) => typeof value === "string",
-  Boolean: (value) => typeof value === "boolean",
-  Array: (value) => Array.isArray(value),
-  Object: (value) => typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date),
-  Date: (value) => value instanceof Date && !Number.isNaN(value.getTime())
-};
+var TYPE_VALIDATORS = /* @__PURE__ */ new Map([
+  [Number, (value) => typeof value === "number" && !Number.isNaN(value)],
+  [String, (value) => typeof value === "string"],
+  [Boolean, (value) => typeof value === "boolean"],
+  [Array, (value) => Array.isArray(value)],
+  [Object, (value) => typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date)],
+  [Date, (value) => value instanceof Date && !Number.isNaN(value.getTime())]
+]);
 function isValidateExpression(ctor) {
   return typeof ctor === "object" && !Array.isArray(ctor);
 }
@@ -52,33 +52,42 @@ function isBothOptionalAndNullable(ctor) {
   return ctor.__optional === true && ctor.__nullable === true;
 }
 function unwrapOptionalNullable(ctor) {
-  if (!ctor || typeof ctor !== "object") {
-    return ctor;
-  }
-  if (Array.isArray(ctor)) {
-    return ctor;
-  }
-  if (ctor.__type) {
-    return ctor.__type;
-  }
-  const unwrapped = {};
-  for (const key in ctor) {
-    if (key !== "__optional" && key !== "__nullable" && key !== "__type") {
-      unwrapped[key] = ctor[key];
-    }
-  }
-  if (Object.keys(unwrapped).length === 0 && (ctor.__optional || ctor.__nullable)) {
-    return ctor;
+  while (ctor && typeof ctor === "object" && !Array.isArray(ctor) && ctor.__type) {
+    ctor = ctor.__type;
   }
-  return unwrapped;
+  return ctor;
 }
 function assertType(key, expectedType, value, isValid) {
   if (!isValid) {
     throw new RuntimeTypeError(key, expectedType, getTypeName(value), value);
   }
 }
+function validateArrayElement(item, schema, path) {
+  if (isArraySchema(schema)) {
+    assertType(path, "Array", item, Array.isArray(item));
+    const innerSchema = schema[0];
+    const arr = item;
+    for (let i = 0; i < arr.length; i++) {
+      validateArrayElement(arr[i], innerSchema, `${path}[${i}]`);
+    }
+  } else if (isValidateExpression(schema)) {
+    const objectValidator = TYPE_VALIDATORS.get(Object);
+    assertType(path, "Object", item, objectValidator?.(item) ?? false);
+    validate(item, schema, path);
+  } else if (typeof schema === "function") {
+    const validator = TYPE_VALIDATORS.get(schema);
+    if (!validator) {
+      throw new Error("Invalid array element expression.");
+    }
+    assertType(path, schema.name, item, validator(item));
+  } else {
+    throw new Error("Invalid array element expression.");
+  }
+}
 function validate(target, expression, path = "") {
-  for (const [key, ctor] of Object.entries(expression)) {
+  for (const key in expression) {
+    if (!Object.prototype.hasOwnProperty.call(expression, key)) continue;
+    const ctor = expression[key];
     const value = target[key];
     const currentPath = path ? `${path}.${key}` : key;
     if (isBothOptionalAndNullable(ctor)) {
@@ -96,33 +105,20 @@ function validate(target, expression, path = "") {
     if (isArraySchema(unwrappedCtor)) {
       assertType(currentPath, "Array", value, Array.isArray(value));
       const elementSchema = unwrappedCtor[0];
-      value.forEach((item, index) => {
-        const arrayPath = `${currentPath}[${index}]`;
-        if (isValidateExpression(elementSchema)) {
-          const objectValidator = TYPE_VALIDATORS["Object"];
-          assertType(arrayPath, "Object", item, objectValidator?.(item) ?? false);
-          validate(item, elementSchema, arrayPath);
-        } else {
-          const validator = TYPE_VALIDATORS[elementSchema.name];
-          if (!validator) {
-            throw new Error("Invalid array element expression.");
-          }
-          assertType(arrayPath, elementSchema.name, item, validator(item));
-        }
-      });
+      const arr = value;
+      for (let i = 0; i < arr.length; i++) {
+        validateArrayElement(arr[i], elementSchema, `${currentPath}[${i}]`);
+      }
       continue;
     }
     if (typeof unwrappedCtor === "function") {
-      const validator = TYPE_VALIDATORS[unwrappedCtor.name];
+      const validator = TYPE_VALIDATORS.get(unwrappedCtor);
       if (!validator) {
         throw new Error("Invalid expression. Use 'Number' or 'String' or 'Boolean' or 'Array' or 'Object'.");
       }
       assertType(currentPath, unwrappedCtor.name, value, validator(value));
     } else if (isValidateExpression(unwrappedCtor)) {
-      const objectValidator = TYPE_VALIDATORS["Object"];
-      if (!objectValidator) {
-        throw new Error("Object validator not found");
-      }
+      const objectValidator = TYPE_VALIDATORS.get(Object);
       assertType(currentPath, "Object", value, objectValidator(value));
       validate(value, unwrappedCtor, currentPath);
     } else {

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["type OptionalMarker = { __optional: true };\ntype NullableMarker = { __nullable: true };\n\ntype ArraySchema = [PrimitiveType | Expression];\n\ntype Expression = {\n    [key: string | number]: PrimitiveType | (PrimitiveType & OptionalMarker) | (PrimitiveType & NullableMarker) | (PrimitiveType & OptionalMarker & NullableMarker) | Expression | (Expression & OptionalMarker) | (Expression & NullableMarker) | (Expression & OptionalMarker & NullableMarker) | ArraySchema | (ArraySchema & OptionalMarker) | (ArraySchema & NullableMarker) | (ArraySchema & OptionalMarker & NullableMarker)\n}\n\ntype PrimitiveType = NumberConstructor | StringConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor | DateConstructor;\n\ntype InferPrimitiveType<T> =\n    T extends NumberConstructor ? number :\n        T extends StringConstructor ? string :\n            T extends BooleanConstructor ? boolean :\n                T extends ArrayConstructor ? any[] :\n                    T extends ObjectConstructor ? object :\n                        T extends DateConstructor ? Date :\n                            never;\n\ntype InferType<T> =\n    T extends PrimitiveType & OptionalMarker & NullableMarker\n        ? InferPrimitiveType<T> | undefined | null\n        : T extends PrimitiveType & OptionalMarker\n            ? InferPrimitiveType<T> | undefined\n            : T extends PrimitiveType & NullableMarker\n                ? InferPrimitiveType<T> | null\n                : T extends PrimitiveType\n                    ? InferPrimitiveType<T>\n                    : T extends Expression & OptionalMarker & NullableMarker\n                        ? { [K in keyof T]: InferType<T[K]> } | undefined | null\n                        : T extends Expression & OptionalMarker\n                            ? { [K in keyof T]: InferType<T[K]> } | undefined\n                            : T extends Expression & NullableMarker\n                                ? { [K in keyof T]: InferType<T[K]> } | null\n                                : T extends ArraySchema & OptionalMarker & NullableMarker\n                                    ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | undefined | null\n                                    : T extends ArraySchema & OptionalMarker\n                                        ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | undefined\n                                        : T extends ArraySchema & NullableMarker\n                                            ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | null\n                                            : T extends [infer U]\n                                                ? U extends Expression\n                                                    ? InferType<U>[]\n                                                    : U extends PrimitiveType\n                                                        ? InferPrimitiveType<U>[]\n                                                        : never\n                                                : T extends Expression\n                                                    ? { [K in keyof T]: InferType<T[K]> }\n                                                    : never;\n\n/**\n * Marks a field as optional.\n * Optional fields pass validation even if they are undefined.\n * The type is inferred as T | undefined.\n * @example\n * ```ts\n * validate(data, {\n *     required_field: String,           // string (required)\n *     optional_field: Optional(String), // string | undefined\n *     optional_object: Optional({       // { id: string } | undefined\n *         id: String\n *     }),\n *     optional_array: Optional([String]) // string[] | undefined\n * });\n * ```\n */\nexport function Optional<T extends PrimitiveType | Expression | ArraySchema>(ctor: T): T & OptionalMarker {\n    return {\n        ...ctor as any,\n        __optional: true,\n        __type: ctor\n    } as T & OptionalMarker;\n}\n\n/**\n * Marks a field as nullable.\n * Nullable fields pass validation even if they are null.\n * The type is inferred as T | null.\n * @example\n * ```ts\n * validate(data, {\n *     required_field: String,           // string (required)\n *     nullable_field: Nullable(String), // string | null\n *     nullable_object: Nullable({       // { id: string } | null\n *         id: String\n *     }),\n *     nullable_array: Nullable([String]) // string[] | null\n * });\n * ```\n */\nexport function Nullable<T extends PrimitiveType | Expression | ArraySchema>(ctor: T): T & NullableMarker {\n    return {\n        ...ctor as any,\n        __nullable: true,\n        __type: ctor\n    } as T & NullableMarker;\n}\n\nexport class RuntimeTypeError extends Error {\n    constructor(\n        key: string,\n        requiredType: string,\n        actualType: string,\n        actualValue: any,\n        message?: string\n    ) {\n        if (message) message += \": \"\n        super(`${message || \"\"}${key} must be ${requiredType}, but got ${actualType}. Actual value: ${actualValue}`);\n    }\n}\n\nfunction getTypeName(value: any): string {\n    if (value === null) return 'null';\n    if (value === undefined) return 'undefined';\n    if (Array.isArray(value)) return 'Array';\n    if (typeof value === 'number' && Number.isNaN(value)) return 'NaN';\n    if (typeof value === 'object') return 'Object';\n\n    const type = typeof value;\n    return type.charAt(0).toUpperCase() + type.slice(1);\n}\n\nconst TYPE_VALIDATORS: Record<string, (value: any) => boolean> = {\n    Number: (value) => typeof value === 'number' && !Number.isNaN(value),\n    String: (value) => typeof value === 'string',\n    Boolean: (value) => typeof value === 'boolean',\n    Array: (value) => Array.isArray(value),\n    Object: (value) => typeof value === 'object' && value !== null && !Array.isArray(value) && !(value instanceof Date),\n    Date: (value) => value instanceof Date && !Number.isNaN(value.getTime())\n};\n\nfunction isValidateExpression(ctor: any): ctor is Expression {\n    return typeof ctor === 'object' && !Array.isArray(ctor);\n}\n\nfunction isArraySchema(ctor: any): ctor is [PrimitiveType | Expression] {\n    return Array.isArray(ctor) && ctor.length === 1;\n}\n\nfunction isOptional(ctor: any): boolean {\n    return ctor.__optional === true;\n}\n\nfunction isNullable(ctor: any): boolean {\n    return ctor.__nullable === true;\n}\n\nfunction isBothOptionalAndNullable(ctor: any): boolean {\n    return ctor.__optional === true && ctor.__nullable === true;\n}\n\nfunction unwrapOptionalNullable(ctor: any): any {\n    if (!ctor || typeof ctor !== 'object') {\n        return ctor;\n    }\n    \n    if (Array.isArray(ctor)) {\n        return ctor;\n    }\n    \n    if (ctor.__type) {\n        return ctor.__type;\n    }\n    \n    const unwrapped: any = {};\n    for (const key in ctor) {\n        if (key !== '__optional' && key !== '__nullable' && key !== '__type') {\n            unwrapped[key] = ctor[key];\n        }\n    }\n    \n    if (Object.keys(unwrapped).length === 0 && (ctor.__optional || ctor.__nullable)) {\n        return ctor;\n    }\n    \n    return unwrapped;\n}\n\nfunction assertType(key: string, expectedType: string, value: any, isValid: boolean): void {\n    if (!isValid) {\n        throw new RuntimeTypeError(key, expectedType, getTypeName(value), value);\n    }\n}\n\n/**\n * Asserts the type of target according to the expression schema.\n * The expression should be represented using primitive type constructors.\n * Supports nested types and array element type validation.\n *\n * Fields not declared in the expression but present in target are ignored.\n *\n * Fields declared in the expression do not allow undefined or null by default.\n * Wrap with Optional() to allow undefined.\n * Wrap with Nullable() to allow null.\n *\n * @param target - The value to validate\n * @param expression - The schema expression to validate against\n * @throws {RuntimeTypeError} When type mismatch occurs\n * @throws {RuntimeTypeError} When value is undefined or null (unless optional/nullable)\n * @example\n * ```ts\n * const data: unknown = getData();\n *\n * validate(data, {\n *     \"a\": Boolean,\n *     \"b\": {\n *         \"c\": Number,\n *         \"d\": Optional(String),  // string | undefined\n *         \"e\": Nullable(String)   // string | null\n *     },\n *     \"items\": [{\n *         \"name\": String,\n *         \"value\": Number\n *     }]\n * });\n *\n * // From this point, data is type-asserted\n * data.a // boolean\n * data.b.c // number\n * data.b.d // string | undefined\n * data.b.e // string | null\n * data.items[0].name // string\n * ```\n */\nexport function validate<T extends Expression>(\n    target: any,\n    expression: T,\n    path: string = \"\"\n): asserts target is InferType<T> {\n    for (const [key, ctor] of Object.entries(expression)) {\n        const value = target[key];\n        const currentPath = path ? `${path}.${key}` : key;\n\n        if (isBothOptionalAndNullable(ctor)) {\n            if (value === undefined || value === null) {\n                continue\n            }\n        } else if (value === undefined && isOptional(ctor)) {\n            continue;\n        } else if (value === null && isNullable(ctor)) {\n            continue;\n        } else {\n            assertType(currentPath, \"not undefined or null\", value, value !== undefined && value !== null);\n        }\n\n        const unwrappedCtor = unwrapOptionalNullable(ctor);\n\n        if (isArraySchema(unwrappedCtor)) {\n            assertType(currentPath, \"Array\", value, Array.isArray(value));\n            const elementSchema = unwrappedCtor[0];\n\n            (value as any[]).forEach((item, index) => {\n                const arrayPath = `${currentPath}[${index}]`;\n                if (isValidateExpression(elementSchema)) {\n                    const objectValidator = TYPE_VALIDATORS['Object'];\n                    assertType(arrayPath, \"Object\", item, objectValidator?.(item) ?? false);\n                    validate(item, elementSchema, arrayPath);\n                } else {\n                    const validator = TYPE_VALIDATORS[elementSchema.name];\n                    if (!validator) {\n                        throw new Error(\"Invalid array element expression.\");\n                    }\n                    assertType(arrayPath, elementSchema.name, item, validator(item));\n                }\n            });\n            continue;\n        }\n\n        if (typeof unwrappedCtor === 'function') {\n            const validator = TYPE_VALIDATORS[unwrappedCtor.name];\n            if (!validator) {\n                throw new Error(\"Invalid expression. Use 'Number' or 'String' or 'Boolean' or 'Array' or 'Object'.\");\n            }\n            assertType(currentPath, unwrappedCtor.name, value, validator(value));\n        } else if (isValidateExpression(unwrappedCtor)) {\n            const objectValidator = TYPE_VALIDATORS['Object'];\n            if (!objectValidator) {\n                throw new Error(\"Object validator not found\");\n            }\n            assertType(currentPath, \"Object\", value, objectValidator(value));\n            validate(value, unwrappedCtor, currentPath);\n        } else {\n            throw new Error(\"Invalid expression. Use 'Number' or 'String' or 'Boolean' or 'Array' or 'Object'.\");\n        }\n    }\n}"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["type OptionalMarker = { __optional: true };\ntype NullableMarker = { __nullable: true };\ntype MarkerKeys = '__optional' | '__nullable' | '__type';\n\ntype ArraySchema = [PrimitiveType | Expression];\n\ntype Expression = {\n    [key: string | number]: PrimitiveType | Expression | ArraySchema | (PrimitiveType & OptionalMarker) | (PrimitiveType & NullableMarker) | (PrimitiveType & OptionalMarker & NullableMarker) | (Expression & OptionalMarker) | (Expression & NullableMarker) | (Expression & OptionalMarker & NullableMarker) | (ArraySchema & OptionalMarker) | (ArraySchema & NullableMarker) | (ArraySchema & OptionalMarker & NullableMarker) | true\n}\n\ntype PrimitiveType = NumberConstructor | StringConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor | DateConstructor;\n\ntype InferPrimitiveType<T> =\n    T extends NumberConstructor ? number :\n        T extends StringConstructor ? string :\n            T extends BooleanConstructor ? boolean :\n                T extends ArrayConstructor ? any[] :\n                    T extends ObjectConstructor ? object :\n                        T extends DateConstructor ? Date :\n                            never;\n\ntype InferType<T> =\n    T extends PrimitiveType & OptionalMarker & NullableMarker\n        ? InferPrimitiveType<T> | undefined | null\n        : T extends PrimitiveType & OptionalMarker\n            ? InferPrimitiveType<T> | undefined\n            : T extends PrimitiveType & NullableMarker\n                ? InferPrimitiveType<T> | null\n                : T extends PrimitiveType\n                    ? InferPrimitiveType<T>\n                    : T extends ArraySchema & OptionalMarker & NullableMarker\n                        ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | undefined | null\n                        : T extends ArraySchema & OptionalMarker\n                            ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | undefined\n                            : T extends ArraySchema & NullableMarker\n                                ? (T extends [infer U] ? (U extends Expression ? InferType<U>[] : U extends PrimitiveType ? InferPrimitiveType<U>[] : never) : never) | null\n                                : T extends [infer U]\n                                    ? U extends Expression\n                                        ? InferType<U>[]\n                                        : U extends PrimitiveType\n                                            ? InferPrimitiveType<U>[]\n                                            : never\n                                    : T extends OptionalMarker & NullableMarker\n                                        ? { [K in keyof T as K extends MarkerKeys ? never : K]: InferType<T[K]> } | undefined | null\n                                        : T extends OptionalMarker\n                                            ? { [K in keyof T as K extends MarkerKeys ? never : K]: InferType<T[K]> } | undefined\n                                            : T extends NullableMarker\n                                                ? { [K in keyof T as K extends MarkerKeys ? never : K]: InferType<T[K]> } | null\n                                                : T extends Expression\n                                                    ? { [K in keyof T]: InferType<T[K]> }\n                                                    : never;\n\n/**\n * Marks a field as optional.\n * Optional fields pass validation even if they are undefined.\n * The type is inferred as T | undefined.\n * @example\n * ```ts\n * validate(data, {\n *     required_field: String,           // string (required)\n *     optional_field: Optional(String), // string | undefined\n *     optional_object: Optional({       // { id: string } | undefined\n *         id: String\n *     }),\n *     optional_array: Optional([String]) // string[] | undefined\n * });\n * ```\n */\nexport function Optional<T extends PrimitiveType | Expression | ArraySchema>(ctor: T): T & OptionalMarker {\n    return {\n        ...ctor as any,\n        __optional: true,\n        __type: ctor\n    } as T & OptionalMarker;\n}\n\n/**\n * Marks a field as nullable.\n * Nullable fields pass validation even if they are null.\n * The type is inferred as T | null.\n * @example\n * ```ts\n * validate(data, {\n *     required_field: String,           // string (required)\n *     nullable_field: Nullable(String), // string | null\n *     nullable_object: Nullable({       // { id: string } | null\n *         id: String\n *     }),\n *     nullable_array: Nullable([String]) // string[] | null\n * });\n * ```\n */\nexport function Nullable<T extends PrimitiveType | Expression | ArraySchema>(ctor: T): T & NullableMarker {\n    return {\n        ...ctor as any,\n        __nullable: true,\n        __type: ctor\n    } as T & NullableMarker;\n}\n\nexport class RuntimeTypeError extends Error {\n    constructor(\n        key: string,\n        requiredType: string,\n        actualType: string,\n        actualValue: any,\n        message?: string\n    ) {\n        if (message) message += \": \"\n        super(`${message || \"\"}${key} must be ${requiredType}, but got ${actualType}. Actual value: ${actualValue}`);\n    }\n}\n\nfunction getTypeName(value: any): string {\n    if (value === null) return 'null';\n    if (value === undefined) return 'undefined';\n    if (Array.isArray(value)) return 'Array';\n    if (typeof value === 'number' && Number.isNaN(value)) return 'NaN';\n    if (typeof value === 'object') return 'Object';\n\n    const type = typeof value;\n    return type.charAt(0).toUpperCase() + type.slice(1);\n}\n\nconst TYPE_VALIDATORS = new Map<Function, (value: any) => boolean>([\n    [Number, (value) => typeof value === 'number' && !Number.isNaN(value)],\n    [String, (value) => typeof value === 'string'],\n    [Boolean, (value) => typeof value === 'boolean'],\n    [Array, (value) => Array.isArray(value)],\n    [Object, (value) => typeof value === 'object' && value !== null && !Array.isArray(value) && !(value instanceof Date)],\n    [Date, (value) => value instanceof Date && !Number.isNaN(value.getTime())]\n]);\n\nfunction isValidateExpression(ctor: any): ctor is Expression {\n    return typeof ctor === 'object' && !Array.isArray(ctor);\n}\n\nfunction isArraySchema(ctor: any): ctor is [PrimitiveType | Expression] {\n    return Array.isArray(ctor) && ctor.length === 1;\n}\n\nfunction isOptional(ctor: any): boolean {\n    return ctor.__optional === true;\n}\n\nfunction isNullable(ctor: any): boolean {\n    return ctor.__nullable === true;\n}\n\nfunction isBothOptionalAndNullable(ctor: any): boolean {\n    return ctor.__optional === true && ctor.__nullable === true;\n}\n\nfunction unwrapOptionalNullable(ctor: any): any {\n    while (ctor && typeof ctor === 'object' && !Array.isArray(ctor) && ctor.__type) {\n        ctor = ctor.__type;\n    }\n    return ctor;\n}\n\nfunction assertType(key: string, expectedType: string, value: any, isValid: boolean): void {\n    if (!isValid) {\n        throw new RuntimeTypeError(key, expectedType, getTypeName(value), value);\n    }\n}\n\nfunction validateArrayElement(item: any, schema: any, path: string): void {\n    if (isArraySchema(schema)) {\n        assertType(path, \"Array\", item, Array.isArray(item));\n        const innerSchema = schema[0];\n        const arr = item as any[];\n        for (let i = 0; i < arr.length; i++) {\n            validateArrayElement(arr[i], innerSchema, `${path}[${i}]`);\n        }\n    } else if (isValidateExpression(schema)) {\n        const objectValidator = TYPE_VALIDATORS.get(Object);\n        assertType(path, \"Object\", item, objectValidator?.(item) ?? false);\n        validate(item, schema, path);\n    } else if (typeof schema === 'function') {\n        const validator = TYPE_VALIDATORS.get(schema);\n        if (!validator) {\n            throw new Error(\"Invalid array element expression.\");\n        }\n        assertType(path, schema.name, item, validator(item));\n    } else {\n        throw new Error(\"Invalid array element expression.\");\n    }\n}\n\n/**\n * Asserts the type of target according to the expression schema.\n * The expression should be represented using primitive type constructors.\n * Supports nested types and array element type validation.\n *\n * Fields not declared in the expression but present in target are ignored.\n *\n * Fields declared in the expression do not allow undefined or null by default.\n * Wrap with Optional() to allow undefined.\n * Wrap with Nullable() to allow null.\n *\n * @param target - The value to validate\n * @param expression - The schema expression to validate against\n * @throws {RuntimeTypeError} When type mismatch occurs\n * @throws {RuntimeTypeError} When value is undefined or null (unless optional/nullable)\n * @example\n * ```ts\n * const data: unknown = getData();\n *\n * validate(data, {\n *     \"a\": Boolean,\n *     \"b\": {\n *         \"c\": Number,\n *         \"d\": Optional(String),  // string | undefined\n *         \"e\": Nullable(String)   // string | null\n *     },\n *     \"items\": [{\n *         \"name\": String,\n *         \"value\": Number\n *     }]\n * });\n *\n * // From this point, data is type-asserted\n * data.a // boolean\n * data.b.c // number\n * data.b.d // string | undefined\n * data.b.e // string | null\n * data.items[0].name // string\n * ```\n */\nexport function validate<T extends Expression>(\n    target: any,\n    expression: T,\n    path: string = \"\"\n): asserts target is InferType<T> {\n    for (const key in expression) {\n        if (!Object.prototype.hasOwnProperty.call(expression, key)) continue;\n\n        const ctor = expression[key];\n        const value = target[key];\n        const currentPath = path ? `${path}.${key}` : key;\n\n        if (isBothOptionalAndNullable(ctor)) {\n            if (value === undefined || value === null) {\n                continue\n            }\n        } else if (value === undefined && isOptional(ctor)) {\n            continue;\n        } else if (value === null && isNullable(ctor)) {\n            continue;\n        } else {\n            assertType(currentPath, \"not undefined or null\", value, value !== undefined && value !== null);\n        }\n\n        const unwrappedCtor = unwrapOptionalNullable(ctor);\n\n        if (isArraySchema(unwrappedCtor)) {\n            assertType(currentPath, \"Array\", value, Array.isArray(value));\n            const elementSchema = unwrappedCtor[0];\n            const arr = value as any[];\n\n            for (let i = 0; i < arr.length; i++) {\n                validateArrayElement(arr[i], elementSchema, `${currentPath}[${i}]`);\n            }\n            continue;\n        }\n\n        if (typeof unwrappedCtor === 'function') {\n            const validator = TYPE_VALIDATORS.get(unwrappedCtor);\n            if (!validator) {\n                throw new Error(\"Invalid expression. Use 'Number' or 'String' or 'Boolean' or 'Array' or 'Object'.\");\n            }\n            assertType(currentPath, unwrappedCtor.name, value, validator(value));\n        } else if (isValidateExpression(unwrappedCtor)) {\n            const objectValidator = TYPE_VALIDATORS.get(Object)!;\n            assertType(currentPath, \"Object\", value, objectValidator(value));\n            validate(value, unwrappedCtor, currentPath);\n        } else {\n            throw new Error(\"Invalid expression. Use 'Number' or 'String' or 'Boolean' or 'Array' or 'Object'.\");\n        }\n    }\n}"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "valdex",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Runtime type validation with TypeScript type inference",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -23,7 +23,7 @@
   "scripts": {
     "build": "tsup",
     "prepublishOnly": "npm run build",
-    "test": "tsx test.ts"
+    "test": "jest"
   },
   "keywords": [
     "typescript",
@@ -36,9 +36,12 @@
   "author": "",
   "license": "MIT",
   "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
     "tsup": "^8.3.5",
-    "typescript": "^5.7.2",
-    "tsx": "^4.19.2"
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
   },
   "repository": {
     "type": "git",