@oxog/vld 2.0.2 → 2.1.0

package/dist/validators/map.js

@@ -0,0 +1,214 @@
+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 createMapError(message) {
+    return new VldError([{ code: 'invalid_type', path: [], message }]);
+}
+/**
+ * Immutable Map validator
+ */
+class VldMap extends VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(keyValidator, valueValidator, errorMessage) {
+        super(VLD_VALIDATOR_TYPES.MAP);
+        this.keyValidator = keyValidator;
+        this.valueValidator = valueValidator;
+        this.errorMessage = errorMessage;
+        this._simpleKeyMode = this.getSimpleItemMode(keyValidator);
+        this._simpleValueMode = this.getSimpleItemMode(valueValidator);
+        this._simpleKeyValue = this._simpleKeyMode === 'literal' ? keyValidator.literal : undefined;
+        this._simpleValueValue = this._simpleValueMode === 'literal' ? valueValidator.literal : undefined;
+    }
+    get keySchema() {
+        return this.keyValidator;
+    }
+    get valueSchema() {
+        return this.valueValidator;
+    }
+    /**
+     * Create a new Map validator
+     */
+    static create(keyValidator, valueValidator) {
+        return new VldMap(keyValidator, valueValidator);
+    }
+    getSimpleItemMode(validator) {
+        if (validator.isSimple !== true) {
+            return undefined;
+        }
+        switch (validator.validatorType) {
+            case VLD_VALIDATOR_TYPES.STRING:
+                return 'string';
+            case VLD_VALIDATOR_TYPES.NUMBER:
+                return 'number';
+            case VLD_VALIDATOR_TYPES.BOOLEAN:
+                return 'boolean';
+            case VLD_VALIDATOR_TYPES.BIGINT:
+                return 'bigint';
+            case VLD_VALIDATOR_TYPES.SYMBOL:
+                return 'symbol';
+            case VLD_VALIDATOR_TYPES.NULL:
+                return 'null';
+            case VLD_VALIDATOR_TYPES.UNDEFINED:
+            case VLD_VALIDATOR_TYPES.VOID:
+                return 'undefinedValue';
+            case VLD_VALIDATOR_TYPES.LITERAL:
+                return 'literal';
+            case VLD_VALIDATOR_TYPES.ANY:
+            case VLD_VALIDATOR_TYPES.UNKNOWN:
+                return 'passthrough';
+            default:
+                return undefined;
+        }
+    }
+    getSimpleItemError(mode, expected, received) {
+        switch (mode) {
+            case 'string':
+                return getMessages().invalidString;
+            case 'number':
+                return getMessages().invalidNumber;
+            case 'boolean':
+                return getMessages().invalidBoolean;
+            case 'bigint':
+                return getMessages().invalidBigint;
+            case 'symbol':
+                return getMessages().invalidSymbol;
+            case 'null':
+                return `Expected null, received ${typeof received}`;
+            case 'undefinedValue':
+                return getMessages().expectedUndefined;
+            case 'literal':
+                return getMessages().literalExpected(JSON.stringify(expected), JSON.stringify(received));
+            default:
+                return getMessages().invalidMap;
+        }
+    }
+    parseSimpleItem(mode, expected, value) {
+        switch (mode) {
+            case 'string':
+                if (typeof value !== 'string') {
+                    throw new Error(this.getSimpleItemError(mode, expected, value));
+                }
+                return value;
+            case 'number':
+                if (typeof value !== 'number' || isNaN(value)) {
+                    throw new Error(this.getSimpleItemError(mode, expected, value));
+                }
+                return value;
+            case 'boolean':
+                if (typeof value !== 'boolean') {
+                    throw new Error(this.getSimpleItemError(mode, expected, value));
+                }
+                return value;
+            case 'bigint':
+                if (typeof value !== 'bigint') {
+                    throw new Error(this.getSimpleItemError(mode, expected, value));
+                }
+                return value;
+            case 'symbol':
+                if (typeof value !== 'symbol') {
+                    throw new Error(this.getSimpleItemError(mode, expected, value));
+                }
+                return value;
+            case 'null':
+                if (value !== null) {
+                    throw new Error(this.getSimpleItemError(mode, expected, value));
+                }
+                return null;
+            case 'undefinedValue':
+                if (value !== undefined) {
+                    throw new Error(this.getSimpleItemError(mode, expected, value));
+                }
+                return undefined;
+            case 'literal':
+                if (value !== expected) {
+                    throw new Error(this.getSimpleItemError(mode, expected, value));
+                }
+                return expected;
+            case 'passthrough':
+                return value;
+        }
+    }
+    /**
+     * Parse and validate a Map value
+     */
+    parse(value) {
+        if (!(value instanceof Map)) {
+            throw new Error(this.errorMessage || getMessages().invalidMap);
+        }
+        return this.parseKnownMap(value);
+    }
+    /**
+     * Parse a value that has already passed the Map instance guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownMap(value) {
+        const result = new Map();
+        const simpleKeyMode = this._simpleKeyMode;
+        const simpleValueMode = this._simpleValueMode;
+        if (simpleKeyMode === 'string' && simpleValueMode === 'number') {
+            for (const [key, val] of value) {
+                if (typeof key !== 'string') {
+                    throw new Error(this.getSimpleItemError(simpleKeyMode, this._simpleKeyValue, key));
+                }
+                if (typeof val !== 'number' || isNaN(val)) {
+                    throw new Error(this.getSimpleItemError(simpleValueMode, this._simpleValueValue, val));
+                }
+                result.set(key, val);
+            }
+            return result;
+        }
+        if (simpleKeyMode === 'string' && simpleValueMode === 'string') {
+            for (const [key, val] of value) {
+                if (typeof key !== 'string') {
+                    throw new Error(this.getSimpleItemError(simpleKeyMode, this._simpleKeyValue, key));
+                }
+                if (typeof val !== 'string') {
+                    throw new Error(this.getSimpleItemError(simpleValueMode, this._simpleValueValue, val));
+                }
+                result.set(key, val);
+            }
+            return result;
+        }
+        if (simpleKeyMode !== undefined && simpleValueMode !== undefined) {
+            const keyMode = simpleKeyMode;
+            const valueMode = simpleValueMode;
+            for (const [key, val] of value) {
+                const validKey = this.parseSimpleItem(keyMode, this._simpleKeyValue, key);
+                const validValue = this.parseSimpleItem(valueMode, this._simpleValueValue, val);
+                result.set(validKey, validValue);
+            }
+            return result;
+        }
+        for (const [key, val] of value) {
+            try {
+                const validKey = simpleKeyMode === undefined
+                    ? this.keyValidator.parse(key)
+                    : this.parseSimpleItem(simpleKeyMode, this._simpleKeyValue, key);
+                const validValue = simpleValueMode === undefined
+                    ? this.valueValidator.parse(val)
+                    : this.parseSimpleItem(simpleValueMode, this._simpleValueValue, val);
+                result.set(validKey, validValue);
+            }
+            catch (error) {
+                throw new Error(error.message);
+            }
+        }
+        return result;
+    }
+    /**
+     * Safely parse and validate a Map value
+     */
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: createMapError(error.message) };
+        }
+    }
+}
+
+export { VldMap };

