@oxog/vld 2.0.2 → 2.1.0

package/dist/cjs/validators/union.cjs

@@ -0,0 +1,191 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+var locales_runtime = require('../locales/runtime.cjs');
+require('../registry.cjs');
+require('../locales/en.cjs');
+
+/**
+ * Optimized immutable union validator for multiple type options
+ * Features type-checking shortcuts for 110x performance improvement
+ */
+class VldUnion extends validators_base.VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(validators, errorMessage) {
+        super(validators_base.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 validators_base.VLD_VALIDATOR_TYPES.STRING:
+                return 'string';
+            case validators_base.VLD_VALIDATOR_TYPES.NUMBER:
+                return 'number';
+            case validators_base.VLD_VALIDATOR_TYPES.BOOLEAN:
+                return 'boolean';
+            case validators_base.VLD_VALIDATOR_TYPES.BIGINT:
+                return 'bigint';
+            case validators_base.VLD_VALIDATOR_TYPES.SYMBOL:
+                return 'symbol';
+            case validators_base.VLD_VALIDATOR_TYPES.NULL:
+                return 'null';
+            case validators_base.VLD_VALIDATOR_TYPES.UNDEFINED:
+            case validators_base.VLD_VALIDATOR_TYPES.VOID:
+                return 'undefined';
+            case validators_base.VLD_VALIDATOR_TYPES.LITERAL:
+                return 'literal';
+            case validators_base.VLD_VALIDATOR_TYPES.ANY:
+            case validators_base.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 validators_base.VLD_VALIDATOR_TYPES.STRING:
+                return (v) => typeof v === 'string';
+            case validators_base.VLD_VALIDATOR_TYPES.NUMBER:
+                return (v) => typeof v === 'number' && !isNaN(v);
+            case validators_base.VLD_VALIDATOR_TYPES.BOOLEAN:
+                return (v) => typeof v === 'boolean';
+            case validators_base.VLD_VALIDATOR_TYPES.BIGINT:
+                return (v) => typeof v === 'bigint';
+            case validators_base.VLD_VALIDATOR_TYPES.SYMBOL:
+                return (v) => typeof v === 'symbol';
+            case validators_base.VLD_VALIDATOR_TYPES.NAN:
+                return (v) => typeof v === 'number' && Number.isNaN(v);
+            case validators_base.VLD_VALIDATOR_TYPES.ARRAY:
+                return Array.isArray;
+            case validators_base.VLD_VALIDATOR_TYPES.OBJECT:
+                return (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+            case validators_base.VLD_VALIDATOR_TYPES.NULL:
+                return (v) => v === null;
+            case validators_base.VLD_VALIDATOR_TYPES.UNDEFINED:
+            case validators_base.VLD_VALIDATOR_TYPES.VOID:
+                return (v) => v === undefined;
+            case validators_base.VLD_VALIDATOR_TYPES.ENUM:
+                return (v) => typeof v === 'string' || typeof v === 'number';
+            case validators_base.VLD_VALIDATOR_TYPES.LITERAL: {
+                const literal = validator.literal;
+                return (v) => v === literal;
+            }
+            case validators_base.VLD_VALIDATOR_TYPES.NEVER:
+                return () => false;
+            case validators_base.VLD_VALIDATOR_TYPES.ANY:
+            case validators_base.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 ||
+            locales_runtime.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 ||
+                locales_runtime.getMessages().unionNoMatch(errors))
+        };
+    }
+}
+
+exports.VldUnion = VldUnion;

package/dist/cjs/validators/unknown.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+require('../registry.cjs');
+
+/**
+ * Validator that accepts unknown values
+ */
+class VldUnknown extends validators_base.VldBase {
+    constructor() {
+        super(validators_base.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 };
+    }
+}
+
+exports.VldUnknown = VldUnknown;

package/dist/cjs/validators/void.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+var locales_runtime = require('../locales/runtime.cjs');
+var errorsCore = require('../chunks/errors-core-DWxLFs2f.cjs');
+require('../registry.cjs');
+require('../locales/en.cjs');
+
+/**
+ * Validator that only accepts undefined
+ */
+class VldVoid extends validators_base.VldBase {
+    constructor() {
+        super(validators_base.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(locales_runtime.getMessages().expectedUndefined);
+        }
+        return undefined;
+    }
+    /**
+     * Safely parse void value
+     */
+    safeParse(value) {
+        if (value === undefined) {
+            return { success: true, data: undefined };
+        }
+        return {
+            success: false,
+            error: new errorsCore.VldError([{ code: 'invalid_type', path: [], message: locales_runtime.getMessages().expectedUndefined }])
+        };
+    }
+}
+
+exports.VldVoid = VldVoid;

package/dist/cjs/validators/xor.cjs

@@ -0,0 +1,69 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+require('../registry.cjs');
+
+/**
+ * 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 validators_base.VldBase {
+    constructor(_options) {
+        super(validators_base.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;
+    }
+}
+
+exports.VldXor = VldXor;

package/dist/cli/bin.d.ts

@@ -5,4 +5,3 @@
  * This is the main entry point for the `vld` command-line tool.
  */
 export {};
-//# sourceMappingURL=bin.d.ts.map