@oxog/vld 2.0.3 → 2.1.0

package/dist/validators/template-literal.js

@@ -0,0 +1,103 @@
+import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
+import { getMessages } from '../locales/runtime.js';
+
+/**
+ * Immutable template literal validator
+ * Validates strings matching a template pattern
+ */
+class VldTemplateLiteral extends VldBase {
+    constructor(pattern) {
+        super(VLD_VALIDATOR_TYPES.TEMPLATE_LITERAL);
+        this.pattern = pattern;
+    }
+    /**
+     * Create a template literal validator from components
+     */
+    static create(...components) {
+        // Build regex pattern from components
+        let pattern = '^';
+        for (const comp of components) {
+            if (typeof comp === 'string') {
+                // Escape special regex characters
+                pattern += comp.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            }
+            else {
+                // Add appropriate pattern based on validator type
+                pattern += getPatternForValidator(comp);
+            }
+        }
+        pattern += '$';
+        return new VldTemplateLiteral(new RegExp(pattern));
+    }
+    /**
+     * Parse and validate a template literal string
+     */
+    parse(value) {
+        if (typeof value !== 'string') {
+            throw new Error(getMessages().invalidString);
+        }
+        if (!this.pattern.test(value)) {
+            throw new Error(getMessages().stringPatternInvalid);
+        }
+        return value;
+    }
+    /**
+     * Safely parse and validate a template literal string
+     */
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error
+            };
+        }
+    }
+}
+/**
+ * Get regex pattern for a validator type
+ */
+function getPatternForValidator(validator) {
+    // For template literals, we need to identify the validator type
+    // and return an appropriate capture group pattern
+    switch (validator.validatorType) {
+        case VLD_VALIDATOR_TYPES.STRING:
+        case VLD_VALIDATOR_TYPES.STRING_FORMAT:
+            return '(.+)';
+        case VLD_VALIDATOR_TYPES.NUMBER:
+        case VLD_VALIDATOR_TYPES.COERCE_NUMBER:
+            return '(-?\\d+(?:\\.\\d+)?)';
+        case VLD_VALIDATOR_TYPES.BIGINT:
+        case VLD_VALIDATOR_TYPES.COERCE_BIGINT:
+            return '(-?\\d+)';
+        case VLD_VALIDATOR_TYPES.BOOLEAN:
+        case VLD_VALIDATOR_TYPES.COERCE_BOOLEAN:
+            return '(true|false)';
+        case VLD_VALIDATOR_TYPES.NULL:
+            return '(null)';
+        case VLD_VALIDATOR_TYPES.UNDEFINED:
+        case VLD_VALIDATOR_TYPES.VOID:
+            return '(undefined)';
+        case VLD_VALIDATOR_TYPES.LITERAL: {
+            const literalValidator = validator;
+            if (literalValidator.literal !== undefined) {
+                const valueStr = String(literalValidator.literal);
+                return '(' + valueStr.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + ')';
+            }
+            break;
+        }
+    }
+    // Default: match any string
+    return '(.+)';
+}
+/**
+ * Helper function to create template literal validators
+ * Usage: v.templateLiteral(v.string(), '-', v.number())
+ */
+function templateLiteral(...components) {
+    return VldTemplateLiteral.create(...components);
+}
+
+export { VldTemplateLiteral, templateLiteral };

package/dist/validators/tuple.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Immutable tuple validator for fixed-length arrays
  */
@@ -10,7 +10,14 @@ export declare class VldTuple<T extends readonly VldBase<any, any>[]> extends Vl
     /**
      * Private constructor to enforce immutability
      */
+    private readonly _length;
+    private readonly _validatorTypes;
+    private readonly _simpleItemModes;
+    private readonly _simpleItemValues;
     private constructor();
+    get items(): T;
+    private getSimpleItemMode;
+    private getSimpleItemError;
     /**
      * Create a new tuple validator
      */
@@ -21,6 +28,13 @@ export declare class VldTuple<T extends readonly VldBase<any, any>[]> extends Vl
     parse(value: unknown): {
         [K in keyof T]: T[K] extends VldBase<any, infer U> ? U : never;
     };
+    /**
+     * Parse a value that has already passed the tuple array type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownTuple(value: unknown[]): {
+        [K in keyof T]: T[K] extends VldBase<any, infer U> ? U : never;
+    };
     /**
      * Safely parse and validate a tuple value
      */
@@ -28,4 +42,3 @@ export declare class VldTuple<T extends readonly VldBase<any, any>[]> extends Vl
         [K in keyof T]: T[K] extends VldBase<any, infer U> ? U : never;
     }>;
 }
-//# sourceMappingURL=tuple.d.ts.map

package/dist/validators/tuple.js