package/dist/validators/nan.d.ts

@@ -2,8 +2,8 @@
  * VldNan - Validates that a value is NaN (Not a Number)
  * Part of Zod 4 API parity implementation
  */
-import { VldBase } from './base';
-import type { ParseResult } from './base';
+import { VldBase } from './base.js';
+import type { ParseResult } from './base.js';
 /**
  * NaN validator - validates that a value is NaN
  * Note: Uses Number.isNaN() which is more strict than global isNaN()
@@ -14,4 +14,3 @@ export declare class VldNan extends VldBase<unknown, number> {
     parse(value: unknown): number;
     safeParse(value: unknown): ParseResult<number>;
 }
-//# sourceMappingURL=nan.d.ts.map

package/dist/validators/nan.js

@@ -0,0 +1,38 @@
+import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
+import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
+
+/**
+ * VldNan - Validates that a value is NaN (Not a Number)
+ * Part of Zod 4 API parity implementation
+ */
+function createNanError(message) {
+    return new VldError([{ code: 'invalid_number', path: [], message }]);
+}
+/**
+ * NaN validator - validates that a value is NaN
+ * Note: Uses Number.isNaN() which is more strict than global isNaN()
+ */
+class VldNan extends VldBase {
+    constructor() {
+        super(VLD_VALIDATOR_TYPES.NAN);
+    }
+    static create() {
+        return new VldNan();
+    }
+    parse(value) {
+        if (typeof value !== 'number' || !Number.isNaN(value)) {
+            throw new Error(`Expected NaN, received ${typeof value === 'number' ? 'a valid number' : typeof value}`);
+        }
+        return value;
+    }
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: createNanError(error.message) };
+        }
+    }
+}
+
+export { VldNan };

package/dist/validators/never.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Validator that never succeeds
  */
@@ -16,4 +16,3 @@ export declare class VldNever extends VldBase<never, never> {
      */
     safeParse(_value: unknown): ParseResult<never>;
 }
