@oxog/vld 2.0.3 → 2.1.0

package/dist/cjs/validators/base64.cjs

@@ -0,0 +1,73 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+var errors = require('../errors.cjs');
+var locales_runtime = require('../locales/runtime.cjs');
+var errorsCore = require('../chunks/errors-core-DWxLFs2f.cjs');
+require('../registry.cjs');
+require('../pigment.cjs');
+require('../locales/en.cjs');
+
+/**
+ * Base64 string validator
+ */
+class VldBase64 extends validators_base.VldBase {
+    constructor(urlSafe = false) {
+        super(validators_base.VLD_VALIDATOR_TYPES.BASE64);
+        this.urlSafe = urlSafe;
+    }
+    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 errorsCore.VldError([
+                    errors.createIssue('invalid_type', [], locales_runtime.getMessages().expectedString)
+                ])
+            };
+        }
+        // Check if it's a valid base64 string
+        const regex = this.urlSafe ? VldBase64.BASE64_URL_REGEX : VldBase64.BASE64_REGEX;
+        // Check basic format
+        if (!regex.test(value)) {
+            return {
+                success: false,
+                error: new errorsCore.VldError([
+                    errors.createIssue('custom', [], locales_runtime.getMessages().invalidBase64)
+                ])
+            };
+        }
+        // For standard base64, check length is multiple of 4 (after padding)
+        // Empty strings are valid (decode to empty buffer)
+        // For URL-safe base64, padding is not required
+        if (!this.urlSafe && value.length > 0 && value.length % 4 !== 0) {
+            return {
+                success: false,
+                error: new errorsCore.VldError([
+                    errors.createIssue('custom', [], locales_runtime.getMessages().invalidBase64)
+                ])
+            };
+        }
+        return { success: true, data: value };
+    }
+    /**
+     * Create a URL-safe base64 validator
+     */
+    urlSafeMode() {
+        return new VldBase64(true);
+    }
+    static create(urlSafe = false) {
+        return new VldBase64(urlSafe);
+    }
+}
+VldBase64.BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
+// Note: RFC 4648 specifies URL-safe base64 should omit padding, but we allow it for compatibility
+VldBase64.BASE64_URL_REGEX = /^[A-Za-z0-9_-]*={0,2}$/;
+
+exports.VldBase64 = VldBase64;

package/dist/cjs/validators/bigint.cjs

