valdex 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jaewook Lee
+
+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,151 @@
+# valdex
+
+Runtime type validation with TypeScript type inference.
+
+## Installation
+
+```bash
+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
+
+## 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`        |
+
+## 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,101 @@
+type OptionalMarker = {
+    __optional: true;
+};
+type NullableMarker = {
+    __nullable: true;
+};
+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);
+};
+type PrimitiveType = NumberConstructor | StringConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor;
+type InferPrimitiveType<T> = T extends NumberConstructor ? number : T extends StringConstructor ? string : T extends BooleanConstructor ? boolean : T extends ArrayConstructor ? any[] : T extends ObjectConstructor ? object : 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 ? {
+    [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 { Nullable, Optional, RuntimeTypeError, validate };

package/dist/index.d.ts

@@ -0,0 +1,101 @@
+type OptionalMarker = {
+    __optional: true;
+};
+type NullableMarker = {
+    __nullable: true;
+};
+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);
+};
+type PrimitiveType = NumberConstructor | StringConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor;
+type InferPrimitiveType<T> = T extends NumberConstructor ? number : T extends StringConstructor ? string : T extends BooleanConstructor ? boolean : T extends ArrayConstructor ? any[] : T extends ObjectConstructor ? object : 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 ? {
+    [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 { Nullable, Optional, RuntimeTypeError, validate };

package/dist/index.js

@@ -0,0 +1,166 @@
+"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 = {
+  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)
+};
+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) {
+  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;
+  }
+  return unwrapped;
+}
+function assertType(key, expectedType, value, isValid) {
+  if (!isValid) {
+    throw new RuntimeTypeError(key, expectedType, getTypeName(value), value);
+  }
+}
+function validate(target, expression, path = "") {
+  for (const [key, ctor] of Object.entries(expression)) {
+    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];
+      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));
+        }
+      });
+      continue;
+    }
+    if (typeof unwrappedCtor === "function") {
+      const validator = TYPE_VALIDATORS[unwrappedCtor.name];
+      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");
+      }
+      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 };\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;\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                        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)\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":[]}

package/dist/index.mjs

