@oxog/vld 2.4.0 → 3.0.1

package/dist/validators/union-v2.js

@@ -0,0 +1 @@
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{V as s}from"../chunks/errors-core-BU14-Dk8.js";import{getMessages as t}from"../locales/runtime.js";function n(e){if(!0===e.isSimple)switch(e.validatorType){case r.STRING:return"string";case r.NUMBER:return"number";case r.BOOLEAN:return"boolean";case r.BIGINT:return"bigint";case r.SYMBOL:return"symbol";case r.NULL:return"null";case r.UNDEFINED:case r.VOID:return"undefined";case r.LITERAL:return"literal";case r.ANY:case r.UNKNOWN:return"passthrough";default:return}}function a(e){switch(e.validatorType){case r.STRING:return e=>"string"==typeof e;case r.NUMBER:return e=>"number"==typeof e&&!isNaN(e);case r.BOOLEAN:return e=>"boolean"==typeof e;case r.BIGINT:return e=>"bigint"==typeof e;case r.SYMBOL:return e=>"symbol"==typeof e;case r.NAN:return e=>"number"==typeof e&&Number.isNaN(e);case r.ARRAY:return Array.isArray;case r.OBJECT:return e=>"object"==typeof e&&null!==e&&!Array.isArray(e);case r.NULL:return e=>null===e;case r.UNDEFINED:case r.VOID:return e=>void 0===e;case r.ENUM:return e=>"string"==typeof e||"number"==typeof e;case r.LITERAL:{const r=e.literal;return e=>e===r}case r.NEVER:return()=>!1;case r.ANY:case r.UNKNOWN:default:return()=>!0}}class VldUnionV2 extends e{constructor(e,s){super(r.UNION),this.__def=function(e,r){const s=e.map(a),t=e.map(n),c=e.map((e,r)=>"literal"===t[r]?e.literal:void 0);return{type:"union",validators:e,typeCheckers:s,simpleModes:t,simpleValues:c,errorMessage:r}}(e,s)}static create(...e){return new VldUnionV2(e)}get options(){return this.__def.validators}parse(e){const r=[],{validators:s,typeCheckers:n,simpleModes:a,simpleValues:c}=this.__def;for(let t=0;t<s.length;t++){const o=s[t],u=n[t];if(u&&!u(e))continue;const i=a[t];if(void 0!==i)switch(i){case"string":case"number":case"boolean":case"bigint":case"symbol":case"passthrough":return e;case"null":return null;case"undefined":return;case"literal":return c[t]}try{return o.parse(e)}catch(e){r.push(e instanceof Error?e.message:String(e))}}throw new Error(this.__def.errorMessage||t().unionNoMatch(r))}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:e instanceof s?e:new s([{code:"custom",path:[],message:e.message}])}}}}export{VldUnionV2};

package/dist/validators/void.js

@@ -1 +1 @@
-import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{getMessages as s}from"../locales/runtime.js";import{V as o}from"../chunks/errors-core-CerMg2rq.js";class VldVoid extends e{constructor(){super(r.VOID)}static create(){return new VldVoid}get isSimple(){return!0}parse(e){if(void 0!==e)throw new Error(s().expectedUndefined)}safeParse(e){return void 0===e?{success:!0,data:void 0}:{success:!1,error:new o([{code:"invalid_type",path:[],message:s().expectedUndefined}])}}}export{VldVoid};
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{getMessages as s}from"../locales/runtime.js";import{V as o}from"../chunks/errors-core-BU14-Dk8.js";class VldVoid extends e{constructor(){super(r.VOID)}static create(){return new VldVoid}get isSimple(){return!0}parse(e){if(void 0!==e)throw new Error(s().expectedUndefined)}safeParse(e){return void 0===e?{success:!0,data:void 0}:{success:!1,error:new o([{code:"invalid_type",path:[],message:s().expectedUndefined}])}}}export{VldVoid};

package/dist/validators/wrapper-v2.d.ts

