@warlock.js/seal 4.0.48 → 4.0.60

package/esm/validators/base-validator.js

@@ -0,0 +1,1160 @@
+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,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';/**
+ * Base validator class - foundation for all validators
+ */
+class BaseValidator {
+    rules = [];
+    mutators = [];
+    defaultValue;
+    description;
+    shouldOmit = false;
+    isNullable = false;
+    /**
+     * Pipeline to transform the mutated/original data before returning it
+     */
+    dataTransformers = [];
+    /**
+     * Attributes text to be replaced on translations
+     * If the value is an object, it will be used as the attributes list for the rule
+     * If the value is a string, it will be used as the attributes list for the rule
+     */
+    attributesText = {};
+    /**
+     * Attributed that will be always using the attribute translator
+     */
+    translatedAttributes = {};
+    /**
+     * Get the default value
+     * Supports lazy evaluation via callbacks
+     */
+    getDefaultValue() {
+        return typeof this.defaultValue === "function" ? this.defaultValue() : this.defaultValue;
+    }
+    /**
+     * Determine if value accepts null value
+     */
+    nullable() {
+        this.isNullable = true;
+        return this;
+    }
+    /**
+     * Explicitly disallow null values after calling nullable
+     */
+    notNullable() {
+        this.isNullable = false;
+        return this;
+    }
+    /**
+     * 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' }
+     * )
+     * ```
+     */
+    addTransformer(transform, options = {}) {
+        this.dataTransformers.push({
+            transform,
+            options,
+        });
+        return this;
+    }
+    /**
+     * Transform the output value - simple one-time transformation
+     *
+     * @param callback - Simple callback receiving data and context
+     *
+     * @example
+     * ```ts
+     * // Simple transformation
+     * v.string().outputAs(data => data.toUpperCase())
+     *
+     * // With context
+     * v.string().outputAs((data, context) => {
+     *   console.log(`Transforming ${context.path}`);
+     *   return data.toLowerCase();
+     * })
+     * ```
+     */
+    outputAs(callback) {
+        this.addTransformer((data, { context }) => callback(data, context));
+        return this;
+    }
+    /**
+     * Transform output to JSON string
+     *
+     * Works with any validator type (string, number, date, object, array, etc.)
+     *
+     * @param indent - Optional indentation for pretty printing (default: 0 for compact)
+     *
+     * @example
+     * ```ts
+     * // Compact JSON
+     * v.object({ name: v.string() }).toJSON()
+     * // Output: '{"name":"John"}'
+     *
+     * // Pretty-printed JSON
+     * v.array(v.object({...})).toJSON(2)
+     * // Output:
+     * // [
+     * //   {
+     * //     "name": "John"
+     * //   }
+     * // ]
+     *
+     * // Works with any type
+     * v.string().toJSON()  // '"hello"'
+     * v.number().toJSON()  // '42'
+     * v.date().toJSON()    // '"2024-10-26T00:00:00.000Z"'
+     * ```
+     *
+     * @category Transformer
+     */
+    toJSON(indent) {
+        this.addTransformer((data, { options }) => JSON.stringify(data, null, options.indent), {
+            indent: indent ?? 0,
+        });
+        return this;
+    }
+    /**
+     * Start data transformation pipeline
+     * Context is passed at runtime, not stored
+     */
+    async startTransformationPipeline(data, context) {
+        for (const transformer of this.dataTransformers) {
+            data = await transformer.transform(data, {
+                options: transformer.options,
+                context,
+            });
+        }
+        return data;
+    }
+    /**
+     * Set attributes text to be replaced on translations
+     * If the value is an object, it will be used as the attributes list for the rule
+     * If the value is a string, it will be used as the attributes list for the rule
+     *
+     * @example
+     * v.string().attributes({
+     *   name: "Name",
+     *   email: "Email",
+     * });
+     * // Example 2: Add custom attributes for matches
+     * v.string().matches("confirmPassword").attributes({
+     *   matches: {
+     *     confirmPassword: "Confirm Password",
+     *   },
+     * });
+     */
+    attributes(attributes) {
+        for (const key in attributes) {
+            this.attributesText[key] = attributes[key];
+        }
+        return this;
+    }
+    /**
+     * Define a lazy getter property for each attribute in the given object and use the config attribute translator
+     */
+    transAttributes(attributes) {
+        for (const key in attributes) {
+            this.translatedAttributes[key] = attributes[key];
+        }
+        return this;
+    }
+    /**
+     * Add description to the validator
+     */
+    describe(description) {
+        this.description = description;
+        return this;
+    }
+    /**
+     * Check if this validator can handle the given value's type
+     * Override this in specific validators to enable type-based routing in union validators
+     *
+     * Default: returns true (validator will attempt to validate any type)
+     *
+     * @param value - The value to check
+     * @returns True if this validator can handle this type
+     *
+     * @example
+     * ```ts
+     * // StringValidator
+     * public matchesType(value: any): boolean {
+     *   return typeof value === 'string';
+     * }
+     *
+     * // Custom FileValidator
+     * public matchesType(value: any): boolean {
+     *   return value instanceof UploadedFile;
+     * }
+     * ```
+     */
+    matchesType(_value) {
+        return true; // Default: permissive, attempt to validate any type
+    }
+    /**
+     * Create a copy of this validator with the same configuration
+     * Copies all rules, mutators, transformers, default values, and settings
+     *
+     * @returns A new validator instance with copied configuration
+     *
+     * @example
+     * ```ts
+     * // Create reusable validator templates
+     * const baseString = v.string().required().trim().min(3);
+     * const emailField = baseString.clone().email();
+     * const usernameField = baseString.clone().alphanumeric().max(20);
+     *
+     * // Works with all validators
+     * const positiveInt = v.int().positive().required();
+     * const ageField = positiveInt.clone().min(18).max(120);
+     * ```
+     */
+    clone() {
+        // Create a new instance using Object.create to preserve the prototype chain
+        const Constructor = this.constructor;
+        const cloned = Object.create(Constructor.prototype);
+        // Copy all BaseValidator properties
+        cloned.rules = [...this.rules];
+        cloned.mutators = [...this.mutators];
+        cloned.dataTransformers = [...this.dataTransformers];
+        cloned.defaultValue = this.defaultValue;
+        cloned.shouldOmit = this.shouldOmit;
+        cloned.description = this.description;
+        cloned.attributesText = { ...this.attributesText };
+        cloned.isNullable = this.isNullable;
+        return cloned;
+    }
+    /**
+     * @deprecated This method is no longer needed and does nothing.
+     * Empty values are now automatically skipped for validation rules by default.
+     * Only presence validators (required, present, etc.) will check empty values.
+     * You can safely remove this call from your code.
+     */
+    ignoreEmptyValue(_ignoreEmptyValue = true) {
+        // No-op for backward compatibility
+        return this;
+    }
+    /**
+     * Omit this field from the validated data output
+     *
+     * Field will still be validated but not included in the final result.
+     * Useful for confirmation fields, captcha, terms acceptance, etc.
+     *
+     * @example
+     * ```ts
+     * v.object({
+     *   password: v.string().required(),
+     *   confirmPassword: v.string().required().sameAs("password").omit(),
+     *   acceptTerms: v.boolean().required().omit(),
+     * });
+     * // Output: { password: "..." }
+     * // confirmPassword and acceptTerms validated but omitted
+     * ```
+     */
+    omit() {
+        this.shouldOmit = true;
+        return this;
+    }
+    /**
+     * @alias omit
+     */
+    exclude() {
+        return this.omit();
+    }
+    /**
+     * Check if this field should be omitted from the output
+     */
+    isOmitted() {
+        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
+     */
+    sameAsSibling(field, errorMessage) {
+        const rule = this.addRule(equalsFieldRule, errorMessage);
+        rule.context.options.field = field;
+        rule.context.options.scope = "sibling";
+        return this;
+    }
+    /**
+     * Value must be different from another field's value
+     */
+    differentFrom(field, errorMessage) {
+        const rule = this.addRule(notEqualsFieldRule, errorMessage);
+        rule.context.options.field = field;
+        rule.context.options.scope = "global";
+        return this;
+    }
+    /**
+     * Value must be different from another sibling field's value
+     */
+    differentFromSibling(field, errorMessage) {
+        const rule = this.addRule(notEqualsFieldRule, errorMessage);
+        rule.context.options.field = field;
+        rule.context.options.scope = "sibling";
+        return this;
+    }
+    /**
+     * Add rule to the validator
+     */
+    addRule(rule, errorMessage) {
+        const newRule = {
+            ...clone(rule),
+            context: {
+                errorMessage,
+                options: {},
+                attributesList: this.attributesText,
+                translatedAttributes: this.translatedAttributes,
+            },
+        };
+        if (errorMessage) {
+            newRule.errorMessage = errorMessage;
+        }
+        if (rule.sortOrder === undefined) {
+            newRule.sortOrder = this.rules.length + 1;
+        }
+        this.rules.push(newRule);
+        return newRule;
+    }
+    /**
+     * Use a custom or pre-built validation rule
+     *
+     * @param rule - The validation rule to apply
+     * @param options - Rule options including errorMessage and any rule-specific options
+     *
+     * @example
+     * ```ts
+     * import { hexColorRule } from "@warlock.js/seal";
+     *
+     * v.string().useRule(hexColorRule, { errorMessage: "Invalid color" });
+     * ```
+     *
+     * @example
+     * ```ts
+     * // With rule options
+     * v.string().useRule(myCustomRule, {
+     *   customOption: true,
+     *   errorMessage: "Custom validation failed"
+     * });
+     * ```
+     */
+    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;
+    }
+    /**
+     * Define custom rule
+     */
+    refine(callback) {
+        this.addRule({
+            name: "custom",
+            async validate(value, context) {
+                const result = await callback(value, context);
+                if (result) {
+                    this.context.errorMessage = result;
+                    return invalidRule(this, context);
+                }
+                return VALID_RULE;
+            },
+        });
+        return this;
+    }
+    /**
+     * Add mutator to the validator
+     */
+    addMutator(mutator, options = {}) {
+        this.mutators.push({
+            mutate: mutator,
+            context: {
+                options,
+                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;
+    }
+    /**
+     * 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;
+    }
+    /**
+     * Mutate the data
+     */
+    async mutate(data, context) {
+        let mutatedData = data;
+        for (const mutator of this.mutators) {
+            mutator.context.ctx = context;
+            mutatedData = await mutator.mutate(mutatedData, mutator.context);
+        }
+        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;
+    }
+    /**
+     * Validate the data
+     */
+    async validate(data, context) {
+        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 errors = [];
+        let isValid = true;
+        const isFirstErrorOnly = context.configurations?.firstErrorOnly ?? true;
+        const isEmpty = isEmptyValue(valueForRules);
+        for (const rule of this.rules) {
+            if ((rule.requiresValue ?? true) && isEmpty)
+                continue;
+            this.setRuleAttributesList(rule);
+            const result = await rule.validate(mutatedData, context);
+            if (result.isValid === false) {
+                isValid = false;
+                errors.push({
+                    type: rule.name,
+                    error: result.error,
+                    input: result.path ?? context.path,
+                });
+                if (isFirstErrorOnly) {
+                    break;
+                }
+            }
+        }
+        return {
+            isValid,
+            errors,
+            data: mutatedData !== undefined
+                ? await this.startTransformationPipeline(mutatedData, context)
+                : undefined,
+        };
+    }
+    /**
+     * Set rule attributes list
+     */
+    setRuleAttributesList(rule) {
+        rule.context.attributesList =
+            typeof this.attributesText[rule.name] === "object"
+                ? this.attributesText[rule.name]
+                : this.attributesText;
+    }
+}export{BaseValidator};//# sourceMappingURL=base-validator.js.map