mobx-react-form/lib/validators/VJF.js

Reactive MobX Form State Management

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.VJF = void 0;
const lodash_1 = __importDefault(require("lodash"));
function isPromise(obj) {
    return (!!obj &&
        typeof obj.then === "function" &&
        (typeof obj === "object" || typeof obj === "function"));
}
class VJF {
    constructor({ config, state = null, promises = [], }) {
        Object.defineProperty(this, "promises", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, "config", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, "state", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, "extend", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, "validator", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        this.state = state;
        this.promises = promises;
        this.config = config;
        this.extend = config === null || config === void 0 ? void 0 : config.extend;
        this.validator = config === null || config === void 0 ? void 0 : config.package;
        this.extendValidator();
    }
    extendValidator() {
        if (typeof this.extend === "function") {
            this.extend({
                validator: this.validator,
                form: this.state.form,
            });
        }
    }
    validate(field) {
        if (!field.validators)
            return;
        const validators = Array.isArray(field.validators) ? field.validators : [field.validators];
        validators.forEach((fn) => this.collectData(fn, field));
        this.executeValidation(field);
    }
    collectData(fn, field) {
        const result = this.handleFunctionResult(fn, field);
        if (isPromise(result)) {
            const $p = result
                .then(([valid, message]) => field.setValidationAsyncData(valid, message))
                .then(() => this.executeAsyncValidation(field));
            this.promises.push($p);
            return;
        }
        field.validationFunctionsData.unshift({
            valid: result[0],
            message: result[1],
        });
    }
    executeValidation(field) {
        field.validationFunctionsData.forEach(({ valid, message }) => {
            if (valid === false) {
                field.invalidate(message, false);
            }
        });
    }
    executeAsyncValidation(field) {
        const data = field.validationAsyncData;
        if (data.valid === false) {
            field.invalidate(data.message, false, true);
        }
    }
    handleFunctionResult(fn, field) {
        const result = fn({
            validator: this.validator,
            form: this.state.form,
            field,
        });
        if (Array.isArray(result)) {
            return [result[0] || false, result[1] || "Error"];
        }
        if (lodash_1.default.isBoolean(result)) {
            return [result, "Error"];
        }
        if (lodash_1.default.isString(result)) {
            return [false, result];
        }
        if (isPromise(result)) {
            return result;
        }
        return [false, "Error"];
    }
}
exports.VJF = VJF;
exports.default = (config) => ({
    class: (VJF),
    config,
});
//# sourceMappingURL=VJF.js.map