@@ -0,0 +1,232 @@
+'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');
+
+function createBigIntError(message) {
+    return new errorsCore.VldError([{ code: 'invalid_type', path: [], message }]);
+}
+/**
+ * Immutable bigint validator
+ */
+class VldBigInt extends validators_base.VldBase {
+    /**
+     * Protected constructor to allow extension while maintaining immutability
+     */
+    constructor(config) {
+        super(config?.validatorType || validators_base.VLD_VALIDATOR_TYPES.BIGINT);
+        this.config = {
+            checks: config?.checks || [],
+            errorMessage: config?.errorMessage,
+            jsonSchema: config?.jsonSchema
+        };
+        this._checks = this.config.checks;
+        this._fastCheckMode = this.detectFastCheckMode();
+    }
+    get jsonSchema() {
+        return this.config.jsonSchema;
+    }
+    get isSimple() {
+        return this._checks.length === 0;
+    }
+    /**
+     * Create a new bigint validator
+     */
+    static create() {
+        return new VldBigInt();
+    }
+    detectFastCheckMode() {
+        if (this._checks.length === 0) {
+            return 'none';
+        }
+        if (this._checks.length !== 1) {
+            return undefined;
+        }
+        const schema = this.config.jsonSchema;
+        if (schema?.exclusiveMinimum === 0n && schema.minimum === undefined && schema.maximum === undefined) {
+            return 'positive';
+        }
+        if (schema?.exclusiveMaximum === 0n && schema.minimum === undefined && schema.maximum === undefined) {
+            return 'negative';
+        }
+        if (schema?.minimum === 0n && schema.maximum === undefined && schema.exclusiveMaximum === undefined) {
+            return 'nonnegative';
+        }
+        if (schema?.maximum === 0n && schema.minimum === undefined && schema.exclusiveMinimum === undefined) {
+            return 'nonpositive';
+        }
+        return undefined;
+    }
+    getValidationError() {
+        return new Error(this.config.errorMessage || locales_runtime.getMessages().invalidBigint);
+    }
+    /**
+     * Parse and validate a bigint value
+     */
+    parse(value) {
+        if (typeof value !== 'bigint') {
+            throw this.getValidationError();
+        }
+        return this.parseKnownBigInt(value);
+    }
+    /**
+     * Parse a value that has already passed the bigint type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownBigInt(value) {
+        switch (this._fastCheckMode) {
+            case 'none':
+                return value;
+            case 'positive':
+                if (value > 0n)
+                    return value;
+                throw this.getValidationError();
+            case 'negative':
+                if (value < 0n)
+                    return value;
+                throw this.getValidationError();
+            case 'nonnegative':
+                if (value >= 0n)
+                    return value;
+                throw this.getValidationError();
+            case 'nonpositive':
+                if (value <= 0n)
+                    return value;
+                throw this.getValidationError();
+        }
+        // Apply all checks
+        for (const check of this._checks) {
+            if (!check(value)) {
+                throw this.getValidationError();
+            }
+        }
+        return value;
+    }
+    /**
+     * Safely parse and validate a bigint value
+     */
+    safeParse(value) {
+        if (typeof value !== 'bigint') {
+            return { success: false, error: createBigIntError(this.getValidationError().message) };
+        }
+        try {
+            return { success: true, data: this.parseKnownBigInt(value) };
+        }
+        catch (error) {
+            return { success: false, error: createBigIntError(error.message) };
+        }
+    }
+    /**
+     * Create a new validator with minimum value constraint
+     */
+    min(value, message) {
+        return new VldBigInt({
+            ...this.config,
+            checks: [...this.config.checks, (v) => v >= value],
+            errorMessage: message || `BigInt must be at least ${value}`,
+            jsonSchema: { ...this.config.jsonSchema, minimum: value }
+        });
+    }
+    /**
+     * Create a new validator with maximum value constraint
+     */
+    max(value, message) {
+        return new VldBigInt({
+            ...this.config,
+            checks: [...this.config.checks, (v) => v <= value],
+            errorMessage: message || `BigInt must be at most ${value}`,
+            jsonSchema: { ...this.config.jsonSchema, maximum: value }
+        });
+    }
+    /**
+     * Create a new validator that checks for positive values
+     */
+    positive(message) {
+        return new VldBigInt({
+            ...this.config,
+            checks: [...this.config.checks, (v) => v > 0n],
+            errorMessage: message || 'BigInt must be positive',
+            jsonSchema: { ...this.config.jsonSchema, exclusiveMinimum: 0n }
+        });
+    }
+    /**
+     * Create a new validator that checks for negative values
+     */
+    negative(message) {
+        return new VldBigInt({
+            ...this.config,
+            checks: [...this.config.checks, (v) => v < 0n],
+            errorMessage: message || 'BigInt must be negative',
+            jsonSchema: { ...this.config.jsonSchema, exclusiveMaximum: 0n }
+        });
+    }
+    /**
+     * Create a new validator that checks for non-negative values
+     */
+    nonnegative(message) {
+        return new VldBigInt({
+            ...this.config,
+            checks: [...this.config.checks, (v) => v >= 0n],
+            errorMessage: message || 'BigInt must be non-negative',
+            jsonSchema: { ...this.config.jsonSchema, minimum: 0n }
+        });
+    }
+    /**
+     * Create a new validator that checks for non-positive values
+     */
+    nonpositive(message) {
+        return new VldBigInt({
+            ...this.config,
+            checks: [...this.config.checks, (v) => v <= 0n],
+            errorMessage: message || 'BigInt must be non-positive',
+            jsonSchema: { ...this.config.jsonSchema, maximum: 0n }
+        });
+    }
+    /**
+     * Create a new validator with strict greater than constraint
+     * Zod 4 API parity - strictly greater than (not equal to)
+     */
+    gt(value, message) {
+        const compareValue = typeof value === 'bigint' ? value : BigInt(value);
+        return new VldBigInt({
+            ...this.config,
+            checks: [...this.config.checks, (v) => v > compareValue],
+            errorMessage: message || `BigInt must be greater than ${compareValue}`,
+            jsonSchema: { ...this.config.jsonSchema, exclusiveMinimum: compareValue }
+        });
+    }
+    /**
+     * Create a new validator with strict less than constraint
+     * Zod 4 API parity - strictly less than (not equal to)
+     */
+    lt(value, message) {
+        const compareValue = typeof value === 'bigint' ? value : BigInt(value);
+        return new VldBigInt({
+            ...this.config,
+            checks: [...this.config.checks, (v) => v < compareValue],
+            errorMessage: message || `BigInt must be less than ${compareValue}`,
+            jsonSchema: { ...this.config.jsonSchema, exclusiveMaximum: compareValue }
+        });
+    }
+    /**
+     * Create a new validator with greater than or equal constraint
+     * Zod 4 API parity - alias for min()
+     */
+    gte(value, message) {
+        const compareValue = typeof value === 'bigint' ? value : BigInt(value);
+        return this.min(compareValue, message);
+    }
+    /**
+     * Create a new validator with less than or equal constraint
+     * Zod 4 API parity - alias for max()
+     */
+    lte(value, message) {
+        const compareValue = typeof value === 'bigint' ? value : BigInt(value);
+        return this.max(compareValue, message);
+    }
+}
+
+exports.VldBigInt = VldBigInt;