@@ -0,0 +1,138 @@
+// 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 = {
+  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)
+};
+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) {
+  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;
+  }
+  return unwrapped;
+}
+function assertType(key, expectedType, value, isValid) {
+  if (!isValid) {
+    throw new RuntimeTypeError(key, expectedType, getTypeName(value), value);
+  }
+}
+function validate(target, expression, path = "") {
+  for (const [key, ctor] of Object.entries(expression)) {
+    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];
+      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));
+        }
+      });
+      continue;
+    }
+    if (typeof unwrappedCtor === "function") {
+      const validator = TYPE_VALIDATORS[unwrappedCtor.name];
+      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");
+      }
+      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 };\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;\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                        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)\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":";AAkEO,SAAS,SAA6D,MAA6B;AACtG,SAAO;AAAA,IACH,GAAG;AAAA,IACH,YAAY;AAAA,IACZ,QAAQ;AAAA,EACZ;AACJ;AAkBO,SAAS,SAA6D,MAA6B;AACtG,SAAO;AAAA,IACH,GAAG;AAAA,IACH,YAAY;AAAA,IACZ,QAAQ;AAAA,EACZ;AACJ;AAEO,IAAM,mBAAN,cAA+B,MAAM;AAAA,EACxC,YACI,KACA,cACA,YACA,aACA,SACF;AACE,QAAI,QAAS,YAAW;AACxB,UAAM,GAAG,WAAW,EAAE,GAAG,GAAG,YAAY,YAAY,aAAa,UAAU,mBAAmB,WAAW,EAAE;AAAA,EAC/G;AACJ;AAEA,SAAS,YAAY,OAAoB;AACrC,MAAI,UAAU,KAAM,QAAO;AAC3B,MAAI,UAAU,OAAW,QAAO;AAChC,MAAI,MAAM,QAAQ,KAAK,EAAG,QAAO;AACjC,MAAI,OAAO,UAAU,YAAY,OAAO,MAAM,KAAK,EAAG,QAAO;AAC7D,MAAI,OAAO,UAAU,SAAU,QAAO;AAEtC,QAAM,OAAO,OAAO;AACpB,SAAO,KAAK,OAAO,CAAC,EAAE,YAAY,IAAI,KAAK,MAAM,CAAC;AACtD;AAEA,IAAM,kBAA2D;AAAA,EAC7D,QAAQ,CAAC,UAAU,OAAO,UAAU,YAAY,CAAC,OAAO,MAAM,KAAK;AAAA,EACnE,QAAQ,CAAC,UAAU,OAAO,UAAU;AAAA,EACpC,SAAS,CAAC,UAAU,OAAO,UAAU;AAAA,EACrC,OAAO,CAAC,UAAU,MAAM,QAAQ,KAAK;AAAA,EACrC,QAAQ,CAAC,UAAU,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC1F;AAEA,SAAS,qBAAqB,MAA+B;AACzD,SAAO,OAAO,SAAS,YAAY,CAAC,MAAM,QAAQ,IAAI;AAC1D;AAEA,SAAS,cAAc,MAAiD;AACpE,SAAO,MAAM,QAAQ,IAAI,KAAK,KAAK,WAAW;AAClD;AAEA,SAAS,WAAW,MAAoB;AACpC,SAAO,KAAK,eAAe;AAC/B;AAEA,SAAS,WAAW,MAAoB;AACpC,SAAO,KAAK,eAAe;AAC/B;AAEA,SAAS,0BAA0B,MAAoB;AACnD,SAAO,KAAK,eAAe,QAAQ,KAAK,eAAe;AAC3D;AAEA,SAAS,uBAAuB,MAAgB;AAC5C,MAAI,CAAC,QAAQ,OAAO,SAAS,UAAU;AACnC,WAAO;AAAA,EACX;AAEA,MAAI,MAAM,QAAQ,IAAI,GAAG;AACrB,WAAO;AAAA,EACX;AAEA,MAAI,KAAK,QAAQ;AACb,WAAO,KAAK;AAAA,EAChB;AAEA,QAAM,YAAiB,CAAC;AACxB,aAAW,OAAO,MAAM;AACpB,QAAI,QAAQ,gBAAgB,QAAQ,gBAAgB,QAAQ,UAAU;AAClE,gBAAU,GAAG,IAAI,KAAK,GAAG;AAAA,IAC7B;AAAA,EACJ;AAEA,MAAI,OAAO,KAAK,SAAS,EAAE,WAAW,MAAM,KAAK,cAAc,KAAK,aAAa;AAC7E,WAAO;AAAA,EACX;AAEA,SAAO;AACX;AAEA,SAAS,WAAW,KAAa,cAAsB,OAAY,SAAwB;AACvF,MAAI,CAAC,SAAS;AACV,UAAM,IAAI,iBAAiB,KAAK,cAAc,YAAY,KAAK,GAAG,KAAK;AAAA,EAC3E;AACJ;AA0CO,SAAS,SACZ,QACA,YACA,OAAe,IACe;AAC9B,aAAW,CAAC,KAAK,IAAI,KAAK,OAAO,QAAQ,UAAU,GAAG;AAClD,UAAM,QAAQ,OAAO,GAAG;AACxB,UAAM,cAAc,OAAO,GAAG,IAAI,IAAI,GAAG,KAAK;AAE9C,QAAI,0BAA0B,IAAI,GAAG;AACjC,UAAI,UAAU,UAAa,UAAU,MAAM;AACvC;AAAA,MACJ;AAAA,IACJ,WAAW,UAAU,UAAa,WAAW,IAAI,GAAG;AAChD;AAAA,IACJ,WAAW,UAAU,QAAQ,WAAW,IAAI,GAAG;AAC3C;AAAA,IACJ,OAAO;AACH,iBAAW,aAAa,yBAAyB,OAAO,UAAU,UAAa,UAAU,IAAI;AAAA,IACjG;AAEA,UAAM,gBAAgB,uBAAuB,IAAI;AAEjD,QAAI,cAAc,aAAa,GAAG;AAC9B,iBAAW,aAAa,SAAS,OAAO,MAAM,QAAQ,KAAK,CAAC;AAC5D,YAAM,gBAAgB,cAAc,CAAC;AAErC,MAAC,MAAgB,QAAQ,CAAC,MAAM,UAAU;AACtC,cAAM,YAAY,GAAG,WAAW,IAAI,KAAK;AACzC,YAAI,qBAAqB,aAAa,GAAG;AACrC,gBAAM,kBAAkB,gBAAgB,QAAQ;AAChD,qBAAW,WAAW,UAAU,MAAM,kBAAkB,IAAI,KAAK,KAAK;AACtE,mBAAS,MAAM,eAAe,SAAS;AAAA,QAC3C,OAAO;AACH,gBAAM,YAAY,gBAAgB,cAAc,IAAI;AACpD,cAAI,CAAC,WAAW;AACZ,kBAAM,IAAI,MAAM,mCAAmC;AAAA,UACvD;AACA,qBAAW,WAAW,cAAc,MAAM,MAAM,UAAU,IAAI,CAAC;AAAA,QACnE;AAAA,MACJ,CAAC;AACD;AAAA,IACJ;AAEA,QAAI,OAAO,kBAAkB,YAAY;AACrC,YAAM,YAAY,gBAAgB,cAAc,IAAI;AACpD,UAAI,CAAC,WAAW;AACZ,cAAM,IAAI,MAAM,mFAAmF;AAAA,MACvG;AACA,iBAAW,aAAa,cAAc,MAAM,OAAO,UAAU,KAAK,CAAC;AAAA,IACvE,WAAW,qBAAqB,aAAa,GAAG;AAC5C,YAAM,kBAAkB,gBAAgB,QAAQ;AAChD,UAAI,CAAC,iBAAiB;AAClB,cAAM,IAAI,MAAM,4BAA4B;AAAA,MAChD;AACA,iBAAW,aAAa,UAAU,OAAO,gBAAgB,KAAK,CAAC;AAC/D,eAAS,OAAO,eAAe,WAAW;AAAA,IAC9C,OAAO;AACH,YAAM,IAAI,MAAM,mFAAmF;AAAA,IACvG;AAAA,EACJ;AACJ;","names":[]}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "valdex",
+  "version": "1.0.0",
+  "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": "tsx test.ts"
+  },
+  "keywords": [
+    "typescript",
+    "validation",
+    "runtime",
+    "type-inference",
+    "schema",
+    "validator"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "tsx": "^4.19.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"
+}