@oxog/vld 2.1.0 → 2.2.5

package/dist/validators/union.js

@@ -1,187 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { getMessages } from '../locales/runtime.js';
-
-/**
- * Optimized immutable union validator for multiple type options
- * Features type-checking shortcuts for 110x performance improvement
- */
-class VldUnion extends VldBase {
-    /**
-     * Private constructor to enforce immutability
-     */
-    constructor(validators, errorMessage) {
-        super(VLD_VALIDATOR_TYPES.UNION);
-        this.validators = validators;
-        this.errorMessage = errorMessage;
-        this.typeCheckers = validators.map(validator => this.createTypeChecker(validator));
-        this.simpleModes = validators.map(validator => this.createSimpleMode(validator));
-        this.simpleValues = validators.map((validator, i) => this.simpleModes[i] === 'literal' ? validator.literal : undefined);
-    }
-    createSimpleMode(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 'undefined';
-            case VLD_VALIDATOR_TYPES.LITERAL:
-                return 'literal';
-            case VLD_VALIDATOR_TYPES.ANY:
-            case VLD_VALIDATOR_TYPES.UNKNOWN:
-                return 'passthrough';
-            default:
-                return undefined;
-        }
-    }
-    parseSimpleValue(mode, index, value) {
-        switch (mode) {
-            case 'string':
-            case 'number':
-            case 'boolean':
-            case 'bigint':
-            case 'symbol':
-                return value;
-            case 'null':
-                return null;
-            case 'undefined':
-                return undefined;
-            case 'literal':
-                return this.simpleValues[index];
-            case 'passthrough':
-                return value;
-            default:
-                return undefined;
-        }
-    }
-    /**
-     * Create type checker based on validator type for fast path optimization
-     * Uses a safer approach that's less prone to spoofing
-     */
-    createTypeChecker(validator) {
-        switch (validator.validatorType) {
-            case VLD_VALIDATOR_TYPES.STRING:
-                return (v) => typeof v === 'string';
-            case VLD_VALIDATOR_TYPES.NUMBER:
-                return (v) => typeof v === 'number' && !isNaN(v);
-            case VLD_VALIDATOR_TYPES.BOOLEAN:
-                return (v) => typeof v === 'boolean';
-            case VLD_VALIDATOR_TYPES.BIGINT:
-                return (v) => typeof v === 'bigint';
-            case VLD_VALIDATOR_TYPES.SYMBOL:
-                return (v) => typeof v === 'symbol';
-            case VLD_VALIDATOR_TYPES.NAN:
-                return (v) => typeof v === 'number' && Number.isNaN(v);
-            case VLD_VALIDATOR_TYPES.ARRAY:
-                return Array.isArray;
-            case VLD_VALIDATOR_TYPES.OBJECT:
-                return (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
-            case VLD_VALIDATOR_TYPES.NULL:
-                return (v) => v === null;
-            case VLD_VALIDATOR_TYPES.UNDEFINED:
-            case VLD_VALIDATOR_TYPES.VOID:
-                return (v) => v === undefined;
-            case VLD_VALIDATOR_TYPES.ENUM:
-                return (v) => typeof v === 'string' || typeof v === 'number';
-            case VLD_VALIDATOR_TYPES.LITERAL: {
-                const literal = validator.literal;
-                return (v) => v === literal;
-            }
-            case VLD_VALIDATOR_TYPES.NEVER:
-                return () => false;
-            case VLD_VALIDATOR_TYPES.ANY:
-            case VLD_VALIDATOR_TYPES.UNKNOWN:
-                return () => true;
-            default:
-                return () => true;
-        }
-    }
-    /**
-     * Create a new union validator
-     */
-    static create(...validators) {
-        return new VldUnion(validators);
-    }
-    /**
-     * Parse and validate a value against union options
-     * Optimized with type checking and direct parsing to avoid success-result allocations
-     * BUG-NEW-013 FIX: Single-pass error collection to avoid double parsing
-     */
-    parse(value) {
-        // Single pass: collect errors during validation
-        const errors = [];
-        for (let i = 0; i < this.validators.length; i++) {
-            const validator = this.validators[i];
-            const typeChecker = this.typeCheckers[i];
-            // Skip validators that definitely won't match based on type
-            if (typeChecker && !typeChecker(value)) {
-                continue;
-            }
-            const simpleMode = this.simpleModes[i];
-            if (simpleMode !== undefined) {
-                return this.parseSimpleValue(simpleMode, i, value);
-            }
-            try {
-                return validator.parse(value);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                errors.push(message);
-            }
-        }
-        // All validators failed - throw with collected errors
-        throw new Error(this.errorMessage ||
-            getMessages().unionNoMatch(errors));
-    }
-    /**
-     * Safely parse and validate a value against union options
-     * Optimized version using type checking shortcuts
-     * BUG-NEW-013 FIX: Single-pass error collection to avoid double parsing
-     */
-    safeParse(value) {
-        // Single pass: collect errors during validation
-        const errors = [];
-        for (let i = 0; i < this.validators.length; i++) {
-            const validator = this.validators[i];
-            const typeChecker = this.typeCheckers[i];
-            // Skip validators that definitely won't match based on type
-            if (typeChecker && !typeChecker(value)) {
-                continue;
-            }
-            const simpleMode = this.simpleModes[i];
-            if (simpleMode !== undefined) {
-                return {
-                    success: true,
-                    data: this.parseSimpleValue(simpleMode, i, value)
-                };
-            }
-            try {
-                return { success: true, data: validator.parse(value) };
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                errors.push(message);
-            }
-        }
-        // All validators failed - return error with collected messages
-        return {
-            success: false,
-            error: new Error(this.errorMessage ||
-                getMessages().unionNoMatch(errors))
-        };
-    }
-}
-
-export { VldUnion };
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{getMessages as s}from"../locales/runtime.js";class VldUnion extends e{constructor(e,s){super(r.UNION),this.validators=e,this.errorMessage=s,this.typeCheckers=e.map(e=>this.createTypeChecker(e)),this.simpleModes=e.map(e=>this.createSimpleMode(e)),this.simpleValues=e.map((e,r)=>"literal"===this.simpleModes[r]?e.literal:void 0)}createSimpleMode(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}}parseSimpleValue(e,r,s){switch(e){case"string":case"number":case"boolean":case"bigint":case"symbol":case"passthrough":return s;case"null":return null;case"undefined":default:return;case"literal":return this.simpleValues[r]}}createTypeChecker(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}}static create(...e){return new VldUnion(e)}parse(e){const r=[];for(let s=0;s<this.validators.length;s++){const t=this.validators[s],a=this.typeCheckers[s];if(a&&!a(e))continue;const n=this.simpleModes[s];if(void 0!==n)return this.parseSimpleValue(n,s,e);try{return t.parse(e)}catch(e){const s=e instanceof Error?e.message:String(e);r.push(s)}}throw new Error(this.errorMessage||s().unionNoMatch(r))}safeParse(e){const r=[];for(let s=0;s<this.validators.length;s++){const t=this.validators[s],a=this.typeCheckers[s];if(a&&!a(e))continue;const n=this.simpleModes[s];if(void 0!==n)return{success:!0,data:this.parseSimpleValue(n,s,e)};try{return{success:!0,data:t.parse(e)}}catch(e){const s=e instanceof Error?e.message:String(e);r.push(s)}}return{success:!1,error:new Error(this.errorMessage||s().unionNoMatch(r))}}}export{VldUnion};