package/dist/cjs/validators/boolean.cjs

@@ -0,0 +1,146 @@
+'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');
+
+function createBooleanError(message) {
+    return new errorsCore.VldError([{ code: 'invalid_boolean', path: [], message }]);
+}
+/**
+ * Immutable boolean validator
+ */
+class VldBoolean extends validators_base.VldBase {
+    /**
+     * Protected constructor to allow extension while maintaining immutability
+     */
+    constructor(errorMessage, validatorType) {
+        super(validatorType || validators_base.VLD_VALIDATOR_TYPES.BOOLEAN);
+        this.errorMessage = errorMessage;
+    }
+    /**
+     * Returns true if this is a simple boolean validator with no custom checks
+     * Used by VldObject for optimized fast-path dispatch
+     */
+    get isSimple() {
+        return true;
+    }
+    /**
+     * Create a new boolean validator
+     */
+    static create() {
+        return new VldBoolean();
+    }
+    /**
+     * Parse and validate a boolean value
+     */
+    parse(value) {
+        if (typeof value !== 'boolean') {
+            throw new Error(this.errorMessage || locales_runtime.getMessages().invalidBoolean);
+        }
+        return value;
+    }
+    /**
+     * Parse a value that has already passed the boolean type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownBoolean(value) {
+        return value;
+    }
+    /**
+     * Safely parse and validate a boolean value
+     */
+    safeParse(value) {
+        if (typeof value === 'boolean') {
+            return { success: true, data: value };
+        }
+        return {
+            success: false,
+            error: createBooleanError(this.errorMessage || locales_runtime.getMessages().invalidBoolean)
+        };
+    }
+    /**
+     * Create a new validator that only accepts true
+     */
+    true(message) {
+        return new VldTrue(message || 'Value must be true');
+    }
+    /**
+     * Create a new validator that only accepts false
+     */
+    false(message) {
+        return new VldFalse(message || 'Value must be false');
+    }
+}
+/**
+ * Validator that only accepts true
+ */
+class VldTrue extends VldBoolean {
+    constructor(message) {
+        super(message);
+        this.message = message;
+    }
+    get isSimple() {
+        return false;
+    }
+    parse(value) {
+        if (value !== true) {
+            throw new Error(this.message);
+        }
+        return true;
+    }
+    parseKnownBoolean(value) {
+        if (value !== true) {
+            throw new Error(this.message);
+        }
+        return true;
+    }
+    // BUG-003 FIX: Override safeParse to ensure true validation
+    safeParse(value) {
+        if (value !== true) {
+            return {
+                success: false,
+                error: createBooleanError(this.message)
+            };
+        }
+        return { success: true, data: true };
+    }
+}
+/**
+ * Validator that only accepts false
+ */
+class VldFalse extends VldBoolean {
+    constructor(message) {
+        super(message);
+        this.message = message;
+    }
+    get isSimple() {
+        return false;
+    }
+    parse(value) {
+        if (value !== false) {
+            throw new Error(this.message);
+        }
+        return false;
+    }
+    parseKnownBoolean(value) {
+        if (value !== false) {
+            throw new Error(this.message);
+        }
+        return false;
+    }
+    // BUG-003 FIX: Override safeParse to ensure false validation
+    safeParse(value) {
+        if (value !== false) {
+            return {
+                success: false,
+                error: createBooleanError(this.message)
+            };
+        }
+        return { success: true, data: false };
+    }
+}
+
+exports.VldBoolean = VldBoolean;

package/dist/cjs/validators/codec.cjs

