@oxog/vld 2.0.3 → 2.1.0

package/dist/validators/discriminated-union.js

@@ -0,0 +1,123 @@
+import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
+import { VldObject } from './object.js';
+import { VldLiteral } from './literal.js';
+import { VldEnum } from './enum.js';
+
+/**
+ * VldDiscriminatedUnion - Fast union validation using discriminator field
+ * Part of Zod 4 API parity implementation
+ * Provides O(1) lookup performance by using a discriminator key
+ */
+/**
+ * Extract literal values from a schema
+ */
+function extractLiteralValues(schema) {
+    if (schema instanceof VldLiteral) {
+        return [schema.literal];
+    }
+    if (schema instanceof VldEnum) {
+        return [...schema.values];
+    }
+    throw new Error('Discriminator must be a literal or enum schema');
+}
+/**
+ * Discriminated union validator - validates union based on discriminator key
+ * Much faster than regular union when you have a discriminator field
+ */
+class VldDiscriminatedUnion extends VldBase {
+    constructor(_discriminator, _options) {
+        super(VLD_VALIDATOR_TYPES.DISCRIMINATED_UNION);
+        this._discriminator = _discriminator;
+        this._options = _options;
+        // Build discriminator map for O(1) lookup
+        this._discriminatorMap = new Map();
+        this._stringDiscriminatorMap = Object.create(null);
+        for (const option of _options) {
+            if (!(option instanceof VldObject)) {
+                throw new Error('All options in a discriminated union must be objects');
+            }
+            const discriminatorSchema = option.config?.shape?.[this._discriminator];
+            if (!discriminatorSchema) {
+                throw new Error(`Missing discriminator key "${this._discriminator}" in one of the options`);
+            }
+            const values = extractLiteralValues(discriminatorSchema);
+            for (const value of values) {
+                if (this._discriminatorMap.has(value)) {
+                    throw new Error(`Duplicate discriminator value "${String(value)}" found in discriminated union`);
+                }
+                this._discriminatorMap.set(value, option);
+                if (typeof value === 'string') {
+                    this._stringDiscriminatorMap[value] = option;
+                }
+            }
+        }
+        this._validValues = Array.from(this._discriminatorMap.keys());
+    }
+    static create(discriminator, options) {
+        return new VldDiscriminatedUnion(discriminator, options);
+    }
+    parse(value) {
+        if (typeof value !== 'object' || value === null) {
+            throw new Error(`Expected object, received ${value === null ? 'null' : typeof value}`);
+        }
+        const discriminatorValue = value[this._discriminator];
+        const matchedSchema = typeof discriminatorValue === 'string'
+            ? this._stringDiscriminatorMap[discriminatorValue]
+            : this._discriminatorMap.get(discriminatorValue);
+        if (!matchedSchema) {
+            throw new Error(`Invalid discriminator value for "${this._discriminator}". ` +
+                `Expected one of: ${JSON.stringify(this._validValues)}, ` +
+                `received: ${JSON.stringify(discriminatorValue)}`);
+        }
+        return matchedSchema.parseTrustedKnownObject(value, this._discriminator);
+    }
+    safeParse(value) {
+        // Check if input is an object
+        if (typeof value !== 'object' || value === null) {
+            return {
+                success: false,
+                error: new Error(`Expected object, received ${value === null ? 'null' : typeof value}`)
+            };
+        }
+        // Get discriminator value
+        const discriminatorValue = value[this._discriminator];
+        // Look up matching schema
+        const matchedSchema = typeof discriminatorValue === 'string'
+            ? this._stringDiscriminatorMap[discriminatorValue]
+            : this._discriminatorMap.get(discriminatorValue);
+        if (!matchedSchema) {
+            return {
+                success: false,
+                error: new Error(`Invalid discriminator value for "${this._discriminator}". ` +
+                    `Expected one of: ${JSON.stringify(this._validValues)}, ` +
+                    `received: ${JSON.stringify(discriminatorValue)}`)
+            };
+        }
+        try {
+            return {
+                success: true,
+                data: matchedSchema.parseTrustedKnownObject(value, this._discriminator)
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error
+            };
+        }
+    }
+    /**
+     * Get the discriminator key
+     */
+    getDiscriminator() {
+        return this._discriminator;
+    }
+    /**
+     * Get all options
+     */
+    getOptions() {
+        return this._options;
+    }
+}
+
+export { VldDiscriminatedUnion };