@@ -0,0 +1,183 @@
+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 createTupleError(message) {
+    return new VldError([{ code: 'invalid_array', path: [], message }]);
+}
+/**
+ * Immutable tuple validator for fixed-length arrays
+ */
+class VldTuple extends VldBase {
+    constructor(validators, errorMessage) {
+        super(VLD_VALIDATOR_TYPES.TUPLE);
+        this.validators = validators;
+        this.errorMessage = errorMessage;
+        this._length = validators.length;
+        this._validatorTypes = validators.map(validator => validator.validatorType);
+        this._simpleItemModes = validators.map((validator, index) => this.getSimpleItemMode(validator, this._validatorTypes[index]));
+        this._simpleItemValues = validators.map((validator, index) => this._simpleItemModes[index] === 'literal' ? validator.literal : undefined);
+    }
+    get items() {
+        return this.validators;
+    }
+    getSimpleItemMode(validator, type) {
+        if (validator.isSimple !== true) {
+            return undefined;
+        }
+        switch (type) {
+            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().invalidTuple;
+        }
+    }
+    /**
+     * Create a new tuple validator
+     */
+    static create(...validators) {
+        return new VldTuple(validators);
+    }
+    /**
+     * Parse and validate a tuple value
+     */
+    parse(value) {
+        if (!Array.isArray(value)) {
+            throw new Error(this.errorMessage || getMessages().invalidTuple);
+        }
+        return this.parseKnownTuple(value);
+    }
+    /**
+     * Parse a value that has already passed the tuple array type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownTuple(value) {
+        if (value.length !== this._length) {
+            throw new Error(this.errorMessage ||
+                getMessages().tupleLength(this._length, value.length));
+        }
+        const result = new Array(this._length);
+        for (let i = 0; i < this._length; i++) {
+            const simpleMode = this._simpleItemModes[i];
+            const item = value[i];
+            if (simpleMode !== undefined) {
+                switch (simpleMode) {
+                    case 'string':
+                        if (typeof item !== 'string') {
+                            throw new Error(getMessages().arrayItem(i, getMessages().invalidString));
+                        }
+                        result[i] = item;
+                        continue;
+                    case 'number':
+                        if (typeof item !== 'number' || isNaN(item)) {
+                            throw new Error(getMessages().arrayItem(i, getMessages().invalidNumber));
+                        }
+                        result[i] = item;
+                        continue;
+                    case 'boolean':
+                        if (typeof item !== 'boolean') {
+                            throw new Error(getMessages().arrayItem(i, getMessages().invalidBoolean));
+                        }
+                        result[i] = item;
+                        continue;
+                    case 'bigint':
+                        if (typeof item !== 'bigint') {
+                            throw new Error(getMessages().arrayItem(i, getMessages().invalidBigint));
+                        }
+                        result[i] = item;
+                        continue;
+                    case 'symbol':
+                        if (typeof item !== 'symbol') {
+                            throw new Error(getMessages().arrayItem(i, getMessages().invalidSymbol));
+                        }
+                        result[i] = item;
+                        continue;
+                    case 'null':
+                        if (item !== null) {
+                            throw new Error(getMessages().arrayItem(i, this.getSimpleItemError(simpleMode, undefined, item)));
+                        }
+                        result[i] = null;
+                        continue;
+                    case 'undefinedValue':
+                        if (item !== undefined) {
+                            throw new Error(getMessages().arrayItem(i, getMessages().expectedUndefined));
+                        }
+                        result[i] = undefined;
+                        continue;
+                    case 'literal': {
+                        const literal = this._simpleItemValues[i];
+                        if (item !== literal) {
+                            throw new Error(getMessages().arrayItem(i, this.getSimpleItemError(simpleMode, literal, item)));
+                        }
+                        result[i] = literal;
+                        continue;
+                    }
+                    case 'passthrough':
+                        result[i] = item;
+                        continue;
+                }
+            }
+            try {
+                const validator = this.validators[i];
+                result[i] = validator.parse(item);
+            }
+            catch (error) {
+                throw new Error(getMessages().arrayItem(i, error.message));
+            }
+        }
+        return result;
+    }
+    /**
+     * Safely parse and validate a tuple value
+     */
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: createTupleError(error.message) };
+        }
+    }
+}
+
+export { VldTuple };

package/dist/validators/uint8array.d.ts

