@oxog/vld 2.1.0 → 2.2.5

package/dist/validators/map.js

@@ -1,214 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { getMessages } from '../locales/runtime.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-function createMapError(message) {
-    return new VldError([{ code: 'invalid_type', path: [], message }]);
-}
-/**
- * Immutable Map validator
- */
-class VldMap extends VldBase {
-    /**
-     * Private constructor to enforce immutability
-     */
-    constructor(keyValidator, valueValidator, errorMessage) {
-        super(VLD_VALIDATOR_TYPES.MAP);
-        this.keyValidator = keyValidator;
-        this.valueValidator = valueValidator;
-        this.errorMessage = errorMessage;
-        this._simpleKeyMode = this.getSimpleItemMode(keyValidator);
-        this._simpleValueMode = this.getSimpleItemMode(valueValidator);
-        this._simpleKeyValue = this._simpleKeyMode === 'literal' ? keyValidator.literal : undefined;
-        this._simpleValueValue = this._simpleValueMode === 'literal' ? valueValidator.literal : undefined;
-    }
-    get keySchema() {
-        return this.keyValidator;
-    }
-    get valueSchema() {
-        return this.valueValidator;
-    }
-    /**
-     * Create a new Map validator
-     */
-    static create(keyValidator, valueValidator) {
-        return new VldMap(keyValidator, valueValidator);
-    }
-    getSimpleItemMode(validator) {
-        if (validator.isSimple !== true) {
-            return undefined;
-        }
-        switch (validator.validatorType) {
-            case VLD_VALIDATOR_TYPES.STRING:
-                return 'string';
-            case VLD_VALIDATOR_TYPES.NUMBER:
-                return 'number';
-            case VLD_VALIDATOR_TYPES.BOOLEAN:
-                return 'boolean';
-            case VLD_VALIDATOR_TYPES.BIGINT:
-                return 'bigint';
-            case VLD_VALIDATOR_TYPES.SYMBOL:
-                return 'symbol';
-            case VLD_VALIDATOR_TYPES.NULL:
-                return 'null';
-            case VLD_VALIDATOR_TYPES.UNDEFINED:
-            case VLD_VALIDATOR_TYPES.VOID:
-                return 'undefinedValue';
-            case VLD_VALIDATOR_TYPES.LITERAL:
-                return 'literal';
-            case VLD_VALIDATOR_TYPES.ANY:
-            case VLD_VALIDATOR_TYPES.UNKNOWN:
-                return 'passthrough';
-            default:
-                return undefined;
-        }
-    }
-    getSimpleItemError(mode, expected, received) {
-        switch (mode) {
-            case 'string':
-                return getMessages().invalidString;
-            case 'number':
-                return getMessages().invalidNumber;
-            case 'boolean':
-                return getMessages().invalidBoolean;
-            case 'bigint':
-                return getMessages().invalidBigint;
-            case 'symbol':
-                return getMessages().invalidSymbol;
-            case 'null':
-                return `Expected null, received ${typeof received}`;
-            case 'undefinedValue':
-                return getMessages().expectedUndefined;
-            case 'literal':
-                return getMessages().literalExpected(JSON.stringify(expected), JSON.stringify(received));
-            default:
-                return getMessages().invalidMap;
-        }
-    }
-    parseSimpleItem(mode, expected, value) {
-        switch (mode) {
-            case 'string':
-                if (typeof value !== 'string') {
-                    throw new Error(this.getSimpleItemError(mode, expected, value));
-                }
-                return value;
-            case 'number':
-                if (typeof value !== 'number' || isNaN(value)) {
-                    throw new Error(this.getSimpleItemError(mode, expected, value));
-                }
-                return value;
-            case 'boolean':
-                if (typeof value !== 'boolean') {
-                    throw new Error(this.getSimpleItemError(mode, expected, value));
-                }
-                return value;
-            case 'bigint':
-                if (typeof value !== 'bigint') {
-                    throw new Error(this.getSimpleItemError(mode, expected, value));
-                }
-                return value;
-            case 'symbol':
-                if (typeof value !== 'symbol') {
-                    throw new Error(this.getSimpleItemError(mode, expected, value));
-                }
-                return value;
-            case 'null':
-                if (value !== null) {
-                    throw new Error(this.getSimpleItemError(mode, expected, value));
-                }
-                return null;
-            case 'undefinedValue':
-                if (value !== undefined) {
-                    throw new Error(this.getSimpleItemError(mode, expected, value));
-                }
-                return undefined;
-            case 'literal':
-                if (value !== expected) {
-                    throw new Error(this.getSimpleItemError(mode, expected, value));
-                }
-                return expected;
-            case 'passthrough':
-                return value;
-        }
-    }
-    /**
-     * Parse and validate a Map value
-     */
-    parse(value) {
-        if (!(value instanceof Map)) {
-            throw new Error(this.errorMessage || getMessages().invalidMap);
-        }
-        return this.parseKnownMap(value);
-    }
-    /**
-     * Parse a value that has already passed the Map instance guard.
-     * @internal Used by object validators to avoid duplicate hot-path checks.
-     */
-    parseKnownMap(value) {
-        const result = new Map();
-        const simpleKeyMode = this._simpleKeyMode;
-        const simpleValueMode = this._simpleValueMode;
-        if (simpleKeyMode === 'string' && simpleValueMode === 'number') {
-            for (const [key, val] of value) {
-                if (typeof key !== 'string') {
-                    throw new Error(this.getSimpleItemError(simpleKeyMode, this._simpleKeyValue, key));
-                }
-                if (typeof val !== 'number' || isNaN(val)) {
-                    throw new Error(this.getSimpleItemError(simpleValueMode, this._simpleValueValue, val));
-                }
-                result.set(key, val);
-            }
-            return result;
-        }
-        if (simpleKeyMode === 'string' && simpleValueMode === 'string') {
-            for (const [key, val] of value) {
-                if (typeof key !== 'string') {
-                    throw new Error(this.getSimpleItemError(simpleKeyMode, this._simpleKeyValue, key));
-                }
-                if (typeof val !== 'string') {
-                    throw new Error(this.getSimpleItemError(simpleValueMode, this._simpleValueValue, val));
-                }
-                result.set(key, val);
-            }
-            return result;
-        }
-        if (simpleKeyMode !== undefined && simpleValueMode !== undefined) {
-            const keyMode = simpleKeyMode;
-            const valueMode = simpleValueMode;
-            for (const [key, val] of value) {
-                const validKey = this.parseSimpleItem(keyMode, this._simpleKeyValue, key);
-                const validValue = this.parseSimpleItem(valueMode, this._simpleValueValue, val);
-                result.set(validKey, validValue);
-            }
-            return result;
-        }
-        for (const [key, val] of value) {
-            try {
-                const validKey = simpleKeyMode === undefined
-                    ? this.keyValidator.parse(key)
-                    : this.parseSimpleItem(simpleKeyMode, this._simpleKeyValue, key);
-                const validValue = simpleValueMode === undefined
-                    ? this.valueValidator.parse(val)
-                    : this.parseSimpleItem(simpleValueMode, this._simpleValueValue, val);
-                result.set(validKey, validValue);
-            }
-            catch (error) {
-                throw new Error(error.message);
-            }
-        }
-        return result;
-    }
-    /**
-     * Safely parse and validate a Map value
-     */
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: createMapError(error.message) };
-        }
-    }
-}
-
-export { VldMap };
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{getMessages as t}from"../locales/runtime.js";import{V as i}from"../chunks/errors-core-Cqi4-9ew.js";class VldMap extends e{constructor(e,t,i){super(r.MAP),this.keyValidator=e,this.valueValidator=t,this.errorMessage=i,this._simpleKeyMode=this.getSimpleItemMode(e),this._simpleValueMode=this.getSimpleItemMode(t),this._simpleKeyValue="literal"===this._simpleKeyMode?e.literal:void 0,this._simpleValueValue="literal"===this._simpleValueMode?t.literal:void 0}get keySchema(){return this.keyValidator}get valueSchema(){return this.valueValidator}static create(e,r){return new VldMap(e,r)}getSimpleItemMode(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"undefinedValue";case r.LITERAL:return"literal";case r.ANY:case r.UNKNOWN:return"passthrough";default:return}}getSimpleItemError(e,r,i){switch(e){case"string":return t().invalidString;case"number":return t().invalidNumber;case"boolean":return t().invalidBoolean;case"bigint":return t().invalidBigint;case"symbol":return t().invalidSymbol;case"null":return"Expected null, received "+typeof i;case"undefinedValue":return t().expectedUndefined;case"literal":return t().literalExpected(JSON.stringify(r),JSON.stringify(i));default:return t().invalidMap}}parseSimpleItem(e,r,t){switch(e){case"string":if("string"!=typeof t)throw new Error(this.getSimpleItemError(e,r,t));return t;case"number":if("number"!=typeof t||isNaN(t))throw new Error(this.getSimpleItemError(e,r,t));return t;case"boolean":if("boolean"!=typeof t)throw new Error(this.getSimpleItemError(e,r,t));return t;case"bigint":if("bigint"!=typeof t)throw new Error(this.getSimpleItemError(e,r,t));return t;case"symbol":if("symbol"!=typeof t)throw new Error(this.getSimpleItemError(e,r,t));return t;case"null":if(null!==t)throw new Error(this.getSimpleItemError(e,r,t));return null;case"undefinedValue":if(void 0!==t)throw new Error(this.getSimpleItemError(e,r,t));return;case"literal":if(t!==r)throw new Error(this.getSimpleItemError(e,r,t));return r;case"passthrough":return t}}parse(e){if(!(e instanceof Map))throw new Error(this.errorMessage||t().invalidMap);return this.parseKnownMap(e)}parseKnownMap(e){const r=new Map,t=this._simpleKeyMode,i=this._simpleValueMode;if("string"===t&&"number"===i){for(const[s,a]of e){if("string"!=typeof s)throw new Error(this.getSimpleItemError(t,this._simpleKeyValue,s));if("number"!=typeof a||isNaN(a))throw new Error(this.getSimpleItemError(i,this._simpleValueValue,a));r.set(s,a)}return r}if("string"===t&&"string"===i){for(const[s,a]of e){if("string"!=typeof s)throw new Error(this.getSimpleItemError(t,this._simpleKeyValue,s));if("string"!=typeof a)throw new Error(this.getSimpleItemError(i,this._simpleValueValue,a));r.set(s,a)}return r}if(void 0!==t&&void 0!==i){const s=t,a=i;for(const[t,i]of e){const e=this.parseSimpleItem(s,this._simpleKeyValue,t),o=this.parseSimpleItem(a,this._simpleValueValue,i);r.set(e,o)}return r}for(const[s,a]of e)try{const e=void 0===t?this.keyValidator.parse(s):this.parseSimpleItem(t,this._simpleKeyValue,s),o=void 0===i?this.valueValidator.parse(a):this.parseSimpleItem(i,this._simpleValueValue,a);r.set(e,o)}catch(e){throw new Error(e.message)}return r}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:(r=e.message,new i([{code:"invalid_type",path:[],message:r}]))}}var r}}export{VldMap};

