@oxog/vld 2.0.2 → 2.1.0

package/dist/cjs/validators/custom.cjs

@@ -0,0 +1,71 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+require('../registry.cjs');
+
+/**
+ * Immutable custom validator for user-defined validation logic
+ * Provides type safety while allowing complete control over validation
+ */
+class VldCustom extends validators_base.VldBase {
+    constructor(options) {
+        super(validators_base.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);
+}
+
+exports.VldCustom = VldCustom;
+exports.custom = custom;

package/dist/cjs/validators/date.cjs

@@ -0,0 +1,278 @@
+'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 createDateError(message) {
+    return new errorsCore.VldError([{ code: 'invalid_date', path: [], message }]);
+}
+/**
+ * Immutable date validator with chainable methods
+ */
+class VldDate extends validators_base.VldBase {
+    /**
+     * Protected constructor to allow extension while maintaining immutability
+     */
+    constructor(config) {
+        super(config?.validatorType || validators_base.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 || locales_runtime.getMessages().invalidDate);
+        }
+        // Check if the date is valid
+        if (isNaN(date.getTime())) {
+            throw new Error(this.config.errorMessage || locales_runtime.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 || locales_runtime.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 || locales_runtime.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 || locales_runtime.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() }
+        });
+    }
+}
+
+exports.VldDate = VldDate;

package/dist/cjs/validators/discriminated-union.cjs

@@ -0,0 +1,130 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+var validators_object = require('./object.cjs');
+var validators_literal = require('./literal.cjs');
+var validators_enum = require('./enum.cjs');
+require('../registry.cjs');
+require('../locales/runtime.cjs');
+require('../locales/en.cjs');
+require('../chunks/security-Dc3Jh13T.cjs');
+require('../chunks/errors-core-DWxLFs2f.cjs');
+
+/**
+ * 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 validators_literal.VldLiteral) {
+        return [schema.literal];
+    }
+    if (schema instanceof validators_enum.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 validators_base.VldBase {
+    constructor(_discriminator, _options) {
+        super(validators_base.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 validators_object.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;
+    }
+}
+
+exports.VldDiscriminatedUnion = VldDiscriminatedUnion;

package/dist/cjs/validators/enum.cjs

@@ -0,0 +1,154 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+var locales_runtime = require('../locales/runtime.cjs');
+require('../registry.cjs');
+require('../locales/en.cjs');
+
+class VldEnum extends validators_base.VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(_values, errorMessage) {
+        super(validators_base.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 ||
+            locales_runtime.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);
+    }
+}
+
+exports.VldEnum = VldEnum;