@warlock.js/seal 4.0.31 → 4.0.39

package/esm/validators/base-validator.js

@@ -1,1154 +0,0 @@
-import {clone}from'@mongez/reinforcements';import {isEmpty}from'@mongez/supportive-is';import {invalidRule,VALID_RULE}from'../helpers/validation-helpers.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'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
-     */
-    getDefaultValue() {
-        return 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-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 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;
-        for (const rule of this.rules) {
-            if ((rule.requiresValue ?? true) && isEmpty(valueForRules))
-                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;
-    }
-}export{BaseValidator};//# sourceMappingURL=base-validator.js.map