package/dist/validators/enum.d.ts

@@ -1,14 +1,17 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
- * Immutable enum validator for string enum values
+ * Immutable enum validator for string and number enum values
  */
-export declare class VldEnum<T extends readonly [string, ...string[]]> extends VldBase<string, T[number]> {
+type EnumValue = string | number;
+export declare class VldEnum<T extends readonly [EnumValue, ...EnumValue[]]> extends VldBase<EnumValue, T[number]> {
     private readonly _values;
     private readonly errorMessage?;
+    private readonly _valueSet;
     /**
      * Private constructor to enforce immutability
      */
     private constructor();
+    private createError;
     /**
      * Get the enum values
      */
@@ -16,7 +19,7 @@ export declare class VldEnum<T extends readonly [string, ...string[]]> extends V
     /**
      * Create a new enum validator
      */
-    static create<T extends readonly [string, ...string[]]>(values: T): VldEnum<T>;
+    static create<T extends readonly [EnumValue, ...EnumValue[]]>(values: T): VldEnum<T>;
     /**
      * Parse and validate an enum value
      */
@@ -29,11 +32,11 @@ export declare class VldEnum<T extends readonly [string, ...string[]]> extends V
      * Exclude specific values from the enum
      * Creates a new enum validator without the specified values
      */
-    exclude<const E extends readonly string[]>(...excludeValues: E): VldEnum<T[number] extends E[number] ? never : T[number] extends Exclude<T[number], E[number]> ? T : Exclude<T, E>>;
+    exclude<const E extends readonly EnumValue[]>(...excludeValues: E): VldEnum<T[number] extends E[number] ? never : T[number] extends Exclude<T[number], E[number]> ? T : Exclude<T, E>>;
     /**
      * Extract specific values from the enum
      * Creates a new enum validator with only the specified values
      */
-    extract<const E extends readonly string[]>(...extractValues: E): VldEnum<[string, ...string[]]>;
+    extract<const E extends readonly EnumValue[]>(...extractValues: E): VldEnum<[E[number], ...E[number][]]>;
 }
-//# sourceMappingURL=enum.d.ts.map
+export {};

package/dist/validators/enum.js

@@ -0,0 +1,150 @@
+import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
+import { getMessages } from '../locales/runtime.js';
+
+class VldEnum extends VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(_values, errorMessage) {
+        super(VLD_VALIDATOR_TYPES.ENUM);
+        this._values = _values;
+        this.errorMessage = errorMessage;
+        this._valueSet = _values.length > 6 ? new Set(_values) : undefined;
+    }
+    createError(value) {
+        return new Error(this.errorMessage ||
+            getMessages().enumExpected([...this._values], JSON.stringify(value)));
+    }
+    /**
+     * Get the enum values
+     */
+    get values() {
+        return this._values;
+    }
+    /**
+     * Create a new enum validator
+     */
+    static create(values) {
+        return new VldEnum(values);
+    }
+    /**
+     * Parse and validate an enum value
+     */
+    parse(value) {
+        // BUG-002 FIX: Add type check before includes() to prevent type confusion
+        if (typeof value !== 'string' && typeof value !== 'number') {
+            throw this.createError(value);
+        }
+        const values = this._values;
+        switch (values.length) {
+            case 1:
+                if (value === values[0])
+                    return value;
+                break;
+            case 2:
+                if (value === values[0] || value === values[1])
+                    return value;
+                break;
+            case 3:
+                if (value === values[0] || value === values[1] || value === values[2])
+                    return value;
+                break;
+            case 4:
+                if (value === values[0] || value === values[1] || value === values[2] || value === values[3]) {
+                    return value;
+                }
+                break;
+            case 5:
+                if (value === values[0] || value === values[1] || value === values[2] || value === values[3] || value === values[4]) {
+                    return value;
+                }
+                break;
+            case 6:
+                if (value === values[0] || value === values[1] || value === values[2] || value === values[3] || value === values[4] || value === values[5]) {
+                    return value;
+                }
+                break;
+            default:
+                if (this._valueSet.has(value))
+                    return value;
+                break;
+        }
+        throw this.createError(value);
+    }
+    /**
+     * Safely parse and validate an enum value
+     */
+    safeParse(value) {
+        // BUG-002 FIX: Add type check before includes() to prevent type confusion
+        if (typeof value !== 'string' && typeof value !== 'number') {
+            return {
+                success: false,
+                error: this.createError(value)
+            };
+        }
+        const values = this._values;
+        switch (values.length) {
+            case 1:
+                if (value === values[0])
+                    return { success: true, data: value };
+                break;
+            case 2:
+                if (value === values[0] || value === values[1])
+                    return { success: true, data: value };
+                break;
+            case 3:
+                if (value === values[0] || value === values[1] || value === values[2])
+                    return { success: true, data: value };
+                break;
+            case 4:
+                if (value === values[0] || value === values[1] || value === values[2] || value === values[3]) {
+                    return { success: true, data: value };
+                }
+                break;
+            case 5:
+                if (value === values[0] || value === values[1] || value === values[2] || value === values[3] || value === values[4]) {
+                    return { success: true, data: value };
+                }
+                break;
+            case 6:
+                if (value === values[0] || value === values[1] || value === values[2] || value === values[3] || value === values[4] || value === values[5]) {
+                    return { success: true, data: value };
+                }
+                break;
+            default:
+                if (this._valueSet.has(value))
+                    return { success: true, data: value };
+                break;
+        }
+        return {
+            success: false,
+            error: this.createError(value)
+        };
+    }
+    /**
+     * Exclude specific values from the enum
+     * Creates a new enum validator without the specified values
+     */
+    exclude(...excludeValues) {
+        const filtered = this._values.filter(v => !excludeValues.includes(v));
+        if (filtered.length === 0) {
+            throw new Error('Cannot exclude all enum values');
+        }
+        // Type assertion needed because TypeScript can't guarantee the filtered array maintains the required type
+        return new VldEnum(filtered, this.errorMessage);
+    }
+    /**
+     * Extract specific values from the enum
+     * Creates a new enum validator with only the specified values
+     */
+    extract(...extractValues) {
+        const extracted = this._values.filter(v => extractValues.includes(v));
+        if (extracted.length === 0) {
+            throw new Error('Cannot extract non-existent enum values');
+        }
+        // Type assertion needed because TypeScript can't guarantee the extracted array has the required type
+        return new VldEnum(extracted, this.errorMessage);
+    }
+}
+
+export { VldEnum };

