@oxog/vld 2.0.2 → 2.1.0

package/dist/cjs/validators/number.cjs

@@ -0,0 +1,427 @@
+'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 createNumberError(message) {
+    return new errorsCore.VldError([{ code: 'invalid_number', path: [], message }]);
+}
+/**
+ * Immutable number validator with chainable methods
+ */
+class VldNumber extends validators_base.VldBase {
+    /**
+     * Protected constructor to allow extension while maintaining immutability
+     */
+    constructor(config) {
+        super(config?.validatorType || validators_base.VLD_VALIDATOR_TYPES.NUMBER);
+        this.config = {
+            checks: config?.checks || [],
+            errorMessage: config?.errorMessage,
+            jsonSchema: config?.jsonSchema
+        };
+        this._checks = this.config.checks;
+        this._isSimple = this._checks.length === 0;
+        this._fastCheckMode = this.detectFastCheckMode();
+    }
+    detectFastCheckMode() {
+        const schema = this.config.jsonSchema;
+        if (this._checks.length === 0) {
+            return 'none';
+        }
+        if (this._checks.length === 1 &&
+            schema?.exclusiveMinimum === 0 &&
+            schema.type !== 'integer') {
+            return 'positive';
+        }
+        if (this._checks.length === 2 &&
+            schema?.exclusiveMinimum === 0 &&
+            schema.type === 'integer') {
+            return 'positive-int';
+        }
+        return undefined;
+    }
+    /**
+     * Returns true if this validator has custom checks (min, max, positive, etc.)
+     * Used by VldObject for optimized fast-path dispatch
+     */
+    get hasCustomChecks() {
+        return !this._isSimple;
+    }
+    /**
+     * Returns true if this is a simple number validator with no custom checks
+     * Used by VldObject for optimized fast-path dispatch
+     */
+    get isSimple() {
+        return this._isSimple;
+    }
+    /**
+     * Create a new number validator
+     */
+    static create() {
+        return new VldNumber();
+    }
+    /**
+     * Parse and validate a number value
+     */
+    parse(value) {
+        if (typeof value !== 'number' || isNaN(value)) {
+            throw new Error(this.config.errorMessage || locales_runtime.getMessages().invalidNumber);
+        }
+        switch (this._fastCheckMode) {
+            case 'none':
+                return value;
+            case 'positive':
+                if (value > 0)
+                    return value;
+                throw new Error(this.config.errorMessage || locales_runtime.getMessages().invalidNumber);
+            case 'positive-int':
+                if (value > 0 && Number.isInteger(value))
+                    return value;
+                throw new Error(this.config.errorMessage || locales_runtime.getMessages().invalidNumber);
+        }
+        return this.parseKnownNumber(value);
+    }
+    /**
+     * Parse a value that has already passed the number type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownNumber(value) {
+        switch (this._fastCheckMode) {
+            case 'none':
+                return value;
+            case 'positive':
+                if (value > 0)
+                    return value;
+                throw new Error(this.config.errorMessage || locales_runtime.getMessages().invalidNumber);
+            case 'positive-int':
+                if (value > 0 && Number.isInteger(value))
+                    return value;
+                throw new Error(this.config.errorMessage || locales_runtime.getMessages().invalidNumber);
+        }
+        const checks = this._checks;
+        switch (checks.length) {
+            case 1:
+                if (checks[0](value))
+                    return value;
+                break;
+            case 2:
+                if (checks[0](value) && checks[1](value))
+                    return value;
+                break;
+            case 3:
+                if (checks[0](value) && checks[1](value) && checks[2](value))
+                    return value;
+                break;
+            default:
+                for (let i = 0; i < checks.length; i++) {
+                    if (!checks[i](value)) {
+                        throw new Error(this.config.errorMessage || locales_runtime.getMessages().invalidNumber);
+                    }
+                }
+                return value;
+        }
+        throw new Error(this.config.errorMessage || locales_runtime.getMessages().invalidNumber);
+    }
+    passesChecks(value) {
+        switch (this._fastCheckMode) {
+            case 'none':
+                return true;
+            case 'positive':
+                return value > 0;
+            case 'positive-int':
+                return value > 0 && Number.isInteger(value);
+        }
+        const checks = this._checks;
+        switch (checks.length) {
+            case 1:
+                return checks[0](value);
+            case 2:
+                return checks[0](value) && checks[1](value);
+            case 3:
+                return checks[0](value) && checks[1](value) && checks[2](value);
+            default:
+                for (let i = 0; i < checks.length; i++) {
+                    if (!checks[i](value)) {
+                        return false;
+                    }
+                }
+                return true;
+        }
+    }
+    /**
+     * Safely parse and validate a number value
+     */
+    safeParse(value) {
+        try {
+            if (typeof value !== 'number' || isNaN(value) || !this.passesChecks(value)) {
+                return { success: false, error: createNumberError(this.config.errorMessage || locales_runtime.getMessages().invalidNumber) };
+            }
+            return { success: true, data: value };
+        }
+        catch (error) {
+            return { success: false, error: createNumberError(error.message) };
+        }
+    }
+    /**
+     * Create a new validator with minimum value constraint
+     */
+    min(value, message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => v >= value],
+            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().numberMin(value)),
+            jsonSchema: { ...this.config.jsonSchema, minimum: value }
+        });
+    }
+    /**
+     * Create a new validator with maximum value constraint
+     */
+    max(value, message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => v <= value],
+            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().numberMax(value)),
+            jsonSchema: { ...this.config.jsonSchema, maximum: value }
+        });
+    }
+    /**
+     * Create a new validator that checks for integer values
+     */
+    int(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => Number.isInteger(v)],
+            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().numberInt),
+            jsonSchema: { ...this.config.jsonSchema, type: 'integer' }
+        });
+    }
+    /**
+     * Create a new validator that checks for positive values
+     */
+    positive(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => v > 0],
+            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().numberPositive),
+            jsonSchema: { ...this.config.jsonSchema, exclusiveMinimum: 0 }
+        });
+    }
+    /**
+     * Create a new validator that checks for negative values
+     */
+    negative(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => v < 0],
+            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().numberNegative),
+            jsonSchema: { ...this.config.jsonSchema, exclusiveMaximum: 0 }
+        });
+    }
+    /**
+     * Create a new validator that checks for non-negative values
+     */
+    nonnegative(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => v >= 0],
+            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().numberNonnegative),
+            jsonSchema: { ...this.config.jsonSchema, minimum: 0 }
+        });
+    }
+    /**
+     * Create a new validator that checks for non-positive values
+     */
+    nonpositive(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => v <= 0],
+            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().numberNonpositive),
+            jsonSchema: { ...this.config.jsonSchema, maximum: 0 }
+        });
+    }
+    /**
+     * Create a new validator that checks for finite values
+     */
+    finite(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => Number.isFinite(v)],
+            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().numberFinite),
+            jsonSchema: this.config.jsonSchema
+        });
+    }
+    /**
+     * Create a new validator that checks for safe integer values
+     */
+    safe(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => Number.isSafeInteger(v)],
+            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().numberSafe),
+            jsonSchema: { ...this.config.jsonSchema, type: 'integer' }
+        });
+    }
+    /**
+     * Create a new validator that checks if value is multiple of another
+     */
+    multipleOf(value, message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => {
+                    // Use epsilon comparison for floating point precision
+                    const remainder = Math.abs(v % value);
+                    return remainder < Number.EPSILON || Math.abs(remainder - Math.abs(value)) < Number.EPSILON;
+                }],
+            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().numberMultipleOf(value)),
+            jsonSchema: { ...this.config.jsonSchema, multipleOf: value }
+        });
+    }
+    /**
+     * Alias for multipleOf
+     */
+    step(value, message) {
+        return this.multipleOf(value, message);
+    }
+    /**
+     * Create a new validator with a range constraint
+     */
+    between(min, max, message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => v >= min && v <= max],
+            errorMessage: validators_base.resolveErrorMessage(message, `Number must be between ${min} and ${max}`),
+            jsonSchema: { ...this.config.jsonSchema, minimum: min, maximum: max }
+        });
+    }
+    /**
+     * Create a new validator that checks for even numbers
+     * BUG-011 FIX: Require integers for even/odd validation (more mathematically correct)
+     */
+    even(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => {
+                    // Even/odd only makes sense for integers
+                    if (!Number.isInteger(v)) {
+                        return false;
+                    }
+                    return v % 2 === 0;
+                }],
+            errorMessage: validators_base.resolveErrorMessage(message, 'Number must be even'),
+            jsonSchema: { ...this.config.jsonSchema, type: 'integer', multipleOf: 2 }
+        });
+    }
+    /**
+     * Create a new validator that checks for odd numbers
+     * BUG-011 FIX: Require integers for even/odd validation (more mathematically correct)
+     */
+    odd(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => {
+                    // Even/odd only makes sense for integers
+                    if (!Number.isInteger(v)) {
+                        return false;
+                    }
+                    return v % 2 !== 0;
+                }],
+            errorMessage: validators_base.resolveErrorMessage(message, 'Number must be odd'),
+            jsonSchema: { ...this.config.jsonSchema, type: 'integer' }
+        });
+    }
+    /**
+     * Create a new validator with strict greater than constraint
+     * Zod 4 API parity - strictly greater than (not equal to)
+     */
+    gt(value, message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => v > value],
+            errorMessage: validators_base.resolveErrorMessage(message, `Number must be greater than ${value}`),
+            jsonSchema: { ...this.config.jsonSchema, exclusiveMinimum: value }
+        });
+    }
+    /**
+     * Create a new validator with strict less than constraint
+     * Zod 4 API parity - strictly less than (not equal to)
+     */
+    lt(value, message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => v < value],
+            errorMessage: validators_base.resolveErrorMessage(message, `Number must be less than ${value}`),
+            jsonSchema: { ...this.config.jsonSchema, exclusiveMaximum: value }
+        });
+    }
+    /**
+     * Create a new validator with greater than or equal constraint
+     * Zod 4 API parity - alias for min()
+     */
+    gte(value, message) {
+        return this.min(value, message);
+    }
+    /**
+     * Create a new validator with less than or equal constraint
+     * Zod 4 API parity - alias for max()
+     */
+    lte(value, message) {
+        return this.max(value, message);
+    }
+    /**
+     * Create a validator for unsigned 32-bit integers
+     * Range: 0 to 4,294,967,295
+     */
+    uint32(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => Number.isSafeInteger(v) && v >= 0 && v <= 4294967295],
+            errorMessage: validators_base.resolveErrorMessage(message, 'Expected an unsigned 32-bit integer'),
+            jsonSchema: { ...this.config.jsonSchema, type: 'integer', minimum: 0, maximum: 4294967295 }
+        });
+    }
+    /**
+     * Create a validator for unsigned 64-bit integers
+     * Range: 0 to 2^53-1 (safe integer limit)
+     */
+    uint64(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => Number.isSafeInteger(v) && v >= 0],
+            errorMessage: validators_base.resolveErrorMessage(message, 'Expected an unsigned 64-bit integer'),
+            jsonSchema: { ...this.config.jsonSchema, type: 'integer', minimum: 0 }
+        });
+    }
+    /**
+     * Create a validator for signed 32-bit integers
+     * Range: -2,147,483,648 to 2,147,483,647
+     */
+    int32(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => Number.isSafeInteger(v) && v >= -2147483648 && v <= 2147483647],
+            errorMessage: validators_base.resolveErrorMessage(message, 'Expected a signed 32-bit integer'),
+            jsonSchema: { ...this.config.jsonSchema, type: 'integer', minimum: -2147483648, maximum: 2147483647 }
+        });
+    }
+    /**
+     * Create a validator for signed 64-bit integers
+     * Range: -(2^53-1) to 2^53-1 (safe integer limit)
+     */
+    int64(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => Number.isSafeInteger(v)],
+            errorMessage: validators_base.resolveErrorMessage(message, 'Expected a signed 64-bit integer'),
+            jsonSchema: { ...this.config.jsonSchema, type: 'integer' }
+        });
+    }
+    /**
+     * Create a validator for 32-bit floats (IEEE 754 single precision)
+     * Range: -3.4e38 to 3.4e38, precision ~7 decimal digits
+     */
+    float32(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => Number.isFinite(v) && Math.abs(v) <= 3.4e38],
+            errorMessage: validators_base.resolveErrorMessage(message, 'Expected a 32-bit float'),
+            jsonSchema: { ...this.config.jsonSchema, minimum: -34e37, maximum: 3.4e38 }
+        });
+    }
+    /**
+     * Create a validator for 64-bit floats (IEEE 754 double precision)
+     * Alias for standard number validation
+     */
+    float64(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => Number.isFinite(v)],
+            errorMessage: validators_base.resolveErrorMessage(message, 'Expected a 64-bit float'),
+            jsonSchema: this.config.jsonSchema
+        });
+    }
+}
+
+exports.VldNumber = VldNumber;