package/dist/validators/nan.js

@@ -1,38 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-/**
- * VldNan - Validates that a value is NaN (Not a Number)
- * Part of Zod 4 API parity implementation
- */
-function createNanError(message) {
-    return new VldError([{ code: 'invalid_number', path: [], message }]);
-}
-/**
- * NaN validator - validates that a value is NaN
- * Note: Uses Number.isNaN() which is more strict than global isNaN()
- */
-class VldNan extends VldBase {
-    constructor() {
-        super(VLD_VALIDATOR_TYPES.NAN);
-    }
-    static create() {
-        return new VldNan();
-    }
-    parse(value) {
-        if (typeof value !== 'number' || !Number.isNaN(value)) {
-            throw new Error(`Expected NaN, received ${typeof value === 'number' ? 'a valid number' : typeof value}`);
-        }
-        return value;
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: createNanError(error.message) };
-        }
-    }
-}
-
-export { VldNan };
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{V as s}from"../chunks/errors-core-Cqi4-9ew.js";class VldNan extends e{constructor(){super(r.NAN)}static create(){return new VldNan}parse(e){if("number"!=typeof e||!Number.isNaN(e))throw new Error("Expected NaN, received "+("number"==typeof e?"a valid number":typeof e));return e}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:(r=e.message,new s([{code:"invalid_number",path:[],message:r}]))}}var r}}export{VldNan};