package/dist/validators/file.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * File representation for validation
  * In browsers: File object
@@ -20,10 +20,16 @@ export declare class VldFile extends VldBase<unknown, VldFileValue> {
      * Create a new file validator
      */
     static create(): VldFile;
+    private isFileLike;
     /**
      * Parse and validate a file value
      */
     parse(value: unknown): VldFileValue;
+    /**
+     * Parse a value that has already passed the file-like type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownFile(value: VldFileValue): VldFileValue;
     /**
      * Run all validation checks on the file
      */
@@ -54,4 +60,3 @@ export declare class VldFile extends VldBase<unknown, VldFileValue> {
  * Usage: v.file().min(1024).max(10485760).mime(['image/jpeg', 'image/png'])
  */
 export declare function file(): VldFile;
-//# sourceMappingURL=file.d.ts.map

package/dist/validators/file.js

@@ -0,0 +1,125 @@
+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 createFileError(message) {
+    return new VldError([{ code: 'invalid_type', path: [], message }]);
+}
+/**
+ * Immutable file validator for file uploads
+ * Supports size and MIME type validation
+ */
+class VldFile extends VldBase {
+    constructor(checks = []) {
+        super(VLD_VALIDATOR_TYPES.FILE);
+        this.checks = checks;
+    }
+    /**
+     * Create a new file validator
+     */
+    static create() {
+        return new VldFile();
+    }
+    isFileLike(value) {
+        if (typeof value !== 'object' || value === null) {
+            return false;
+        }
+        if (typeof File !== 'undefined' && value instanceof File) {
+            return true;
+        }
+        return 'size' in value && 'type' in value;
+    }
+    /**
+     * Parse and validate a file value
+     */
+    parse(value) {
+        if (this.isFileLike(value)) {
+            return this.parseKnownFile(value);
+        }
+        if (typeof File === 'undefined') {
+            throw new Error(getMessages().fileNotSupported || 'File API not supported in this environment');
+        }
+        throw new Error(getMessages().invalidFile || 'Expected a File object');
+    }
+    /**
+     * Parse a value that has already passed the file-like type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownFile(value) {
+        return this.runChecks(value);
+    }
+    /**
+     * Run all validation checks on the file
+     */
+    runChecks(file) {
+        const msgs = getMessages();
+        for (const check of this.checks) {
+            switch (check.type) {
+                case 'min':
+                    if (file.size < check.value) {
+                        throw new Error(check.message ||
+                            (msgs.fileMinSize?.(check.value) || `File size must be at least ${check.value} bytes`));
+                    }
+                    break;
+                case 'max':
+                    if (file.size > check.value) {
+                        throw new Error(check.message ||
+                            (msgs.fileMaxSize?.(check.value) || `File size must not exceed ${check.value} bytes`));
+                    }
+                    break;
+                case 'mime':
+                    if (!check.value.includes(file.type)) {
+                        throw new Error(check.message ||
+                            (msgs.fileMimeType?.(check.value) || `Invalid file type. Expected: ${check.value.join(', ')}`));
+                    }
+                    break;
+            }
+        }
+        return file;
+    }
+    /**
+     * Safely parse and validate a file value
+     */
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: createFileError(error.message) };
+        }
+    }
+    /**
+     * Set minimum file size in bytes
+     */
+    min(bytes, message) {
+        return new VldFile([...this.checks, { type: 'min', value: bytes, message }]);
+    }
+    /**
+     * Set maximum file size in bytes
+     */
+    max(bytes, message) {
+        return new VldFile([...this.checks, { type: 'max', value: bytes, message }]);
+    }
+    /**
+     * Set allowed MIME types
+     */
+    mime(types, message) {
+        const typeArray = Array.isArray(types) ? types : [types];
+        return new VldFile([...this.checks, { type: 'mime', value: typeArray, message }]);
+    }
+    /**
+     * Set both minimum and maximum file size
+     */
+    size(min, max, message) {
+        return this.min(min, message).max(max, message);
+    }
+}
+/**
+ * Helper function to create file validators
+ * Usage: v.file().min(1024).max(10485760).mime(['image/jpeg', 'image/png'])
+ */
+function file() {
+    return VldFile.create();
+}
+
+export { VldFile, file };