-//# sourceMappingURL=never.d.ts.map

package/dist/validators/never.js

@@ -0,0 +1,32 @@
+import { VldBase } from './base.js';
+import { getMessages } from '../locales/runtime.js';
+import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
+
+/**
+ * Validator that never succeeds
+ */
+class VldNever extends VldBase {
+    /**
+     * Create a new never validator
+     */
+    static create() {
+        return new VldNever();
+    }
+    /**
+     * Parse never value (always fails)
+     */
+    parse(_value) {
+        throw new Error(getMessages().neverType);
+    }
+    /**
+     * Safely parse never value (always fails)
+     */
+    safeParse(_value) {
+        return {
+            success: false,
+            error: new VldError([{ code: 'invalid_type', path: [], message: getMessages().neverType }])
+        };
+    }
+}
+
+export { VldNever };

package/dist/validators/null.d.ts

@@ -2,15 +2,15 @@
  * VldNull - Validates that a value is exactly null
  * Part of Zod 4 API parity implementation
  */
-import { VldBase } from './base';
-import type { ParseResult } from './base';
+import { VldBase } from './base.js';
+import type { ParseResult } from './base.js';
 /**
  * Null validator - validates that a value is exactly null
  */
 export declare class VldNull extends VldBase<unknown, null> {
     private constructor();
     static create(): VldNull;
+    get isSimple(): boolean;
     parse(value: unknown): null;
     safeParse(value: unknown): ParseResult<null>;
 }
-//# sourceMappingURL=null.d.ts.map

package/dist/validators/null.js

@@ -0,0 +1,40 @@
+import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
+import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
+
+/**
+ * VldNull - Validates that a value is exactly null
+ * Part of Zod 4 API parity implementation
+ */
+function createNullError(message) {
+    return new VldError([{ code: 'invalid_type', path: [], message }]);
+}
+/**
+ * Null validator - validates that a value is exactly null
+ */
+class VldNull extends VldBase {
+    constructor() {
+        super(VLD_VALIDATOR_TYPES.NULL);
+    }
+    static create() {
+        return new VldNull();
+    }
+    get isSimple() {
+        return true;
+    }
+    parse(value) {
+        if (value !== null) {
+            throw new Error(`Expected null, received ${typeof value}`);
+        }
+        return null;
+    }
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: createNullError(error.message) };
+        }
+    }
+}
+
+export { VldNull };

package/dist/validators/number.d.ts

@@ -1,24 +1,48 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult, ValidatorType, type ErrorParam } from './base.js';
 /**
  * Type for number validation check functions
  */
 type NumberCheck = (value: number) => boolean;