@@ -0,0 +1,74 @@
+/**
+ * V2 wrappers: VldOptionalV2, VldNullableV2, VldNullishV2, VldRefineV2, VldTransformV2.
+ * All single-def pattern. Public API mirrors legacy wrappers 1:1.
+ */
+import { VldBase, type ParseResult } from './base.js';
+export interface VldOptionalDef<TInput, TOutput> {
+    readonly type: 'optional';
+    readonly inner: VldBase<TInput, TOutput>;
+}
+export declare class VldOptionalV2<TInput, TOutput> extends VldBase<TInput | undefined, TOutput | undefined> {
+    readonly __def: VldOptionalDef<TInput, TOutput>;
+    constructor(inner: VldBase<TInput, TOutput>);
+    static create<TInput, TOutput>(baseValidator: VldBase<TInput, TOutput>): VldOptionalV2<TInput, TOutput>;
+    parse(value: unknown): TOutput | undefined;
+    safeParse(value: unknown): ParseResult<TOutput | undefined>;
+    unwrap(): VldBase<TInput, TOutput>;
+}
+export interface VldNullableDef<TInput, TOutput> {
+    readonly type: 'nullable';
+    readonly inner: VldBase<TInput, TOutput>;
+}
+export declare class VldNullableV2<TInput, TOutput> extends VldBase<TInput | null, TOutput | null> {
+    readonly __def: VldNullableDef<TInput, TOutput>;
+    constructor(inner: VldBase<TInput, TOutput>);
+    static create<TInput, TOutput>(baseValidator: VldBase<TInput, TOutput>): VldNullableV2<TInput, TOutput>;
+    parse(value: unknown): TOutput | null;
+    safeParse(value: unknown): ParseResult<TOutput | null>;
+    unwrap(): VldBase<TInput, TOutput>;
+}
+export interface VldNullishDef<TInput, TOutput> {
+    readonly type: 'nullish';
+    readonly inner: VldBase<TInput, TOutput>;
+}
+export declare class VldNullishV2<TInput, TOutput> extends VldBase<TInput | null | undefined, TOutput | null | undefined> {
+    readonly __def: VldNullishDef<TInput, TOutput>;
+    constructor(inner: VldBase<TInput, TOutput>);
+    static create<TInput, TOutput>(baseValidator: VldBase<TInput, TOutput>): VldNullishV2<TInput, TOutput>;
+    parse(value: unknown): TOutput | null | undefined;
+    safeParse(value: unknown): ParseResult<TOutput | null | undefined>;
+    unwrap(): VldBase<TInput, TOutput>;
+}
+export interface VldRefineDef<TInput, TBase> {
+    readonly type: 'refine';
+    readonly inner: VldBase<TInput, TBase>;
+    readonly predicate: (value: TBase) => boolean | Promise<boolean>;
+    readonly message: string;
+    readonly path?: ReadonlyArray<string | number> | undefined;
+}
+export declare class VldRefineV2<TInput, TBase, TOutput extends TBase = TBase> extends VldBase<TInput, TOutput> {
+    readonly __def: VldRefineDef<TInput, TBase>;
+    constructor(inner: VldBase<TInput, TBase>, predicate: (value: TBase) => boolean | Promise<boolean>, message?: string, path?: ReadonlyArray<string | number>);
+    static create<TInput, TBase, TOutput extends TBase = TBase>(inner: VldBase<TInput, TBase>, predicate: (value: TBase) => value is TOutput, message?: string): VldRefineV2<TInput, TBase, TOutput>;
+    static create<TInput, TBase, TOutput extends TBase = TBase>(inner: VldBase<TInput, TBase>, predicate: (value: TBase) => boolean | Promise<boolean>, message?: string): VldRefineV2<TInput, TBase, TOutput>;
+    parse(value: unknown): TOutput;
+    safeParse(value: unknown): ParseResult<TOutput>;
+    parseAsync(value: unknown): Promise<TOutput>;
+    safeParseAsync(value: unknown): Promise<ParseResult<TOutput>>;
+    unwrap(): VldBase<TInput, TBase>;
+}
+export interface VldTransformDef<TInput, TBase, TOutput> {
+    readonly type: 'transform';
+    readonly inner: VldBase<TInput, TBase>;
+    readonly transformer: (value: TBase) => TOutput | Promise<TOutput>;
+}
+export declare class VldTransformV2<TInput, TBase, TOutput> extends VldBase<TInput, TOutput> {
+    readonly __def: VldTransformDef<TInput, TBase, TOutput>;
+    constructor(inner: VldBase<TInput, TBase>, transformer: (value: TBase) => TOutput | Promise<TOutput>);
+    static create<TInput, TBase, TOutput>(inner: VldBase<TInput, TBase>, transformer: (value: TBase) => TOutput | Promise<TOutput>): VldTransformV2<TInput, TBase, TOutput>;
+    parse(value: unknown): TOutput;
+    safeParse(value: unknown): ParseResult<TOutput>;
+    parseAsync(value: unknown): Promise<TOutput>;
+    safeParseAsync(value: unknown): Promise<ParseResult<TOutput>>;
+    unwrap(): VldBase<TInput, TBase>;
+}

