@warlock.js/core 3.0.12 → 3.0.14

package/esm/validator/v/rules.js

@@ -1,914 +0,0 @@
-import {get}from'@mongez/reinforcements';import {isEmpty,isPlainObject,isEmail,isNumeric}from'@mongez/supportive-is';import dayjs from'dayjs';import {isIP}from'net';import {UploadedFile}from'../../http/UploadedFile.js';import {Upload}from'../../modules/uploads/models/upload.js';import {invalidRule,VALID_RULE,setKeyPath}from'./utils.js';import'@warlock.js/cascade';import'../../http/middleware/inject-request-context.js';const requiredRule = {
-    name: "required",
-    defaultErrorMessage: "The :input is required",
-    requiresValue: false,
-    sortOrder: -2,
-    async validate(value, context) {
-        if (isEmpty(value)) {
-            return invalidRule(this, context);
-        }
-        return VALID_RULE;
-    },
-};
-const requiredWithRule = {
-    name: "requiredWith",
-    description: "The field is required if another field is present",
-    sortOrder: -2,
-    requiresValue: false,
-    defaultErrorMessage: "The :input is required",
-    async validate(value, context) {
-        const otherField = this.context.options.field;
-        const fieldValue = get(context.allValues, otherField);
-        if ([undefined, null].includes(fieldValue)) {
-            return VALID_RULE;
-        }
-        if (isEmpty(value)) {
-            return invalidRule(this, context);
-        }
-        return VALID_RULE;
-    },
-};
-const requiredIfAbsentRule = {
-    name: "requiredIfAbsent",
-    description: "The field is required if another field is absent",
-    sortOrder: -2,
-    requiresValue: false,
-    defaultErrorMessage: "The :input is required",
-    async validate(value, context) {
-        const otherField = this.context.options.field;
-        const fieldValue = get(context.allValues || {}, otherField);
-        const isPresent = ![undefined, null].includes(fieldValue);
-        if (!isPresent && isEmpty(value)) {
-            return invalidRule(this, context);
-        }
-        return VALID_RULE;
-    },
-};
-const requiredIfSiblingFieldIsAbsentRule = {
-    name: "requiredIfSiblingFieldIsAbsent",
-    description: "The :input is required",
-    sortOrder: -2,
-    requiresValue: false,
-    defaultErrorMessage: ":input field is required",
-    async validate(value, context) {
-        const otherField = this.context.options.field;
-        const otherFieldValue = get(context.parent, otherField);
-        const isPresent = ![undefined, null].includes(otherFieldValue);
-        if (!isPresent && isEmpty(value)) {
-            return invalidRule(this, context);
-        }
-        return VALID_RULE;
-    },
-};
-const requiredIfSiblingFieldAllAbsentRule = {
-    name: "requiredIfSiblingFieldAllAbsent",
-    description: "The field is required if all other fields are absent",
-    sortOrder: -2,
-    requiresValue: false,
-    defaultErrorMessage: "The :input is required",
-    async validate(value, context) {
-        const fields = this.context.options.fields;
-        let isPresent = false;
-        for (const field of fields) {
-            const fieldValue = get(context.parent, field);
-            if (![undefined, null].includes(fieldValue)) {
-                isPresent = true;
-                break;
-            }
-        }
-        if (!isPresent && isEmpty(value)) {
-            return invalidRule(this, context);
-        }
-        return VALID_RULE;
-    },
-};
-const requiredIfEmptyRule = {
-    name: "requiredIfEmpty",
-    description: "The field is required if another field is empty",
-    sortOrder: -2,
-    requiresValue: false,
-    defaultErrorMessage: "The :input is required",
-    async validate(value, context) {
-        const otherField = this.context.options.field;
-        const fieldValue = get(context.allValues, otherField);
-        if (isEmpty(fieldValue) && isEmpty(value)) {
-            return invalidRule(this, context);
-        }
-        return VALID_RULE;
-    },
-};
-// required if sibling field is empty
-const requiredIfSiblingFieldEmptyRule = {
-    name: "requiredIfSiblingFieldEmpty",
-    description: "The field is required if another field in same parent context is empty",
-    sortOrder: -2,
-    requiresValue: false,
-    defaultErrorMessage: "The :input is required",
-    async validate(value, context) {
-        const otherField = this.context.options.field;
-        const fieldValue = get(context.parent, otherField);
-        if (isEmpty(fieldValue) && isEmpty(value)) {
-            return invalidRule(this, context);
-        }
-        return VALID_RULE;
-    },
-};
-const requiredIfFieldRule = {
-    name: "requiredIfField",
-    description: "The field is required if another field has a specific value",
-    sortOrder: -2,
-    requiresValue: false,
-    defaultErrorMessage: "The :input is required",
-    async validate(value, context) {
-        const otherField = this.context.options.field;
-        const otherFieldValue = this.context.options.value;
-        if (otherField === undefined) {
-            throw new Error("The field option is required for requiredIfField rule");
-        }
-        const fieldValue = get(context.allValues, otherField);
-        if (fieldValue === otherFieldValue && isEmpty(value)) {
-            return invalidRule(this, context);
-        }
-        return VALID_RULE;
-    },
-};
-const requiredIfSiblingFieldRule = {
-    name: "requiredIfSiblingField",
-    description: "The field is required if another field in same parent context has a specific value",
-    sortOrder: -2,
-    requiresValue: false,
-    defaultErrorMessage: "The :input is required",
-    async validate(value, context) {
-        const otherField = this.context.options.field;
-        const otherFieldValue = this.context.options.value;
-        const parentValues = context.parent;
-        const fieldValue = get(parentValues, otherField);
-        if (fieldValue === otherFieldValue && isEmpty(value)) {
-            return invalidRule(this, context);
-        }
-        return VALID_RULE;
-    },
-};
-const requiredUnlessSiblingFieldRule = {
-    name: "requiredUnlessSiblingField",
-    description: "The field is required unless another field in same parent context has a specific value",
-    sortOrder: -2,
-    requiresValue: false,
-    defaultErrorMessage: "The :input is required",
-    async validate(value, context) {
-        const otherField = this.context.options.field;
-        const otherFieldValue = this.context.options.value;
-        const parentValues = context.parent;
-        const fieldValue = get(parentValues, otherField);
-        if (fieldValue !== otherFieldValue && isEmpty(value)) {
-            return invalidRule(this, context);
-        }
-        return VALID_RULE;
-    },
-};
-const objectRule = {
-    name: "object",
-    defaultErrorMessage: "The :input must be an object",
-    async validate(value, context) {
-        if (isPlainObject(value)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const stringRule = {
-    name: "string",
-    defaultErrorMessage: "The :input must be a string",
-    async validate(value, context) {
-        if (typeof value === "string") {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const numberRule = {
-    name: "number",
-    defaultErrorMessage: "The :input must be a number",
-    async validate(value, context) {
-        if (typeof value === "number") {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const booleanRule = {
-    name: "boolean",
-    defaultErrorMessage: "The :input must be a boolean",
-    async validate(value, context) {
-        if (typeof value === "boolean") {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const intRule = {
-    name: "int",
-    defaultErrorMessage: "The :input must be an integer",
-    async validate(value, context) {
-        if (Number.isInteger(value)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const floatRule = {
-    name: "float",
-    defaultErrorMessage: "The :input must be a float",
-    async validate(value, context) {
-        if (Number.isFinite(value) && !Number.isInteger(value)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const inRule = {
-    name: "in",
-    defaultErrorMessage: "The :input must be one of the following values: :options",
-    async validate(value, context) {
-        if (this.context.options.values.includes(value)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const enumRule = {
-    name: "enum",
-    defaultErrorMessage: "The :input must be one of the following values: :options",
-    async validate(value, context) {
-        const enumObject = this.context.options.enum;
-        const enumValues = Object.values(enumObject);
-        if (enumValues.includes(value)) {
-            return VALID_RULE;
-        }
-        this.context.options.enum = enumValues.join(", ");
-        return invalidRule(this, context);
-    },
-};
-const withoutWhitespaceRule = {
-    name: "withoutWhitespace",
-    defaultErrorMessage: "The :input must not contain whitespace",
-    async validate(value, context) {
-        if (!/\s/.test(value)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const minWordsRule = {
-    name: "minWords",
-    defaultErrorMessage: `The :input must be at least :minWords words`,
-    async validate(value, context) {
-        if (String(value || "").split(" ").length >= this.context.options.minWords) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const maxWordsRule = {
-    name: "maxWords",
-    defaultErrorMessage: `The :input must be at most :maxWords words`,
-    async validate(value, context) {
-        if (String(value || "").split(" ").length <= this.context.options.maxWords) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const wordsRule = {
-    name: "words",
-    defaultErrorMessage: `The :input must be exactly :words words`,
-    async validate(value, context) {
-        if (String(value || "").split(" ").length === this.context.options.words) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const minLengthRule = {
-    name: "minLength",
-    defaultErrorMessage: `The :input must be at least :minLength characters long`,
-    async validate(value, context) {
-        if (String(value || "").length >= this.context.options.minLength) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const maxLengthRule = {
-    name: "maxLength",
-    defaultErrorMessage: `The :input must not exceed :maxLength characters`,
-    async validate(value, context) {
-        if (String(value || "").length <= this.context.options.maxLength) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const lengthRule = {
-    name: "length",
-    defaultErrorMessage: `The :input must be exactly :length characters long`,
-    async validate(value, context) {
-        if (String(value || "").length === this.context.options.length) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const minRule = {
-    name: "min",
-    defaultErrorMessage: `The :input must be at least :min`,
-    async validate(value, context) {
-        if (value >= this.context.options.min) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const maxRule = {
-    name: "max",
-    defaultErrorMessage: `The :input must equal to or less than :max`,
-    async validate(value, context) {
-        if (value <= this.context.options.max) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const equalRule = {
-    name: "equal",
-    defaultErrorMessage: `The :input must be equal to :value`,
-    async validate(input, context) {
-        if (input === this.context.options.value) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const emailRule = {
-    name: "email",
-    defaultErrorMessage: "The :input must be a valid email address",
-    async validate(value, context) {
-        if (isEmail(value)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const scalarRule = {
-    name: "scalar",
-    defaultErrorMessage: "The :input must be a scalar value",
-    async validate(value, context) {
-        // a valid value considered to beb either a string, number, or boolean
-        if (["string", "number", "boolean"].includes(typeof value)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const unknownKeyRule = {
-    name: "unknownKey",
-    sortOrder: -1,
-    defaultErrorMessage: "The :input contains unknown properties",
-    async validate(value, context) {
-        const schema = this.context.options.schema;
-        const allowedKeys = this.context.options.allowedKeys || [];
-        for (const key in value) {
-            if (!schema[key] && !allowedKeys.includes(key)) {
-                this.context.options.key = setKeyPath(context.path, key);
-                const newContext = {
-                    ...context,
-                    key,
-                    path: setKeyPath(context.path, key),
-                };
-                return invalidRule(this, newContext);
-            }
-        }
-        return VALID_RULE;
-    },
-};
-const matchesRule = {
-    name: "matches",
-    defaultErrorMessage: "The :input must match the :field",
-    async validate(value, context) {
-        const otherField = this.context.options.field;
-        if (value === get(context.allValues, otherField)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const dateRule = {
-    name: "date",
-    defaultErrorMessage: "The :input must be a valid date",
-    async validate(value, context) {
-        const format = this.context.options.format;
-        // use dayjs for date validation
-        if (format) {
-            const date = dayjs(value, format);
-            if (date.isValid()) {
-                return VALID_RULE;
-            }
-            return invalidRule(this, context);
-        }
-        if (new Date(value).toString() !== "Invalid Date") {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-// Must be used with Date mutator
-const minDateRule = {
-    name: "minDate",
-    description: "The field must be at least the given date",
-    defaultErrorMessage: `The :input must be at least :minDate`,
-    async validate(value, context) {
-        if (value >= this.context.options.minDate) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-// Must be used with Date mutator
-const maxDateRule = {
-    name: "maxDate",
-    defaultErrorMessage: `The :input must be at most :maxDate`,
-    async validate(value, context) {
-        if (value <= this.context.options.maxDate) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const urlRule = {
-    name: "url",
-    defaultErrorMessage: "The :input must be a valid URL",
-    async validate(value, context) {
-        try {
-            new URL(value);
-            return VALID_RULE;
-        }
-        catch (error) {
-            return invalidRule(this, context);
-        }
-    },
-};
-const ipRule = {
-    name: "ip",
-    defaultErrorMessage: "The :input must be a valid IP address",
-    async validate(value, context) {
-        const result = isIP(value);
-        if (result !== 0) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const ip4Rule = {
-    name: "ip4",
-    defaultErrorMessage: "The :input must be a valid IPv4 address",
-    async validate(value, context) {
-        const result = isIP(value);
-        if (result === 4) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const ip6Rule = {
-    name: "ip6",
-    defaultErrorMessage: "The :input must be a valid IPv6 address",
-    async validate(value, context) {
-        const result = isIP(value);
-        if (result === 6) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const isNumericRule = {
-    name: "isNumeric",
-    defaultErrorMessage: "The :input must be a numeric value",
-    async validate(value, context) {
-        if (isNumeric(value)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const startsWithRule = {
-    name: "startsWith",
-    defaultErrorMessage: "The :input must start with :value",
-    async validate(value, context) {
-        if (value.startsWith(this.context.options.value)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const endsWithRule = {
-    name: "endsWith",
-    defaultErrorMessage: "The :input must end with :value",
-    async validate(value, context) {
-        if (value.endsWith(this.context.options.value)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const containsRule = {
-    name: "contains",
-    defaultErrorMessage: "The :input must contain :value",
-    async validate(value, context) {
-        if (value.includes(this.context.options.value)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const notContainsRule = {
-    name: "notContains",
-    defaultErrorMessage: "The :input must not contain :value",
-    async validate(value, context) {
-        if (!value.includes(this.context.options.value)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const alphaRule = {
-    name: "alpha",
-    defaultErrorMessage: "The :input must contain only alphabetic characters",
-    async validate(value, context) {
-        if (/^[a-zA-Z]+$/.test(value)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const alphaNumericRule = {
-    name: "alphaNumeric",
-    errorMessage: "The :input must contain only alphabetic and numeric characters",
-    async validate(value, context) {
-        if (/^[a-zA-Z0-9]+$/.test(value)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const patternRule = {
-    name: "pattern",
-    defaultErrorMessage: "The :input does not match the pattern",
-    async validate(value, context) {
-        if (this.context.options.pattern.test(value)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const moduloRule = {
-    name: "modulo",
-    defaultErrorMessage: "The :input must be a multiple of :value",
-    async validate(value, context) {
-        if (value % this.context.options.value === 0) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const isCreditCardRule = {
-    name: "isCreditCard",
-    description: "The field must be a valid credit card number",
-    defaultErrorMessage: "The :input must be a valid credit card number",
-    async validate(value, context) {
-        // Luhn algorithm
-        const cardNumber = value.toString().replace(/\D/g, "");
-        let sum = 0;
-        let isEven = false;
-        for (let i = cardNumber.length - 1; i >= 0; i--) {
-            let digit = parseInt(cardNumber[i]);
-            if (isEven) {
-                digit *= 2;
-                if (digit > 9) {
-                    digit -= 9;
-                }
-            }
-            sum += digit;
-            isEven = !isEven;
-        }
-        if (sum % 10 === 0) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const positiveRule = {
-    name: "positive",
-    defaultErrorMessage: "The :input must be a positive number",
-    async validate(value, context) {
-        if (value > 0) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-// unique for array
-const uniqueArrayRule = {
-    name: "uniqueArray",
-    description: "The array must contain unique values",
-    defaultErrorMessage: "The :input must contain unique values",
-    async validate(value, context) {
-        const uniqueValues = new Set(value);
-        if (uniqueValues.size === value.length) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const uploadableRule = {
-    name: "uploadable",
-    defaultErrorMessage: "The :input must be a valid uploadable hash id",
-    async validate(value, context) {
-        const hashExists = await Upload.aggregate().where("hash", value).exists();
-        if (hashExists) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const fileRule = {
-    name: "file",
-    defaultErrorMessage: "The :input must be a file",
-    async validate(value, context) {
-        if (value instanceof UploadedFile) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const fileTypeRule = {
-    name: "fileType",
-    defaultErrorMessage: "The :input must be a :types file",
-    async validate(value, context) {
-        let mimeTypes = this.context.options.mimeTypes;
-        if (typeof mimeTypes === "string") {
-            mimeTypes = [mimeTypes];
-        }
-        if (mimeTypes.includes(value.mimeType)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const fileExtensionRule = {
-    name: "fileExtension",
-    errorMessage: "The :input must have one of the following extensions: :extensions",
-    async validate(value, context) {
-        let extensions = this.context.options.extensions;
-        if (typeof extensions === "string") {
-            extensions = [extensions];
-        }
-        if (extensions.includes(value.extension)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const maxFileSizeRule = {
-    name: "maxFileSize",
-    defaultErrorMessage: "The :input must not exceed :maxFileSize",
-    async validate(value, context) {
-        if (value.size <= this.context.options.maxFileSize) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const minFileSizeRule = {
-    name: "minFileSize",
-    defaultErrorMessage: "The :input must be at least :minFileSize",
-    async validate(value, context) {
-        if (value.size >= this.context.options.minFileSize) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const imageRule = {
-    name: "image",
-    defaultErrorMessage: "The :input must be an image",
-    async validate(value, context) {
-        if (value instanceof UploadedFile && value.isImage) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const minWidthRule = {
-    name: "minWidth",
-    defaultErrorMessage: "The :input must be at least :minWidth pixels wide",
-    async validate(value, context) {
-        const dimensions = await value.dimensions();
-        if (dimensions.width >= this.context.options.minWidth) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const maxWidthRule = {
-    name: "maxWidth",
-    defaultErrorMessage: "The :input must be at most :maxWidth pixels wide",
-    async validate(value, context) {
-        const dimensions = await value.dimensions();
-        if (dimensions.width <= this.context.options.maxWidth) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const minHeightRule = {
-    name: "minHeight",
-    defaultErrorMessage: "The :input must be at least :minHeight pixels tall",
-    async validate(value, context) {
-        const dimensions = await value.dimensions();
-        if (dimensions.height >= this.context.options.minHeight) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const maxHeightRule = {
-    name: "maxHeight",
-    defaultErrorMessage: "The :input must be at most :maxHeight pixels tall",
-    async validate(value, context) {
-        const dimensions = await value.dimensions();
-        if (dimensions.height <= this.context.options.maxHeight) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-/**
- * Check if the value is one of the allowed values
- */
-const allowedValuesRule = {
-    name: "arrayOfValues",
-    errorMessage: "The :input must be an array containing only the allowed values: :allowedValues",
-    async validate(value, context) {
-        const allowedValues = this.context.options.allowedValues;
-        // Check if the value is an array
-        if (!Array.isArray(value)) {
-            return invalidRule(this, context);
-        }
-        // Check if all elements in the array are allowed values
-        const isValid = value.every(item => allowedValues.includes(item));
-        if (isValid) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-/**
- * Value must not be any of the given values
- */
-const notAllowedValuesRule = {
-    name: "notAllowedValues",
-    errorMessage: "The :input must not be any of the following values: :notAllowedValues",
-    async validate(value, context) {
-        const notAllowedValues = this.context.options.notAllowedValues;
-        if (!notAllowedValues.includes(value)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-// Array rules
-const arrayRule = {
-    name: "array",
-    defaultErrorMessage: "The :input must be an array",
-    async validate(value, context) {
-        if (Array.isArray(value)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-// End of Array rules
-// Color rules
-const colorValidationRegex = {
-    hex: /^#([0-9a-f]{3}){1,2}$/i,
-    rgb: /^rgb\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\)$/,
-    rgba: /^rgba\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3}),\s*(0?\.\d+)\)$/,
-    hsl: /^hsl\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\)$/,
-    light: /^#([0-9a-f]{3}){1,2}$/i,
-    dark: /^#([0-9a-f]{3}){1,2}$/i,
-};
-const rgbColorRule = {
-    name: "rgbColor",
-    defaultErrorMessage: "The :input must be a valid RGB color",
-    async validate(value, context) {
-        if (value.match(colorValidationRegex.rgb)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const rgbaColorRule = {
-    name: "rgbaColor",
-    defaultErrorMessage: "The :input must be a valid RGBA color",
-    async validate(value, context) {
-        if (value.match(colorValidationRegex.rgba)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const hexColorRule = {
-    name: "hexColor",
-    defaultErrorMessage: "The :input must be a valid hex color",
-    async validate(value, context) {
-        if (value.match(colorValidationRegex.hex)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const hslColorRule = {
-    name: "hslColor",
-    defaultErrorMessage: "The :input must be a valid HSL color",
-    async validate(value, context) {
-        if (value.match(colorValidationRegex.hsl)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const lightColorRule = {
-    name: "lightColor",
-    defaultErrorMessage: "The :input must be a light color",
-    async validate(value, context) {
-        if (value.match(colorValidationRegex.light)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const darkColorRule = {
-    name: "darkColor",
-    defaultErrorMessage: "The :input must be a dark color",
-    async validate(value, context) {
-        if (value.match(colorValidationRegex.dark)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const colorRule = {
-    name: "color",
-    defaultErrorMessage: "The :input must be a valid color",
-    async validate(value, context) {
-        if (value.match(colorValidationRegex.hex) ||
-            value.match(colorValidationRegex.rgb) ||
-            value.match(colorValidationRegex.rgba) ||
-            value.match(colorValidationRegex.hsl)) {
-            return VALID_RULE;
-        }
-        return invalidRule(this, context);
-    },
-};
-const forbiddenRule = {
-    name: "forbidden",
-    defaultErrorMessage: "The :input is forbidden",
-    async validate(_value, context) {
-        return invalidRule(this, context);
-    },
-};
-/**
- * When rule applies a condition validation rule based on another field value
- */
-const whenRule = {
-    name: "when",
-    description: "Apply conditional validation rules based on another field value",
-    async validate(value, context) {
-        const { field, is, otherwise, local } = this.context.options;
-        const parent = local ? context.parent : context.allValues;
-        const fieldValue = get(parent, field);
-        const condition = is[fieldValue] || otherwise;
-        if (condition) {
-            const result = await condition.validate(value, context);
-            if (!result.isValid) {
-                return {
-                    isValid: false,
-                    error: result.errors[0].error,
-                    input: result.errors[0].input,
-                    path: context.path,
-                };
-            }
-        }
-        return VALID_RULE;
-    },
-};export{allowedValuesRule,alphaNumericRule,alphaRule,arrayRule,booleanRule,colorRule,containsRule,darkColorRule,dateRule,emailRule,endsWithRule,enumRule,equalRule,fileExtensionRule,fileRule,fileTypeRule,floatRule,forbiddenRule,hexColorRule,hslColorRule,imageRule,inRule,intRule,ip4Rule,ip6Rule,ipRule,isCreditCardRule,isNumericRule,lengthRule,lightColorRule,matchesRule,maxDateRule,maxFileSizeRule,maxHeightRule,maxLengthRule,maxRule,maxWidthRule,maxWordsRule,minDateRule,minFileSizeRule,minHeightRule,minLengthRule,minRule,minWidthRule,minWordsRule,moduloRule,notAllowedValuesRule,notContainsRule,numberRule,objectRule,patternRule,positiveRule,requiredIfAbsentRule,requiredIfEmptyRule,requiredIfFieldRule,requiredIfSiblingFieldAllAbsentRule,requiredIfSiblingFieldEmptyRule,requiredIfSiblingFieldIsAbsentRule,requiredIfSiblingFieldRule,requiredRule,requiredUnlessSiblingFieldRule,requiredWithRule,rgbColorRule,rgbaColorRule,scalarRule,startsWithRule,stringRule,uniqueArrayRule,unknownKeyRule,uploadableRule,urlRule,whenRule,withoutWhitespaceRule,wordsRule};//# sourceMappingURL=rules.js.map