package/dist/validators/never.js

@@ -1,32 +1 @@
-import { VldBase } from './base.js';
-import { getMessages } from '../locales/runtime.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-/**
- * Validator that never succeeds
- */
-class VldNever extends VldBase {
-    /**
-     * Create a new never validator
-     */
-    static create() {
-        return new VldNever();
-    }
-    /**
-     * Parse never value (always fails)
-     */
-    parse(_value) {
-        throw new Error(getMessages().neverType);
-    }
-    /**
-     * Safely parse never value (always fails)
-     */
-    safeParse(_value) {
-        return {
-            success: false,
-            error: new VldError([{ code: 'invalid_type', path: [], message: getMessages().neverType }])
-        };
-    }
-}
-
-export { VldNever };
+import{VldBase as e}from"./base.js";import{getMessages as r}from"../locales/runtime.js";import{V as s}from"../chunks/errors-core-Cqi4-9ew.js";class VldNever extends e{static create(){return new VldNever}parse(e){throw new Error(r().neverType)}safeParse(e){return{success:!1,error:new s([{code:"invalid_type",path:[],message:r().neverType}])}}}export{VldNever};

package/dist/validators/null.js

@@ -1,40 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-/**
- * VldNull - Validates that a value is exactly null
- * Part of Zod 4 API parity implementation
- */
-function createNullError(message) {
-    return new VldError([{ code: 'invalid_type', path: [], message }]);
-}
-/**
- * Null validator - validates that a value is exactly null
- */
-class VldNull extends VldBase {
-    constructor() {
-        super(VLD_VALIDATOR_TYPES.NULL);
-    }
-    static create() {
-        return new VldNull();
-    }
-    get isSimple() {
-        return true;
-    }
-    parse(value) {
-        if (value !== null) {
-            throw new Error(`Expected null, received ${typeof value}`);
-        }
-        return null;
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: createNullError(error.message) };
-        }
-    }
-}
-
-export { VldNull };
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{V as s}from"../chunks/errors-core-Cqi4-9ew.js";class VldNull extends e{constructor(){super(r.NULL)}static create(){return new VldNull}get isSimple(){return!0}parse(e){if(null!==e)throw new Error("Expected null, received "+typeof e);return null}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:(r=e.message,new s([{code:"invalid_type",path:[],message:r}]))}}var r}}export{VldNull};

