xanv 1.1.11 → 1.1.13

package/readme.md

@@ -1,199 +1,199 @@
-# Xanv — Lightweight Runtime Validation with TypeScript Inference
-
-[![npm version](https://img.shields.io/badge/npm-v0.0.0-blue.svg)](#)
-[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
-
-**Xanv** is a minimal runtime validation library that pairs elegantly with TypeScript. It provides a fluent API for building runtime-safe schemas that retain full static typing at compile time. With generic class-based validators, you get the best of both worlds — reliable runtime checks and precise type inference.
-
----
-
-## Table of Contents
-
-* Features
-* Installation
-* Quick Start
-* Type Inference & TypeScript Integration
-* API Reference
-* Advanced Examples
-* Migration Notes
-* Development & Testing
-* Contributing
-* Changelog
-* License
-
----
-
-## Features
-
-* 🚀 **Lightweight & dependency-free** — zero external dependencies.
-* 🔗 **Fluent API** — chainable constraints and transformations.
-* 🧩 **Generic XV classes** — `XVArray<T>`, `XVObject<S>`, `XVMap<K, V>`, and more, for perfect type inference.
-* 🧠 **Type inference helper** — `xv.infer<T>` extracts TypeScript types directly from schema definitions.
-
----
-
-## Installation
-
-```bash
-npm install xanv
-# or
-yarn add xanv
-```
-
----
-
-## Quick Start
-
-Validate and parse data with type safety:
-
-```ts
-import { xv } from 'xanv';
-
-const schema = xv.object({
-  id: xv.string().min(3),
-  age: xv.number().min(0),
-  tags: xv.array(xv.string()),
-});
-
-const parsed = schema.parse({ id: 'abc', age: 30, tags: ['x'] });
-console.log(parsed.id);
-```
-
-The `parse()` method returns a validated value or throws on failure.
-Control missing or nullable values with `.optional()`, `.nullable()`, and `.default()`.
-
----
-
-## Type Inference & TypeScript Integration
-
-Because each factory returns a **generic class instance**, Xanv retains full type information across schema definitions.
-
-```ts
-import { xv } from 'xanv';
-
-const schema = {
-  id: xv.string(),
-  age: xv.number(),
-  tags: xv.array(xv.string()),
-} as const;
-
-type SchemaT = xv.infer<typeof schema>;
-// { id: string; age: number; tags: string[] }
-
-const obj = xv.object(schema);
-type ObjT = xv.infer<typeof schema>; // same as SchemaT
-
-const maybe: ObjT | undefined | null = obj.parse({ id: 'a', age: 1, tags: ['x'] });
-```
-
-### How Inference Works
-
-* Each `XV` class is generic, e.g. `XVObject<S>`, `XVArray<T>`, `XVRecord<K, V>`, `XVTuple<Ts>`.
-* The `xv.infer<typeof schema>` utility traverses schema literals and extracts TypeScript equivalents.
-
----
-
-## API Reference
-
-Each top-level factory method on the `xv` export returns a typed validator class.
-
-| Method                    | Returns              | Description                  |
-| ------------------------- | -------------------- | ---------------------------- |
-| `xv.string(length?)`      | `XVString<string>`   | String validator             |
-| `xv.number()`             | `XVNumber<number>`   | Number validator             |
-| `xv.boolean()`            | `XVBoolean<boolean>` | Boolean validator            |
-| `xv.date()`               | `XVDate<Date>`       | Date validator               |
-| `xv.array(type, length?)` | `XVArray<T>`         | Array of a specific type     |
-| `xv.tuple(types)`         | `XVTuple<T>`         | Tuple with precise types     |
-| `xv.union(types)`         | `XVUnion<T>`         | Union of multiple validators |
-| `xv.object(schema?)`      | `XVObject<S>`        | Object validator             |
-| `xv.map(key, value)`      | `XVMap<K, V>`        | Map validator                |
-| `xv.set(type)`            | `XVSet<T>`           | Set validator                |
-| `xv.record(key, value)`   | `XVRecord<K, V>`     | Record validator             |
-| `xv.enum(values)`         | `XVEnum<T>`          | Enum validator               |
-
-### Common Instance Methods
-
-* `parse(value: any): T | undefined | null`
-* `optional(): this`
-* `nullable(): this`
-* `default(value: T | (() => T)): this`
-* `transform(cb: (value: T) => T): this`
-
-Additional constraint methods are available in `src/types` (e.g., `.min`, `.max`, `.email`, `.unique`, `.float`, `.integer`, etc.).
-
----
-
-## Advanced Examples
-
-### Tuple with Exact Types
-
-```ts
-const tpl = xv.tuple([xv.string(), xv.number()]);
-type Tpl = xv.infer<typeof ({ a: tpl })['a']>;
-// [string, number]
-```
-
-### Nested Objects and Arrays
-
-```ts
-const user = xv.object({ name: xv.string(), id: xv.number() });
-const schema = xv.object({ users: xv.array(user) });
-
-type SchemaT = xv.infer<typeof schema['arg']>;
-// { users: { name: string; id: number }[] }
-```
-
-### Validation with Transform and Default
-
-```ts
-const s = xv.string().transform(v => v.trim()).default('n/a');
-const parsed = s.parse(undefined); // "n/a"
-```
-
----
-
-## Migration Notes
-
-If you’re upgrading from a pre-generic version of Xanv:
-
-* Factories now return **generic class types** — remove legacy wrappers.
-* Use `as const` on schema literals for optimal `xv.infer` inference.
-
----
-
-## Development & Testing
-
-Run TypeScript checks and tests:
-
-```bash
-npx tsc --noEmit
-npm test
-```
-
-### Adding New Types
-
-1. Create a new generic class under `src/types`.
-2. Add its factory signature in `src/index.ts`.
-3. Write unit tests and update documentation examples.
-
----
-
-## Contributing
-
-* Open issues before large changes.
-* Keep PRs focused and include relevant tests.
-* Update public type definitions and README when altering APIs.
-
----
-
-## Changelog
-
-Refer to `CHANGELOG.md` for updates.
-Include short migration notes for any breaking changes.
-
----
-
-## License
-
-MIT © 2025
+# Xanv — Lightweight Runtime Validation with TypeScript Inference
+
+[![npm version](https://img.shields.io/badge/npm-v0.0.0-blue.svg)](#)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+**Xanv** is a minimal runtime validation library that pairs elegantly with TypeScript. It provides a fluent API for building runtime-safe schemas that retain full static typing at compile time. With generic class-based validators, you get the best of both worlds — reliable runtime checks and precise type inference.
+
+---
+
+## Table of Contents
+
+* Features
+* Installation
+* Quick Start
+* Type Inference & TypeScript Integration
+* API Reference
+* Advanced Examples
+* Migration Notes
+* Development & Testing
+* Contributing
+* Changelog
+* License
+
+---
+
+## Features
+
+* 🚀 **Lightweight & dependency-free** — zero external dependencies.
+* 🔗 **Fluent API** — chainable constraints and transformations.
+* 🧩 **Generic XV classes** — `XVArray<T>`, `XVObject<S>`, `XVMap<K, V>`, and more, for perfect type inference.
+* 🧠 **Type inference helper** — `xv.infer<T>` extracts TypeScript types directly from schema definitions.
+
+---
+
+## Installation
+
+```bash
+npm install xanv
+# or
+yarn add xanv
+```
+
+---
+
+## Quick Start
+
+Validate and parse data with type safety:
+
+```ts
+import { xv } from 'xanv';
+
+const schema = xv.object({
+  id: xv.string().min(3),
+  age: xv.number().min(0),
+  tags: xv.array(xv.string()),
+});
+
+const parsed = schema.parse({ id: 'abc', age: 30, tags: ['x'] });
+console.log(parsed.id);
+```
+
+The `parse()` method returns a validated value or throws on failure.
+Control missing or nullable values with `.optional()`, `.nullable()`, and `.default()`.
+
+---
+
+## Type Inference & TypeScript Integration
+
+Because each factory returns a **generic class instance**, Xanv retains full type information across schema definitions.
+
+```ts
+import { xv } from 'xanv';
+
+const schema = {
+  id: xv.string(),
+  age: xv.number(),
+  tags: xv.array(xv.string()),
+} as const;
+
+type SchemaT = xv.infer<typeof schema>;
+// { id: string; age: number; tags: string[] }
+
+const obj = xv.object(schema);
+type ObjT = xv.infer<typeof schema>; // same as SchemaT
+
+const maybe: ObjT | undefined | null = obj.parse({ id: 'a', age: 1, tags: ['x'] });
+```
+
+### How Inference Works
+
+* Each `XV` class is generic, e.g. `XVObject<S>`, `XVArray<T>`, `XVRecord<K, V>`, `XVTuple<Ts>`.
+* The `xv.infer<typeof schema>` utility traverses schema literals and extracts TypeScript equivalents.
+
+---
+
+## API Reference
+
+Each top-level factory method on the `xv` export returns a typed validator class.
+
+| Method                    | Returns              | Description                  |
+| ------------------------- | -------------------- | ---------------------------- |
+| `xv.string(length?)`      | `XVString<string>`   | String validator             |
+| `xv.number()`             | `XVNumber<number>`   | Number validator             |
+| `xv.boolean()`            | `XVBoolean<boolean>` | Boolean validator            |
+| `xv.date()`               | `XVDate<Date>`       | Date validator               |
+| `xv.array(type, length?)` | `XVArray<T>`         | Array of a specific type     |
+| `xv.tuple(types)`         | `XVTuple<T>`         | Tuple with precise types     |
+| `xv.union(types)`         | `XVUnion<T>`         | Union of multiple validators |
+| `xv.object(schema?)`      | `XVObject<S>`        | Object validator             |
+| `xv.map(key, value)`      | `XVMap<K, V>`        | Map validator                |
+| `xv.set(type)`            | `XVSet<T>`           | Set validator                |
+| `xv.record(key, value)`   | `XVRecord<K, V>`     | Record validator             |
+| `xv.enum(values)`         | `XVEnum<T>`          | Enum validator               |
+
+### Common Instance Methods
+
+* `parse(value: any): T | undefined | null`
+* `optional(): this`
+* `nullable(): this`
+* `default(value: T | (() => T)): this`
+* `transform(cb: (value: T) => T): this`
+
+Additional constraint methods are available in `src/types` (e.g., `.min`, `.max`, `.email`, `.unique`, `.float`, `.integer`, etc.).
+
+---
+
+## Advanced Examples
+
+### Tuple with Exact Types
+
+```ts
+const tpl = xv.tuple([xv.string(), xv.number()]);
+type Tpl = xv.infer<typeof ({ a: tpl })['a']>;
+// [string, number]
+```
+
+### Nested Objects and Arrays
+
+```ts
+const user = xv.object({ name: xv.string(), id: xv.number() });
+const schema = xv.object({ users: xv.array(user) });
+
+type SchemaT = xv.infer<typeof schema['arg']>;
+// { users: { name: string; id: number }[] }
+```
+
+### Validation with Transform and Default
+
+```ts
+const s = xv.string().transform(v => v.trim()).default('n/a');
+const parsed = s.parse(undefined); // "n/a"
+```
+
+---
+
+## Migration Notes
+
+If you’re upgrading from a pre-generic version of Xanv:
+
+* Factories now return **generic class types** — remove legacy wrappers.
+* Use `as const` on schema literals for optimal `xv.infer` inference.
+
+---
+
+## Development & Testing
+
+Run TypeScript checks and tests:
+
+```bash
+npx tsc --noEmit
+npm test
+```
+
+### Adding New Types
+
+1. Create a new generic class under `src/types`.
+2. Add its factory signature in `src/index.ts`.
+3. Write unit tests and update documentation examples.
+
+---
+
+## Contributing
+
+* Open issues before large changes.
+* Keep PRs focused and include relevant tests.
+* Update public type definitions and README when altering APIs.
+
+---
+
+## Changelog
+
+Refer to `CHANGELOG.md` for updates.
+Include short migration notes for any breaking changes.
+
+---
+
+## License
+
+MIT © 2025

package/types/Any.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var XanvType = require('../XanvType.cjs');
+
+class XVAny extends XanvType {
+    check(value) {
+        // Accept any value as-is
+        return value;
+    }
+    parse(value) {
+        return super.parse(value);
+    }
+}
+
+module.exports = XVAny;
+//# sourceMappingURL=Any.cjs.map

package/types/Any.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Any.cjs","sources":["../../src/types/Any.ts"],"sourcesContent":["import XanvType from \"../XanvType\";\r\n\r\nclass XVAny extends XanvType<any, any> {\r\n   protected check(value: any): any {\r\n      // Accept any value as-is\r\n      return value;\r\n   }\r\n\r\n   parse(value: any): any | undefined | null {\r\n      return super.parse(value);\r\n   }\r\n}\r\n\r\nexport default XVAny;\r\n"],"names":[],"mappings":";;;;AAEA,MAAM,KAAM,SAAQ,QAAkB,CAAA;AACzB,IAAA,KAAK,CAAC,KAAU,EAAA;;AAEvB,QAAA,OAAO,KAAK,CAAC;IAChB,CAAC;AAED,IAAA,KAAK,CAAC,KAAU,EAAA;AACb,QAAA,OAAO,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;AACH;;;;"}

package/types/Any.d.ts

@@ -1,8 +1,8 @@
 import XanvType from '../XanvType.js';
 
-declare class XVAny<T = any> extends XanvType<T> {
-    protected check(): void;
-    parse(value: any): T | undefined | null;
+declare class XVAny extends XanvType<any, any> {
+    protected check(value: any): any;
+    parse(value: any): any | undefined | null;
 }
 
 export { XVAny as default };

package/types/Any.js

@@ -1,6 +1,14 @@
-'use strict';Object.defineProperty(exports,'__esModule',{value:true});var XanvType=require('../XanvType.js');class XVAny extends XanvType.default {
-    check() { }
-    parse(value) {
-        return super.parse(value);
-    }
-}exports.default=XVAny;//# sourceMappingURL=Any.js.map
+import XanvType from '../XanvType.js';
+
+class XVAny extends XanvType {
+    check(value) {
+        // Accept any value as-is
+        return value;
+    }
+    parse(value) {
+        return super.parse(value);
+    }
+}
+
+export { XVAny as default };
+//# sourceMappingURL=Any.js.map

package/types/Any.js.map

@@ -1 +1 @@
-{"version":3,"file":"Any.js","sources":["../../src/types/Any.ts"],"sourcesContent":["import XanvType from \"../XanvType\";\n\nclass XVAny<T = any> extends XanvType<T> {\n   protected check() { }\n\n   parse(value: any): T | undefined | null {\n      return super.parse(value) as any;\n   }\n}\n\nexport default XVAny;"],"names":["XanvType"],"mappings":"6GAEA,MAAM,KAAe,SAAQA,gBAAW,CAAA;AAC3B,IAAA,KAAK,KAAK;AAEpB,IAAA,KAAK,CAAC,KAAU,EAAA;AACb,QAAA,OAAO,KAAK,CAAC,KAAK,CAAC,KAAK,CAAQ;IACnC;AACF"}
+{"version":3,"file":"Any.js","sources":["../../src/types/Any.ts"],"sourcesContent":["import XanvType from \"../XanvType\";\r\n\r\nclass XVAny extends XanvType<any, any> {\r\n   protected check(value: any): any {\r\n      // Accept any value as-is\r\n      return value;\r\n   }\r\n\r\n   parse(value: any): any | undefined | null {\r\n      return super.parse(value);\r\n   }\r\n}\r\n\r\nexport default XVAny;\r\n"],"names":[],"mappings":";;AAEA,MAAM,KAAM,SAAQ,QAAkB,CAAA;AACzB,IAAA,KAAK,CAAC,KAAU,EAAA;;AAEvB,QAAA,OAAO,KAAK,CAAC;IAChB,CAAC;AAED,IAAA,KAAK,CAAC,KAAU,EAAA;AACb,QAAA,OAAO,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;AACH;;;;"}

package/types/Array.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+var XanvType = require('../XanvType.cjs');
+
+class XVArray extends XanvType {
+    constructor(type, length) {
+        super();
+        this.type = type;
+        this.length = length;
+    }
+    check(value) {
+        if (!Array.isArray(value)) {
+            throw new Error(`Value should be an array, received ${typeof value}`);
+        }
+        if (this.length !== undefined && value.length !== this.length) {
+            throw new Error(`Array length should be ${this.length}, received ${value.length}`);
+        }
+        const result = [];
+        if (this.type) {
+            for (let i = 0; i < value.length; i++) {
+                try {
+                    result[i] = this.type.parse(value[i]);
+                }
+                catch (err) {
+                    throw new Error(`Array item at index ${i} should be of type ${this.type.constructor.name}, received ${typeof value[i]}: ${err.message}`);
+                }
+            }
+        }
+        else {
+            result.push(...value);
+        }
+        return result;
+    }
+    min(length) {
+        return this.set("min", (v) => {
+            const arr = v;
+            if (arr.length < length) {
+                throw new Error(`Array length should be at least ${length} items, received ${arr.length}`);
+            }
+        }, length);
+    }
+    max(length) {
+        return this.set("max", (v) => {
+            const arr = v;
+            if (arr.length > length) {
+                throw new Error(`Array length should not exceed ${length} items, received ${arr.length}`);
+            }
+        }, length);
+    }
+    unique() {
+        return this.set("unique", (v) => {
+            const arr = v;
+            const seen = new Set();
+            for (const item of arr) {
+                const key = JSON.stringify(item);
+                if (seen.has(key)) {
+                    throw new Error(`Array items should be unique, found duplicate: ${key}`);
+                }
+                seen.add(key);
+            }
+        });
+    }
+}
+
+module.exports = XVArray;
+//# sourceMappingURL=Array.cjs.map

package/types/Array.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Array.cjs","sources":["../../src/types/Array.ts"],"sourcesContent":["import XVMap from \"./Map\";\r\nimport XVObject from \"./Object\";\r\nimport XVRecord from \"./Record\";\r\nimport XanvType from \"../XanvType\";\r\nimport { XVInstanceType, Infer } from \"../types\";\r\n\r\nclass XVArray<T extends XVInstanceType = XVInstanceType> extends XanvType<Infer<T>[]> {\r\n   private type?: T;\r\n   private length?: number;\r\n\r\n   constructor(type?: T, length?: number) {\r\n      super();\r\n      this.type = type;\r\n      this.length = length;\r\n   }\r\n\r\n   protected check(value: unknown): Infer<T>[] {\r\n      if (!Array.isArray(value)) {\r\n         throw new Error(`Value should be an array, received ${typeof value}`);\r\n      }\r\n\r\n      if (this.length !== undefined && value.length !== this.length) {\r\n         throw new Error(`Array length should be ${this.length}, received ${value.length}`);\r\n      }\r\n\r\n      const result: Infer<T>[] = [];\r\n\r\n      if (this.type) {\r\n         for (let i = 0; i < value.length; i++) {\r\n            try {\r\n               result[i] = this.type.parse(value[i]) as Infer<T>;\r\n            } catch (err: any) {\r\n               throw new Error(\r\n                  `Array item at index ${i} should be of type ${this.type.constructor.name}, received ${typeof value[i]}: ${err.message}`\r\n               );\r\n            }\r\n         }\r\n      } else {\r\n         result.push(...(value as any[]));\r\n      }\r\n\r\n      return result;\r\n   }\r\n\r\n   min(length: number) {\r\n      return this.set(\"min\", (v: unknown) => {\r\n         const arr = v as Infer<T>[];\r\n         if (arr.length < length) {\r\n            throw new Error(`Array length should be at least ${length} items, received ${arr.length}`);\r\n         }\r\n      }, length);\r\n   }\r\n\r\n\r\n   max(length: number) {\r\n      return this.set(\"max\", (v: unknown) => {\r\n         const arr = v as Infer<T>[];\r\n         if (arr.length > length) {\r\n            throw new Error(`Array length should not exceed ${length} items, received ${arr.length}`);\r\n         }\r\n      }, length);\r\n   }\r\n\r\n   unique() {\r\n      return this.set(\"unique\", (v: unknown) => {\r\n         const arr = v as Infer<T>[];\r\n         const seen = new Set<string>();\r\n\r\n         for (const item of arr) {\r\n            const key = JSON.stringify(item);\r\n            if (seen.has(key)) {\r\n               throw new Error(`Array items should be unique, found duplicate: ${key}`);\r\n            }\r\n            seen.add(key);\r\n         }\r\n      });\r\n   }\r\n}\r\n\r\nexport default XVArray;\r\n"],"names":[],"mappings":"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"}

package/types/Array.d.ts

@@ -1,14 +1,14 @@
 import XanvType from '../XanvType.js';
-import { XVInstanceType } from '../types.js';
+import { XVInstanceType, Infer } from '../types.js';
 
-declare class XVArray<T = any[]> extends XanvType<T[]> {
-    private type?;
-    private length?;
-    constructor(type?: XVInstanceType, length?: number);
-    protected check(value: any): void;
-    min(length: number): this;
-    max(length: number): this;
-    unique(): this;
+declare class XVArray<T extends XVInstanceType = XVInstanceType> extends XanvType<Infer<T>[]> {
+    private type?;
+    private length?;
+    constructor(type?: T, length?: number);
+    protected check(value: unknown): Infer<T>[];
+    min(length: number): this;
+    max(length: number): this;
+    unique(): this;
 }
 
 export { XVArray as default };