package/dist/validators/wrapper-v2.js

@@ -0,0 +1 @@
+import{VldBase as e,VLD_VALIDATOR_TYPES as r,ensureVldError as s}from"./base.js";import{V as t}from"../chunks/errors-core-BU14-Dk8.js";class VldOptionalV2 extends e{constructor(e){super(r.OPTIONAL),this.__def=Object.freeze({type:"optional",inner:e})}static create(e){return new VldOptionalV2(e)}parse(e){if(void 0!==e)return this.__def.inner.parse(e)}safeParse(e){return void 0===e?{success:!0,data:void 0}:this.__def.inner.safeParse(e)}unwrap(){return this.__def.inner}}class VldNullableV2 extends e{constructor(e){super(r.NULLABLE),this.__def=Object.freeze({type:"nullable",inner:e})}static create(e){return new VldNullableV2(e)}parse(e){return null===e?null:this.__def.inner.parse(e)}safeParse(e){return null===e?{success:!0,data:null}:this.__def.inner.safeParse(e)}unwrap(){return this.__def.inner}}class VldNullishV2 extends e{constructor(e){super(r.NULLISH),this.__def=Object.freeze({type:"nullish",inner:e})}static create(e){return new VldNullishV2(e)}parse(e){return null==e?e:this.__def.inner.parse(e)}safeParse(e){return null==e?{success:!0,data:e}:this.__def.inner.safeParse(e)}unwrap(){return this.__def.inner}}class VldRefineV2 extends e{constructor(e,s,t="Refinement check failed",n){super(r.REFINE),this.__def=Object.freeze({type:"refine",inner:e,predicate:s,message:t,path:n})}static create(e,r,s="Refinement check failed"){return new VldRefineV2(e,r,s)}parse(e){const r=this.__def.inner.parse(e),s=this.__def.predicate(r);if(s instanceof Promise)throw new Error("Use parseAsync for async refinements");if(!s)throw new t([{code:"custom",path:this.__def.path?[...this.__def.path]:[],message:this.__def.message}]);return r}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:s(e)}}}async parseAsync(e){const r=await this.__def.inner.parseAsync(e);if(!await this.__def.predicate(r))throw new t([{code:"custom",path:[],message:this.__def.message}]);return r}async safeParseAsync(e){try{return{success:!0,data:await this.parseAsync(e)}}catch(e){return{success:!1,error:s(e)}}}unwrap(){return this.__def.inner}}class VldTransformV2 extends e{constructor(e,s){super(r.TRANSFORM),this.__def=Object.freeze({type:"transform",inner:e,transformer:s})}static create(e,r){return new VldTransformV2(e,r)}parse(e){const r=this.__def.inner.parse(e);try{const e=this.__def.transformer(r);if(e instanceof Promise)throw new Error("Use parseAsync for async transforms");return e}catch(e){throw new Error(`Transform failed: ${e.message}`)}}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:s(e)}}}async parseAsync(e){const r=await this.__def.inner.parseAsync(e);return this.__def.transformer(r)}async safeParseAsync(e){try{return{success:!0,data:await this.parseAsync(e)}}catch(e){return{success:!1,error:s(e)}}}unwrap(){return this.__def.inner}}export{VldNullableV2,VldNullishV2,VldOptionalV2,VldRefineV2,VldTransformV2};

package/dist/zod-error.d.ts

