@mantine/form/esm/validate/validate-values.mjs

Mantine form management library

"use client";
import { filterErrors } from "../hooks/use-form-errors/filter-errors/filter-errors.mjs";
import { getPath } from "../paths/get-path.mjs";
//#region packages/@mantine/form/src/validate/validate-values.ts
const formRootRule = Symbol("root-rule");
function getValidationResults(errors) {
	const filteredErrors = filterErrors(errors);
	return {
		hasErrors: Object.keys(filteredErrors).length > 0,
		errors: filteredErrors
	};
}
function validateRulesRecord(rules, values, resolveValidationError, signal, path = "", errors = {}) {
	if (typeof rules !== "object" || rules === null) return errors;
	const asyncTasks = [];
	const pendingRecursions = [];
	for (const ruleKey of Object.keys(rules)) {
		const rule = rules[ruleKey];
		const rulePath = `${path === "" ? "" : `${path}.`}${ruleKey}`;
		const value = getPath(rulePath, values);
		let arrayValidation = false;
		if (typeof rule === "function") {
			const result = rule(value, values, rulePath, signal);
			if (result instanceof Promise) asyncTasks.push({
				rulePath,
				promise: result
			});
			else errors[rulePath] = result;
		}
		if (typeof rule === "object" && Array.isArray(value)) {
			arrayValidation = true;
			for (let index = 0; index < value.length; index++) {
				const recursionResult = validateRulesRecord(rule, values, resolveValidationError, signal, `${rulePath}.${index}`, errors);
				if (recursionResult instanceof Promise) pendingRecursions.push(recursionResult);
			}
			if (formRootRule in rule) {
				const rootResult = rule[formRootRule](value, values, rulePath, signal);
				if (rootResult instanceof Promise) asyncTasks.push({
					rulePath,
					promise: rootResult
				});
				else errors[rulePath] = rootResult;
			}
		}
		if (typeof rule === "object" && typeof value === "object" && value !== null) {
			if (!arrayValidation) {
				const recursionResult = validateRulesRecord(rule, values, resolveValidationError, signal, rulePath, errors);
				if (recursionResult instanceof Promise) pendingRecursions.push(recursionResult);
			}
			if (formRootRule in rule) {
				const rootResult = rule[formRootRule](value, values, rulePath, signal);
				if (rootResult instanceof Promise) asyncTasks.push({
					rulePath,
					promise: rootResult
				});
				else errors[rulePath] = rootResult;
			}
		}
	}
	if (asyncTasks.length === 0 && pendingRecursions.length === 0) return errors;
	return (async () => {
		await Promise.all(pendingRecursions);
		if (asyncTasks.length > 0) (await Promise.allSettled(asyncTasks.map((t) => t.promise))).forEach((result, index) => {
			const { rulePath } = asyncTasks[index];
			if (result.status === "fulfilled") errors[rulePath] = result.value;
			else errors[rulePath] = resolveValidationError(result.reason);
		});
		return errors;
	})();
}
const defaultResolveError = (err) => err instanceof Error ? err.message : String(err);
function validateValues(validate, values, resolveValidationError = defaultResolveError, signal = new AbortController().signal) {
	if (typeof validate === "function") {
		const result = validate(values);
		if (result instanceof Promise) return result.then(getValidationResults);
		return getValidationResults(result);
	}
	const errorsResult = validateRulesRecord(validate, values, resolveValidationError, signal);
	if (errorsResult instanceof Promise) return errorsResult.then(getValidationResults);
	return getValidationResults(errorsResult);
}
//#endregion
export { formRootRule, validateValues };

//# sourceMappingURL=validate-values.mjs.map