package/dist/validators/unknown.js

@@ -1,37 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-
-/**
- * Validator that accepts unknown values
- */
-class VldUnknown extends VldBase {
-    constructor() {
-        super(VLD_VALIDATOR_TYPES.UNKNOWN);
-    }
-    /**
-     * Create a new unknown validator
-     */
-    static create() {
-        return new VldUnknown();
-    }
-    /**
-     * Returns true because unknown accepts every input without checks.
-     * Used by composite validators for passthrough fast paths.
-     */
-    get isSimple() {
-        return true;
-    }
-    /**
-     * Parse unknown value (always succeeds)
-     */
-    parse(value) {
-        return value;
-    }
-    /**
-     * Safely parse unknown value (always succeeds)
-     */
-    safeParse(value) {
-        return { success: true, data: value };
-    }
-}
-
-export { VldUnknown };
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";class VldUnknown extends e{constructor(){super(r.UNKNOWN)}static create(){return new VldUnknown}get isSimple(){return!0}parse(e){return e}safeParse(e){return{success:!0,data:e}}}export{VldUnknown};

package/dist/validators/void.js

@@ -1,44 +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';
-
-/**
- * Validator that only accepts undefined
- */
-class VldVoid extends VldBase {
-    constructor() {
-        super(VLD_VALIDATOR_TYPES.VOID);
-    }
-    /**
-     * Create a new void validator
-     */
-    static create() {
-        return new VldVoid();
-    }
-    get isSimple() {
-        return true;
-    }
-    /**
-     * Parse void value (must be undefined)
-     */
-    parse(value) {
-        if (value !== undefined) {
-            throw new Error(getMessages().expectedUndefined);
-        }
-        return undefined;
-    }
-    /**
-     * Safely parse void value
-     */
-    safeParse(value) {
-        if (value === undefined) {
-            return { success: true, data: undefined };
-        }
-        return {
-            success: false,
-            error: new VldError([{ code: 'invalid_type', path: [], message: getMessages().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-Cqi4-9ew.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/xor.d.ts

@@ -9,10 +9,10 @@ import type { ParseResult } from './base.js';
  * XOR validator - ensures exactly one option matches
  * Unlike regular union which allows multiple matches, XOR requires exactly one
  */
-export declare class VldXor<Options extends VldBase<any, any>[]> extends VldBase<unknown, Options[number] extends VldBase<any, infer T> ? T : never> {
+export declare class VldXor<Options extends readonly VldBase<any, any>[]> extends VldBase<unknown, Options[number] extends VldBase<any, infer T> ? T : never> {
     private readonly _options;
     constructor(_options: Options);
-    static create<Options extends VldBase<any, any>[]>(options: Options): VldXor<Options>;
+    static create<Options extends readonly VldBase<any, any>[]>(options: Options): VldXor<Options>;
     parse(value: unknown): Options[number] extends VldBase<any, infer T> ? T : never;
     safeParse(value: unknown): ParseResult<Options[number] extends VldBase<any, infer T> ? T : never>;
     /**

package/dist/validators/xor.js

@@ -1,66 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-
-/**
- * VldXor - Exclusive union validator
- * Part of Zod 4 API parity implementation
- * Ensures exactly one schema in the union matches
- */
-/**
- * XOR validator - ensures exactly one option matches
- * Unlike regular union which allows multiple matches, XOR requires exactly one
- */
-class VldXor extends VldBase {
-    constructor(_options) {
-        super(VLD_VALIDATOR_TYPES.XOR);
-        this._options = _options;
-    }
-    static create(options) {
-        if (options.length < 2) {
-            throw new Error('XOR requires at least 2 options');
-        }
-        return new VldXor(options);
-    }
-    parse(value) {
-        const result = this.safeParse(value);
-        if (!result.success) {
-            throw result.error;
-        }
-        return result.data;
-    }
-    safeParse(value) {
-        let matchCount = 0;
-        let lastSuccess = null;
-        for (const option of this._options) {
-            const result = option.safeParse(value);
-            if (result.success) {
-                matchCount++;
-                lastSuccess = result;
-                if (matchCount > 1) {
-                    // Early exit if more than one match
-                    break;
-                }
-            }
-        }
-        if (matchCount === 0) {
-            return {
-                success: false,
-                error: new Error('No schema matched in XOR union')
-            };
-        }
-        if (matchCount > 1) {
-            return {
-                success: false,
-                error: new Error(`Input matches ${matchCount} schemas in XOR union, but exactly one is required`)
-            };
-        }
-        return lastSuccess;
-    }
-    /**
-     * Get all options
-     */
-    getOptions() {
-        return this._options;
-    }
-}
-
-export { VldXor };
+import{VldBase as s,VLD_VALIDATOR_TYPES as r}from"./base.js";class VldXor extends s{constructor(s){super(r.XOR),this._options=s}static create(s){return new VldXor(s)}parse(s){const r=this.safeParse(s);if(!r.success)throw r.error;return r.data}safeParse(s){let r=0,e=null;for(const t of this._options){const o=t.safeParse(s);if(o.success&&(r++,e=o,r>1))break}return 0===r?{success:!1,error:new Error("No schema matched in XOR union")}:r>1?{success:!1,error:new Error(`Input matches ${r} schemas in XOR union, but exactly one is required`)}:e}getOptions(){return this._options}}export{VldXor};