@@ -0,0 +1,84 @@
+/**
+ * ZodError compatibility layer.
+ *
+ * Converts a VldError into a ZodError-shaped object so VLD can be a true
+ * drop-in replacement for Zod. The result has the same `issues` shape
+ * and `format()` / `flatten()` helpers that Zod users expect.
+ *
+ * @example
+ *   const r = v.object({ a: v.string() }).safeParse({ a: 1 });
+ *   if (!r.success) {
+ *     const zErr = toZodError(r.error);
+ *     console.log(zErr.issues[0].expected); // "string"
+ *     console.log(zErr.format());
+ *   }
+ */
+export interface ZodLikeIssue {
+    /** The validator that failed: 'string', 'number', 'object', etc. */
+    origin?: string;
+    /** Discriminator code: 'invalid_type', 'too_small', 'invalid_format', etc. */
+    code: string;
+    /** Path to the failing field. */
+    path: (string | number)[];
+    /** Human-readable error message. */
+    message: string;
+    /** The expected value/type, when applicable. */
+    expected?: string | number | boolean | null;
+    /** The actual value/type that was received, when applicable. */
+    received?: unknown;
+    /** For numeric bounds. */
+    minimum?: number;
+    maximum?: number;
+    inclusive?: boolean;
+    /** For string length / array length bounds. */
+    format?: string;
+    pattern?: string;
+    /** Allow additional fields. */
+    [key: string]: unknown;
+}
+export declare class ZodLikeError extends Error {
+    /** Array of individual issue descriptors. */
+    readonly issues: ReadonlyArray<ZodLikeIssue>;
+    /** Top-level error code (VLD-specific; Zod doesn't have this). */
+    readonly code: string;
+    constructor(issues: ReadonlyArray<ZodLikeIssue>);
+    /**
+     * Zod-compatible `format()` method. Returns a nested error tree
+     * keyed by path. For backward compatibility with Zod, the default
+     * format() returns `_errors: string[]` and any nested fields.
+     */
+    format(): Record<string, any>;
+    /**
+     * Zod-compatible `flatten()` method. Returns `{ formErrors: string[],
+     * fieldErrors: Record<string, string[]> }`.
+     */
+    flatten(): {
+        formErrors: string[];
+        fieldErrors: Record<string, string[]>;
+    };
+    /** Zod-compatible `errors` getter (alias of `issues`). */
+    get errors(): ReadonlyArray<ZodLikeIssue>;
+}
+/**
+ * Convert a VldError to a ZodError-shaped error.
+ *
+ * The returned ZodLikeError has the same `issues` array shape, plus
+ * `format()` and `flatten()` helpers that Zod users expect.
+ */
+export declare function toZodError(vldError: any): ZodLikeError;
+/**
+ * Convenience: convert a safeParse result to a Zod-shaped result.
+ * If `result.success === false`, the `error` field will be a ZodLikeError
+ * instead of the raw VldError. Otherwise the result is unchanged.
+ */
+export declare function toZodSafeResult<T>(result: {
+    success: boolean;
+    data?: T;
+    error?: any;
+}): {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: ZodLikeError;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxog/vld",
-  "version": "2.4.0",
+  "version": "3.0.1",
   "description": "Ultra-fast TypeScript-first schema validation with zero dependencies, 27+ language support, plugin system, and CLI tools",
   "type": "module",
   "main": "./dist/cjs/index.cjs",

package/dist/chunks/errors-core-CerMg2rq.js

@@ -1 +0,0 @@
-function e(e){return null===e?"null":void 0===e?"undefined":Array.isArray(e)?"array":"number"==typeof e?Number.isNaN(e)?"nan":e===1/0?"Infinity":e===-1/0?"-Infinity":"number":e instanceof Date?"date":e instanceof Map?"map":e instanceof Set?"set":typeof e}function s(e,s,r){return{code:"invalid_type",path:[],expected:e,received:s,message:r??`Invalid input: expected ${e}, received ${s}`}}function r(e){const s={code:e.code,path:e.path,message:e.message};return void 0!==e.expected&&(s.expected=e.expected),void 0!==e.received&&(s.received=e.received),void 0!==e.keys&&(s.keys=e.keys),void 0!==e.minimum&&(s.minimum=e.minimum),void 0!==e.maximum&&(s.maximum=e.maximum),void 0!==e.exact&&(s.exact=e.exact),void 0!==e.inclusive&&(s.inclusive=e.inclusive),void 0!==e.origin&&(s.origin=e.origin),void 0!==e.format&&(s.format=e.format),void 0!==e.values&&(s.values=e.values),void 0!==e.pattern&&(s.pattern=e.pattern),s}function i(e){const s={code:e.code,path:e.path,message:e.message};return void 0!==e.expected&&(s.expected=e.expected),void 0!==e.received&&(s.received=e.received),void 0!==e.keys&&(s.keys=e.keys),void 0!==e.minimum&&(s.minimum=e.minimum),void 0!==e.maximum&&(s.maximum=e.maximum),void 0!==e.exact&&(s.exact=e.exact),void 0!==e.inclusive&&(s.inclusive=e.inclusive),void 0!==e.origin&&(s.origin=e.origin),void 0!==e.format&&(s.format=e.format),void 0!==e.values&&(s.values=e.values),void 0!==e.pattern&&(s.pattern=e.pattern),s}class VldError extends Error{constructor(e,s){const r=e[0];super(void 0!==s?s:1===e.length&&void 0!==r?r.message:`${e.length} validation errors`),this.name="VldError",this.issues=e,Error.captureStackTrace&&Error.captureStackTrace(this,VldError)}get firstError(){return this.issues[0]}get errors(){return this.issues}get isEmpty(){return 0===this.issues.length}get formattedErrors(){return this.issues.map(e=>e.message)}addIssue(e){this.issues.push(e)}addIssues(e=[]){this.issues.push(...e)}format(){const e={_errors:[]};for(const s of this.issues)if(s.path&&0!==s.path.length){let r=e;for(const e of s.path)r[e]||(r[e]={_errors:[]}),r=r[e];r._errors.push(s.message)}else e._errors.push(s.message);return e}flatten(e){const s=e??(e=>e.message),r=[],i={};for(const e of this.issues)if(e.path&&0!==e.path.length){const r=String(e.path[0]);i[r]=i[r]??[],i[r].push(s(e))}else r.push(s(e));return{formErrors:r,fieldErrors:i}}toJSON(){return{name:this.name,message:this.message,code:"VLD_VALIDATION_ERROR",issues:this.issues.map(r)}}static fromJSON(e){const s=e.issues.map(i);return new VldError(s)}static isVldError(e){return e instanceof VldError}}export{VldError as V,s as c,e as g};

package/dist/cjs/chunks/errors-core-DrydF46s.cjs

@@ -1 +0,0 @@
-"use strict";function e(e){const s={code:e.code,path:e.path,message:e.message};return void 0!==e.expected&&(s.expected=e.expected),void 0!==e.received&&(s.received=e.received),void 0!==e.keys&&(s.keys=e.keys),void 0!==e.minimum&&(s.minimum=e.minimum),void 0!==e.maximum&&(s.maximum=e.maximum),void 0!==e.exact&&(s.exact=e.exact),void 0!==e.inclusive&&(s.inclusive=e.inclusive),void 0!==e.origin&&(s.origin=e.origin),void 0!==e.format&&(s.format=e.format),void 0!==e.values&&(s.values=e.values),void 0!==e.pattern&&(s.pattern=e.pattern),s}function s(e){const s={code:e.code,path:e.path,message:e.message};return void 0!==e.expected&&(s.expected=e.expected),void 0!==e.received&&(s.received=e.received),void 0!==e.keys&&(s.keys=e.keys),void 0!==e.minimum&&(s.minimum=e.minimum),void 0!==e.maximum&&(s.maximum=e.maximum),void 0!==e.exact&&(s.exact=e.exact),void 0!==e.inclusive&&(s.inclusive=e.inclusive),void 0!==e.origin&&(s.origin=e.origin),void 0!==e.format&&(s.format=e.format),void 0!==e.values&&(s.values=e.values),void 0!==e.pattern&&(s.pattern=e.pattern),s}class VldError extends Error{constructor(e,s){const r=e[0];super(void 0!==s?s:1===e.length&&void 0!==r?r.message:`${e.length} validation errors`),this.name="VldError",this.issues=e,Error.captureStackTrace&&Error.captureStackTrace(this,VldError)}get firstError(){return this.issues[0]}get errors(){return this.issues}get isEmpty(){return 0===this.issues.length}get formattedErrors(){return this.issues.map(e=>e.message)}addIssue(e){this.issues.push(e)}addIssues(e=[]){this.issues.push(...e)}format(){const e={_errors:[]};for(const s of this.issues)if(s.path&&0!==s.path.length){let r=e;for(const e of s.path)r[e]||(r[e]={_errors:[]}),r=r[e];r._errors.push(s.message)}else e._errors.push(s.message);return e}flatten(e){const s=e??(e=>e.message),r=[],t={};for(const e of this.issues)if(e.path&&0!==e.path.length){const r=String(e.path[0]);t[r]=t[r]??[],t[r].push(s(e))}else r.push(s(e));return{formErrors:r,fieldErrors:t}}toJSON(){return{name:this.name,message:this.message,code:"VLD_VALIDATION_ERROR",issues:this.issues.map(e)}}static fromJSON(e){const r=e.issues.map(s);return new VldError(r)}static isVldError(e){return e instanceof VldError}}exports.VldError=VldError,exports.createInvalidTypeIssue=function(e,s,r){return{code:"invalid_type",path:[],expected:e,received:s,message:r??`Invalid input: expected ${e}, received ${s}`}},exports.getTypeName=function(e){return null===e?"null":void 0===e?"undefined":Array.isArray(e)?"array":"number"==typeof e?Number.isNaN(e)?"nan":e===1/0?"Infinity":e===-1/0?"-Infinity":"number":e instanceof Date?"date":e instanceof Map?"map":e instanceof Set?"set":typeof e};