@oxog/vld 2.0.3 → 2.1.0

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,111 +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?: string): VldNumber;
+    uint32(message?: ErrorParam): VldNumber;
     /**
      * Create a validator for unsigned 64-bit integers
      * Range: 0 to 2^53-1 (safe integer limit)
      */
-    uint64(message?: string): VldNumber;
+    uint64(message?: ErrorParam): VldNumber;
     /**
      * Create a validator for signed 32-bit integers
      * Range: -2,147,483,648 to 2,147,483,647
      */
-    int32(message?: string): VldNumber;
+    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?: string): VldNumber;
+    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?: string): VldNumber;
+    float32(message?: ErrorParam): VldNumber;
     /**
      * Create a validator for 64-bit floats (IEEE 754 double precision)
      * Alias for standard number validation
      */
-    float64(message?: string): VldNumber;
+    float64(message?: ErrorParam): VldNumber;
 }
 export {};
-//# sourceMappingURL=number.d.ts.map