@regle/rules 1.2.2 → 1.3.0-beta.1

package/dist/regle-rules.js

@@ -0,0 +1,1210 @@
+import { InternalRuleType, createRule, unwrapRuleParameters } from "@regle/core";
+import { computed, toValue, unref } from "vue";
+
+//#region src/helpers/withMessage.ts
+function withMessage(rule, newMessage) {
+	let _type;
+	let validator;
+	let _active;
+	let _params;
+	if (typeof rule === "function" && !("_validator" in rule)) {
+		_type = InternalRuleType.Inline;
+		validator = rule;
+	} else ({_type, validator, _active, _params} = rule);
+	const newRule = createRule({
+		type: _type,
+		validator,
+		active: _active,
+		message: newMessage
+	});
+	const newParams = [..._params ?? []];
+	newRule._params = newParams;
+	newRule._message_patched = true;
+	if (typeof newRule === "function") {
+		if (_params != null) {
+			const executedRule = newRule(...newParams);
+			executedRule._message_patched = true;
+			return executedRule;
+		}
+		return newRule;
+	} else return newRule;
+}
+
+//#endregion
+//#region src/helpers/withTooltip.ts
+function withTooltip(rule, newTooltip) {
+	let _type;
+	let validator;
+	let _active;
+	let _params;
+	let _message;
+	if (typeof rule === "function" && !("_validator" in rule)) {
+		_type = InternalRuleType.Inline;
+		validator = rule;
+	} else ({_type, validator, _active, _params, _message} = rule);
+	const newRule = createRule({
+		type: _type,
+		validator,
+		active: _active,
+		message: _message,
+		tooltip: newTooltip
+	});
+	const newParams = [..._params ?? []];
+	newRule._params = newParams;
+	newRule._tooltip_patched = true;
+	if (typeof newRule === "function") {
+		const executedRule = newRule(...newParams);
+		newRule._tooltip_patched = true;
+		return executedRule;
+	} else return newRule;
+}
+
+//#endregion
+//#region src/helpers/withAsync.ts
+function withAsync(rule, depsArray) {
+	let _type;
+	let validator;
+	let _params = [];
+	let _message = "";
+	if (typeof rule === "function") {
+		_type = InternalRuleType.Inline;
+		validator = async (value, ...params) => {
+			return rule(value, ...params);
+		};
+		_params = [depsArray];
+	} else {
+		({_type, _message} = rule);
+		_params = _params = rule._params?.concat(depsArray);
+		validator = async (...args) => rule.validator(args);
+	}
+	const newRule = createRule({
+		type: InternalRuleType.Async,
+		validator,
+		message: _message
+	});
+	newRule._params = newRule._params?.concat(_params);
+	return newRule(...depsArray ?? []);
+}
+
+//#endregion
+//#region src/helpers/withParams.ts
+function withParams(rule, depsArray) {
+	let _type;
+	let validator;
+	let _params = [];
+	let _message = "";
+	if (typeof rule === "function") {
+		_type = InternalRuleType.Inline;
+		validator = (value, ...params) => {
+			return rule(value, ...params);
+		};
+		_params = [depsArray];
+	} else {
+		({_type, validator, _message} = rule);
+		_params = _params = rule._params?.concat(depsArray);
+	}
+	const newRule = createRule({
+		type: InternalRuleType.Inline,
+		validator,
+		message: _message
+	});
+	newRule._params = newRule._params?.concat(_params);
+	return newRule(...depsArray);
+}
+
+//#endregion
+//#region src/helpers/applyIf.ts
+/**
+* The applyIf operator is similar to requiredIf, but it can be used with any rule. It simplifies conditional rule declarations.
+*/
+function applyIf(_condition, rule) {
+	let _type;
+	let validator;
+	let _params = [];
+	let _message = "";
+	if (typeof rule === "function") {
+		_type = InternalRuleType.Inline;
+		validator = rule;
+		_params = [_condition];
+	} else {
+		({_type, validator, _message} = rule);
+		_params = rule._params?.concat([_condition]);
+	}
+	function newValidator(value, ...args) {
+		const [condition] = unwrapRuleParameters([_condition]);
+		if (condition) return validator(value, ...args);
+		return true;
+	}
+	function newActive(metadata) {
+		const [condition] = unwrapRuleParameters([_condition]);
+		return condition;
+	}
+	const newRule = createRule({
+		type: _type,
+		validator: newValidator,
+		active: newActive,
+		message: _message
+	});
+	const newParams = [..._params ?? []];
+	newRule._params = newParams;
+	if (typeof newRule === "function") {
+		const executedRule = newRule(...newParams);
+		return executedRule;
+	} else return newRule;
+}
+
+//#endregion
+//#region ../shared/utils/isFile.ts
+/**
+* Server side friendly way of checking for a File
+*/
+function isFile(value) {
+	return value?.constructor.name == "File" || value?.constructor.name == "FileList";
+}
+
+//#endregion
+//#region ../shared/utils/isEmpty.ts
+/**
+* This is the inverse of isFilled. It will check if the value is in any way empty (including arrays and objects)
+*
+* isEmpty also acts as a type guard.
+*
+* @param value - the target value
+* @param [considerEmptyArrayInvalid=true] - will return false if set to `false`. (default: `true`)
+*/
+function isEmpty(value, considerEmptyArrayInvalid = true) {
+	if (value === void 0 || value === null) return true;
+	if (value instanceof Date) return isNaN(value.getTime());
+	else if (isFile(value)) return value.size <= 0;
+	else if (Array.isArray(value)) {
+		if (considerEmptyArrayInvalid) return value.length === 0;
+		return false;
+	} else if (typeof value === "object" && value != null) return Object.keys(value).length === 0;
+	return !String(value).length;
+}
+
+//#endregion
+//#region ../shared/utils/symbol.ts
+const RegleRuleSymbol = Symbol("regle-rule");
+
+//#endregion
+//#region ../shared/utils/isDate.ts
+/**
+* This is a useful helper that can check if the provided value is a Date, it is used internally for date rules. This can also check strings.
+*/
+function isDate(value) {
+	if (isEmpty(value)) return false;
+	try {
+		let possibleDate = null;
+		if (value instanceof Date) possibleDate = value;
+		else if (typeof value === "string") {
+			const date$1 = new Date(value);
+			if (date$1.toString() === "Invalid Date") return false;
+			possibleDate = date$1;
+		}
+		return !!possibleDate;
+	} catch (e) {
+		return false;
+	}
+}
+
+//#endregion
+//#region ../shared/utils/toDate.ts
+/**
+* This utility will coerce any string, number or Date value into a Date using the Date constructor.
+*/
+function toDate(argument) {
+	const argStr = Object.prototype.toString.call(argument);
+	if (argument == null) return new Date(NaN);
+	else if (argument instanceof Date || typeof argument === "object" && argStr === "[object Date]") return new Date(argument.getTime());
+	else if (typeof argument === "number" || argStr === "[object Number]") return new Date(argument);
+	else if (typeof argument === "string" || argStr === "[object String]") return new Date(argument);
+	else return new Date(NaN);
+}
+
+//#endregion
+//#region src/helpers/ruleHelpers/isFilled.ts
+/**
+* This is almost a must have for optional fields. It checks if any value you provided is defined (including arrays and objects). You can base your validator result on this.
+*
+* isFilled also acts as a type guard.
+*
+* @param value - the target value
+* @param [considerEmptyArrayInvalid=true] - will return true if set to `false`. (default: `true`)
+*/
+function isFilled(value, considerEmptyArrayInvalid = true) {
+	return !isEmpty(typeof value === "string" ? value.trim() : value, considerEmptyArrayInvalid);
+}
+
+//#endregion
+//#region src/helpers/ruleHelpers/isNumber.ts
+/**
+* This is a type guard that will check if the passed value is a real Number. This also returns false for NaN, so this is better than typeof value === "number".
+*/
+function isNumber(value) {
+	if (value == null) return false;
+	else if (typeof value !== "number") return false;
+	else if (isNaN(value)) return false;
+	else return true;
+}
+
+//#endregion
+//#region src/helpers/ruleHelpers/matchRegex.ts
+/**
+* This utility can take multiple regular expressions as arguments. It checks the input's validity and tests it against the provided regex patterns.
+*/
+function matchRegex(_value, ...expr) {
+	if (isEmpty(_value)) return true;
+	const value = typeof _value === "number" ? _value.toString() : _value;
+	return expr.every((reg) => {
+		reg.lastIndex = 0;
+		return reg.test(value);
+	});
+}
+
+//#endregion
+//#region src/helpers/ruleHelpers/getSize.ts
+/**
+* This helper will return the length of any data type you pass. It works with strings, arrays, objects and numbers.
+*/
+function getSize(value) {
+	const _value = unref(value);
+	if (Array.isArray(_value)) return _value.length;
+	if (typeof _value === "object") return Object.keys(_value).length;
+	if (typeof _value === "number") {
+		if (isNaN(_value)) return 0;
+		return _value;
+	}
+	return String(_value).length;
+}
+
+//#endregion
+//#region src/helpers/ruleHelpers/toNumber.ts
+/**
+* This utility converts any string (or number) into a number using the Number constructor.
+*
+* @returns ⚠️ Warning, returned value can be NaN
+*/
+function toNumber(argument) {
+	if (typeof argument === "number") return argument;
+	else if (argument != null) {
+		if (typeof argument === "string") {
+			const isPadded = argument.trim() !== argument;
+			if (isPadded) return NaN;
+			return +argument;
+		}
+		return NaN;
+	}
+	return NaN;
+}
+
+//#endregion
+//#region src/helpers/and.ts
+/**
+* The and operator combines multiple rules and validates successfully only if all provided rules are valid.
+*/
+function and(...rules) {
+	const isAnyRuleAsync = rules.some((rule) => {
+		if (typeof rule === "function") return rule.constructor.name === "AsyncFunction";
+		else return rule._async;
+	});
+	const _params = rules.map((rule) => {
+		if (typeof rule === "function") return null;
+		else {
+			const $params = rule._params;
+			if (!$params?.length) return [];
+			else return $params;
+		}
+	}).flat().filter((param) => !!param);
+	function computeRules(rules$1, value, ...params) {
+		const $rules = [];
+		let paramIndex = 0;
+		for (let rule of rules$1) if (typeof rule === "function") {
+			$rules.push(rule(value));
+			paramIndex++;
+		} else {
+			const paramsLength = rule._params?.length ?? 0;
+			$rules.push(rule.validator(value, ...params.slice(paramIndex, paramsLength)));
+			if (paramsLength) paramIndex += paramsLength;
+		}
+		return $rules;
+	}
+	function computeMetadata(results) {
+		const isAnyResultMetaData = results?.some((s) => typeof s !== "boolean");
+		if (isAnyResultMetaData) return {
+			$valid: results.every((result) => {
+				if (typeof result === "boolean") return !!result;
+				return result.$valid;
+			}),
+			...results.reduce((acc, result) => {
+				if (typeof result === "boolean") return acc;
+				const { $valid,...rest } = result;
+				return {
+					...acc,
+					...rest
+				};
+			}, {})
+		};
+		else return results.every((result) => !!result);
+	}
+	let validator;
+	if (!!rules.length) validator = isAnyRuleAsync ? async (value, ...params) => {
+		const results = await Promise.all(computeRules(rules, value, ...params));
+		return computeMetadata(results);
+	} : (value, ...params) => {
+		const $rules = computeRules(rules, value, ...params);
+		return computeMetadata($rules);
+	};
+	else validator = (value) => {
+		return false;
+	};
+	const newRule = createRule({
+		type: "and",
+		validator,
+		message: "The value does not match all of the provided validators"
+	});
+	const newParams = [..._params ?? []];
+	newRule._params = newParams;
+	if (typeof newRule === "function") {
+		const executedRule = newRule(...newParams);
+		return executedRule;
+	} else return newRule;
+}
+
+//#endregion
+//#region src/helpers/or.ts
+/**
+* The or operator validates successfully if at least one of the provided rules is valid.
+*/
+function or(...rules) {
+	const isAnyRuleAsync = rules.some((rule) => {
+		if (typeof rule === "function") return rule.constructor.name === "AsyncFunction";
+		else return rule._async;
+	});
+	const _params = rules.map((rule) => {
+		if (typeof rule === "function") return null;
+		else return rule._params;
+	}).flat().filter((param) => !!param);
+	function computeRules(rules$1, value, ...params) {
+		const $rules = [];
+		let paramIndex = 0;
+		for (let rule of rules$1) if (typeof rule === "function") {
+			$rules.push(rule(value));
+			paramIndex++;
+		} else {
+			const paramsLength = rule._params?.length ?? 0;
+			$rules.push(rule.validator(value, ...params.slice(paramIndex, paramsLength)));
+			if (paramsLength) paramIndex += paramsLength;
+		}
+		return $rules;
+	}
+	function computeMetadata(results) {
+		const isAnyResultMetaData = results.some((s) => typeof s !== "boolean");
+		if (isAnyResultMetaData) return {
+			$valid: results.some((result) => {
+				if (typeof result === "boolean") return !!result;
+				return result.$valid;
+			}),
+			...results.reduce((acc, result) => {
+				if (typeof result === "boolean") return acc;
+				const { $valid,...rest } = result;
+				return {
+					...acc,
+					...rest
+				};
+			}, {})
+		};
+		else return results.some((result) => !!result);
+	}
+	const validator = isAnyRuleAsync ? async (value, ...params) => {
+		const results = await Promise.all(computeRules(rules, value, ...params));
+		return computeMetadata(results);
+	} : (value, ...params) => {
+		const $rules = computeRules(rules, value, ...params);
+		return computeMetadata($rules);
+	};
+	const newRule = createRule({
+		type: "or",
+		validator,
+		message: "The value does not match any of the provided validators"
+	});
+	const newParams = [..._params ?? []];
+	newRule._params = newParams;
+	if (typeof newRule === "function") {
+		const executedRule = newRule(...newParams);
+		return executedRule;
+	} else return newRule;
+}
+
+//#endregion
+//#region src/helpers/not.ts
+/**
+* The not operator passes when the provided rule fails and fails when the rule passes. It can be combined with other rules.
+*/
+function not(rule, message) {
+	let _type;
+	let validator;
+	let newValidator;
+	let _params;
+	let _async;
+	if (typeof rule === "function") {
+		validator = rule;
+		_async = rule.constructor.name === "AsyncFunction";
+	} else {
+		({_type, validator, _params} = rule);
+		_async = rule._async;
+	}
+	if (_async) newValidator = async (value, ...params) => {
+		if (isFilled(value)) {
+			const result = await validator(value, ...params);
+			return !result;
+		}
+		return true;
+	};
+	else newValidator = (value, ...params) => {
+		if (isFilled(value)) return !validator(value, ...params);
+		return true;
+	};
+	const newRule = createRule({
+		type: "not",
+		validator: newValidator,
+		message: message ?? "Error"
+	});
+	const newParams = [..._params ?? []];
+	newRule._params = newParams;
+	if (typeof newRule === "function") {
+		const executedRule = newRule(...newParams);
+		return executedRule;
+	} else return newRule;
+}
+
+//#endregion
+//#region src/rules/alpha.ts
+const alphaRegex = /^[a-zA-Z]*$/;
+const alphaSymbolRegex = /^[\w.]+$/;
+/**
+* Allows only alphabetic characters.
+*
+* @param [options] - Alpha rules options
+* */
+const alpha = createRule({
+	type: "alpha",
+	validator(value, options) {
+		if (isEmpty(value)) return true;
+		if (options?.allowSymbols) return matchRegex(value, alphaSymbolRegex);
+		return matchRegex(value, alphaRegex);
+	},
+	message: "The value is not alphabetical"
+});
+
+//#endregion
+//#region src/rules/alphaNum.ts
+const alphaNumRegex = /^[a-zA-Z0-9]*$/;
+const alphaNumSymbolRegex = /^[a-zA-Z0-9_]*$/;
+/**
+* Allows only alphanumeric characters.
+*
+* @param [options] - Alpha rules options
+*/
+const alphaNum = createRule({
+	type: "alphaNum",
+	validator(value, options) {
+		if (isEmpty(value)) return true;
+		if (options?.allowSymbols) return matchRegex(value, alphaNumSymbolRegex);
+		return matchRegex(value, alphaNumRegex);
+	},
+	message: "The value must be alpha-numeric"
+});
+
+//#endregion
+//#region src/rules/between.ts
+/**
+* Checks if a number is in specified bounds. min and max are both inclusive.
+*
+* @param min - the minimum limit
+* @param max - the maximum limit
+*/
+const between = createRule({
+	type: "between",
+	validator: (value, min, max, options) => {
+		const { allowEqual = true } = options ?? {};
+		if (isFilled(value) && isFilled(min) && isFilled(max)) {
+			const tValue = toNumber(value);
+			const tMin = toNumber(min);
+			const tMax = toNumber(max);
+			if (isNumber(tValue) && isNumber(tMin) && isNumber(tMax)) if (allowEqual) return tValue >= tMin && tValue <= tMax;
+			else return tValue > tMin && tValue < tMax;
+			console.warn(`[between] Value or parameters aren't numbers, got value: ${value}, min: ${min}, max: ${max}`);
+			return false;
+		}
+		return true;
+	},
+	message: ({ $params: [min, max] }) => {
+		return `The value must be between ${min} and ${max}`;
+	}
+});
+
+//#endregion
+//#region src/rules/boolean.ts
+/**
+* Requires a value to be a native boolean type
+*
+* Mainly used for typing
+*/
+const boolean = createRule({
+	type: "boolean",
+	validator: (value) => {
+		if (isFilled(value)) return typeof value === "boolean";
+		return true;
+	},
+	message: "The value must be a native boolean"
+});
+
+//#endregion
+//#region src/rules/checked.ts
+/**
+* Requires a boolean value to be true. This is useful for checkbox inputs.
+*/
+const checked = createRule({
+	type: "checked",
+	validator: (value) => {
+		if (isFilled(value)) return value === true;
+		return true;
+	},
+	message: "The field must be checked"
+});
+
+//#endregion
+//#region src/rules/contains.ts
+/**
+* Checks if the string contains the specified substring.
+*
+* @param part - the part the value needs to contain
+*/
+const contains = createRule({
+	type: "contains",
+	validator(value, part) {
+		if (isFilled(value) && isFilled(part)) return value.includes(part);
+		return true;
+	},
+	message({ $params: [part] }) {
+		return `The value must contain ${part}`;
+	}
+});
+
+//#endregion
+//#region src/rules/date.ts
+/**
+* Requires a value to be a native Date constructor
+*
+* Mainly used for typing
+*/
+const date = createRule({
+	type: "date",
+	validator: (value) => {
+		if (isFilled(value)) return value instanceof Date;
+		return true;
+	},
+	message: "The value must be a native Date constructor"
+});
+
+//#endregion
+//#region src/utils/getLocale.util.ts
+function getUserLocale() {
+	if (navigator.languages != void 0) return navigator.languages[0];
+	return navigator.language;
+}
+function formatLocaleDate(date$1) {
+	if (date$1) return new Intl.DateTimeFormat(getUserLocale(), { dateStyle: "short" }).format(new Date(date$1));
+	return "?";
+}
+
+//#endregion
+//#region src/rules/dateAfter.ts
+/**
+* Checks if the date is after the given parameter.
+*
+* @param after - the date to compare to
+* @param options - comparison options
+*/
+const dateAfter = createRule({
+	type: "dateAfter",
+	validator: (value, after, options) => {
+		const { allowEqual = true } = options ?? {};
+		if (isFilled(value) && isFilled(after)) {
+			if (isDate(value) && isDate(after)) {
+				const result = allowEqual ? toDate(value).getTime() >= toDate(after).getTime() : toDate(value).getTime() > toDate(after).getTime();
+				if (result) return true;
+				return {
+					$valid: false,
+					error: "date-not-after"
+				};
+			}
+			return {
+				$valid: false,
+				error: "value-or-parameter-not-a-date"
+			};
+		}
+		return true;
+	},
+	message: ({ $params: [after], error }) => {
+		if (error === "value-or-parameter-not-a-date") return "The values must be dates";
+		return `The date must be after ${formatLocaleDate(after)}`;
+	}
+});
+
+//#endregion
+//#region src/rules/dateBefore.ts
+/**
+* Checks if the date is before the given parameter.
+*
+* @param before - the date to compare to
+* @param options - comparison options
+*/
+const dateBefore = createRule({
+	type: "dateBefore",
+	validator: (value, before, options) => {
+		const { allowEqual = true } = options ?? {};
+		if (isFilled(value) && isFilled(before)) {
+			if (isDate(value) && isDate(before)) {
+				const result = allowEqual ? toDate(value).getTime() <= toDate(before).getTime() : toDate(value).getTime() < toDate(before).getTime();
+				if (result) return true;
+				return {
+					$valid: false,
+					error: "date-not-before"
+				};
+			}
+			return {
+				$valid: false,
+				error: "value-or-parameter-not-a-date"
+			};
+		}
+		return true;
+	},
+	message: ({ $params: [before], error }) => {
+		if (error === "value-or-parameter-not-a-date") return "The values must be dates";
+		return `The date must be before ${formatLocaleDate(before)}`;
+	}
+});
+
+//#endregion
+//#region src/rules/dateBetween.ts
+/**
+* Checks if the date falls between the specified bounds.
+*
+* @param before - the minimum limit
+* @param after - the maximum limit
+* @param options - comparison options
+*/
+const dateBetween = createRule({
+	type: "dateBetween",
+	validator: (value, before, after, options) => {
+		const { allowEqual = true } = options ?? {};
+		if (isDate(value) && isDate(before) && isDate(after)) if (allowEqual) return toDate(value).getTime() >= toDate(before).getTime() && toDate(value).getTime() <= toDate(after).getTime();
+		else return toDate(value).getTime() > toDate(before).getTime() && toDate(value).getTime() < toDate(after).getTime();
+		return true;
+	},
+	message: ({ $params: [before, after] }) => {
+		return `The date must be between ${formatLocaleDate(before)} and ${formatLocaleDate(after)}`;
+	}
+});
+
+//#endregion
+//#region src/rules/decimal.ts
+const decimalRegex = /^[-]?\d*(\.\d+)?$/;
+/**
+* Allows positive and negative decimal numbers.
+*/
+const decimal = createRule({
+	type: "decimal",
+	validator(value) {
+		if (isEmpty(value)) return true;
+		return matchRegex(value, decimalRegex);
+	},
+	message: "The value must be decimal"
+});
+
+//#endregion
+//#region src/rules/email.ts
+const emailRegex = /^(?:[A-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[A-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9]{2,}(?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$/i;
+/**
+* Validates email addresses. Always verify on the server to ensure the address is real and not already in use.
+*/
+const email = createRule({
+	type: "email",
+	validator(value) {
+		if (isEmpty(value)) return true;
+		return matchRegex(value, emailRegex);
+	},
+	message: "The value must be an valid email address"
+});
+
+//#endregion
+//#region src/rules/endsWith.ts
+/**
+* Checks if the string ends with the specified substring.
+*
+* @param part - the value the field must end with
+*/
+const endsWith = createRule({
+	type: "endsWith",
+	validator(value, part) {
+		if (isFilled(value) && isFilled(part)) return value.endsWith(part);
+		return true;
+	},
+	message({ $params: [part] }) {
+		return `The value must end with ${part}`;
+	}
+});
+
+//#endregion
+//#region src/rules/exactLength.ts
+/**
+* Requires the input value to have a strict specified length, inclusive. Works with arrays, objects and strings.
+*
+* @param count - the required length
+*/
+const exactLength = createRule({
+	type: "exactLength",
+	validator: (value, count) => {
+		if (isFilled(value, false) && isFilled(count)) {
+			if (isNumber(count)) return getSize(value) === count;
+			console.warn(`[minLength] Parameter isn't a number, got parameter: ${count}`);
+			return false;
+		}
+		return true;
+	},
+	message: ({ $params: [count] }) => {
+		return `The value should be exactly ${count} characters long`;
+	}
+});
+
+//#endregion
+//#region src/rules/exactValue.ts
+/**
+* Requires a field to have a strict numeric value.
+*/
+const exactValue = createRule({
+	type: "exactValue",
+	validator: (value, count) => {
+		if (isFilled(value) && isFilled(count)) {
+			if (isNumber(count) && !isNaN(toNumber(value))) return toNumber(value) === count;
+			console.warn(`[exactValue] Value or parameter isn't a number, got value: ${value}, parameter: ${count}`);
+			return true;
+		}
+		return true;
+	},
+	message: ({ $params: [count] }) => {
+		return `The value must be equal to ${count}`;
+	}
+});
+
+//#endregion
+//#region src/rules/hexadecimal.ts
+const hexadecimalRegex = /^[a-fA-F0-9]*$/;
+/**
+* Allows only hexadecimal values.
+*/
+const hexadecimal = createRule({
+	type: "hexadecimal",
+	validator(value) {
+		if (isEmpty(value)) return true;
+		return matchRegex(value, hexadecimalRegex);
+	},
+	message: "The value must be hexadecimal"
+});
+
+//#endregion
+//#region src/rules/integer.ts
+const integerRegex = /(^[0-9]*$)|(^-[0-9]+$)/;
+/**
+* Allows only integers (positive and negative).
+*/
+const integer = createRule({
+	type: "integer",
+	validator(value) {
+		if (isEmpty(value)) return true;
+		return matchRegex(value, integerRegex);
+	},
+	message: "The value must be an integer"
+});
+
+//#endregion
+//#region src/rules/ipv4Address.ts
+function nibbleValid(nibble) {
+	if (nibble.length > 3 || nibble.length === 0) return false;
+	if (nibble[0] === "0" && nibble !== "0") return false;
+	if (!nibble.match(/^\d+$/)) return false;
+	const numeric$1 = +nibble | 0;
+	return numeric$1 >= 0 && numeric$1 <= 255;
+}
+/**
+* Validates IPv4 addresses in dotted decimal notation 127.0.0.1.
+*/
+const ipv4Address = createRule({
+	type: "ipv4Address",
+	validator(value) {
+		if (isEmpty(value)) return true;
+		if (typeof value !== "string") return false;
+		const nibbles = value.split(".");
+		return nibbles.length === 4 && nibbles.every(nibbleValid);
+	},
+	message: "The value is not a valid IPv4 address"
+});
+
+//#endregion
+//#region src/rules/literal.ts
+/**
+* Allow only one possible literal value
+*/
+function literal(literal$1) {
+	const params = computed(() => toValue(literal$1));
+	const rule = withMessage(withParams((value, literal$2) => {
+		if (isFilled(value) && isFilled(literal$2)) return literal$2 === value;
+		return true;
+	}, [params]), ({ $params: [literal$2] }) => `Value should be ${literal$2}.`);
+	return rule;
+}
+
+//#endregion
+//#region src/rules/macAddress.ts
+/**
+* Validates MAC addresses. Call as a function to specify a custom separator (e.g., ':' or an empty string for 00ff1122334455).
+*
+* @param separator - the custom separator
+*/
+const macAddress = createRule({
+	type: "macAddress",
+	validator(value, separator = ":") {
+		if (isEmpty(value)) return true;
+		if (typeof value !== "string") return false;
+		const parts = typeof separator === "string" && separator !== "" ? value.split(separator) : value.length === 12 || value.length === 16 ? value.match(/.{2}/g) : null;
+		return parts !== null && (parts.length === 6 || parts.length === 8) && parts.every(hexValid);
+	},
+	message: "The value is not a valid MAC Address"
+});
+const hexValid = (hex) => hex.toLowerCase().match(/^[0-9a-f]{2}$/);
+
+//#endregion
+//#region src/rules/maxLength.ts
+/**
+* Requires the input value to have a maximum specified length, inclusive. Works with arrays, objects and strings.
+*
+* @param max - the maximum length
+* @param options - comparison options
+*/
+const maxLength = createRule({
+	type: "maxLength",
+	validator: (value, count, options) => {
+		const { allowEqual = true } = options ?? {};
+		if (isFilled(value, false) && isFilled(count)) {
+			if (isNumber(count)) if (allowEqual) return getSize(value) <= count;
+			else return getSize(value) < count;
+			console.warn(`[maxLength] Value or parameter isn't a number, got value: ${value}, parameter: ${count}`);
+			return false;
+		}
+		return true;
+	},
+	message: ({ $value, $params: [count] }) => {
+		if (Array.isArray($value)) return `This list should have maximum ${count} items`;
+		return `The value length should not exceed ${count}`;
+	}
+});
+
+//#endregion
+//#region src/rules/maxValue.ts
+/**
+* Requires a field to have a specified maximum numeric value.
+*
+* @param max - the maximum value
+* @param options - comparison options
+*/
+const maxValue = createRule({
+	type: "maxValue",
+	validator: (value, count, options) => {
+		const { allowEqual = true } = options ?? {};
+		if (isFilled(value) && isFilled(count)) {
+			if (isNumber(count) && !isNaN(toNumber(value))) if (allowEqual) return toNumber(value) <= count;
+			else return toNumber(value) < count;
+			console.warn(`[maxValue] Value or parameter isn't a number, got value: ${value}, parameter: ${count}`);
+			return true;
+		}
+		return true;
+	},
+	message: ({ $params: [count, options] }) => {
+		const { allowEqual = true } = options ?? {};
+		if (allowEqual) return `The value must be less than or equal to ${count}`;
+		else return `The value must be less than ${count}`;
+	}
+});
+
+//#endregion
+//#region src/rules/minLength.ts
+/**
+* Requires the input value to have a minimum specified length, inclusive. Works with arrays, objects and strings.
+*
+* @param min - the minimum value
+* @param options - comparison options
+*/
+const minLength = createRule({
+	type: "minLength",
+	validator: (value, count, options) => {
+		const { allowEqual = true } = options ?? {};
+		if (isFilled(value, false) && isFilled(count)) {
+			if (isNumber(count)) if (allowEqual) return getSize(value) >= count;
+			else return getSize(value) > count;
+			console.warn(`[minLength] Parameter isn't a number, got parameter: ${count}`);
+			return false;
+		}
+		return true;
+	},
+	message: ({ $value, $params: [count] }) => {
+		if (Array.isArray($value)) return `The list should have at least ${count} items`;
+		return `The value length should be at least ${count}`;
+	}
+});
+
+//#endregion
+//#region src/rules/minValue.ts
+/**
+* Requires a field to have a specified minimum numeric value.
+*
+* @param count - the minimum count
+* @param options - comparison options
+*/
+const minValue = createRule({
+	type: "minValue",
+	validator: (value, count, options) => {
+		const { allowEqual = true } = options ?? {};
+		if (isFilled(value) && isFilled(count)) {
+			if (isNumber(count) && !isNaN(toNumber(value))) if (allowEqual) return toNumber(value) >= count;
+			else return toNumber(value) > count;
+			console.warn(`[minValue] Value or parameter isn't a number, got value: ${value}, parameter: ${count}`);
+			return true;
+		}
+		return true;
+	},
+	message: ({ $params: [count, options] }) => {
+		const { allowEqual = true } = options ?? {};
+		if (allowEqual) return `The value must be greater than or equal to ${count}`;
+		else return `The value must be greater than ${count}`;
+	}
+});
+
+//#endregion
+//#region src/rules/nativeEnum.ts
+function getValidEnumValues(obj) {
+	const validKeys = Object.keys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+	const filtered = {};
+	for (const k of validKeys) filtered[k] = obj[k];
+	return Object.values(filtered);
+}
+/**
+* Validate against a native Typescript enum value.
+*/
+function nativeEnum(enumLike) {
+	const params = computed(() => toValue(enumLike));
+	const rule = withMessage(withParams((value, enumLike$1) => {
+		if (isFilled(value) && !isEmpty(enumLike$1)) {
+			const validValues = getValidEnumValues(enumLike$1);
+			return validValues.includes(value);
+		}
+		return true;
+	}, [params]), ({ $params: [enumLike$1] }) => `The value should be one of those options: ${Object.values(enumLike$1).join(", ")}.`);
+	return rule;
+}
+
+//#endregion
+//#region src/rules/number.ts
+/**
+* Requires a value to be a native number type
+*
+* Mainly used for typing
+*/
+const number = createRule({
+	type: "number",
+	validator: (value) => {
+		if (isFilled(value)) return isNumber(value);
+		return true;
+	},
+	message: "The value must be a native number"
+});
+
+//#endregion
+//#region src/rules/numeric.ts
+const numericRegex = /^\d*(\.\d+)?$/;
+/**
+* Allows only numeric values (including numeric strings).
+*/
+const numeric = createRule({
+	type: "numeric",
+	validator(value) {
+		if (isEmpty(value)) return true;
+		return matchRegex(value, numericRegex);
+	},
+	message: "The value must be numeric"
+});
+
+//#endregion
+//#region src/rules/oneOf.ts
+/**
+* Allow only one of the values from a fixed Array of possible entries.
+*/
+function oneOf(options) {
+	const params = computed(() => toValue(options));
+	const rule = withMessage(withParams((value, options$1) => {
+		if (isFilled(value) && isFilled(options$1, false)) return options$1.includes(value);
+		return true;
+	}, [params]), ({ $params: [options$1] }) => `The value should be one of those options: ${options$1.join(", ")}.`);
+	return rule;
+}
+
+//#endregion
+//#region src/rules/regex.ts
+/**
+* Checks if the value matches one or more regular expressions.
+*/
+const regex = createRule({
+	type: "regex",
+	validator(value, regexp) {
+		if (isFilled(value)) {
+			const filteredRegexp = Array.isArray(regexp) ? regexp : [regexp];
+			return matchRegex(value, ...filteredRegexp);
+		}
+		return true;
+	},
+	message: "The value does not match the required pattern"
+});
+
+//#endregion
+//#region src/rules/required.ts
+/**
+* Requires non-empty data. Checks for empty arrays and strings containing only whitespaces.
+*/
+const required = createRule({
+	type: "required",
+	validator: (value) => {
+		return isFilled(value);
+	},
+	message: "This field is required"
+});
+
+//#endregion
+//#region src/rules/requiredIf.ts
+/**
+* Requires non-empty data, only if provided data property, ref, or a function resolves to true.
+*
+* @param condition - the condition to enable the required rule
+*/
+const requiredIf = createRule({
+	type: "required",
+	validator(value, condition) {
+		if (condition) return isFilled(value);
+		return true;
+	},
+	message: "This field is required",
+	active({ $params: [condition] }) {
+		return condition;
+	}
+});
+
+//#endregion
+//#region src/rules/requiredUnless.ts
+/**
+* Requires non-empty data, only if provided data property, ref, or a function resolves to false.
+*
+* @param condition - the condition to disable the required rule
+*/
+const requiredUnless = createRule({
+	type: "required",
+	validator(value, condition) {
+		if (!condition) return isFilled(value);
+		return true;
+	},
+	message: "This field is required",
+	active({ $params: [condition] }) {
+		return !condition;
+	}
+});
+
+//#endregion
+//#region src/rules/sameAs.ts
+/**
+* Checks if the value matches the specified property or ref.
+*/
+const sameAs = createRule({
+	type: "sameAs",
+	validator(value, target, otherName) {
+		if (isEmpty(value)) return true;
+		return value === target;
+	},
+	message({ $params: [_, otherName = "other"] }) {
+		return `The value must be equal to the ${otherName} value`;
+	}
+});
+
+//#endregion
+//#region src/rules/startsWith.ts
+/**
+* Checks if the string starts with the specified substring.
+*
+* @private part - the value the field must start with
+*/
+const startsWith = createRule({
+	type: "startsWith",
+	validator(value, part) {
+		if (isFilled(value) && isFilled(part)) return value.startsWith(part);
+		return true;
+	},
+	message({ $params: [part] }) {
+		return `The value must end with ${part}`;
+	}
+});
+
+//#endregion
+//#region src/rules/string.ts
+/**
+* Requires a value to be a native string type
+*
+* Mainly used for typing
+*/
+const string = createRule({
+	type: "string",
+	validator: (value) => {
+		if (isFilled(value)) return typeof value === "string";
+		return true;
+	},
+	message: "The value must be a string"
+});
+
+//#endregion
+//#region src/rules/type.ts
+/**
+* Define the input type of a rule. No runtime validation.
+*
+* Override any input type set by other rules.
+*/
+function type() {
+	return () => true;
+}
+
+//#endregion
+//#region src/rules/url.ts
+/**
+* Regex taken from {@link https://gist.github.com/dperini/729294}
+*/
+const urlRegex = /^(?:(?:(?:https?|ftp):)?\/\/)(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u00a1-\uffff][a-z0-9\u00a1-\uffff_-]{0,62})?[a-z0-9\u00a1-\uffff]\.)+(?:[a-z\u00a1-\uffff]{2,}\.?))(?::\d{2,5})?(?:[/?#]\S*)?$/i;
+/**
+* Validates URLs.
+*/
+const url = createRule({
+	type: "url",
+	validator(value) {
+		if (isEmpty(value)) return true;
+		return matchRegex(value, urlRegex);
+	},
+	message: "The value is not a valid URL address"
+});
+
+//#endregion
+export { alpha, alphaNum, and, applyIf, between, boolean, checked, contains, date, dateAfter, dateBefore, dateBetween, decimal, email, endsWith, exactLength, exactValue, getSize, hexadecimal, integer, ipv4Address, isDate, isEmpty, isFilled, isNumber, literal, macAddress, matchRegex, maxLength, maxValue, minLength, minValue, nativeEnum, not, number, numeric, oneOf, or, regex, required, requiredIf, requiredUnless, sameAs, startsWith, string, toDate, toNumber, type, url, withAsync, withMessage, withParams, withTooltip };