@cosva-lab/form-builder/utils/validate/InputsValidator.mjs

React form builder.

import { hasErrors } from "../hasErrors.mjs";
import { __decorate } from "../../_virtual/_@oxc-project_runtime@0.112.0/helpers/decorate.mjs";
import { action, makeObservable, observable, runInAction, toJS } from "mobx";

//#region src/utils/validate/InputsValidator.ts
var InputsValidator = class {
	get invalid() {
		return !this.valid;
	}
	get validate() {
		return typeof this._validate === "function" ? this._validate(this) : this._validate;
	}
	set validate(validate) {
		this._validate = validate;
		if (validate) this.validity();
		for (const field of this.fields || []) if (validate && !field._validate) field._validate = true;
		else field.errors = void 0;
	}
	constructor({ fields, validate }) {
		this.valid = true;
		this.fieldsMap = {};
		this._validate = false;
		makeObservable(this);
		if (typeof validate !== "undefined") this._validate = validate;
		this.callbackField = this.callbackField.bind(this);
		this.fields = fields;
		for (const field of this.fields) {
			const name = field.name;
			this.fieldsMap[name] = field;
		}
	}
	async callbackField(callback) {
		const fields = this.fields;
		for (const field of this.fields || []) {
			let cancel = false;
			await callback(field, () => cancel = true);
			if (cancel) break;
		}
		return fields;
	}
	async validityBase(args) {
		this.valid = true;
		const { setErrors = true, throwFirstError = false, validateDisabled = false } = { ...args };
		await this.callbackField(async (field, cancel) => {
			if (field.enabled || validateDisabled) {
				const valid = setErrors ? await field.validity() : !await field.hasErrors();
				runInAction(() => {
					if (!valid) this.valid = valid;
				});
				if (throwFirstError && !this.valid) cancel();
			}
		});
		return this.valid;
	}
	validity() {
		this._validate = true;
		return this.validityBase();
	}
	async hasErrors(params) {
		const { setErrors = false, throwFirstError = false, validateDisabled = false } = { ...params };
		if (setErrors) this._validate = true;
		return !await this.validityBase({
			setErrors,
			throwFirstError,
			validateDisabled
		});
	}
	addErrors(errors) {
		if (!this.validate) this.validate = true;
		for (const key in errors) if (errors.hasOwnProperty(key)) {
			const error = errors[key];
			this.callbackField((field) => {
				if (field.name === key) field.addErrors(error);
			});
		}
	}
	setErrors(errors) {
		errors && this.addErrors(errors);
	}
	async getErrors() {
		const fieldsErrors = {};
		for (const { name, errors, enabled } of this.fields) if (hasErrors(errors) && enabled) fieldsErrors[name] = errors;
		return toJS(fieldsErrors);
	}
};
__decorate([observable], InputsValidator.prototype, "valid", void 0);
__decorate([observable], InputsValidator.prototype, "fields", void 0);
__decorate([observable], InputsValidator.prototype, "_validate", void 0);
__decorate([action], InputsValidator.prototype, "validityBase", null);
__decorate([action.bound], InputsValidator.prototype, "hasErrors", null);
__decorate([action.bound], InputsValidator.prototype, "addErrors", null);
__decorate([action.bound], InputsValidator.prototype, "setErrors", null);
__decorate([action.bound], InputsValidator.prototype, "getErrors", null);

//#endregion
export { InputsValidator as default };