react-form-with-constraints/dist/cjs/Async.js

Simple form validation for React

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Async = exports.Status = void 0;
const React = require("react");
const prop_types_1 = require("prop-types");
const assert_1 = require("./assert");
const FieldFeedbacks_1 = require("./FieldFeedbacks");
const FormWithConstraints_1 = require("./FormWithConstraints");
const withValidateFieldEventEmitter_1 = require("./withValidateFieldEventEmitter");
var Status;
(function (Status) {
    Status[Status["None"] = 0] = "None";
    Status[Status["Pending"] = 1] = "Pending";
    Status[Status["Rejected"] = 2] = "Rejected";
    Status[Status["Resolved"] = 3] = "Resolved";
})(Status = exports.Status || (exports.Status = {}));
class AsyncComponent extends React.PureComponent {
}
class Async extends (0, withValidateFieldEventEmitter_1.withValidateFieldEventEmitter)(AsyncComponent) {
    constructor() {
        super(...arguments);
        this.state = {
            status: Status.None
        };
        this.validate = (input) => {
            const { form, fieldFeedbacks } = this.context;
            let validations;
            const field = form.fieldsStore.getField(input.name);
            if ((fieldFeedbacks.props.stop === 'first' && field.hasFeedbacks(fieldFeedbacks.key)) ||
                (fieldFeedbacks.props.stop === 'first-error' && field.hasErrors(fieldFeedbacks.key)) ||
                (fieldFeedbacks.props.stop === 'first-warning' && field.hasWarnings(fieldFeedbacks.key)) ||
                (fieldFeedbacks.props.stop === 'first-info' && field.hasInfos(fieldFeedbacks.key))) {
                this.setState({ status: Status.None });
            }
            else {
                validations = this._validate(input);
            }
            return validations;
        };
    }
    getChildContext() {
        return {
            async: this
        };
    }
    componentDidMount() {
        this.context.fieldFeedbacks.addValidateFieldEventListener(this.validate);
    }
    componentWillUnmount() {
        this.context.fieldFeedbacks.removeValidateFieldEventListener(this.validate);
    }
    async setStateSync(state) {
        return new Promise(resolve => {
            this.setState(state, resolve);
        });
    }
    async _validate(input) {
        let state = {
            status: Status.Pending
        };
        this.setState(state);
        try {
            const value = await this.props.promise(input.value);
            state = { status: Status.Resolved, value };
        }
        catch (e) {
            state = { status: Status.Rejected, value: e };
        }
        await this.setStateSync(state);
        return this.emitValidateFieldEvent(input);
    }
    render() {
        const { props, state } = this;
        let element = null;
        switch (state.status) {
            case Status.None:
                break;
            case Status.Pending:
                if (props.pending)
                    element = props.pending;
                break;
            case Status.Resolved:
                if (props.then)
                    element = props.then(state.value);
                break;
            case Status.Rejected:
                if (props.catch)
                    element = props.catch(state.value);
                break;
            default:
                (0, assert_1.assert)(false, `Unknown status: '${state.status}'`);
        }
        return element;
    }
}
exports.Async = Async;
Async.contextTypes = {
    form: (0, prop_types_1.instanceOf)(FormWithConstraints_1.FormWithConstraints).isRequired,
    fieldFeedbacks: (0, prop_types_1.instanceOf)(FieldFeedbacks_1.FieldFeedbacks).isRequired
};
Async.childContextTypes = {
    async: (0, prop_types_1.instanceOf)(Async).isRequired
};