package/dist/validators/function.d.ts

@@ -1,9 +1,10 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
+type AnyFunction = (...args: any[]) => any;
 /**
  * Immutable function validator
  * Validates that a value is a function
  */
-export declare class VldFunction extends VldBase<unknown, Function> {
+export declare class VldFunction extends VldBase<unknown, AnyFunction> {
     private constructor();
     /**
      * Create a new function validator
@@ -12,15 +13,20 @@ export declare class VldFunction extends VldBase<unknown, Function> {
     /**
      * Parse and validate a function value
      */
-    parse(value: unknown): Function;
+    parse(value: unknown): AnyFunction;
+    /**
+     * Parse a value that has already passed the function type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownFunction(value: AnyFunction): AnyFunction;
     /**
      * Safely parse and validate a function value
      */
-    safeParse(value: unknown): ParseResult<Function>;
+    safeParse(value: unknown): ParseResult<AnyFunction>;
 }
 /**
  * Helper function to create function validators
  * Usage: v.function()
  */
 export declare function functionValidator(): VldFunction;
-//# sourceMappingURL=function.d.ts.map
+export {};

package/dist/validators/function.js

@@ -0,0 +1,58 @@
+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 createFunctionError(message) {
+    return new VldError([{ code: 'invalid_type', path: [], message }]);
+}
+/**
+ * Immutable function validator
+ * Validates that a value is a function
+ */
+class VldFunction extends VldBase {
+    constructor() {
+        super(VLD_VALIDATOR_TYPES.FUNCTION);
+    }
+    /**
+     * Create a new function validator
+     */
+    static create() {
+        return new VldFunction();
+    }
+    /**
+     * Parse and validate a function value
+     */
+    parse(value) {
+        if (typeof value !== 'function') {
+            throw new Error(getMessages().invalidFunction || 'Expected a function');
+        }
+        return value;
+    }
+    /**
+     * Parse a value that has already passed the function type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownFunction(value) {
+        return value;
+    }
+    /**
+     * Safely parse and validate a function value
+     */
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: createFunctionError(error.message) };
+        }
+    }
+}
+/**
+ * Helper function to create function validators
+ * Usage: v.function()
+ */
+function functionValidator() {
+    return VldFunction.create();
+}
+
+export { VldFunction, functionValidator };

