@point3/valdex 1.0.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 point3 (violetpay)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,176 @@
+# valdex
+
+**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
+
+```bash
+npm install valdex
+```
+
+## Features
+
+- **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
+
+### Basic Validation
+
+```typescript
+import { validate } from 'valdex';
+
+const data: unknown = await fetchData();
+
+validate(data, {
+  name: String,
+  age: Number,
+  active: Boolean
+});
+
+// TypeScript now knows the exact type of data
+data.name   // string
+data.age    // number
+data.active // boolean
+```
+
+### Nested Objects
+
+```typescript
+validate(data, {
+  user: {
+    id: Number,
+    profile: {
+      name: String,
+      email: String
+    }
+  }
+});
+
+data.user.profile.name // string
+```
+
+### Arrays
+
+```typescript
+validate(data, {
+  tags: [String],  // string[]
+  items: [{        // { id: number, name: string }[]
+    id: Number,
+    name: String
+  }]
+});
+
+data.tags[0]       // string
+data.items[0].id   // number
+```
+
+### Optional Fields
+
+Use `Optional()` to allow `undefined` values:
+
+```typescript
+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
+});
+```
+
+### Nullable Fields
+
+Use `Nullable()` to allow `null` values:
+
+```typescript
+import { validate, Nullable } from 'valdex';
+
+validate(data, {
+  required: String,
+  nullable: Nullable(String),  // string | null
+  nullableObject: Nullable({   // { id: number } | null
+    id: Number
+  })
+});
+```
+
+### Combining Optional and Nullable
+
+```typescript
+import { validate, Optional, Nullable } from 'valdex';
+
+validate(data, {
+  field: Optional(Nullable(String)) // string | undefined | null
+});
+```
+
+## Supported Types
+
+| Constructor | TypeScript Type |
+|-------------|-----------------|
+| `String`    | `string`        |
+| `Number`    | `number`        |
+| `Boolean`   | `boolean`       |
+| `Array`     | `any[]`         |
+| `Object`    | `object`        |
+| `Date`      | `Date`          |
+
+## Error Handling
+
+When validation fails, a `RuntimeTypeError` is thrown:
+
+```typescript
+import { validate, RuntimeTypeError } from 'valdex';
+
+try {
+  validate(data, { count: Number });
+} catch (error) {
+  if (error instanceof RuntimeTypeError) {
+    console.error(error.message);
+    // "count must be Number, but got String. Actual value: hello"
+  }
+}
+```
+
+## How It Works
+
+- Fields not declared in the schema but present in data are ignored
+- All declared fields are required by default (no `undefined` or `null`)
+- Use `Optional()` to allow `undefined`
+- Use `Nullable()` to allow `null`
+- `NaN` is not considered a valid `Number`
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,102 @@
+type OptionalMarker = {
+    __optional: true;
+};
+type NullableMarker = {
+    __nullable: true;
+};
+type MarkerKeys = '__optional' | '__nullable' | '__type';
+type ArraySchema = [PrimitiveType | Expression];
+type Expression = {
+    [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 ArraySchema & OptionalMarker & NullableMarker ? (T extends [infer U] ? (U extends PrimitiveType ? InferPrimitiveType<U>[] : InferType<U>[]) : never) | undefined | null : T extends ArraySchema & OptionalMarker ? (T extends [infer U] ? (U extends PrimitiveType ? InferPrimitiveType<U>[] : InferType<U>[]) : never) | undefined : T extends ArraySchema & NullableMarker ? (T extends [infer U] ? (U extends PrimitiveType ? InferPrimitiveType<U>[] : InferType<U>[]) : never) | null : T extends [infer U] ? U extends PrimitiveType ? InferPrimitiveType<U>[] : InferType<U>[] : 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 Record<string, any> ? {
+    [K in keyof T]: InferType<T[K]>;
+} : never;
+/**
+ * Marks a field as optional.
+ * Optional fields pass validation even if they are undefined.
+ * The type is inferred as T | undefined.
+ * @example
+ * ```ts
+ * validate(data, {
+ *     required_field: String,           // string (required)
+ *     optional_field: Optional(String), // string | undefined
+ *     optional_object: Optional({       // { id: string } | undefined
+ *         id: String
+ *     }),
+ *     optional_array: Optional([String]) // string[] | undefined
+ * });
+ * ```
+ */
+declare function Optional<T extends PrimitiveType | Expression | ArraySchema>(ctor: T): T & OptionalMarker;
+/**
+ * Marks a field as nullable.
+ * Nullable fields pass validation even if they are null.
+ * The type is inferred as T | null.
+ * @example
+ * ```ts
+ * validate(data, {
+ *     required_field: String,           // string (required)
+ *     nullable_field: Nullable(String), // string | null
+ *     nullable_object: Nullable({       // { id: string } | null
+ *         id: String
+ *     }),
+ *     nullable_array: Nullable([String]) // string[] | null
+ * });
+ * ```
+ */
+declare function Nullable<T extends PrimitiveType | Expression | ArraySchema>(ctor: T): T & NullableMarker;
+declare class RuntimeTypeError extends Error {
+    constructor(key: string, requiredType: string, actualType: string, actualValue: any, message?: string);
+}
+/**
+ * Asserts the type of target according to the expression schema.
+ * The expression should be represented using primitive type constructors.
+ * Supports nested types and array element type validation.
+ *
+ * Fields not declared in the expression but present in target are ignored.
+ *
+ * Fields declared in the expression do not allow undefined or null by default.
+ * Wrap with Optional() to allow undefined.
+ * Wrap with Nullable() to allow null.
+ *
+ * @param target - The value to validate
+ * @param expression - The schema expression to validate against
+ * @throws {RuntimeTypeError} When type mismatch occurs
+ * @throws {RuntimeTypeError} When value is undefined or null (unless optional/nullable)
+ * @example
+ * ```ts
+ * const data: unknown = getData();
+ *
+ * validate(data, {
+ *     "a": Boolean,
+ *     "b": {
+ *         "c": Number,
+ *         "d": Optional(String),  // string | undefined
+ *         "e": Nullable(String)   // string | null
+ *     },
+ *     "items": [{
+ *         "name": String,
+ *         "value": Number
+ *     }]
+ * });
+ *
+ * // From this point, data is type-asserted
+ * data.a // boolean
+ * data.b.c // number
+ * data.b.d // string | undefined
+ * data.b.e // string | null
+ * data.items[0].name // string
+ * ```
+ */
+declare function validate<T extends Expression>(target: any, expression: T, path?: string): asserts target is InferType<T>;
+
+export { type InferType, Nullable, Optional, RuntimeTypeError, validate };

package/dist/index.d.ts

@@ -0,0 +1,102 @@
+type OptionalMarker = {
+    __optional: true;
+};
+type NullableMarker = {
+    __nullable: true;
+};
+type MarkerKeys = '__optional' | '__nullable' | '__type';
+type ArraySchema = [PrimitiveType | Expression];
+type Expression = {
+    [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 ArraySchema & OptionalMarker & NullableMarker ? (T extends [infer U] ? (U extends PrimitiveType ? InferPrimitiveType<U>[] : InferType<U>[]) : never) | undefined | null : T extends ArraySchema & OptionalMarker ? (T extends [infer U] ? (U extends PrimitiveType ? InferPrimitiveType<U>[] : InferType<U>[]) : never) | undefined : T extends ArraySchema & NullableMarker ? (T extends [infer U] ? (U extends PrimitiveType ? InferPrimitiveType<U>[] : InferType<U>[]) : never) | null : T extends [infer U] ? U extends PrimitiveType ? InferPrimitiveType<U>[] : InferType<U>[] : 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 Record<string, any> ? {
+    [K in keyof T]: InferType<T[K]>;
+} : never;
+/**
+ * Marks a field as optional.
+ * Optional fields pass validation even if they are undefined.
+ * The type is inferred as T | undefined.
+ * @example
+ * ```ts
+ * validate(data, {
+ *     required_field: String,           // string (required)
+ *     optional_field: Optional(String), // string | undefined
+ *     optional_object: Optional({       // { id: string } | undefined
+ *         id: String
+ *     }),
+ *     optional_array: Optional([String]) // string[] | undefined
+ * });
+ * ```
+ */
+declare function Optional<T extends PrimitiveType | Expression | ArraySchema>(ctor: T): T & OptionalMarker;
+/**
+ * Marks a field as nullable.
+ * Nullable fields pass validation even if they are null.
+ * The type is inferred as T | null.
+ * @example
+ * ```ts
+ * validate(data, {
+ *     required_field: String,           // string (required)
+ *     nullable_field: Nullable(String), // string | null
+ *     nullable_object: Nullable({       // { id: string } | null
+ *         id: String
+ *     }),
+ *     nullable_array: Nullable([String]) // string[] | null
+ * });
+ * ```
+ */
+declare function Nullable<T extends PrimitiveType | Expression | ArraySchema>(ctor: T): T & NullableMarker;
+declare class RuntimeTypeError extends Error {
+    constructor(key: string, requiredType: string, actualType: string, actualValue: any, message?: string);
+}
+/**
+ * Asserts the type of target according to the expression schema.
+ * The expression should be represented using primitive type constructors.
+ * Supports nested types and array element type validation.
+ *
+ * Fields not declared in the expression but present in target are ignored.
+ *
+ * Fields declared in the expression do not allow undefined or null by default.
+ * Wrap with Optional() to allow undefined.
+ * Wrap with Nullable() to allow null.
+ *
+ * @param target - The value to validate
+ * @param expression - The schema expression to validate against
+ * @throws {RuntimeTypeError} When type mismatch occurs
+ * @throws {RuntimeTypeError} When value is undefined or null (unless optional/nullable)
+ * @example
+ * ```ts
+ * const data: unknown = getData();
+ *
+ * validate(data, {
+ *     "a": Boolean,
+ *     "b": {
+ *         "c": Number,
+ *         "d": Optional(String),  // string | undefined
+ *         "e": Nullable(String)   // string | null
+ *     },
+ *     "items": [{
+ *         "name": String,
+ *         "value": Number
+ *     }]
+ * });
+ *
+ * // From this point, data is type-asserted
+ * data.a // boolean
+ * data.b.c // number
+ * data.b.d // string | undefined
+ * data.b.e // string | null
+ * data.items[0].name // string
+ * ```
+ */
+declare function validate<T extends Expression>(target: any, expression: T, path?: string): asserts target is InferType<T>;
+
+export { type InferType, Nullable, Optional, RuntimeTypeError, validate };

package/dist/index.js

@@ -0,0 +1,163 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Nullable: () => Nullable,
+  Optional: () => Optional,
+  RuntimeTypeError: () => RuntimeTypeError,
+  validate: () => validate
+});
+module.exports = __toCommonJS(index_exports);
+function Optional(ctor) {
+  return {
+    ...ctor,
+    __optional: true,
+    __type: ctor
+  };
+}
+function Nullable(ctor) {
+  return {
+    ...ctor,
+    __nullable: true,
+    __type: ctor
+  };
+}
+var RuntimeTypeError = class extends Error {
+  constructor(key, requiredType, actualType, actualValue, message) {
+    if (message) message += ": ";
+    super(`${message || ""}${key} must be ${requiredType}, but got ${actualType}. Actual value: ${actualValue}`);
+  }
+};
+function getTypeName(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (Array.isArray(value)) return "Array";
+  if (typeof value === "number" && Number.isNaN(value)) return "NaN";
+  if (typeof value === "object") return "Object";
+  const type = typeof value;
+  return type.charAt(0).toUpperCase() + type.slice(1);
+}
+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);
+}
+function isArraySchema(ctor) {
+  return Array.isArray(ctor) && ctor.length === 1;
+}
+function isOptional(ctor) {
+  return ctor.__optional === true;
+}
+function isNullable(ctor) {
+  return ctor.__nullable === true;
+}
+function isBothOptionalAndNullable(ctor) {
+  return ctor.__optional === true && ctor.__nullable === true;
+}
+function unwrapOptionalNullable(ctor) {
+  while (ctor && typeof ctor === "object" && !Array.isArray(ctor) && ctor.__type) {
+    ctor = ctor.__type;
+  }
+  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 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)) {
+      if (value === void 0 || value === null) {
+        continue;
+      }
+    } else if (value === void 0 && isOptional(ctor)) {
+      continue;
+    } else if (value === null && isNullable(ctor)) {
+      continue;
+    } else {
+      assertType(currentPath, "not undefined or null", value, value !== void 0 && value !== null);
+    }
+    const unwrappedCtor = unwrapOptionalNullable(ctor);
+    if (isArraySchema(unwrappedCtor)) {
+      assertType(currentPath, "Array", value, Array.isArray(value));
+      const elementSchema = unwrappedCtor[0];
+      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.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.get(Object);
+      assertType(currentPath, "Object", value, objectValidator(value));
+      validate(value, unwrappedCtor, currentPath);
+    } else {
+      throw new Error("Invalid expression. Use 'Number' or 'String' or 'Boolean' or 'Array' or 'Object'.");
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Nullable,
+  Optional,
+  RuntimeTypeError,
+  validate
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"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\nexport type 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 PrimitiveType ? InferPrimitiveType<U>[] : InferType<U>[]) : never) | undefined | null\n                        : T extends ArraySchema & OptionalMarker\n                            ? (T extends [infer U] ? (U extends PrimitiveType ? InferPrimitiveType<U>[] : InferType<U>[]) : never) | undefined\n                            : T extends ArraySchema & NullableMarker\n                                ? (T extends [infer U] ? (U extends PrimitiveType ? InferPrimitiveType<U>[] : InferType<U>[]) : never) | null\n                                : T extends [infer U]\n                                    ? U extends PrimitiveType\n                                        ? InferPrimitiveType<U>[]\n                                        : InferType<U>[]\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 Record<string, any>\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

@@ -0,0 +1,135 @@
+// src/index.ts
+function Optional(ctor) {
+  return {
+    ...ctor,
+    __optional: true,
+    __type: ctor
+  };
+}
+function Nullable(ctor) {
+  return {
+    ...ctor,
+    __nullable: true,
+    __type: ctor
+  };
+}
+var RuntimeTypeError = class extends Error {
+  constructor(key, requiredType, actualType, actualValue, message) {
+    if (message) message += ": ";
+    super(`${message || ""}${key} must be ${requiredType}, but got ${actualType}. Actual value: ${actualValue}`);
+  }
+};
+function getTypeName(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (Array.isArray(value)) return "Array";
+  if (typeof value === "number" && Number.isNaN(value)) return "NaN";
+  if (typeof value === "object") return "Object";
+  const type = typeof value;
+  return type.charAt(0).toUpperCase() + type.slice(1);
+}
+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);
+}
+function isArraySchema(ctor) {
+  return Array.isArray(ctor) && ctor.length === 1;
+}
+function isOptional(ctor) {
+  return ctor.__optional === true;
+}
+function isNullable(ctor) {
+  return ctor.__nullable === true;
+}
+function isBothOptionalAndNullable(ctor) {
+  return ctor.__optional === true && ctor.__nullable === true;
+}
+function unwrapOptionalNullable(ctor) {
+  while (ctor && typeof ctor === "object" && !Array.isArray(ctor) && ctor.__type) {
+    ctor = ctor.__type;
+  }
+  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 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)) {
+      if (value === void 0 || value === null) {
+        continue;
+      }
+    } else if (value === void 0 && isOptional(ctor)) {
+      continue;
+    } else if (value === null && isNullable(ctor)) {
+      continue;
+    } else {
+      assertType(currentPath, "not undefined or null", value, value !== void 0 && value !== null);
+    }
+    const unwrappedCtor = unwrapOptionalNullable(ctor);
+    if (isArraySchema(unwrappedCtor)) {
+      assertType(currentPath, "Array", value, Array.isArray(value));
+      const elementSchema = unwrappedCtor[0];
+      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.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.get(Object);
+      assertType(currentPath, "Object", value, objectValidator(value));
+      validate(value, unwrappedCtor, currentPath);
+    } else {
+      throw new Error("Invalid expression. Use 'Number' or 'String' or 'Boolean' or 'Array' or 'Object'.");
+    }
+  }
+}
+export {
+  Nullable,
+  Optional,
+  RuntimeTypeError,
+  validate
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"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\nexport type 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 PrimitiveType ? InferPrimitiveType<U>[] : InferType<U>[]) : never) | undefined | null\n                        : T extends ArraySchema & OptionalMarker\n                            ? (T extends [infer U] ? (U extends PrimitiveType ? InferPrimitiveType<U>[] : InferType<U>[]) : never) | undefined\n                            : T extends ArraySchema & NullableMarker\n                                ? (T extends [infer U] ? (U extends PrimitiveType ? InferPrimitiveType<U>[] : InferType<U>[]) : never) | null\n                                : T extends [infer U]\n                                    ? U extends PrimitiveType\n                                        ? InferPrimitiveType<U>[]\n                                        : InferType<U>[]\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 Record<string, any>\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

@@ -0,0 +1,61 @@
+{
+  "name": "@point3/valdex",
+  "version": "1.0.4",
+  "description": "Runtime type validation with TypeScript type inference",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "npm run build",
+    "test": "jest",
+    "test:types": "tsd",
+    "test:all": "npm test && npm run test:types"
+  },
+  "tsd": {
+    "directory": "src",
+    "typingsFile": "src/index.ts"
+  },
+  "keywords": [
+    "typescript",
+    "validation",
+    "runtime",
+    "type-inference",
+    "schema",
+    "validator"
+  ],
+  "author": "point3 (violetpay)",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
+    "tsd": "^0.33.0",
+    "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/asheswook/valdex.git"
+  },
+  "bugs": {
+    "url": "https://github.com/asheswook/valdex/issues"
+  },
+  "homepage": "https://github.com/asheswook/valdex#readme"
+}