@warlock.js/seal 4.0.134 → 4.0.136

package/esm/validators/base-validator.js

@@ -1,4 +1,4 @@
-import {clone}from'@mongez/reinforcements';import {invalidRule,VALID_RULE}from'../helpers/validation-helpers.js';import {isEmptyValue}from'../helpers/is-empty-value.js';import {equalRule}from'../rules/core/equal.js';import {forbiddenRule}from'../rules/core/forbidden.js';import {requiredRule,presentRule}from'../rules/core/required.js';import {whenRule}from'../rules/core/when.js';import'@mongez/supportive-is';import'net';import {requiredIfRule,requiredIfEmptyRule,requiredIfNotEmptyRule,requiredIfAllEmptyRule,requiredIfAnyEmptyRule,requiredIfAllNotEmptyRule,requiredIfAnyNotEmptyRule,requiredIfInRule,requiredIfNotInRule}from'../rules/conditional/required-if-rules.js';import {requiredUnlessRule}from'../rules/conditional/required-unless-rules.js';import {requiredWithRule,requiredWithAllRule,requiredWithAnyRule}from'../rules/conditional/required-with-rules.js';import {requiredWithoutRule,requiredWithoutAllRule,requiredWithoutAnyRule}from'../rules/conditional/required-without-rules.js';import {presentIfRule,presentIfEmptyRule,presentIfNotEmptyRule,presentIfInRule,presentIfNotInRule}from'../rules/conditional/present-if-rules.js';import {presentUnlessRule}from'../rules/conditional/present-unless-rules.js';import {presentWithRule,presentWithAllRule,presentWithAnyRule}from'../rules/conditional/present-with-rules.js';import {presentWithoutRule,presentWithoutAllRule,presentWithoutAnyRule}from'../rules/conditional/present-without-rules.js';import {forbiddenIfRule,forbiddenIfNotRule,forbiddenIfEmptyRule,forbiddenIfNotEmptyRule,forbiddenIfInRule,forbiddenIfNotInRule}from'../rules/conditional/forbidden-if-rules.js';import {equalsFieldRule,notEqualsFieldRule}from'../rules/common/equals-field-rules.js';/**
+import {clone}from'@mongez/reinforcements';import {invalidRule,VALID_RULE}from'../helpers/validation-helpers.js';import {isEmptyValue}from'../helpers/is-empty-value.js';import {requiredRule}from'../rules/core/required.js';/**
  * Base validator class - foundation for all validators
  */
 class BaseValidator {
@@ -8,6 +8,23 @@ class BaseValidator {
     description;
     shouldOmit = false;
     isNullable = false;
+    isMutable = false;
+    /**
+     * Whether the field is optional.
+     * - false (default): field is required unless a requiredRule governs the condition.
+     * - true: field can be absent or empty — set by calling .optional().
+     *
+     * Also used as a TypeScript literal brand via the optional() return type.
+     */
+    isOptional = false;
+    /**
+     * The single required-condition rule for this field.
+     * - null: field uses strict default (always required when not optional).
+     * - set: the rule governs when the field is required (e.g., requiredIf).
+     *
+     * Stored separately from rules[] and prepended at validate() time.
+     */
+    requiredRule = this.createRule(requiredRule);
     /**
      * Pipeline to transform the mutated/original data before returning it
      */
@@ -22,6 +39,28 @@ class BaseValidator {
      * Attributed that will be always using the attribute translator
      */
     translatedAttributes = {};
+    /**
+     * Mark the validator as mutable
+     */
+    get mutable() {
+        this.isMutable = true;
+        return this;
+    }
+    /**
+     * Mark the validator as immutable
+     */
+    get immutable() {
+        this.isMutable = false;
+        return this;
+    }
+    /**
+     * Get the instance to apply changes to.
+     * By default (immutable), returns a clone so the original is unchanged.
+     * When `.mutable` is set, returns `this` to mutate in place.
+     */
+    get instance() {
+        return this.isMutable ? this : this.clone();
+    }
     /**
      * Get the default value
      * Supports lazy evaluation via callbacks
@@ -33,15 +72,17 @@ class BaseValidator {
      * Determine if value accepts null value
      */
     nullable() {
-        this.isNullable = true;
-        return this;
+        const instance = this.instance;
+        instance.isNullable = true;
+        return instance;
     }
     /**
      * Explicitly disallow null values after calling nullable
      */
     notNullable() {
-        this.isNullable = false;
-        return this;
+        const instance = this.instance;
+        instance.isNullable = false;
+        return instance;
     }
     /**
      * Add transformer with optional options
@@ -62,11 +103,33 @@ class BaseValidator {
      * ```
      */
     addTransformer(transform, options = {}) {
+        const instance = this.instance;
+        instance.addMutableTransformer(transform, options);
+        return instance;
+    }
+    /**
+     * Add transformer with optional options
+     *
+     * @param transform - The transformer callback function
+     * @param options - Optional options to pass to the transformer
+     *
+     * @example
+     * ```ts
+     * // Without options
+     * v.date().addTransformer(data => data.toISOString())
+     *
+     * // With options
+     * v.date().addTransformer(
+     *   (data, { options }) => dayjs(data).format(options.format),
+     *   { format: 'YYYY-MM-DD' }
+     * )
+     * ```
+     */
+    addMutableTransformer(transform, options = {}) {
         this.dataTransformers.push({
             transform,
             options,
         });
-        return this;
     }
     /**
      * Transform the output value - simple one-time transformation
@@ -86,8 +149,7 @@ class BaseValidator {
      * ```
      */
     outputAs(callback) {
-        this.addTransformer((data, { context }) => callback(data, context));
-        return this;
+        return this.addTransformer((data, { context }) => callback(data, context));
     }
     /**
      * Transform output to JSON string
@@ -120,10 +182,9 @@ class BaseValidator {
      * @category Transformer
      */
     toJSON(indent) {
-        this.addTransformer((data, { options }) => JSON.stringify(data, null, options.indent), {
+        return this.addTransformer((data, { options }) => JSON.stringify(data, null, options.indent), {
             indent: indent ?? 0,
         });
-        return this;
     }
     /**
      * Start data transformation pipeline
@@ -156,26 +217,29 @@ class BaseValidator {
      * });
      */
     attributes(attributes) {
+        const instance = this.instance;
         for (const key in attributes) {
-            this.attributesText[key] = attributes[key];
+            instance.attributesText[key] = attributes[key];
         }
-        return this;
+        return instance;
     }
     /**
      * Define a lazy getter property for each attribute in the given object and use the config attribute translator
      */
     transAttributes(attributes) {
+        const instance = this.instance;
         for (const key in attributes) {
-            this.translatedAttributes[key] = attributes[key];
+            instance.translatedAttributes[key] = attributes[key];
         }
-        return this;
+        return instance;
     }
     /**
      * Add description to the validator
      */
     describe(description) {
-        this.description = description;
-        return this;
+        const instance = this.instance;
+        instance.description = description;
+        return instance;
     }
     /**
      * Check if this validator can handle the given value's type
@@ -233,6 +297,8 @@ class BaseValidator {
         cloned.description = this.description;
         cloned.attributesText = { ...this.attributesText };
         cloned.isNullable = this.isNullable;
+        cloned.isOptional = this.isOptional;
+        cloned.requiredRule = this.requiredRule; // same reference is fine — rule is treated as immutable
         return cloned;
     }
     /**
@@ -263,8 +329,9 @@ class BaseValidator {
      * ```
      */
     omit() {
-        this.shouldOmit = true;
-        return this;
+        const instance = this.instance;
+        instance.shouldOmit = true;
+        return instance;
     }
     /**
      * @alias omit
@@ -279,60 +346,58 @@ class BaseValidator {
         return this.shouldOmit;
     }
     /**
-     * Value must be equal to the given value
-     */
-    equal(value, errorMessage) {
-        const rule = this.addRule(equalRule, errorMessage);
-        rule.context.options.value = value;
-        return this;
-    }
-    /**
-     * Value must be the same as another field's value
-     */
-    sameAs(field, errorMessage) {
-        const rule = this.addRule(equalsFieldRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value must be the same as another sibling field's value
+     * Add rule to the validator
      */
-    sameAsSibling(field, errorMessage) {
-        const rule = this.addRule(equalsFieldRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "sibling";
-        return this;
+    addRule(rule, errorMessage, options = {}) {
+        const instance = this.instance;
+        instance.addMutableRule(rule, errorMessage, options);
+        return instance;
     }
     /**
-     * Value must be different from another field's value
+     * Set the required-condition rule for this field.
+     *
+     * Unlike addRule(), this does NOT push to rules[]. The rule is stored in the
+     * dedicated `requiredRule` slot and is prepended to the validation pipeline
+     * at runtime. Only one required rule can be active per field — this replaces
+     * any previously set required rule.
+     *
+     * Also marks the field as not optional (isOptional = false).
+     *
+     * @example
+     * ```ts
+     * // Used internally by required(), requiredIf(), requiredWith(), etc.
+     * BaseValidator.prototype.required = function(msg) {
+     *   return this.setRequiredRule(requiredRule, msg);
+     * };
+     * ```
      */
-    differentFrom(field, errorMessage) {
-        const rule = this.addRule(notEqualsFieldRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "global";
-        return this;
+    setRequiredRule(rule, errorMessage, options = {}) {
+        const instance = this.instance;
+        instance.isOptional = false;
+        instance.requiredRule = instance.createRule(rule, errorMessage, options);
+        return instance;
     }
     /**
-     * Value must be different from another sibling field's value
+     * Add mutable rule
      */
-    differentFromSibling(field, errorMessage) {
-        const rule = this.addRule(notEqualsFieldRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "sibling";
-        return this;
+    addMutableRule(rule, errorMessage, options = {}) {
+        const newRule = this.createRule(rule, errorMessage, options);
+        this.rules.push(newRule);
+        return newRule;
     }
     /**
-     * Add rule to the validator
+     * Create new rule
      */
-    addRule(rule, errorMessage) {
+    createRule(rule, errorMessage, options = {}) {
         const newRule = {
             ...clone(rule),
             context: {
                 errorMessage,
-                options: {},
+                options,
                 attributesList: this.attributesText,
                 translatedAttributes: this.translatedAttributes,
+                translationParams: {},
+                translatableParams: {},
             },
         };
         if (errorMessage) {
@@ -341,7 +406,6 @@ class BaseValidator {
         if (rule.sortOrder === undefined) {
             newRule.sortOrder = this.rules.length + 1;
         }
-        this.rules.push(newRule);
         return newRule;
     }
     /**
@@ -368,18 +432,13 @@ class BaseValidator {
      */
     useRule(rule, options) {
         const { errorMessage, ...ruleOptions } = options || {};
-        const ruleInstance = this.addRule(rule, errorMessage);
-        // Assign rule-specific options
-        if (Object.keys(ruleOptions).length > 0) {
-            Object.assign(ruleInstance.context.options, ruleOptions);
-        }
-        return this;
+        return this.addRule(rule, errorMessage, ruleOptions);
     }
     /**
      * Define custom rule
      */
     refine(callback) {
-        this.addRule({
+        return this.addRule({
             name: "custom",
             async validate(value, context) {
                 const result = await callback(value, context);
@@ -390,12 +449,19 @@ class BaseValidator {
                 return VALID_RULE;
             },
         });
-        return this;
     }
     /**
      * Add mutator to the validator
      */
     addMutator(mutator, options = {}) {
+        const instance = this.instance;
+        instance.addMutableMutator(mutator, options);
+        return instance;
+    }
+    /**
+     * Add mutable mutator
+     */
+    addMutableMutator(mutator, options = {}) {
         this.mutators.push({
             mutate: mutator,
             context: {
@@ -403,567 +469,14 @@ class BaseValidator {
                 ctx: {},
             },
         });
-        return this;
     }
     /**
      * Set default value for the field
      */
     default(value) {
-        this.defaultValue = value;
-        return this;
-    }
-    // ==================== UNCONDITIONAL STATES ====================
-    /**
-     * This value must be present and has a value
-     */
-    required(errorMessage) {
-        this.addRule(requiredRule, errorMessage);
-        return this;
-    }
-    /**
-     * Value must be present but not necessarily has a value
-     */
-    present(errorMessage) {
-        this.addRule(presentRule, errorMessage);
-        return this;
-    }
-    /**
-     * Mark the field as optional, so pass it if it has no value or has a value
-     * Because this is the default behavior, this method is just syntactic sugar
-     */
-    optional() {
-        return this;
-    }
-    // ==================== REQUIRED: BASED ON FIELD PRESENCE ====================
-    /**
-     * Value is required if another field exists
-     */
-    requiredWith(field, errorMessage) {
-        const rule = this.addRule(requiredWithRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is required if another sibling field exists
-     */
-    requiredWithSibling(field, errorMessage) {
-        const rule = this.addRule(requiredWithRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Value is required if another field is missing
-     */
-    requiredWithout(field, errorMessage) {
-        const rule = this.addRule(requiredWithoutRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is required if another sibling field is missing
-     */
-    requiredWithoutSibling(field, errorMessage) {
-        const rule = this.addRule(requiredWithoutRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    // ==================== REQUIRED: BASED ON FIELD VALUE ====================
-    /**
-     * Value is required if another field equals a specific value
-     */
-    requiredIf(field, value, errorMessage) {
-        const rule = this.addRule(requiredIfRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.value = value;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is required if another sibling field equals a specific value
-     */
-    requiredIfSibling(field, value, errorMessage) {
-        const rule = this.addRule(requiredIfRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.value = value;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Value is required unless another field equals a specific value
-     */
-    requiredUnless(field, value, errorMessage) {
-        const rule = this.addRule(requiredUnlessRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.value = value;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is required unless another sibling field equals a specific value
-     */
-    requiredUnlessSibling(field, value, errorMessage) {
-        const rule = this.addRule(requiredUnlessRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.value = value;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    // ==================== REQUIRED: BASED ON FIELD EMPTY STATE ====================
-    /**
-     * Value is required if another field is empty
-     */
-    requiredIfEmpty(field, errorMessage) {
-        const rule = this.addRule(requiredIfEmptyRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is required if another sibling field is empty
-     */
-    requiredIfEmptySibling(field, errorMessage) {
-        const rule = this.addRule(requiredIfEmptyRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Value is required if another field is not empty
-     */
-    requiredIfNotEmpty(field, errorMessage) {
-        const rule = this.addRule(requiredIfNotEmptyRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is required if another sibling field is not empty
-     */
-    requiredIfNotEmptySibling(field, errorMessage) {
-        const rule = this.addRule(requiredIfNotEmptyRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    // ==================== REQUIRED: BASED ON MULTIPLE FIELDS EMPTY STATE ====================
-    /**
-     * Value is required if ALL specified fields are empty
-     */
-    requiredIfAllEmpty(fields, errorMessage) {
-        const rule = this.addRule(requiredIfAllEmptyRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is required if ALL specified sibling fields are empty
-     */
-    requiredIfAllEmptySiblings(fields, errorMessage) {
-        const rule = this.addRule(requiredIfAllEmptyRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Value is required if ANY of the specified fields is empty
-     */
-    requiredIfAnyEmpty(fields, errorMessage) {
-        const rule = this.addRule(requiredIfAnyEmptyRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is required if ANY of the specified sibling fields is empty
-     */
-    requiredIfAnyEmptySiblings(fields, errorMessage) {
-        const rule = this.addRule(requiredIfAnyEmptyRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Value is required if ALL specified fields are NOT empty
-     */
-    requiredIfAllNotEmpty(fields, errorMessage) {
-        const rule = this.addRule(requiredIfAllNotEmptyRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is required if ALL specified sibling fields are NOT empty
-     */
-    requiredIfAllNotEmptySiblings(fields, errorMessage) {
-        const rule = this.addRule(requiredIfAllNotEmptyRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Value is required if ANY of the specified fields is NOT empty
-     */
-    requiredIfAnyNotEmpty(fields, errorMessage) {
-        const rule = this.addRule(requiredIfAnyNotEmptyRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is required if ANY of the specified sibling fields is NOT empty
-     */
-    requiredIfAnyNotEmptySiblings(fields, errorMessage) {
-        const rule = this.addRule(requiredIfAnyNotEmptyRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Value is required if another field's value is in the given array
-     */
-    requiredIfIn(field, values, errorMessage) {
-        const rule = this.addRule(requiredIfInRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.values = values;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is required if another sibling field's value is in the given array
-     */
-    requiredIfInSibling(field, values, errorMessage) {
-        const rule = this.addRule(requiredIfInRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.values = values;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Value is required if another field's value is NOT in the given array
-     */
-    requiredIfNotIn(field, values, errorMessage) {
-        const rule = this.addRule(requiredIfNotInRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.values = values;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is required if another sibling field's value is NOT in the given array
-     */
-    requiredIfNotInSibling(field, values, errorMessage) {
-        const rule = this.addRule(requiredIfNotInRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.values = values;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    // ==================== REQUIRED: BASED ON MULTIPLE FIELDS (ALL) ====================
-    /**
-     * Value is required if all specified fields exist
-     */
-    requiredWithAll(fields, errorMessage) {
-        const rule = this.addRule(requiredWithAllRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is required if all specified sibling fields exist
-     */
-    requiredWithAllSiblings(fields, errorMessage) {
-        const rule = this.addRule(requiredWithAllRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Value is required if all specified fields are missing
-     */
-    requiredWithoutAll(fields, errorMessage) {
-        const rule = this.addRule(requiredWithoutAllRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is required if all specified sibling fields are missing
-     */
-    requiredWithoutAllSiblings(fields, errorMessage) {
-        const rule = this.addRule(requiredWithoutAllRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    // ==================== REQUIRED: BASED ON MULTIPLE FIELDS (ANY) ====================
-    /**
-     * Value is required if any of the specified fields exists
-     */
-    requiredWithAny(fields, errorMessage) {
-        const rule = this.addRule(requiredWithAnyRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is required if any of the specified sibling fields exists
-     */
-    requiredWithAnySiblings(fields, errorMessage) {
-        const rule = this.addRule(requiredWithAnyRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Value is required if any of the specified fields is missing
-     */
-    requiredWithoutAny(fields, errorMessage) {
-        const rule = this.addRule(requiredWithoutAnyRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is required if any of the specified sibling fields is missing
-     */
-    requiredWithoutAnySiblings(fields, errorMessage) {
-        const rule = this.addRule(requiredWithoutAnyRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    // ==================== PRESENT: BASED ON FIELD PRESENCE ====================
-    /**
-     * Field must be present if another field exists
-     */
-    presentWith(field, errorMessage) {
-        const rule = this.addRule(presentWithRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Field must be present if another sibling field exists
-     */
-    presentWithSibling(field, errorMessage) {
-        const rule = this.addRule(presentWithRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Field must be present if another field is missing
-     */
-    presentWithout(field, errorMessage) {
-        const rule = this.addRule(presentWithoutRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Field must be present if another sibling field is missing
-     */
-    presentWithoutSibling(field, errorMessage) {
-        const rule = this.addRule(presentWithoutRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    // ==================== PRESENT: BASED ON FIELD VALUE ====================
-    /**
-     * Field must be present if another field equals a specific value
-     */
-    presentIf(field, value, errorMessage) {
-        const rule = this.addRule(presentIfRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.value = value;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Field must be present if another sibling field equals a specific value
-     */
-    presentIfSibling(field, value, errorMessage) {
-        const rule = this.addRule(presentIfRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.value = value;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Field must be present unless another field equals a specific value
-     */
-    presentUnless(field, value, errorMessage) {
-        const rule = this.addRule(presentUnlessRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.value = value;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Field must be present unless another sibling field equals a specific value
-     */
-    presentUnlessSibling(field, value, errorMessage) {
-        const rule = this.addRule(presentUnlessRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.value = value;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    // ==================== PRESENT: BASED ON FIELD EMPTY STATE ====================
-    /**
-     * Field must be present if another field is empty
-     */
-    presentIfEmpty(field, errorMessage) {
-        const rule = this.addRule(presentIfEmptyRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Field must be present if another sibling field is empty
-     */
-    presentIfEmptySibling(field, errorMessage) {
-        const rule = this.addRule(presentIfEmptyRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Field must be present if another field is not empty
-     */
-    presentIfNotEmpty(field, errorMessage) {
-        const rule = this.addRule(presentIfNotEmptyRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Field must be present if another sibling field is not empty
-     */
-    presentIfNotEmptySibling(field, errorMessage) {
-        const rule = this.addRule(presentIfNotEmptyRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Field must be present if another field's value is in the given array
-     */
-    presentIfIn(field, values, errorMessage) {
-        const rule = this.addRule(presentIfInRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.values = values;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Field must be present if another sibling field's value is in the given array
-     */
-    presentIfInSibling(field, values, errorMessage) {
-        const rule = this.addRule(presentIfInRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.values = values;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Field must be present if another field's value is NOT in the given array
-     */
-    presentIfNotIn(field, values, errorMessage) {
-        const rule = this.addRule(presentIfNotInRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.values = values;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Field must be present if another sibling field's value is NOT in the given array
-     */
-    presentIfNotInSibling(field, values, errorMessage) {
-        const rule = this.addRule(presentIfNotInRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.values = values;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    // ==================== PRESENT: BASED ON MULTIPLE FIELDS (ALL) ====================
-    /**
-     * Field must be present if all specified fields exist
-     */
-    presentWithAll(fields, errorMessage) {
-        const rule = this.addRule(presentWithAllRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Field must be present if all specified sibling fields exist
-     */
-    presentWithAllSiblings(fields, errorMessage) {
-        const rule = this.addRule(presentWithAllRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Field must be present if all specified fields are missing
-     */
-    presentWithoutAll(fields, errorMessage) {
-        const rule = this.addRule(presentWithoutAllRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Field must be present if all specified sibling fields are missing
-     */
-    presentWithoutAllSiblings(fields, errorMessage) {
-        const rule = this.addRule(presentWithoutAllRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    // ==================== PRESENT: BASED ON MULTIPLE FIELDS (ANY) ====================
-    /**
-     * Field must be present if any of the specified fields exists
-     */
-    presentWithAny(fields, errorMessage) {
-        const rule = this.addRule(presentWithAnyRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Field must be present if any of the specified sibling fields exists
-     */
-    presentWithAnySiblings(fields, errorMessage) {
-        const rule = this.addRule(presentWithAnyRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Field must be present if any of the specified fields is missing
-     */
-    presentWithoutAny(fields, errorMessage) {
-        const rule = this.addRule(presentWithoutAnyRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Field must be present if any of the specified sibling fields is missing
-     */
-    presentWithoutAnySiblings(fields, errorMessage) {
-        const rule = this.addRule(presentWithoutAnyRule, errorMessage);
-        rule.context.options.fields = fields;
-        rule.context.options.scope = "sibling";
-        return this;
+        const instance = this.instance;
+        instance.defaultValue = value;
+        return instance;
     }
     /**
      * Mutate the data
@@ -976,211 +489,13 @@ class BaseValidator {
         }
         return mutatedData;
     }
-    /**
-     * Value is forbidden to be present
-     */
-    forbidden(errorMessage) {
-        this.addRule(forbiddenRule, errorMessage);
-        return this;
-    }
-    /**
-     * Value is forbidden if another field equals a specific value (global scope)
-     */
-    forbiddenIf(field, value, errorMessage) {
-        const rule = this.addRule(forbiddenIfRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.value = value;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is forbidden if another field equals a specific value (sibling scope)
-     */
-    forbiddenIfSibling(field, value, errorMessage) {
-        const rule = this.addRule(forbiddenIfRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.value = value;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Value is forbidden if another field does NOT equal a specific value (global scope)
-     */
-    forbiddenIfNot(field, value, errorMessage) {
-        const rule = this.addRule(forbiddenIfNotRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.value = value;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is forbidden if another field does NOT equal a specific value (sibling scope)
-     */
-    forbiddenIfNotSibling(field, value, errorMessage) {
-        const rule = this.addRule(forbiddenIfNotRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.value = value;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Value is forbidden if another field is empty (global scope)
-     */
-    forbiddenIfEmpty(field, errorMessage) {
-        const rule = this.addRule(forbiddenIfEmptyRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is forbidden if another field is empty (sibling scope)
-     */
-    forbiddenIfEmptySibling(field, errorMessage) {
-        const rule = this.addRule(forbiddenIfEmptyRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Value is forbidden if another field is not empty (global scope)
-     */
-    forbiddenIfNotEmpty(field, errorMessage) {
-        const rule = this.addRule(forbiddenIfNotEmptyRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is forbidden if another field is not empty (sibling scope)
-     */
-    forbiddenIfNotEmptySibling(field, errorMessage) {
-        const rule = this.addRule(forbiddenIfNotEmptyRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Value is forbidden if another field's value is in the given array (global scope)
-     */
-    forbiddenIfIn(field, values, errorMessage) {
-        const rule = this.addRule(forbiddenIfInRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.values = values;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is forbidden if another field's value is in the given array (sibling scope)
-     */
-    forbiddenIfInSibling(field, values, errorMessage) {
-        const rule = this.addRule(forbiddenIfInRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.values = values;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Value is forbidden if another field's value is NOT in the given array (global scope)
-     */
-    forbiddenIfNotIn(field, values, errorMessage) {
-        const rule = this.addRule(forbiddenIfNotInRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.values = values;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Value is forbidden if another field's value is NOT in the given array (sibling scope)
-     */
-    forbiddenIfNotInSibling(field, values, errorMessage) {
-        const rule = this.addRule(forbiddenIfNotInRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.values = values;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
-    /**
-     * Apply different validation rules based on another field's value (global scope)
-     *
-     * Use this when you need to apply completely different validators
-     * based on another field's value (not just required/optional).
-     *
-     * @param field - Field name to check (can be nested with dot notation)
-     * @param options - Validation options per field value
-     *
-     * @example
-     * ```ts
-     * // Different allowed values based on user type
-     * v.object({
-     *   userType: v.string().in(['admin', 'user']),
-     *   role: v.string().when('userType', {
-     *     is: {
-     *       admin: v.string().in(['super', 'moderator']),
-     *       user: v.string().in(['member', 'guest'])
-     *     },
-     *     otherwise: v.string().optional()
-     *   })
-     * })
-     *
-     * // Different validation rules based on type
-     * v.object({
-     *   contactType: v.string().in(['email', 'phone']),
-     *   contact: v.string().when('contactType', {
-     *     is: {
-     *       email: v.string().email(),
-     *       phone: v.string().pattern(/^\d{10}$/)
-     *     }
-     *   })
-     * })
-     * ```
-     * @category Conditional Validation
-     */
-    when(field, options) {
-        const rule = this.addRule(whenRule);
-        rule.context.options.field = field;
-        rule.context.options.is = options.is;
-        rule.context.options.otherwise = options.otherwise;
-        rule.context.options.scope = "global";
-        return this;
-    }
-    /**
-     * Apply different validation rules based on sibling field's value
-     *
-     * Use this for nested objects where you need to check a field
-     * within the same parent object.
-     *
-     * @param siblingField - Sibling field name to check
-     * @param options - Validation options per field value
-     *
-     * @example
-     * ```ts
-     * // Array of users with role-based permissions
-     * v.array(v.object({
-     *   userType: v.string().in(['admin', 'user']),
-     *   permissions: v.string().whenSibling('userType', {
-     *     is: {
-     *       admin: v.string().in(['read', 'write', 'delete']),
-     *       user: v.string().in(['read'])
-     *     }
-     *   })
-     * }))
-     * ```
-     * @category Conditional Validation
-     */
-    whenSibling(siblingField, options) {
-        const rule = this.addRule(whenRule);
-        rule.context.options.field = siblingField;
-        rule.context.options.is = options.is;
-        rule.context.options.otherwise = options.otherwise;
-        rule.context.options.scope = "sibling";
-        return this;
-    }
     /**
      * Set the label for the validator that will be matching the :input attribute
      */
     label(label) {
-        this.attributesText.input = label;
-        return this;
+        const instance = this.instance;
+        instance.attributesText.input = label;
+        return instance;
     }
     /**
      * Validate the data
@@ -1189,14 +504,17 @@ class BaseValidator {
         if (data === null && this.isNullable) {
             return { isValid: true, errors: [], data: null };
         }
-        const valueForMutation = data ?? this.defaultValue;
-        const mutatedData = await this.mutate(valueForMutation, context);
-        const valueForRules = valueForMutation;
+        const valueForRules = data ?? this.getDefaultValue();
+        const mutatedData = await this.mutate(valueForRules, context);
         const errors = [];
         let isValid = true;
         const isFirstErrorOnly = context.configurations?.firstErrorOnly ?? true;
         const isEmpty = isEmptyValue(valueForRules);
-        for (const rule of this.rules) {
+        console.log("isEmpty", isEmpty, valueForRules);
+        // Prepend the required-condition rule if set, so it always runs first.
+        // requiredRule has requiresValue = false so it runs even on empty values.
+        const rulesToRun = this.requiredRule ? [this.requiredRule, ...this.rules] : this.rules;
+        for (const rule of rulesToRun) {
             if ((rule.requiresValue ?? true) && isEmpty)
                 continue;
             this.setRuleAttributesList(rule);