package/dist/validators/hex.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Hexadecimal string validator
  */
@@ -14,4 +14,3 @@ export declare class VldHex extends VldBase<string, string> {
     lowercaseMode(): VldHex;
     static create(lowercase?: boolean): VldHex;
 }
-//# sourceMappingURL=hex.d.ts.map

package/dist/validators/hex.js

@@ -0,0 +1,65 @@
+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';
+
+/**
+ * Hexadecimal string validator
+ */
+class VldHex extends VldBase {
+    constructor(lowercase = false) {
+        super(VLD_VALIDATOR_TYPES.HEX);
+        this.lowercase = lowercase;
+    }
+    parse(value) {
+        const result = this.safeParse(value);
+        if (!result.success) {
+            throw result.error;
+        }
+        return result.data;
+    }
+    safeParse(value) {
+        if (typeof value !== 'string') {
+            return {
+                success: false,
+                error: new VldError([
+                    createIssue('invalid_type', [], getMessages().expectedString)
+                ])
+            };
+        }
+        // Check if it's a valid hex string
+        if (!VldHex.HEX_REGEX.test(value)) {
+            return {
+                success: false,
+                error: new VldError([
+                    createIssue('custom', [], getMessages().invalidHex)
+                ])
+            };
+        }
+        // Check if even length (full bytes)
+        if (value.length % 2 !== 0) {
+            return {
+                success: false,
+                error: new VldError([
+                    createIssue('custom', [], getMessages().invalidHex)
+                ])
+            };
+        }
+        // Normalize case if required
+        const normalizedValue = this.lowercase ? value.toLowerCase() : value;
+        return { success: true, data: normalizedValue };
+    }
+    /**
+     * Require lowercase hex characters
+     */
+    lowercaseMode() {
+        return new VldHex(true);
+    }
+    static create(lowercase = false) {
+        return new VldHex(lowercase);
+    }
+}
+// BUG-008 FIX: Use * instead of + to allow empty hex strings (consistent with base64 validator)
+VldHex.HEX_REGEX = /^[0-9a-fA-F]*$/;
+
+export { VldHex };