@oxog/vld 2.0.2 → 2.1.0

package/dist/{chunks/date-ODue_rtq.js → cjs/coercion/index.cjs}

@@ -1,13 +1,25 @@
-import { V as VldString, t as getMessages, u as isValidIPv6, a as VldNumber, b as VldBoolean, c as VldDate } from './bigint-DgsCr2dC.js';
+'use strict';
+
+var validators_string = require('../chunks/string-BKZrc4hs.cjs');
+var validators_base = require('../validators/base.cjs');
+var locales_runtime = require('../locales/runtime.cjs');
+var validators_number = require('../validators/number.cjs');
+var validators_boolean = require('../validators/boolean.cjs');
+var validators_date = require('../validators/date.cjs');
+var validators_bigint = require('../validators/bigint.cjs');
+require('../chunks/errors-core-DWxLFs2f.cjs');
+require('../registry.cjs');
+require('../locales/en.cjs');
 
 // BUG-NEW-001 FIX: IPv6 validation moved to shared utility (src/utils/ip-validation.ts)
 // to eliminate code duplication between string.ts and coercion/string.ts
 /**
  * String coercion validator that attempts to convert values to strings
  */
-class VldCoerceString extends VldString {
+class VldCoerceString extends validators_string.VldString {
     constructor(config) {
-        super(config);
+        // Pass COERCE_STRING type to base class instead of STRING
+        super({ ...config, validatorType: validators_base.VLD_VALIDATOR_TYPES.COERCE_STRING });
     }
     /**
      * Create a new coerce string validator
@@ -20,21 +32,21 @@ class VldCoerceString extends VldString {
         return new VldCoerceString({
             checks: [...this.config.checks, (v) => v.length >= length],
             transforms: this.config.transforms,
-            errorMessage: message || getMessages().stringMin(length)
+            errorMessage: message || locales_runtime.getMessages().stringMin(length)
         });
     }
     max(length, message) {
         return new VldCoerceString({
             checks: [...this.config.checks, (v) => v.length <= length],
             transforms: this.config.transforms,
-            errorMessage: message || getMessages().stringMax(length)
+            errorMessage: message || locales_runtime.getMessages().stringMax(length)
         });
     }
     length(length, message) {
         return new VldCoerceString({
             checks: [...this.config.checks, (v) => v.length === length],
             transforms: this.config.transforms,
-            errorMessage: message || getMessages().stringLength(length)
+            errorMessage: message || locales_runtime.getMessages().stringLength(length)
         });
     }
     email(message) {
@@ -43,28 +55,28 @@ class VldCoerceString extends VldString {
         return new VldCoerceString({
             checks: [...this.config.checks, (v) => FAST_EMAIL_REGEX.test(v)],
             transforms: this.config.transforms,
-            errorMessage: message || getMessages().stringEmail
+            errorMessage: message || locales_runtime.getMessages().stringEmail
         });
     }
     url(message) {
         return new VldCoerceString({
             checks: [...this.config.checks, (v) => /^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&//=]*)$/.test(v)],
             transforms: this.config.transforms,
-            errorMessage: message || getMessages().stringUrl
+            errorMessage: message || locales_runtime.getMessages().stringUrl
         });
     }
     uuid(message) {
         return new VldCoerceString({
             checks: [...this.config.checks, (v) => /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(v)],
             transforms: this.config.transforms,
-            errorMessage: message || getMessages().stringUuid
+            errorMessage: message || locales_runtime.getMessages().stringUuid
         });
     }
     regex(pattern, message) {
         return new VldCoerceString({
             checks: [...this.config.checks, (v) => pattern.test(v)],
             transforms: this.config.transforms,
-            errorMessage: message || getMessages().stringRegex
+            errorMessage: message || locales_runtime.getMessages().stringRegex
         });
     }
     trim() {
@@ -92,21 +104,21 @@ class VldCoerceString extends VldString {
         return new VldCoerceString({
             checks: [...this.config.checks, (v) => v.startsWith(str)],
             transforms: this.config.transforms,
-            errorMessage: message || getMessages().stringStartsWith(str)
+            errorMessage: message || locales_runtime.getMessages().stringStartsWith(str)
         });
     }
     endsWith(str, message) {
         return new VldCoerceString({
             checks: [...this.config.checks, (v) => v.endsWith(str)],
             transforms: this.config.transforms,
-            errorMessage: message || getMessages().stringEndsWith(str)
+            errorMessage: message || locales_runtime.getMessages().stringEndsWith(str)
         });
     }
     includes(str, message) {
         return new VldCoerceString({
             checks: [...this.config.checks, (v) => v.includes(str)],
             transforms: this.config.transforms,
-            errorMessage: message || getMessages().stringIncludes(str)
+            errorMessage: message || locales_runtime.getMessages().stringIncludes(str)
         });
     }
     ip(message) {
@@ -116,34 +128,34 @@ class VldCoerceString extends VldString {
                     // Prevent ReDoS: Check length before validation
                     if (v.length > 100)
                         return false;
-                    return ipv4.test(v) || isValidIPv6(v);
+                    return ipv4.test(v) || validators_string.isValidIPv6(v);
                 }],
             transforms: this.config.transforms,
-            errorMessage: message || getMessages().stringIp
+            errorMessage: message || locales_runtime.getMessages().stringIp
         });
     }
     ipv4(message) {
         return new VldCoerceString({
             checks: [...this.config.checks, (v) => /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(v)],
             transforms: this.config.transforms,
-            errorMessage: message || getMessages().stringIpv4
+            errorMessage: message || locales_runtime.getMessages().stringIpv4
         });
     }
     ipv6(message) {
         return new VldCoerceString({
             checks: [...this.config.checks, (v) => {
                     // Use safe IPv6 validation to prevent ReDoS attacks
-                    return isValidIPv6(v);
+                    return validators_string.isValidIPv6(v);
                 }],
             transforms: this.config.transforms,
-            errorMessage: message || getMessages().stringIpv6
+            errorMessage: message || locales_runtime.getMessages().stringIpv6
         });
     }
     nonempty(message) {
         return new VldCoerceString({
             checks: [...this.config.checks, (v) => v.length > 0],
             transforms: this.config.transforms,
-            errorMessage: message || getMessages().stringEmpty
+            errorMessage: message || locales_runtime.getMessages().stringEmpty
         });
     }
     /**
@@ -154,7 +166,7 @@ class VldCoerceString extends VldString {
         if (typeof value === 'string') {
             // Enforce length limits to prevent DoS
             if (value.length > 1000000) {
-                throw new Error(getMessages().coercionFailed('string', value));
+                throw new Error(locales_runtime.getMessages().coercionFailed('string', value));
             }
             // Sanitize control characters for security
             // Remove characters that could cause issues in logs, databases, or UI
@@ -163,10 +175,6 @@ class VldCoerceString extends VldString {
             // Use parent validation with sanitized string
             return super.parse(sanitized);
         }
-        // Handle null and undefined explicitly
-        if (value === null || value === undefined) {
-            throw new Error(getMessages().coercionFailed('string', value));
-        }
         // Safe type coercion with security measures
         let coerced;
         if (typeof value === 'number') {
@@ -182,8 +190,8 @@ class VldCoerceString extends VldString {
             coerced = value.toString();
         }
         else if (typeof value === 'symbol') {
-            // Symbols: explicit error to prevent potential issues
-            throw new Error(getMessages().coercionFailed('string', value));
+            // Symbols: String() matches Zod coercion semantics without throwing.
+            coerced = String(value);
         }
         else if (typeof value === 'object') {
             // Objects: only allow specific safe object types
@@ -215,7 +223,7 @@ class VldCoerceString extends VldString {
         // Apply security controls
         // Enforce length limits to prevent DoS
         if (coerced.length > 1000000) {
-            throw new Error(getMessages().coercionFailed('string', value));
+            throw new Error(locales_runtime.getMessages().coercionFailed('string', value));
         }
         // Sanitize control characters for security
         // Remove characters that could cause issues in logs, databases, or UI
@@ -240,9 +248,9 @@ class VldCoerceString extends VldString {
 /**
  * Number coercion validator that attempts to convert values to numbers
  */
-class VldCoerceNumber extends VldNumber {
+class VldCoerceNumber extends validators_number.VldNumber {
     constructor(config) {
-        super(config);
+        super({ ...config, validatorType: validators_base.VLD_VALIDATOR_TYPES.COERCE_NUMBER });
     }
     /**
      * Create a new coerce number validator
@@ -254,55 +262,55 @@ class VldCoerceNumber extends VldNumber {
     min(value, message) {
         return new VldCoerceNumber({
             checks: [...this.config.checks, (v) => v >= value],
-            errorMessage: message || getMessages().numberMin(value)
+            errorMessage: message || locales_runtime.getMessages().numberMin(value)
         });
     }
     max(value, message) {
         return new VldCoerceNumber({
             checks: [...this.config.checks, (v) => v <= value],
-            errorMessage: message || getMessages().numberMax(value)
+            errorMessage: message || locales_runtime.getMessages().numberMax(value)
         });
     }
     int(message) {
         return new VldCoerceNumber({
             checks: [...this.config.checks, (v) => Number.isInteger(v)],
-            errorMessage: message || getMessages().numberInt
+            errorMessage: message || locales_runtime.getMessages().numberInt
         });
     }
     positive(message) {
         return new VldCoerceNumber({
             checks: [...this.config.checks, (v) => v > 0],
-            errorMessage: message || getMessages().numberPositive
+            errorMessage: message || locales_runtime.getMessages().numberPositive
         });
     }
     negative(message) {
         return new VldCoerceNumber({
             checks: [...this.config.checks, (v) => v < 0],
-            errorMessage: message || getMessages().numberNegative
+            errorMessage: message || locales_runtime.getMessages().numberNegative
         });
     }
     nonnegative(message) {
         return new VldCoerceNumber({
             checks: [...this.config.checks, (v) => v >= 0],
-            errorMessage: message || getMessages().numberNonnegative
+            errorMessage: message || locales_runtime.getMessages().numberNonnegative
         });
     }
     nonpositive(message) {
         return new VldCoerceNumber({
             checks: [...this.config.checks, (v) => v <= 0],
-            errorMessage: message || getMessages().numberNonpositive
+            errorMessage: message || locales_runtime.getMessages().numberNonpositive
         });
     }
     finite(message) {
         return new VldCoerceNumber({
             checks: [...this.config.checks, (v) => Number.isFinite(v)],
-            errorMessage: message || getMessages().numberFinite
+            errorMessage: message || locales_runtime.getMessages().numberFinite
         });
     }
     safe(message) {
         return new VldCoerceNumber({
             checks: [...this.config.checks, (v) => Number.isSafeInteger(v)],
-            errorMessage: message || getMessages().numberSafe
+            errorMessage: message || locales_runtime.getMessages().numberSafe
         });
     }
     multipleOf(value, message) {
@@ -312,7 +320,7 @@ class VldCoerceNumber extends VldNumber {
                     const remainder = Math.abs(v % value);
                     return remainder < Number.EPSILON || Math.abs(remainder - Math.abs(value)) < Number.EPSILON;
                 }],
-            errorMessage: message || getMessages().numberMultipleOf(value)
+            errorMessage: message || locales_runtime.getMessages().numberMultipleOf(value)
         });
     }
     step(value, message) {
@@ -354,30 +362,23 @@ class VldCoerceNumber extends VldNumber {
     parse(value) {
         // If it's already a valid number, use parent validation directly
         if (typeof value === 'number' && !isNaN(value)) {
+            if (this.config.checks.length === 0) {
+                return value;
+            }
             return super.parse(value);
         }
         let coerced;
-        if (typeof value === 'string') {
-            const trimmed = value.trim();
-            if (trimmed === '') {
-                throw new Error(getMessages().coercionFailed('number', value));
-            }
-            coerced = Number(trimmed);
-            if (isNaN(coerced)) {
-                throw new Error(getMessages().coercionFailed('number', value));
-            }
+        try {
+            coerced = Number(value);
         }
-        else if (typeof value === 'boolean') {
-            coerced = value ? 1 : 0;
+        catch {
+            throw new Error(locales_runtime.getMessages().coercionFailed('number', value));
         }
-        else if (value === null || value === undefined) {
-            throw new Error(getMessages().coercionFailed('number', value));
+        if (isNaN(coerced)) {
+            throw new Error(locales_runtime.getMessages().coercionFailed('number', value));
         }
-        else {
-            coerced = Number(value);
-            if (isNaN(coerced)) {
-                throw new Error(getMessages().coercionFailed('number', value));
-            }
+        if (this.config.checks.length === 0) {
+            return coerced;
         }
         // Use parent validation with coerced value
         return super.parse(coerced);
@@ -398,46 +399,21 @@ class VldCoerceNumber extends VldNumber {
 /**
  * Boolean coercion validator that attempts to convert values to booleans
  */
-class VldCoerceBoolean extends VldBoolean {
+class VldCoerceBoolean extends validators_boolean.VldBoolean {
     /**
      * Create a new coerce boolean validator
      */
     static create() {
         return new VldCoerceBoolean();
     }
+    constructor() {
+        super(undefined, validators_base.VLD_VALIDATOR_TYPES.COERCE_BOOLEAN);
+    }
     /**
      * Parse and coerce a value to boolean
      */
     parse(value) {
-        // Handle string values
-        if (typeof value === 'string') {
-            const lower = value.toLowerCase().trim();
-            if (lower === 'true' || lower === '1' || lower === 'yes' || lower === 'on') {
-                return true;
-            }
-            if (lower === 'false' || lower === '0' || lower === 'no' || lower === 'off') {
-                return false;
-            }
-            throw new Error(getMessages().coercionFailed('boolean', value));
-        }
-        // Handle number values
-        if (typeof value === 'number') {
-            if (value === 1)
-                return true;
-            if (value === 0)
-                return false;
-            throw new Error(getMessages().coercionFailed('boolean', value));
-        }
-        // Handle null and undefined
-        if (value === null || value === undefined) {
-            throw new Error(getMessages().coercionFailed('boolean', value));
-        }
-        // Handle actual boolean values
-        if (typeof value === 'boolean') {
-            return value;
-        }
-        // Reject all other unsupported types (objects, arrays, etc.)
-        throw new Error(getMessages().coercionFailed('boolean', value));
+        return Boolean(value);
     }
     /**
      * Safely parse and coerce a value to boolean
@@ -455,38 +431,35 @@ class VldCoerceBoolean extends VldBoolean {
 /**
  * Date coercion validator that attempts to convert values to dates
  */
-class VldCoerceDate extends VldDate {
+class VldCoerceDate extends validators_date.VldDate {
     /**
      * Create a new coerce date validator
      */
     static create() {
         return new VldCoerceDate();
     }
+    constructor() {
+        super({ validatorType: validators_base.VLD_VALIDATOR_TYPES.COERCE_DATE });
+    }
     /**
      * Parse and coerce a value to date
      */
     parse(value) {
         try {
-            // Handle string and number values
-            if (typeof value === 'string' || typeof value === 'number') {
-                const date = new Date(value);
-                if (isNaN(date.getTime())) {
-                    throw new Error(getMessages().coercionFailed('date', value));
-                }
-                return super.parse(date);
+            if (value instanceof Date) {
+                return super.parse(value);
             }
-            // Handle null and undefined
-            if (value === null || value === undefined) {
-                throw new Error(getMessages().coercionFailed('date', value));
+            const date = new Date(value);
+            if (isNaN(date.getTime())) {
+                throw new Error(locales_runtime.getMessages().coercionFailed('date', value));
             }
-            // Use parent validation for actual dates
-            return super.parse(value);
+            return super.parse(date);
         }
         catch (error) {
             if (error.message.includes('Cannot coerce')) {
                 throw error;
             }
-            throw new Error(getMessages().coercionFailed('date', value));
+            throw new Error(locales_runtime.getMessages().coercionFailed('date', value));
         }
     }
     /**
@@ -502,5 +475,114 @@ class VldCoerceDate extends VldDate {
     }
 }
 
-export { VldCoerceDate as V, VldCoerceBoolean as a, VldCoerceNumber as b, VldCoerceString as c };
-//# sourceMappingURL=date-ODue_rtq.js.map
+/**
+ * BigInt coercion validator that attempts to convert values to bigint
+ */
+class VldCoerceBigInt extends validators_bigint.VldBigInt {
+    constructor(config) {
+        super({ ...config, validatorType: validators_base.VLD_VALIDATOR_TYPES.COERCE_BIGINT });
+    }
+    /**
+     * Create a new coerce bigint validator
+     */
+    static create() {
+        return new VldCoerceBigInt();
+    }
+    // Override all chain methods to return VldCoerceBigInt instances
+    min(value, message) {
+        return new VldCoerceBigInt({
+            checks: [...this.config.checks, (v) => v >= value],
+            errorMessage: message || `BigInt must be at least ${value}`
+        });
+    }
+    max(value, message) {
+        return new VldCoerceBigInt({
+            checks: [...this.config.checks, (v) => v <= value],
+            errorMessage: message || `BigInt must be at most ${value}`
+        });
+    }
+    positive(message) {
+        return new VldCoerceBigInt({
+            checks: [...this.config.checks, (v) => v > 0n],
+            errorMessage: message || 'BigInt must be positive'
+        });
+    }
+    negative(message) {
+        return new VldCoerceBigInt({
+            checks: [...this.config.checks, (v) => v < 0n],
+            errorMessage: message || 'BigInt must be negative'
+        });
+    }
+    nonnegative(message) {
+        return new VldCoerceBigInt({
+            checks: [...this.config.checks, (v) => v >= 0n],
+            errorMessage: message || 'BigInt must be non-negative'
+        });
+    }
+    nonpositive(message) {
+        return new VldCoerceBigInt({
+            checks: [...this.config.checks, (v) => v <= 0n],
+            errorMessage: message || 'BigInt must be non-positive'
+        });
+    }
+    /**
+     * Parse and coerce a value to bigint
+     */
+    parse(value) {
+        // If it's already a bigint, use parent validation directly
+        if (typeof value === 'bigint') {
+            return super.parse(value);
+        }
+        // Handle string values
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            if (trimmed === '') {
+                throw new Error(locales_runtime.getMessages().coercionFailed('bigint', value));
+            }
+            try {
+                const coerced = BigInt(trimmed);
+                return super.parse(coerced);
+            }
+            catch {
+                throw new Error(locales_runtime.getMessages().coercionFailed('bigint', value));
+            }
+        }
+        // Handle number values (must be integer)
+        if (typeof value === 'number') {
+            if (!Number.isInteger(value)) {
+                throw new Error(locales_runtime.getMessages().coercionFailed('bigint', value));
+            }
+            const coerced = BigInt(value);
+            return super.parse(coerced);
+        }
+        // Handle null and undefined
+        if (value === null || value === undefined) {
+            throw new Error(locales_runtime.getMessages().coercionFailed('bigint', value));
+        }
+        // Try to coerce other values
+        try {
+            const coerced = BigInt(value);
+            return super.parse(coerced);
+        }
+        catch {
+            throw new Error(locales_runtime.getMessages().coercionFailed('bigint', value));
+        }
+    }
+    /**
+     * Safely parse and coerce a value to bigint
+     */
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: error };
+        }
+    }
+}
+
+exports.VldCoerceBigInt = VldCoerceBigInt;
+exports.VldCoerceBoolean = VldCoerceBoolean;
+exports.VldCoerceDate = VldCoerceDate;
+exports.VldCoerceNumber = VldCoerceNumber;
+exports.VldCoerceString = VldCoerceString;