+interface NumberJSONSchemaHints {
+    type?: 'number' | 'integer';
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    multipleOf?: number;
+}
 /**
  * Configuration for number validator
  */
 interface NumberValidatorConfig {
     readonly checks: ReadonlyArray<NumberCheck>;
-    readonly errorMessage?: string;
+    readonly errorMessage: string | undefined;
+    readonly validatorType?: ValidatorType;
+    readonly jsonSchema: NumberJSONSchemaHints | undefined;
 }
 /**
  * Immutable number validator with chainable methods
  */
 export declare class VldNumber extends VldBase<number, number> {
     protected readonly config: NumberValidatorConfig;
+    private readonly _checks;
+    private readonly _isSimple;
+    private readonly _fastCheckMode;
     /**
      * Protected constructor to allow extension while maintaining immutability
      */
     protected constructor(config?: Partial<NumberValidatorConfig>);
+    private detectFastCheckMode;
+    /**
+     * Returns true if this validator has custom checks (min, max, positive, etc.)
+     * Used by VldObject for optimized fast-path dispatch
+     */
+    get hasCustomChecks(): boolean;
+    /**
+     * Returns true if this is a simple number validator with no custom checks
+     * Used by VldObject for optimized fast-path dispatch
+     */
+    get isSimple(): boolean;
     /**
      * Create a new number validator
      */
@@ -27,6 +51,12 @@ export declare class VldNumber extends VldBase<number, number> {
      * Parse and validate a number value
      */
     parse(value: unknown): number;
+    /**
+     * Parse a value that has already passed the number type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownNumber(value: number): number;
+    private passesChecks;
     /**
      * Safely parse and validate a number value
      */
@@ -34,81 +64,110 @@ export declare class VldNumber extends VldBase<number, number> {
     /**
      * Create a new validator with minimum value constraint
      */
-    min(value: number, message?: string): VldNumber;
+    min(value: number, message?: ErrorParam): VldNumber;
     /**
      * Create a new validator with maximum value constraint
      */
-    max(value: number, message?: string): VldNumber;
+    max(value: number, message?: ErrorParam): VldNumber;
     /**
      * Create a new validator that checks for integer values
      */
-    int(message?: string): VldNumber;
+    int(message?: ErrorParam): VldNumber;
     /**
      * Create a new validator that checks for positive values
      */
-    positive(message?: string): VldNumber;
+    positive(message?: ErrorParam): VldNumber;
     /**
      * Create a new validator that checks for negative values
      */
-    negative(message?: string): VldNumber;
+    negative(message?: ErrorParam): VldNumber;
     /**
      * Create a new validator that checks for non-negative values
      */
-    nonnegative(message?: string): VldNumber;
+    nonnegative(message?: ErrorParam): VldNumber;
     /**
      * Create a new validator that checks for non-positive values
      */
-    nonpositive(message?: string): VldNumber;
+    nonpositive(message?: ErrorParam): VldNumber;
     /**
      * Create a new validator that checks for finite values
      */
-    finite(message?: string): VldNumber;
+    finite(message?: ErrorParam): VldNumber;
     /**
      * Create a new validator that checks for safe integer values
      */
-    safe(message?: string): VldNumber;
+    safe(message?: ErrorParam): VldNumber;
     /**
      * Create a new validator that checks if value is multiple of another
      */
-    multipleOf(value: number, message?: string): VldNumber;
+    multipleOf(value: number, message?: ErrorParam): VldNumber;
     /**
      * Alias for multipleOf
      */
-    step(value: number, message?: string): VldNumber;
+    step(value: number, message?: ErrorParam): VldNumber;
     /**
      * Create a new validator with a range constraint
      */
-    between(min: number, max: number, message?: string): VldNumber;
+    between(min: number, max: number, message?: ErrorParam): VldNumber;
     /**
      * Create a new validator that checks for even numbers
      * BUG-011 FIX: Require integers for even/odd validation (more mathematically correct)
      */
-    even(message?: string): VldNumber;
+    even(message?: ErrorParam): VldNumber;
     /**
      * Create a new validator that checks for odd numbers
      * BUG-011 FIX: Require integers for even/odd validation (more mathematically correct)
      */
-    odd(message?: string): VldNumber;
+    odd(message?: ErrorParam): VldNumber;
     /**
      * Create a new validator with strict greater than constraint
      * Zod 4 API parity - strictly greater than (not equal to)
      */
-    gt(value: number, message?: string): VldNumber;
+    gt(value: number, message?: ErrorParam): VldNumber;
     /**
      * Create a new validator with strict less than constraint
      * Zod 4 API parity - strictly less than (not equal to)
      */
-    lt(value: number, message?: string): VldNumber;
+    lt(value: number, message?: ErrorParam): VldNumber;
     /**
      * Create a new validator with greater than or equal constraint
      * Zod 4 API parity - alias for min()
      */
-    gte(value: number, message?: string): VldNumber;
+    gte(value: number, message?: ErrorParam): VldNumber;
     /**
      * Create a new validator with less than or equal constraint
      * Zod 4 API parity - alias for max()
      */
-    lte(value: number, message?: string): VldNumber;
+    lte(value: number, message?: ErrorParam): VldNumber;
+    /**
+     * Create a validator for unsigned 32-bit integers
+     * Range: 0 to 4,294,967,295
+     */
+    uint32(message?: ErrorParam): VldNumber;
+    /**
+     * Create a validator for unsigned 64-bit integers
+     * Range: 0 to 2^53-1 (safe integer limit)
+     */
+    uint64(message?: ErrorParam): VldNumber;
+    /**
+     * Create a validator for signed 32-bit integers
+     * Range: -2,147,483,648 to 2,147,483,647
+     */
+    int32(message?: ErrorParam): VldNumber;
+    /**
+     * Create a validator for signed 64-bit integers
+     * Range: -(2^53-1) to 2^53-1 (safe integer limit)
+     */
+    int64(message?: ErrorParam): VldNumber;
+    /**
+     * Create a validator for 32-bit floats (IEEE 754 single precision)
+     * Range: -3.4e38 to 3.4e38, precision ~7 decimal digits
+     */
+    float32(message?: ErrorParam): VldNumber;
+    /**
+     * Create a validator for 64-bit floats (IEEE 754 double precision)
+     * Alias for standard number validation
+     */
+    float64(message?: ErrorParam): VldNumber;
 }
 export {};
-//# sourceMappingURL=number.d.ts.map