@oxog/vld 2.0.2 → 2.1.0

package/dist/validators/base64.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Base64 string validator
  */
@@ -15,4 +15,3 @@ export declare class VldBase64 extends VldBase<string, string> {
     urlSafeMode(): VldBase64;
     static create(urlSafe?: boolean): VldBase64;
 }
-//# sourceMappingURL=base64.d.ts.map

package/dist/validators/base64.js

@@ -0,0 +1,68 @@
+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';
+
+/**
+ * Base64 string validator
+ */
+class VldBase64 extends VldBase {
+    constructor(urlSafe = false) {
+        super(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 VldError([
+                    createIssue('invalid_type', [], 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 VldError([
+                    createIssue('custom', [], 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 VldError([
+                    createIssue('custom', [], 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}$/;
+
+export { VldBase64 };

package/dist/validators/bigint.d.ts

@@ -1,32 +1,51 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult, ValidatorType } from './base.js';
 /**
  * Type for bigint validation check functions
  */
 type BigIntCheck = (value: bigint) => boolean;
+interface BigIntJSONSchemaHints {
+    readonly minimum?: bigint;
+    readonly maximum?: bigint;
+    readonly exclusiveMinimum?: bigint;
+    readonly exclusiveMaximum?: bigint;
+}
 /**
  * Configuration for bigint validator
  */
 interface BigIntValidatorConfig {
     readonly checks: ReadonlyArray<BigIntCheck>;
-    readonly errorMessage?: string;
+    readonly errorMessage: string | undefined;
+    readonly validatorType?: ValidatorType;
+    readonly jsonSchema: BigIntJSONSchemaHints | undefined;
 }
 /**
  * Immutable bigint validator
  */
 export declare class VldBigInt extends VldBase<bigint, bigint> {
     protected readonly config: BigIntValidatorConfig;
+    private readonly _checks;
+    private readonly _fastCheckMode;
     /**
      * Protected constructor to allow extension while maintaining immutability
      */
     protected constructor(config?: Partial<BigIntValidatorConfig>);
+    get jsonSchema(): BigIntJSONSchemaHints | undefined;
+    get isSimple(): boolean;
     /**
      * Create a new bigint validator
      */
     static create(): VldBigInt;
+    private detectFastCheckMode;
+    private getValidationError;
     /**
      * Parse and validate a bigint value
      */
     parse(value: unknown): bigint;
+    /**
+     * Parse a value that has already passed the bigint type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownBigInt(value: bigint): bigint;
     /**
      * Safely parse and validate a bigint value
      */
@@ -77,4 +96,3 @@ export declare class VldBigInt extends VldBase<bigint, bigint> {
     lte(value: bigint | number, message?: string): VldBigInt;
 }
 export {};
-//# sourceMappingURL=bigint.d.ts.map

package/dist/validators/bigint.js

@@ -0,0 +1,228 @@
+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 createBigIntError(message) {
+    return new VldError([{ code: 'invalid_type', path: [], message }]);
+}
+/**
+ * Immutable bigint validator
+ */
+class VldBigInt extends VldBase {
+    /**
+     * Protected constructor to allow extension while maintaining immutability
+     */
+    constructor(config) {
+        super(config?.validatorType || 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 || 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);
+    }
+}
+
+export { VldBigInt };

package/dist/validators/boolean.d.ts

@@ -1,13 +1,18 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult, ValidatorType } from './base.js';
 /**
  * Immutable boolean validator
  */
 export declare class VldBoolean extends VldBase<boolean, boolean> {
-    private readonly errorMessage?;
+    private readonly errorMessage;
     /**
      * Protected constructor to allow extension while maintaining immutability
      */
-    protected constructor(errorMessage?: string);
+    protected constructor(errorMessage?: string, validatorType?: ValidatorType);
+    /**
+     * Returns true if this is a simple boolean validator with no custom checks
+     * Used by VldObject for optimized fast-path dispatch
+     */
+    get isSimple(): boolean;
     /**
      * Create a new boolean validator
      */
@@ -16,6 +21,11 @@ export declare class VldBoolean extends VldBase<boolean, boolean> {
      * Parse and validate a boolean value
      */
     parse(value: unknown): boolean;
+    /**
+     * Parse a value that has already passed the boolean type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownBoolean(value: boolean): boolean;
     /**
      * Safely parse and validate a boolean value
      */
@@ -29,4 +39,3 @@ export declare class VldBoolean extends VldBase<boolean, boolean> {
      */
     false(message?: string): VldBoolean;
 }
-//# sourceMappingURL=boolean.d.ts.map

package/dist/validators/boolean.js

@@ -0,0 +1,142 @@
+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 createBooleanError(message) {
+    return new VldError([{ code: 'invalid_boolean', path: [], message }]);
+}
+/**
+ * Immutable boolean validator
+ */
+class VldBoolean extends VldBase {
+    /**
+     * Protected constructor to allow extension while maintaining immutability
+     */
+    constructor(errorMessage, validatorType) {
+        super(validatorType || 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 || 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 || 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 };
+    }
+}
+
+export { VldBoolean };

package/dist/validators/codec.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Codec transform functions for bidirectional transformations
  */
@@ -23,6 +23,10 @@ export declare class VldCodec<TInput, TOutput> extends VldBase<TInput, TOutput>
      * Safely parse (decode) a value from input to output format
      */
     safeParse(value: unknown): ParseResult<TOutput>;
+    /**
+     * Create a new codec with input and output directions swapped.
+     */
+    invert(): VldCodec<TOutput, TInput>;
     /**
      * Encode a value from output back to input format
      */
@@ -51,5 +55,8 @@ export declare class VldCodec<TInput, TOutput> extends VldBase<TInput, TOutput>
      * Create a codec validator
      */
     static create<TInput, TOutput>(inputValidator: VldBase<unknown, TInput>, outputValidator: VldBase<unknown, TOutput>, codecTransform: CodecTransform<TInput, TOutput>): VldCodec<TInput, TOutput>;
+    /**
+     * Create a codec with input and output directions swapped.
+     */
+    static invert<TInput, TOutput>(codec: VldCodec<TInput, TOutput>): VldCodec<TOutput, TInput>;
 }
-//# sourceMappingURL=codec.d.ts.map