package/dist/validators/number.d.ts

@@ -3,6 +3,15 @@ import { VldBase, ParseResult, ValidatorType, type ErrorParam } from './base.js'
  * Type for number validation check functions
  */
 type NumberCheck = (value: number) => boolean;
+/**
+ * Metadata for a single number constraint, enabling Zod 4-compatible issues.
+ */
+interface NumberCheckMeta {
+    readonly kind: 'min' | 'max' | 'int' | 'gt' | 'lt' | 'multiple_of' | 'finite' | 'safe' | 'other';
+    readonly value?: number;
+    readonly inclusive?: boolean;
+    readonly message: string | undefined;
+}
 interface NumberJSONSchemaHints {
     type?: 'number' | 'integer';
     minimum?: number;
@@ -19,6 +28,7 @@ interface NumberValidatorConfig {
     readonly errorMessage: string | undefined;
     readonly validatorType?: ValidatorType;
     readonly jsonSchema: NumberJSONSchemaHints | undefined;
+    readonly checkMetas: ReadonlyArray<NumberCheckMeta> | undefined;
 }
 /**
  * Immutable number validator with chainable methods
@@ -28,6 +38,7 @@ export declare class VldNumber extends VldBase<number, number> {
     private readonly _checks;
     private readonly _isSimple;
     private readonly _fastCheckMode;
+    private readonly _checkMetas;
     /**
      * Protected constructor to allow extension while maintaining immutability
      */
@@ -49,14 +60,22 @@ export declare class VldNumber extends VldBase<number, number> {
     static create(): VldNumber;
     /**
      * Parse and validate a number value
+     * Zod 4 behavior: Infinity and NaN are rejected by default (they are not valid numbers).
      */
     parse(value: unknown): number;
+    /**
+     * Build the Zod 4-compatible VldIssue for a failed number check.
+     */
+    private _createCheckIssue;
+    /**
+     * Run all checks against a known number and return the index of the first failing check, or -1.
+     */
+    private _findFailingCheck;
     /**
      * Parse a value that has already passed the number type guard.
      * @internal Used by object validators to avoid duplicate hot-path checks.
      */
     parseKnownNumber(value: number): number;
-    private passesChecks;
     /**
      * Safely parse and validate a number value
      */