@@ -0,0 +1,205 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+var errors = require('../errors.cjs');
+var locales_runtime = require('../locales/runtime.cjs');
+var errorsCore = require('../chunks/errors-core-DWxLFs2f.cjs');
+require('../registry.cjs');
+require('../pigment.cjs');
+require('../locales/en.cjs');
+
+/**
+ * Codec validator for bidirectional transformations
+ * Enables converting between different data representations
+ */
+class VldCodec extends validators_base.VldBase {
+    constructor(inputValidator, outputValidator, codecTransform) {
+        super(validators_base.VLD_VALIDATOR_TYPES.CODEC);
+        this.inputValidator = inputValidator;
+        this.outputValidator = outputValidator;
+        this.codecTransform = codecTransform;
+    }
+    /**
+     * Parse (decode) a value from input to output format
+     */
+    parse(value) {
+        const result = this.safeParse(value);
+        if (!result.success) {
+            throw result.error;
+        }
+        return result.data;
+    }
+    /**
+     * Safely parse (decode) a value from input to output format
+     */
+    safeParse(value) {
+        // First validate the input
+        const inputResult = this.inputValidator.safeParse(value);
+        if (!inputResult.success) {
+            return { success: false, error: inputResult.error };
+        }
+        try {
+            // Then decode to output
+            const decoded = this.codecTransform.decode(inputResult.data);
+            // Handle async decode
+            if (decoded instanceof Promise) {
+                throw new errorsCore.VldError([
+                    errors.createIssue('custom', [], locales_runtime.getMessages().codecAsyncNotSupported)
+                ]);
+            }
+            // Validate the decoded output
+            return this.outputValidator.safeParse(decoded);
+        }
+        catch (error) {
+            if (error instanceof errorsCore.VldError) {
+                return { success: false, error };
+            }
+            return {
+                success: false,
+                error: new errorsCore.VldError([
+                    errors.createIssue('custom', [], locales_runtime.getMessages().codecDecodeFailed)
+                ])
+            };
+        }
+    }
+    /**
+     * Create a new codec with input and output directions swapped.
+     */
+    invert() {
+        return new VldCodec(this.outputValidator, this.inputValidator, {
+            decode: this.codecTransform.encode,
+            encode: this.codecTransform.decode
+        });
+    }
+    /**
+     * Encode a value from output back to input format
+     */
+    encode(value) {
+        const result = this.safeEncode(value);
+        if (!result.success) {
+            throw result.error;
+        }
+        return result.data;
+    }
+    /**
+     * Safely encode a value from output back to input format
+     */
+    safeEncode(value) {
+        // First validate the output
+        const outputResult = this.outputValidator.safeParse(value);
+        if (!outputResult.success) {
+            return { success: false, error: outputResult.error };
+        }
+        try {
+            // Then encode to input
+            const encoded = this.codecTransform.encode(outputResult.data);
+            // Handle async encode
+            if (encoded instanceof Promise) {
+                throw new errorsCore.VldError([
+                    errors.createIssue('custom', [], locales_runtime.getMessages().codecAsyncNotSupported)
+                ]);
+            }
+            // Validate the encoded input
+            return this.inputValidator.safeParse(encoded);
+        }
+        catch (error) {
+            if (error instanceof errorsCore.VldError) {
+                return { success: false, error };
+            }
+            return {
+                success: false,
+                error: new errorsCore.VldError([
+                    errors.createIssue('custom', [], locales_runtime.getMessages().codecEncodeFailed)
+                ])
+            };
+        }
+    }
+    /**
+     * Async version of parse (decode)
+     */
+    async parseAsync(value) {
+        const result = await this.safeParseAsync(value);
+        if (!result.success) {
+            throw result.error;
+        }
+        return result.data;
+    }
+    /**
+     * Async version of safeParse (decode)
+     */
+    async safeParseAsync(value) {
+        // First validate the input
+        const inputResult = this.inputValidator.safeParse(value);
+        if (!inputResult.success) {
+            return { success: false, error: inputResult.error };
+        }
+        try {
+            // Then decode to output (supports async)
+            const decoded = await this.codecTransform.decode(inputResult.data);
+            // Validate the decoded output
+            return this.outputValidator.safeParse(decoded);
+        }
+        catch (error) {
+            if (error instanceof errorsCore.VldError) {
+                return { success: false, error };
+            }
+            return {
+                success: false,
+                error: new errorsCore.VldError([
+                    errors.createIssue('custom', [], locales_runtime.getMessages().codecDecodeFailed)
+                ])
+            };
+        }
+    }
+    /**
+     * Async version of encode
+     */
+    async encodeAsync(value) {
+        const result = await this.safeEncodeAsync(value);
+        if (!result.success) {
+            throw result.error;
+        }
+        return result.data;
+    }
+    /**
+     * Async version of safeEncode
+     */
+    async safeEncodeAsync(value) {
+        // First validate the output
+        const outputResult = this.outputValidator.safeParse(value);
+        if (!outputResult.success) {
+            return { success: false, error: outputResult.error };
+        }
+        try {
+            // Then encode to input (supports async)
+            const encoded = await this.codecTransform.encode(outputResult.data);
+            // Validate the encoded input
+            return this.inputValidator.safeParse(encoded);
+        }
+        catch (error) {
+            if (error instanceof errorsCore.VldError) {
+                return { success: false, error };
+            }
+            return {
+                success: false,
+                error: new errorsCore.VldError([
+                    errors.createIssue('custom', [], locales_runtime.getMessages().codecEncodeFailed)
+                ])
+            };
+        }
+    }
+    /**
+     * Create a codec validator
+     */
+    static create(inputValidator, outputValidator, codecTransform) {
+        return new VldCodec(inputValidator, outputValidator, codecTransform);
+    }
+    /**
+     * Create a codec with input and output directions swapped.
+     */
+    static invert(codec) {
+        return codec.invert();
+    }
+}
+
+exports.VldCodec = VldCodec;