@warlock.js/seal 3.0.14

package/cjs/validators/base-validator.js

@@ -0,0 +1,950 @@
+'use strict';var reinforcements=require('@mongez/reinforcements'),supportiveIs=require('@mongez/supportive-is'),validationHelpers=require('../helpers/validation-helpers.js'),equal=require('../rules/core/equal.js'),forbidden=require('../rules/core/forbidden.js'),required=require('../rules/core/required.js'),when=require('../rules/core/when.js');require('net');var requiredIfRules=require('../rules/conditional/required-if-rules.js'),requiredUnlessRules=require('../rules/conditional/required-unless-rules.js'),requiredWithRules=require('../rules/conditional/required-with-rules.js'),requiredWithoutRules=require('../rules/conditional/required-without-rules.js'),presentIfRules=require('../rules/conditional/present-if-rules.js'),presentUnlessRules=require('../rules/conditional/present-unless-rules.js'),presentWithRules=require('../rules/conditional/present-with-rules.js'),presentWithoutRules=require('../rules/conditional/present-without-rules.js'),equalsFieldRules=require('../rules/common/equals-field-rules.js');/**
+ * Base validator class - foundation for all validators
+ */
+class BaseValidator {
+    rules = [];
+    mutators = [];
+    defaultValue;
+    description;
+    shouldAllowEmpty = false;
+    shouldOmit = 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 = {};
+    /**
+     * Get the default value
+     */
+    getDefaultValue() {
+        return this.defaultValue;
+    }
+    /**
+     * 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) {
+        this.attributesText = attributes;
+        return this;
+    }
+    /**
+     * Add description to the validator
+     */
+    describe(description) {
+        this.description = description;
+        return this;
+    }
+    /**
+     * Allow empty values and skip validation if the value is empty
+     */
+    allowsEmpty() {
+        this.shouldAllowEmpty = true;
+        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(equal.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(equalsFieldRules.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(equalsFieldRules.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(equalsFieldRules.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(equalsFieldRules.notEqualsFieldRule, errorMessage);
+        rule.context.options.field = field;
+        rule.context.options.scope = "sibling";
+        return this;
+    }
+    /**
+     * Add rule to the validator
+     */
+    addRule(rule, errorMessage) {
+        const newRule = {
+            ...reinforcements.clone(rule),
+            context: {
+                errorMessage,
+                options: {},
+                attributesList: {},
+            },
+        };
+        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-plugins/colors";
+     *
+     * 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 validationHelpers.invalidRule(this, context);
+                }
+                return validationHelpers.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(required.requiredRule, errorMessage);
+        return this;
+    }
+    /**
+     * Value must be present but not necessarily has a value
+     */
+    present(errorMessage) {
+        this.addRule(required.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(requiredWithRules.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(requiredWithRules.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(requiredWithoutRules.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(requiredWithoutRules.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(requiredIfRules.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(requiredIfRules.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(requiredUnlessRules.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(requiredUnlessRules.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(requiredIfRules.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(requiredIfRules.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(requiredIfRules.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(requiredIfRules.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(requiredIfRules.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(requiredIfRules.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(requiredIfRules.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(requiredIfRules.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(requiredWithRules.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(requiredWithRules.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(requiredWithoutRules.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(requiredWithoutRules.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(requiredWithRules.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(requiredWithRules.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(requiredWithoutRules.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(requiredWithoutRules.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(presentWithRules.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(presentWithRules.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(presentWithoutRules.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(presentWithoutRules.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(presentIfRules.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(presentIfRules.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(presentUnlessRules.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(presentUnlessRules.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(presentIfRules.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(presentIfRules.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(presentIfRules.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(presentIfRules.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(presentIfRules.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(presentIfRules.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(presentIfRules.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(presentIfRules.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(presentWithRules.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(presentWithRules.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(presentWithoutRules.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(presentWithoutRules.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(presentWithRules.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(presentWithRules.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(presentWithoutRules.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(presentWithoutRules.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(forbidden.forbiddenRule, errorMessage);
+        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(when.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(when.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 allowsEmpty is enabled and the value is empty, skip validation
+        if (this.shouldAllowEmpty && supportiveIs.isEmpty(data)) {
+            return {
+                isValid: true,
+                errors: [],
+                data,
+            };
+        }
+        const mutatedData = await this.mutate(data ?? this.defaultValue, context);
+        const errors = [];
+        let isValid = true;
+        const isFirstErrorOnly = context.configurations?.firstErrorOnly ?? true;
+        for (const rule of this.rules) {
+            if ((rule.requiresValue ?? true) && data === undefined)
+                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: await this.startTransformationPipeline(mutatedData, context),
+        };
+    }
+    /**
+     * Set rule attributes list
+     */
+    setRuleAttributesList(rule) {
+        rule.context.attributesList =
+            typeof this.attributesText[rule.name] === "object"
+                ? this.attributesText[rule.name]
+                : this.attributesText;
+    }
+}exports.BaseValidator=BaseValidator;//# sourceMappingURL=base-validator.js.map