@@ -1,11 +1,11 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Configuration for Uint8Array validator
  * BUG-NEW-010 FIX: Use config object pattern for immutability
  */
 interface Uint8ArrayValidatorConfig {
-    readonly minLength?: number;
-    readonly maxLength?: number;
+    readonly minLength?: number | undefined;
+    readonly maxLength?: number | undefined;
     readonly exactLength?: number;
 }
 /**
@@ -39,4 +39,3 @@ export declare class VldUint8Array extends VldBase<Uint8Array, Uint8Array> {
     static create(): VldUint8Array;
 }
 export {};
-//# sourceMappingURL=uint8array.d.ts.map

package/dist/validators/uint8array.js

@@ -0,0 +1,101 @@
+import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
+import { createIssue } from '../errors.js';
+import { getMessages } from '../locales/runtime.js';
+import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
+
+/**
+ * Uint8Array validator with immutable configuration
+ * BUG-NEW-010 FIX: Refactored to follow immutability pattern
+ */
+class VldUint8Array extends VldBase {
+    /**
+     * Protected constructor to maintain immutability
+     */
+    constructor(config) {
+        super(VLD_VALIDATOR_TYPES.UINT8_ARRAY);
+        this.config = config || {};
+    }
+    parse(value) {
+        const result = this.safeParse(value);
+        if (!result.success) {
+            throw result.error;
+        }
+        return result.data;
+    }
+    safeParse(value) {
+        if (!(value instanceof Uint8Array)) {
+            return {
+                success: false,
+                error: new VldError([
+                    createIssue('invalid_type', [], getMessages().expectedUint8Array)
+                ])
+            };
+        }
+        // Check exact length if specified
+        if (this.config.exactLength !== undefined && value.length !== this.config.exactLength) {
+            return {
+                success: false,
+                error: new VldError([
+                    createIssue('custom', [], getMessages().uint8ArrayExactLength(this.config.exactLength))
+                ])
+            };
+        }
+        // Check minimum length
+        if (this.config.minLength !== undefined && value.length < this.config.minLength) {
+            return {
+                success: false,
+                error: new VldError([
+                    createIssue('custom', [], getMessages().uint8ArrayMinLength(this.config.minLength))
+                ])
+            };
+        }
+        // Check maximum length
+        if (this.config.maxLength !== undefined && value.length > this.config.maxLength) {
+            return {
+                success: false,
+                error: new VldError([
+                    createIssue('custom', [], getMessages().uint8ArrayMaxLength(this.config.maxLength))
+                ])
+            };
+        }
+        return { success: true, data: value };
+    }
+    /**
+     * Set minimum byte length
+     * Returns new immutable validator instance
+     */
+    min(length) {
+        return new VldUint8Array({
+            ...this.config,
+            minLength: length
+        });
+    }
+    /**
+     * Set maximum byte length
+     * Returns new immutable validator instance
+     */
+    max(length) {
+        return new VldUint8Array({
+            ...this.config,
+            maxLength: length
+        });
+    }
+    /**
+     * Set exact byte length
+     * Returns new immutable validator instance
+     * Clears min/max when setting exact length
+     */
+    length(length) {
+        return new VldUint8Array({
+            exactLength: length,
+            // Clear min/max when exact length is set
+            minLength: undefined,
+            maxLength: undefined
+        });
+    }
+    static create() {
+        return new VldUint8Array();
+    }
+}
+
+export { VldUint8Array };

package/dist/validators/undefined.d.ts

@@ -2,15 +2,15 @@
  * VldUndefined - Validates that a value is exactly undefined
  * Part of Zod 4 API parity implementation
  */
-import { VldBase } from './base';
-import type { ParseResult } from './base';
+import { VldBase } from './base.js';
+import type { ParseResult } from './base.js';
 /**
  * Undefined validator - validates that a value is exactly undefined
  */
 export declare class VldUndefined extends VldBase<unknown, undefined> {
     private constructor();
     static create(): VldUndefined;
+    get isSimple(): boolean;
     parse(value: unknown): undefined;
     safeParse(value: unknown): ParseResult<undefined>;
 }
-//# sourceMappingURL=undefined.d.ts.map

package/dist/validators/undefined.js

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

package/dist/validators/union.d.ts

@@ -1,16 +1,20 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Optimized immutable union validator for multiple type options
  * Features type-checking shortcuts for 110x performance improvement
  */
 export declare class VldUnion<T extends readonly VldBase<any, any>[]> extends VldBase<unknown, T[number] extends VldBase<any, infer U> ? U : never> {
     private readonly validators;
-    private readonly errorMessage?;
+    private readonly errorMessage;
     private readonly typeCheckers;
+    private readonly simpleModes;
+    private readonly simpleValues;
     /**
      * Private constructor to enforce immutability
      */
     private constructor();
+    private createSimpleMode;
+    private parseSimpleValue;
     /**
      * Create type checker based on validator type for fast path optimization
      * Uses a safer approach that's less prone to spoofing
@@ -22,7 +26,7 @@ export declare class VldUnion<T extends readonly VldBase<any, any>[]> extends Vl
     static create<T extends readonly VldBase<any, any>[]>(...validators: T): VldUnion<T>;
     /**
      * Parse and validate a value against union options
-     * Optimized with type checking and safeParse to avoid try-catch overhead
+     * 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: unknown): T[number] extends VldBase<any, infer U> ? U : never;
@@ -33,4 +37,3 @@ export declare class VldUnion<T extends readonly VldBase<any, any>[]> extends Vl
      */
     safeParse(value: unknown): ParseResult<T[number] extends VldBase<any, infer U> ? U : never>;
 }
-//# sourceMappingURL=union.d.ts.map