@oxog/vld 2.0.3 → 2.1.0

package/dist/validators/codec.js

@@ -0,0 +1,200 @@
+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';
+
+/**
+ * Codec validator for bidirectional transformations
+ * Enables converting between different data representations
+ */
+class VldCodec extends VldBase {
+    constructor(inputValidator, outputValidator, codecTransform) {
+        super(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 VldError([
+                    createIssue('custom', [], getMessages().codecAsyncNotSupported)
+                ]);
+            }
+            // Validate the decoded output
+            return this.outputValidator.safeParse(decoded);
+        }
+        catch (error) {
+            if (error instanceof VldError) {
+                return { success: false, error };
+            }
+            return {
+                success: false,
+                error: new VldError([
+                    createIssue('custom', [], 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 VldError([
+                    createIssue('custom', [], getMessages().codecAsyncNotSupported)
+                ]);
+            }
+            // Validate the encoded input
+            return this.inputValidator.safeParse(encoded);
+        }
+        catch (error) {
+            if (error instanceof VldError) {
+                return { success: false, error };
+            }
+            return {
+                success: false,
+                error: new VldError([
+                    createIssue('custom', [], 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 VldError) {
+                return { success: false, error };
+            }
+            return {
+                success: false,
+                error: new VldError([
+                    createIssue('custom', [], 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 VldError) {
+                return { success: false, error };
+            }
+            return {
+                success: false,
+                error: new VldError([
+                    createIssue('custom', [], 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();
+    }
+}
+
+export { VldCodec };

package/dist/validators/custom.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Type-safe custom validator options
  */
@@ -7,11 +7,21 @@ export interface CustomValidatorOptions<TOutput> {
      * Parse function that validates and transforms input
      */
     parse: (value: unknown) => TOutput;
+    /**
+     * Optional async parse implementation
+     * If not provided, async parsing delegates to parse()
+     */
+    parseAsync?: (value: unknown) => Promise<TOutput>;
     /**
      * Optional safeParse implementation
      * If not provided, will use try-catch around parse()
      */
     safeParse?: (value: unknown) => ParseResult<TOutput>;
+    /**
+     * Optional async safeParse implementation
+     * If not provided, will use try-catch around parseAsync()
+     */
+    safeParseAsync?: (value: unknown) => Promise<ParseResult<TOutput>>;
 }
 /**
  * Immutable custom validator for user-defined validation logic
@@ -19,7 +29,9 @@ export interface CustomValidatorOptions<TOutput> {
  */
 export declare class VldCustom<TOutput = unknown> extends VldBase<unknown, TOutput> {
     private readonly _parseFn;
+    private readonly _parseAsyncFn;
     private readonly _safeParseFn;
+    private readonly _safeParseAsyncFn;
     private constructor();
     /**
      * Create a new custom validator
@@ -33,6 +45,8 @@ export declare class VldCustom<TOutput = unknown> extends VldBase<unknown, TOutp
      * Safely parse using the custom safeParse function or default implementation
      */
     safeParse(value: unknown): ParseResult<TOutput>;
+    parseAsync(value: unknown): Promise<TOutput>;
+    safeParseAsync(value: unknown): Promise<ParseResult<TOutput>>;
 }
 /**
  * Helper function to create custom validators
@@ -44,4 +58,3 @@ export declare class VldCustom<TOutput = unknown> extends VldBase<unknown, TOutp
  * })
  */
 export declare function custom<TOutput = unknown>(options: CustomValidatorOptions<TOutput>): VldCustom<TOutput>;
-//# sourceMappingURL=custom.d.ts.map

package/dist/validators/custom.js

@@ -0,0 +1,67 @@
+import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
+
+/**
+ * Immutable custom validator for user-defined validation logic
+ * Provides type safety while allowing complete control over validation
+ */
+class VldCustom extends VldBase {
+    constructor(options) {
+        super(VLD_VALIDATOR_TYPES.CUSTOM);
+        this._parseFn = options.parse;
+        this._parseAsyncFn = options.parseAsync || ((value) => Promise.resolve(this._parseFn(value)));
+        this._safeParseFn = options.safeParse || ((value) => {
+            try {
+                return { success: true, data: this._parseFn(value) };
+            }
+            catch (error) {
+                return { success: false, error: error };
+            }
+        });
+        this._safeParseAsyncFn = options.safeParseAsync || (async (value) => {
+            try {
+                return { success: true, data: await this._parseAsyncFn(value) };
+            }
+            catch (error) {
+                return { success: false, error: error };
+            }
+        });
+    }
+    /**
+     * Create a new custom validator
+     */
+    static create(options) {
+        return new VldCustom(options);
+    }
+    /**
+     * Parse and validate using the custom parse function
+     */
+    parse(value) {
+        return this._parseFn(value);
+    }
+    /**
+     * Safely parse using the custom safeParse function or default implementation
+     */
+    safeParse(value) {
+        return this._safeParseFn(value);
+    }
+    async parseAsync(value) {
+        return this._parseAsyncFn(value);
+    }
+    async safeParseAsync(value) {
+        return this._safeParseAsyncFn(value);
+    }
+}
+/**
+ * Helper function to create custom validators
+ * Usage: v.custom<number>({
+ *   parse: (value) => {
+ *     if (typeof value !== 'string') throw new Error('Expected string');
+ *     return parseInt(value, 10);
+ *   }
+ * })
+ */
+function custom(options) {
+    return VldCustom.create(options);
+}
+
+export { VldCustom, custom };

package/dist/validators/date.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult, ValidatorType } from './base.js';
 /**
  * Type for date validation check functions
  */
@@ -7,22 +7,33 @@ interface DateCheck {
     fn: DateCheckFn;
     message: string;
 }
+interface DateJSONSchemaHints {
+    readonly formatMinimum?: string;
+    readonly formatMaximum?: string;
+    readonly formatExclusiveMinimum?: string;
+    readonly formatExclusiveMaximum?: string;
+}
 /**
  * Configuration for date validator
  */
 interface DateValidatorConfig {
     readonly checks: ReadonlyArray<DateCheck>;
-    readonly errorMessage?: string;
+    readonly errorMessage: string | undefined;
+    readonly validatorType?: ValidatorType;
+    readonly jsonSchema: DateJSONSchemaHints | undefined;
 }
 /**
  * Immutable date validator with chainable methods
  */
 export declare class VldDate extends VldBase<Date, Date> {
     private readonly config;
+    private readonly _checks;
+    private readonly _isSimple;
     /**
      * Protected constructor to allow extension while maintaining immutability
      */
     protected constructor(config?: Partial<DateValidatorConfig>);
+    get jsonSchema(): DateJSONSchemaHints | undefined;
     /**
      * Create a new date validator
      */
@@ -31,6 +42,12 @@ export declare class VldDate extends VldBase<Date, Date> {
      * Parse and validate a date value
      */
     parse(value: unknown): Date;
+    /**
+     * Parse a Date instance that has already passed the Date validity check.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownDate(value: Date): Date;
+    private parseValidDate;
     /**
      * Safely parse and validate a date value
      */
@@ -85,4 +102,3 @@ export declare class VldDate extends VldBase<Date, Date> {
     lt(value: Date | number, message?: string): VldDate;
 }
 export {};
-//# sourceMappingURL=date.d.ts.map

package/dist/validators/date.js

@@ -0,0 +1,274 @@
+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 createDateError(message) {
+    return new VldError([{ code: 'invalid_date', path: [], message }]);
+}
+/**
+ * Immutable date validator with chainable methods
+ */
+class VldDate extends VldBase {
+    /**
+     * Protected constructor to allow extension while maintaining immutability
+     */
+    constructor(config) {
+        super(config?.validatorType || VLD_VALIDATOR_TYPES.DATE);
+        this.config = {
+            checks: config?.checks || [],
+            errorMessage: config?.errorMessage,
+            jsonSchema: config?.jsonSchema
+        };
+        this._checks = this.config.checks;
+        this._isSimple = this._checks.length === 0;
+    }
+    get jsonSchema() {
+        return this.config.jsonSchema;
+    }
+    /**
+     * Create a new date validator
+     */
+    static create() {
+        return new VldDate();
+    }
+    /**
+     * Parse and validate a date value
+     */
+    parse(value) {
+        let date;
+        if (value instanceof Date) {
+            date = value;
+        }
+        else if (typeof value === 'string' || typeof value === 'number') {
+            date = new Date(value);
+        }
+        else {
+            throw new Error(this.config.errorMessage || getMessages().invalidDate);
+        }
+        // Check if the date is valid
+        if (isNaN(date.getTime())) {
+            throw new Error(this.config.errorMessage || getMessages().invalidDate);
+        }
+        return this.parseValidDate(date);
+    }
+    /**
+     * Parse a Date instance that has already passed the Date validity check.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownDate(value) {
+        if (isNaN(value.getTime())) {
+            throw new Error(this.config.errorMessage || getMessages().invalidDate);
+        }
+        return this.parseValidDate(value);
+    }
+    parseValidDate(date) {
+        if (this._isSimple) {
+            return date;
+        }
+        // Apply all checks
+        for (const check of this._checks) {
+            if (!check.fn(date)) {
+                throw new Error(check.message);
+            }
+        }
+        return date;
+    }
+    /**
+     * Safely parse and validate a date value
+     */
+    safeParse(value) {
+        if (value instanceof Date) {
+            try {
+                return { success: true, data: this.parseKnownDate(value) };
+            }
+            catch (error) {
+                return { success: false, error: createDateError(error.message) };
+            }
+        }
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: createDateError(error.message) };
+        }
+    }
+    /**
+     * Create a new validator with minimum date constraint
+     * BUG-NEW-009 FIX: Validate that min date is valid before creating validator
+     */
+    min(date, message) {
+        const minDate = date instanceof Date ? date : new Date(date);
+        // Validate that minDate is valid
+        if (isNaN(minDate.getTime())) {
+            throw new Error(`Invalid date provided to min(): ${date}`);
+        }
+        return new VldDate({
+            ...this.config,
+            checks: [...this.config.checks, {
+                    fn: (v) => v >= minDate,
+                    message: message || getMessages().dateMin(minDate)
+                }],
+            jsonSchema: { ...this.config.jsonSchema, formatMinimum: minDate.toISOString() }
+        });
+    }
+    /**
+     * Create a new validator with maximum date constraint
+     * BUG-NEW-009 FIX: Validate that max date is valid before creating validator
+     */
+    max(date, message) {
+        const maxDate = date instanceof Date ? date : new Date(date);
+        // Validate that maxDate is valid
+        if (isNaN(maxDate.getTime())) {
+            throw new Error(`Invalid date provided to max(): ${date}`);
+        }
+        return new VldDate({
+            ...this.config,
+            checks: [...this.config.checks, {
+                    fn: (v) => v <= maxDate,
+                    message: message || getMessages().dateMax(maxDate)
+                }],
+            jsonSchema: { ...this.config.jsonSchema, formatMaximum: maxDate.toISOString() }
+        });
+    }
+    /**
+     * Create a new validator with a range constraint
+     * BUG-NEW-019 FIX: Validate that min/max dates are valid before creating validator
+     */
+    between(min, max, message) {
+        const minDate = min instanceof Date ? min : new Date(min);
+        const maxDate = max instanceof Date ? max : new Date(max);
+        // Validate that both dates are valid
+        if (isNaN(minDate.getTime())) {
+            throw new Error(`Invalid min date provided to between(): ${min}`);
+        }
+        if (isNaN(maxDate.getTime())) {
+            throw new Error(`Invalid max date provided to between(): ${max}`);
+        }
+        return new VldDate({
+            ...this.config,
+            checks: [...this.config.checks, {
+                    fn: (v) => v >= minDate && v <= maxDate,
+                    message: message || `Date must be between ${minDate.toISOString()} and ${maxDate.toISOString()}`
+                }],
+            jsonSchema: {
+                ...this.config.jsonSchema,
+                formatMinimum: minDate.toISOString(),
+                formatMaximum: maxDate.toISOString()
+            }
+        });
+    }
+    /**
+     * Create a new validator that checks if date is in the past
+     * BUG-NEW-006 FIX: Capture reference date at validator creation time for deterministic behavior
+     */
+    past(message) {
+        const referenceDate = new Date(); // Capture NOW at validator creation time
+        return new VldDate({
+            ...this.config,
+            checks: [...this.config.checks, {
+                    fn: (v) => v < referenceDate,
+                    message: message || 'Date must be in the past'
+                }],
+            jsonSchema: { ...this.config.jsonSchema, formatExclusiveMaximum: referenceDate.toISOString() }
+        });
+    }
+    /**
+     * Create a new validator that checks if date is in the future
+     * BUG-NEW-006 FIX: Capture reference date at validator creation time for deterministic behavior
+     */
+    future(message) {
+        const referenceDate = new Date(); // Capture NOW at validator creation time
+        return new VldDate({
+            ...this.config,
+            checks: [...this.config.checks, {
+                    fn: (v) => v > referenceDate,
+                    message: message || 'Date must be in the future'
+                }],
+            jsonSchema: { ...this.config.jsonSchema, formatExclusiveMinimum: referenceDate.toISOString() }
+        });
+    }
+    /**
+     * Create a new validator that checks if date is today
+     * BUG-NEW-008 FIX: Capture reference date at validator creation time for deterministic behavior
+     */
+    today(message) {
+        // Capture the reference date (today) at validator creation time
+        const referenceDate = new Date();
+        const refYear = referenceDate.getFullYear();
+        const refMonth = referenceDate.getMonth();
+        const refDate = referenceDate.getDate();
+        return new VldDate({
+            ...this.config,
+            checks: [...this.config.checks, {
+                    fn: (v) => {
+                        return v.getFullYear() === refYear &&
+                            v.getMonth() === refMonth &&
+                            v.getDate() === refDate;
+                    },
+                    message: message || 'Date must be today'
+                }]
+        });
+    }
+    /**
+     * Create a new validator that checks if date is a weekday
+     */
+    weekday(message) {
+        return new VldDate({
+            ...this.config,
+            checks: [...this.config.checks, {
+                    fn: (v) => {
+                        const day = v.getDay();
+                        return day >= 1 && day <= 5;
+                    },
+                    message: message || 'Date must be a weekday'
+                }]
+        });
+    }
+    /**
+     * Create a new validator that checks if date is a weekend
+     */
+    weekend(message) {
+        return new VldDate({
+            ...this.config,
+            checks: [...this.config.checks, {
+                    fn: (v) => {
+                        const day = v.getDay();
+                        return day === 0 || day === 6;
+                    },
+                    message: message || 'Date must be a weekend'
+                }]
+        });
+    }
+    /**
+     * Create a new validator with strict greater than constraint
+     * Zod 4 API parity - strictly greater than (not equal to)
+     */
+    gt(value, message) {
+        const compareDate = value instanceof Date ? value : new Date(value);
+        return new VldDate({
+            ...this.config,
+            checks: [...this.config.checks, {
+                    fn: (v) => v.getTime() > compareDate.getTime(),
+                    message: message || `Date must be greater than ${compareDate.toISOString()}`
+                }],
+            jsonSchema: { ...this.config.jsonSchema, formatExclusiveMinimum: compareDate.toISOString() }
+        });
+    }
+    /**
+     * Create a new validator with strict less than constraint
+     * Zod 4 API parity - strictly less than (not equal to)
+     */
+    lt(value, message) {
+        const compareDate = value instanceof Date ? value : new Date(value);
+        return new VldDate({
+            ...this.config,
+            checks: [...this.config.checks, {
+                    fn: (v) => v.getTime() < compareDate.getTime(),
+                    message: message || `Date must be less than ${compareDate.toISOString()}`
+                }],
+            jsonSchema: { ...this.config.jsonSchema, formatExclusiveMaximum: compareDate.toISOString() }
+        });
+    }
+}
+
+export { VldDate };

package/dist/validators/discriminated-union.d.ts

@@ -3,8 +3,8 @@
  * Part of Zod 4 API parity implementation
  * Provides O(1) lookup performance by using a discriminator key
  */
-import { VldBase } from './base';
-import type { ParseResult } from './base';
+import { VldBase } from './base.js';
+import type { ParseResult } from './base.js';
 /**
  * Discriminated union validator - validates union based on discriminator key
  * Much faster than regular union when you have a discriminator field
@@ -13,6 +13,8 @@ export declare class VldDiscriminatedUnion<K extends string, Options extends Vld
     private readonly _discriminator;
     private readonly _options;
     private readonly _discriminatorMap;
+    private readonly _stringDiscriminatorMap;
+    private readonly _validValues;
     constructor(_discriminator: K, _options: Options);
     static create<K extends string, Options extends VldBase<any, any>[]>(discriminator: K, options: Options): VldDiscriminatedUnion<K, Options>;
     parse(value: unknown): Options[number] extends VldBase<any, infer T> ? T : never;
@@ -26,4 +28,3 @@ export declare class VldDiscriminatedUnion<K extends string, Options extends Vld
      */
     getOptions(): Options;
 }
-//# sourceMappingURL=discriminated-union.d.ts.map