react-hook-form-6/dist/index.ie11.development.js

Latest version 6 of react-hook-form

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var React = require('react');

/*! *****************************************************************************
Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */

var __assign = function() {
    __assign = Object.assign || function __assign(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};

function __rest(s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
}

function __awaiter(thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
}

function __generator(thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
}

function __values(o) {
    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
    if (m) return m.call(o);
    if (o && typeof o.length === "number") return {
        next: function () {
            if (o && i >= o.length) o = void 0;
            return { value: o && o[i++], done: !o };
        }
    };
    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}

function __read(o, n) {
    var m = typeof Symbol === "function" && o[Symbol.iterator];
    if (!m) return o;
    var i = m.call(o), r, ar = [], e;
    try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
    }
    catch (error) { e = { error: error }; }
    finally {
        try {
            if (r && !r.done && (m = i["return"])) m.call(i);
        }
        finally { if (e) throw e.error; }
    }
    return ar;
}

function __spread() {
    for (var ar = [], i = 0; i < arguments.length; i++)
        ar = ar.concat(__read(arguments[i]));
    return ar;
}

var isHTMLElement = (function (value) {
    return value instanceof HTMLElement;
});

var EVENTS = {
    BLUR: 'blur',
    CHANGE: 'change',
    INPUT: 'input',
};
var VALIDATION_MODE = {
    onBlur: 'onBlur',
    onChange: 'onChange',
    onSubmit: 'onSubmit',
    onTouched: 'onTouched',
    all: 'all',
};
var SELECT = 'select';
var UNDEFINED = 'undefined';
var INPUT_VALIDATION_RULES = {
    max: 'max',
    min: 'min',
    maxLength: 'maxLength',
    minLength: 'minLength',
    pattern: 'pattern',
    required: 'required',
    validate: 'validate',
};

function attachEventListeners(_a, shouldAttachChangeEvent, handleChange) {
    var ref = _a.ref;
    if (isHTMLElement(ref) && handleChange) {
        ref.addEventListener(shouldAttachChangeEvent ? EVENTS.CHANGE : EVENTS.INPUT, handleChange);
        ref.addEventListener(EVENTS.BLUR, handleChange);
    }
}

var isNullOrUndefined = (function (value) { return value == null; });

var isObjectType = function (value) { return typeof value === 'object'; };
var isObject = (function (value) {
    return !isNullOrUndefined(value) &&
        !Array.isArray(value) &&
        isObjectType(value) &&
        !(value instanceof Date);
});

var isKey = (function (value) { return /^\w*$/.test(value); });

var compact = (function (value) { return value.filter(Boolean); });

var stringToPath = (function (input) {
    return compact(input
        .replace(/["|']/g, '')
        .replace(/\[/g, '.')
        .replace(/\]/g, '')
        .split('.'));
});

function set(object, path, value) {
    var index = -1;
    var tempPath = isKey(path) ? [path] : stringToPath(path);
    var length = tempPath.length;
    var lastIndex = length - 1;
    while (++index < length) {
        var key = tempPath[index];
        var newValue = value;
        if (index !== lastIndex) {
            var objValue = object[key];
            newValue =
                isObject(objValue) || Array.isArray(objValue)
                    ? objValue
                    : !isNaN(+tempPath[index + 1])
                        ? []
                        : {};
        }
        object[key] = newValue;
        object = object[key];
    }
    return object;
}

var transformToNestObject = (function (data, value) {
    if (value === void 0) { value = {}; }
    for (var key in data) {
        !isKey(key) ? set(value, key, data[key]) : (value[key] = data[key]);
    }
    return value;
});

var isUndefined = (function (val) { return val === undefined; });

var get = (function (obj, path, defaultValue) {
    if (obj === void 0) { obj = {}; }
    var result = compact(path.split(/[,[\].]+?/)).reduce(function (result, key) { return (isNullOrUndefined(result) ? result : result[key]); }, obj);
    return isUndefined(result) || result === obj
        ? isUndefined(obj[path])
            ? defaultValue
            : obj[path]
        : result;
});

var focusOnErrorField = (function (fields, fieldErrors) {
    for (var key in fields) {
        if (get(fieldErrors, key)) {
            var field = fields[key];
            if (field) {
                if (field.ref.focus && isUndefined(field.ref.focus())) {
                    break;
                }
                else if (field.options) {
                    field.options[0].ref.focus();
                    break;
                }
            }
        }
    }
});

var removeAllEventListeners = (function (ref, validateWithStateUpdate) {
    if (isHTMLElement(ref) && ref.removeEventListener) {
        ref.removeEventListener(EVENTS.INPUT, validateWithStateUpdate);
        ref.removeEventListener(EVENTS.CHANGE, validateWithStateUpdate);
        ref.removeEventListener(EVENTS.BLUR, validateWithStateUpdate);
    }
});

var defaultReturn = {
    isValid: false,
    value: null,
};
var getRadioValue = (function (options) {
    return Array.isArray(options)
        ? options.reduce(function (previous, option) {
            return option && option.ref.checked
                ? {
                    isValid: true,
                    value: option.ref.value,
                }
                : previous;
        }, defaultReturn)
        : defaultReturn;
});

var getMultipleSelectValue = (function (options) {
    return __spread(options).filter(function (_a) {
        var selected = _a.selected;
        return selected;
    })
        .map(function (_a) {
        var value = _a.value;
        return value;
    });
});

var isRadioInput = (function (element) {
    return element.type === 'radio';
});

var isFileInput = (function (element) {
    return element.type === 'file';
});

var isCheckBoxInput = (function (element) {
    return element.type === 'checkbox';
});

var isMultipleSelect = (function (element) {
    return element.type === SELECT + "-multiple";
});

var defaultResult = {
    value: false,
    isValid: false,
};
var validResult = { value: true, isValid: true };
var getCheckboxValue = (function (options) {
    if (Array.isArray(options)) {
        if (options.length > 1) {
            var values = options
                .filter(function (option) { return option && option.ref.checked; })
                .map(function (_a) {
                var value = _a.ref.value;
                return value;
            });
            return { value: values, isValid: !!values.length };
        }
        var _a = options[0].ref, checked = _a.checked, value = _a.value, attributes = _a.attributes;
        return checked
            ? attributes && !isUndefined(attributes.value)
                ? isUndefined(value) || value === ''
                    ? validResult
                    : { value: value, isValid: true }
                : validResult
            : defaultResult;
    }
    return defaultResult;
});

function getFieldValue(fieldsRef, name, shallowFieldsStateRef, excludeDisabled, shouldKeepRawValue) {
    var field = fieldsRef.current[name];
    if (field) {
        var _a = field.ref, value = _a.value, disabled = _a.disabled, ref = field.ref, valueAsNumber = field.valueAsNumber, valueAsDate = field.valueAsDate, setValueAs = field.setValueAs;
        if (disabled && excludeDisabled) {
            return;
        }
        if (isFileInput(ref)) {
            return ref.files;
        }
        if (isRadioInput(ref)) {
            return getRadioValue(field.options).value;
        }
        if (isMultipleSelect(ref)) {
            return getMultipleSelectValue(ref.options);
        }
        if (isCheckBoxInput(ref)) {
            return getCheckboxValue(field.options).value;
        }
        return shouldKeepRawValue
            ? value
            : valueAsNumber
                ? value === ''
                    ? NaN
                    : +value
                : valueAsDate
                    ? ref.valueAsDate
                    : setValueAs
                        ? setValueAs(value)
                        : value;
    }
    if (shallowFieldsStateRef) {
        return get(shallowFieldsStateRef.current, name);
    }
}

function isDetached(element) {
    if (!element) {
        return true;
    }
    if (!(element instanceof HTMLElement) ||
        element.nodeType === Node.DOCUMENT_NODE) {
        return false;
    }
    return isDetached(element.parentNode);
}

var isEmptyObject = (function (value) {
    return isObject(value) && !Object.keys(value).length;
});

var isBoolean = (function (value) { return typeof value === 'boolean'; });

function baseGet(object, updatePath) {
    var length = updatePath.slice(0, -1).length;
    var index = 0;
    while (index < length) {
        object = isUndefined(object) ? index++ : object[updatePath[index++]];
    }
    return object;
}
function unset(object, path) {
    var updatePath = isKey(path) ? [path] : stringToPath(path);
    var childObject = updatePath.length == 1 ? object : baseGet(object, updatePath);
    var key = updatePath[updatePath.length - 1];
    var previousObjRef;
    if (childObject) {
        delete childObject[key];
    }
    for (var k = 0; k < updatePath.slice(0, -1).length; k++) {
        var index = -1;
        var objectRef = void 0;
        var currentPaths = updatePath.slice(0, -(k + 1));
        var currentPathsLength = currentPaths.length - 1;
        if (k > 0) {
            previousObjRef = object;
        }
        while (++index < currentPaths.length) {
            var item = currentPaths[index];
            objectRef = objectRef ? objectRef[item] : object[item];
            if (currentPathsLength === index &&
                ((isObject(objectRef) && isEmptyObject(objectRef)) ||
                    (Array.isArray(objectRef) &&
                        !objectRef.filter(function (data) {
                            return (isObject(data) && !isEmptyObject(data)) || isBoolean(data);
                        }).length))) {
                previousObjRef ? delete previousObjRef[item] : delete object[item];
            }
            previousObjRef = objectRef;
        }
    }
    return object;
}

var isSameRef = function (fieldValue, ref) {
    return fieldValue && fieldValue.ref === ref;
};
function findRemovedFieldAndRemoveListener(fieldsRef, handleChange, field, shallowFieldsStateRef, shouldUnregister, forceDelete) {
    var ref = field.ref, name = field.ref.name;
    var fieldRef = fieldsRef.current[name];
    if (!shouldUnregister) {
        var value = getFieldValue(fieldsRef, name, shallowFieldsStateRef);
        !isUndefined(value) && set(shallowFieldsStateRef.current, name, value);
    }
    if (!ref.type || !fieldRef) {
        delete fieldsRef.current[name];
        return;
    }
    if (isRadioInput(ref) || isCheckBoxInput(ref)) {
        if (Array.isArray(fieldRef.options) && fieldRef.options.length) {
            compact(fieldRef.options).forEach(function (option, index) {
                if (option === void 0) { option = {}; }
                if ((isDetached(option.ref) && isSameRef(option, option.ref)) ||
                    forceDelete) {
                    removeAllEventListeners(option.ref, handleChange);
                    unset(fieldRef.options, "[" + index + "]");
                }
            });
            if (fieldRef.options && !compact(fieldRef.options).length) {
                delete fieldsRef.current[name];
            }
        }
        else {
            delete fieldsRef.current[name];
        }
    }
    else if ((isDetached(ref) && isSameRef(fieldRef, ref)) || forceDelete) {
        removeAllEventListeners(ref, handleChange);
        delete fieldsRef.current[name];
    }
}

var isPrimitive = (function (value) {
    return isNullOrUndefined(value) || !isObjectType(value);
});

function deepMerge(target, source) {
    if (isPrimitive(target) || isPrimitive(source)) {
        return source;
    }
    for (var key in source) {
        var targetValue = target[key];
        var sourceValue = source[key];
        try {
            target[key] =
                (isObject(targetValue) && isObject(sourceValue)) ||
                    (Array.isArray(targetValue) && Array.isArray(sourceValue))
                    ? deepMerge(targetValue, sourceValue)
                    : sourceValue;
        }
        catch (_a) { }
    }
    return target;
}

function deepEqual(object1, object2, isErrorObject) {
    var e_1, _a;
    if (isPrimitive(object1) ||
        isPrimitive(object2) ||
        object1 instanceof Date ||
        object2 instanceof Date) {
        return object1 === object2;
    }
    if (!React.isValidElement(object1)) {
        var keys1 = Object.keys(object1);
        var keys2 = Object.keys(object2);
        if (keys1.length !== keys2.length) {
            return false;
        }
        try {
            for (var keys1_1 = __values(keys1), keys1_1_1 = keys1_1.next(); !keys1_1_1.done; keys1_1_1 = keys1_1.next()) {
                var key = keys1_1_1.value;
                var val1 = object1[key];
                if (!(isErrorObject && key === 'ref')) {
                    var val2 = object2[key];
                    if ((isObject(val1) || Array.isArray(val1)) &&
                        (isObject(val2) || Array.isArray(val2))
                        ? !deepEqual(val1, val2, isErrorObject)
                        : val1 !== val2) {
                        return false;
                    }
                }
            }
        }
        catch (e_1_1) { e_1 = { error: e_1_1 }; }
        finally {
            try {
                if (keys1_1_1 && !keys1_1_1.done && (_a = keys1_1.return)) _a.call(keys1_1);
            }
            finally { if (e_1) throw e_1.error; }
        }
    }
    return true;
}

function setDirtyFields(values, defaultValues, dirtyFields, parentNode, parentName) {
    var _a;
    var index = -1;
    while (++index < values.length) {
        for (var key in values[index]) {
            if (Array.isArray(values[index][key])) {
                !dirtyFields[index] && (dirtyFields[index] = {});
                dirtyFields[index][key] = [];
                setDirtyFields(values[index][key], get(defaultValues[index] || {}, key, []), dirtyFields[index][key], dirtyFields[index], key);
            }
            else {
                deepEqual(get(defaultValues[index] || {}, key), values[index][key])
                    ? set(dirtyFields[index] || {}, key)
                    : (dirtyFields[index] = __assign(__assign({}, dirtyFields[index]), (_a = {}, _a[key] = true, _a)));
            }
        }
        parentNode &&
            !dirtyFields.length &&
            delete parentNode[parentName];
    }
    return dirtyFields;
}
var setFieldArrayDirtyFields = (function (values, defaultValues, dirtyFields) {
    return deepMerge(setDirtyFields(values, defaultValues, dirtyFields.slice(0, values.length)), setDirtyFields(defaultValues, values, dirtyFields.slice(0, values.length)));
});

var isString = (function (value) { return typeof value === 'string'; });

var getFieldsValues = (function (fieldsRef, shallowFieldsState, shouldUnregister, excludeDisabled, search) {
    var output = {};
    var _loop_1 = function (name_1) {
        if (isUndefined(search) ||
            (isString(search)
                ? name_1.startsWith(search)
                : Array.isArray(search) && search.find(function (data) { return name_1.startsWith(data); }))) {
            output[name_1] = getFieldValue(fieldsRef, name_1, undefined, excludeDisabled);
        }
    };
    for (var name_1 in fieldsRef.current) {
        _loop_1(name_1);
    }
    return shouldUnregister
        ? transformToNestObject(output)
        : deepMerge(shallowFieldsState, transformToNestObject(output));
});

var isErrorStateChanged = (function (_a) {
    var errors = _a.errors, name = _a.name, error = _a.error, validFields = _a.validFields, fieldsWithValidation = _a.fieldsWithValidation;
    var isValid = isUndefined(error);
    var previousError = get(errors, name);
    return ((isValid && !!previousError) ||
        (!isValid && !deepEqual(previousError, error, true)) ||
        (isValid && get(fieldsWithValidation, name) && !get(validFields, name)));
});

var isRegex = (function (value) { return value instanceof RegExp; });

var getValueAndMessage = (function (validationData) {
    return isObject(validationData) && !isRegex(validationData)
        ? validationData
        : {
            value: validationData,
            message: '',
        };
});

var isFunction = (function (value) {
    return typeof value === 'function';
});

var isMessage = (function (value) {
    return isString(value) || React.isValidElement(value);
});

function getValidateError(result, ref, type) {
    if (type === void 0) { type = 'validate'; }
    if (isMessage(result) || (isBoolean(result) && !result)) {
        return {
            type: type,
            message: isMessage(result) ? result : '',
            ref: ref,
        };
    }
}

var appendErrors = (function (name, validateAllFieldCriteria, errors, type, message) {
    var _a;
    return validateAllFieldCriteria
        ? __assign(__assign({}, errors[name]), { types: __assign(__assign({}, (errors[name] && errors[name].types ? errors[name].types : {})), (_a = {}, _a[type] = message || true, _a)) }) : {};
});

var validateField = (function (fieldsRef, validateAllFieldCriteria, _a, shallowFieldsStateRef) {
    var ref = _a.ref, value = _a.ref.value, options = _a.options, required = _a.required, maxLength = _a.maxLength, minLength = _a.minLength, min = _a.min, max = _a.max, pattern = _a.pattern, validate = _a.validate;
    return __awaiter(void 0, void 0, void 0, function () {
        var name, error, isRadio, isCheckBox, isRadioOrCheckbox, isEmpty, appendErrorsCurry, getMinMaxMessage, _b, value_1, message, exceedMax, exceedMin, maxOutput, minOutput, valueNumber, valueDate, maxLengthOutput, minLengthOutput, exceedMax, exceedMin, _c, patternValue, message, fieldValue, validateRef, result, validateError, validationResult, _d, _e, _f, key, validateFunction, validateResult, validateError, e_1_1;
        var e_1, _g;
        return __generator(this, function (_h) {
            switch (_h.label) {
                case 0:
                    name = ref.name;
                    error = {};
                    isRadio = isRadioInput(ref);
                    isCheckBox = isCheckBoxInput(ref);
                    isRadioOrCheckbox = isRadio || isCheckBox;
                    isEmpty = value === '';
                    appendErrorsCurry = appendErrors.bind(null, name, validateAllFieldCriteria, error);
                    getMinMaxMessage = function (exceedMax, maxLengthMessage, minLengthMessage, maxType, minType) {
                        if (maxType === void 0) { maxType = INPUT_VALIDATION_RULES.maxLength; }
                        if (minType === void 0) { minType = INPUT_VALIDATION_RULES.minLength; }
                        var message = exceedMax ? maxLengthMessage : minLengthMessage;
                        error[name] = __assign({ type: exceedMax ? maxType : minType, message: message,
                            ref: ref }, (exceedMax
                            ? appendErrorsCurry(maxType, message)
                            : appendErrorsCurry(minType, message)));
                    };
                    if (required &&
                        ((!isRadio && !isCheckBox && (isEmpty || isNullOrUndefined(value))) ||
                            (isBoolean(value) && !value) ||
                            (isCheckBox && !getCheckboxValue(options).isValid) ||
                            (isRadio && !getRadioValue(options).isValid))) {
                        _b = isMessage(required)
                            ? { value: !!required, message: required }
                            : getValueAndMessage(required), value_1 = _b.value, message = _b.message;
                        if (value_1) {
                            error[name] = __assign({ type: INPUT_VALIDATION_RULES.required, message: message, ref: isRadioOrCheckbox
                                    ? ((fieldsRef.current[name].options || [])[0] || {}).ref
                                    : ref }, appendErrorsCurry(INPUT_VALIDATION_RULES.required, message));
                            if (!validateAllFieldCriteria) {
                                return [2 /*return*/, error];
                            }
                        }
                    }
                    if ((!isNullOrUndefined(min) || !isNullOrUndefined(max)) && value !== '') {
                        exceedMax = void 0;
                        exceedMin = void 0;
                        maxOutput = getValueAndMessage(max);
                        minOutput = getValueAndMessage(min);
                        if (!isNaN(value)) {
                            valueNumber = ref.valueAsNumber || parseFloat(value);
                            if (!isNullOrUndefined(maxOutput.value)) {
                                exceedMax = valueNumber > maxOutput.value;
                            }
                            if (!isNullOrUndefined(minOutput.value)) {
                                exceedMin = valueNumber < minOutput.value;
                            }
                        }
                        else {
                            valueDate = ref.valueAsDate || new Date(value);
                            if (isString(maxOutput.value)) {
                                exceedMax = valueDate > new Date(maxOutput.value);
                            }
                            if (isString(minOutput.value)) {
                                exceedMin = valueDate < new Date(minOutput.value);
                            }
                        }
                        if (exceedMax || exceedMin) {
                            getMinMaxMessage(!!exceedMax, maxOutput.message, minOutput.message, INPUT_VALIDATION_RULES.max, INPUT_VALIDATION_RULES.min);
                            if (!validateAllFieldCriteria) {
                                return [2 /*return*/, error];
                            }
                        }
                    }
                    if (isString(value) && !isEmpty && (maxLength || minLength)) {
                        maxLengthOutput = getValueAndMessage(maxLength);
                        minLengthOutput = getValueAndMessage(minLength);
                        exceedMax = !isNullOrUndefined(maxLengthOutput.value) &&
                            value.length > maxLengthOutput.value;
                        exceedMin = !isNullOrUndefined(minLengthOutput.value) &&
                            value.length < minLengthOutput.value;
                        if (exceedMax || exceedMin) {
                            getMinMaxMessage(exceedMax, maxLengthOutput.message, minLengthOutput.message);
                            if (!validateAllFieldCriteria) {
                                return [2 /*return*/, error];
                            }
                        }
                    }
                    if (isString(value) && pattern && !isEmpty) {
                        _c = getValueAndMessage(pattern), patternValue = _c.value, message = _c.message;
                        if (isRegex(patternValue) && !patternValue.test(value)) {
                            error[name] = __assign({ type: INPUT_VALIDATION_RULES.pattern, message: message,
                                ref: ref }, appendErrorsCurry(INPUT_VALIDATION_RULES.pattern, message));
                            if (!validateAllFieldCriteria) {
                                return [2 /*return*/, error];
                            }
                        }
                    }
                    if (!validate) return [3 /*break*/, 11];
                    fieldValue = getFieldValue(fieldsRef, name, shallowFieldsStateRef, false, true);
                    validateRef = isRadioOrCheckbox && options ? options[0].ref : ref;
                    if (!isFunction(validate)) return [3 /*break*/, 2];
                    return [4 /*yield*/, validate(fieldValue)];
                case 1:
                    result = _h.sent();
                    validateError = getValidateError(result, validateRef);
                    if (validateError) {
                        error[name] = __assign(__assign({}, validateError), appendErrorsCurry(INPUT_VALIDATION_RULES.validate, validateError.message));
                        if (!validateAllFieldCriteria) {
                            return [2 /*return*/, error];
                        }
                    }
                    return [3 /*break*/, 11];
                case 2:
                    if (!isObject(validate)) return [3 /*break*/, 11];
                    validationResult = {};
                    _h.label = 3;
                case 3:
                    _h.trys.push([3, 8, 9, 10]);
                    _d = __values(Object.entries(validate)), _e = _d.next();
                    _h.label = 4;
                case 4:
                    if (!!_e.done) return [3 /*break*/, 7];
                    _f = __read(_e.value, 2), key = _f[0], validateFunction = _f[1];
                    if (!isEmptyObject(validationResult) && !validateAllFieldCriteria) {
                        return [3 /*break*/, 7];
                    }
                    return [4 /*yield*/, validateFunction(fieldValue)];
                case 5:
                    validateResult = _h.sent();
                    validateError = getValidateError(validateResult, validateRef, key);
                    if (validateError) {
                        validationResult = __assign(__assign({}, validateError), appendErrorsCurry(key, validateError.message));
                        if (validateAllFieldCriteria) {
                            error[name] = validationResult;
                        }
                    }
                    _h.label = 6;
                case 6:
                    _e = _d.next();
                    return [3 /*break*/, 4];
                case 7: return [3 /*break*/, 10];
                case 8:
                    e_1_1 = _h.sent();
                    e_1 = { error: e_1_1 };
                    return [3 /*break*/, 10];
                case 9:
                    try {
                        if (_e && !_e.done && (_g = _d.return)) _g.call(_d);
                    }
                    finally { if (e_1) throw e_1.error; }
                    return [7 /*endfinally*/];
                case 10:
                    if (!isEmptyObject(validationResult)) {
                        error[name] = __assign({ ref: validateRef }, validationResult);
                        if (!validateAllFieldCriteria) {
                            return [2 /*return*/, error];
                        }
                    }
                    _h.label = 11;
                case 11: return [2 /*return*/, error];
            }
        });
    });
});

var getPath = function (rootPath, values, paths) {
    if (paths === void 0) { paths = []; }
    for (var property in values) {
        var rootName = (rootPath +
            (isObject(values)
                ? "." + property
                : "[" + property + "]"));
        isPrimitive(values[property])
            ? paths.push(rootName)
            : getPath(rootName, values[property], paths);
    }
    return paths;
};

var assignWatchFields = (function (fieldValues, fieldName, watchFields, inputValue, isSingleField) {
    var value = undefined;
    watchFields.add(fieldName);
    if (!isEmptyObject(fieldValues)) {
        value = get(fieldValues, fieldName);
        if (isObject(value) || Array.isArray(value)) {
            getPath(fieldName, value).forEach(function (name) { return watchFields.add(name); });
        }
    }
    return isUndefined(value)
        ? isSingleField
            ? inputValue
            : get(inputValue, fieldName)
        : value;
});

var skipValidation = (function (_a) {
    var isOnBlur = _a.isOnBlur, isOnChange = _a.isOnChange, isOnTouch = _a.isOnTouch, isTouched = _a.isTouched, isReValidateOnBlur = _a.isReValidateOnBlur, isReValidateOnChange = _a.isReValidateOnChange, isBlurEvent = _a.isBlurEvent, isSubmitted = _a.isSubmitted, isOnAll = _a.isOnAll;
    if (isOnAll) {
        return false;
    }
    else if (!isSubmitted && isOnTouch) {
        return !(isTouched || isBlurEvent);
    }
    else if (isSubmitted ? isReValidateOnBlur : isOnBlur) {
        return !isBlurEvent;
    }
    else if (isSubmitted ? isReValidateOnChange : isOnChange) {
        return isBlurEvent;
    }
    return true;
});

var getFieldArrayParentName = (function (name) { return name.substring(0, name.indexOf('[')); });

var isMatchFieldArrayName = function (name, searchName) {
    return RegExp(("^" + searchName + "([|.)\\d+").replace(/\[/g, '\\[').replace(/\]/g, '\\]')).test(name);
};
var isNameInFieldArray = (function (names, name) { return __spread(names).some(function (current) { return isMatchFieldArrayName(name, current); }); });

var isSelectInput = (function (element) {
    return element.type === SELECT + "-one";
});

function onDomRemove(fieldsRef, removeFieldEventListenerAndRef) {
    var observer = new MutationObserver(function () {
        var e_1, _a, e_2, _b;
        try {
            for (var _c = __values(Object.values(fieldsRef.current)), _d = _c.next(); !_d.done; _d = _c.next()) {
                var field = _d.value;
                if (field && field.options) {
                    try {
                        for (var _e = (e_2 = void 0, __values(field.options)), _f = _e.next(); !_f.done; _f = _e.next()) {
                            var option = _f.value;
                            if (option && option.ref && isDetached(option.ref)) {
                                removeFieldEventListenerAndRef(field);
                            }
                        }
                    }
                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
                    finally {
                        try {
                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
                        }
                        finally { if (e_2) throw e_2.error; }
                    }
                }
                else if (field && isDetached(field.ref)) {
                    removeFieldEventListenerAndRef(field);
                }
            }
        }
        catch (e_1_1) { e_1 = { error: e_1_1 }; }
        finally {
            try {
                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
            }
            finally { if (e_1) throw e_1.error; }
        }
    });
    observer.observe(window.document, {
        childList: true,
        subtree: true,
    });
    return observer;
}

var isWeb = typeof window !== UNDEFINED && typeof document !== UNDEFINED;

function cloneObject(data) {
    var e_1, _a, e_2, _b;
    var _c;
    var copy;
    if (isPrimitive(data) ||
        (isWeb && (data instanceof File || isHTMLElement(data)))) {
        return data;
    }
    if (!['Set', 'Map', 'Object', 'Date', 'Array'].includes((_c = data.constructor) === null || _c === void 0 ? void 0 : _c.name)) {
        return data;
    }
    if (data instanceof Date) {
        copy = new Date(data.getTime());
        return copy;
    }
    if (data instanceof Set) {
        copy = new Set();
        try {
            for (var data_1 = __values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) {
                var item = data_1_1.value;
                copy.add(item);
            }
        }
        catch (e_1_1) { e_1 = { error: e_1_1 }; }
        finally {
            try {
                if (data_1_1 && !data_1_1.done && (_a = data_1.return)) _a.call(data_1);
            }
            finally { if (e_1) throw e_1.error; }
        }
        return copy;
    }
    if (data instanceof Map) {
        copy = new Map();
        try {
            for (var _d = __values(data.keys()), _e = _d.next(); !_e.done; _e = _d.next()) {
                var key = _e.value;
                copy.set(key, cloneObject(data.get(key)));
            }
        }
        catch (e_2_1) { e_2 = { error: e_2_1 }; }
        finally {
            try {
                if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
            }
            finally { if (e_2) throw e_2.error; }
        }
        return copy;
    }
    copy = Array.isArray(data) ? [] : {};
    for (var key in data) {
        copy[key] = cloneObject(data[key]);
    }
    return copy;
}

var modeChecker = (function (mode) { return ({
    isOnSubmit: !mode || mode === VALIDATION_MODE.onSubmit,
    isOnBlur: mode === VALIDATION_MODE.onBlur,
    isOnChange: mode === VALIDATION_MODE.onChange,
    isOnAll: mode === VALIDATION_MODE.all,
    isOnTouch: mode === VALIDATION_MODE.onTouched,
}); });

var isRadioOrCheckboxFunction = (function (ref) {
    return isRadioInput(ref) || isCheckBoxInput(ref);
});

var isWindowUndefined = typeof window === UNDEFINED;
var isProxyEnabled = isWeb ? 'Proxy' in window : typeof Proxy !== UNDEFINED;
function useForm(_a) {
    var _this = this;
    var _b = _a === void 0 ? {} : _a, _c = _b.mode, mode = _c === void 0 ? VALIDATION_MODE.onSubmit : _c, _d = _b.reValidateMode, reValidateMode = _d === void 0 ? VALIDATION_MODE.onChange : _d, resolver = _b.resolver, context = _b.context, _e = _b.defaultValues, defaultValues = _e === void 0 ? {} : _e, _f = _b.shouldFocusError, shouldFocusError = _f === void 0 ? true : _f, _g = _b.shouldUnregister, shouldUnregister = _g === void 0 ? true : _g, criteriaMode = _b.criteriaMode;
    var fieldsRef = React.useRef({});
    var fieldArrayDefaultValuesRef = React.useRef({});
    var fieldArrayValuesRef = React.useRef({});
    var watchFieldsRef = React.useRef(new Set());
    var useWatchFieldsRef = React.useRef({});
    var useWatchRenderFunctionsRef = React.useRef({});
    var fieldsWithValidationRef = React.useRef({});
    var validFieldsRef = React.useRef({});
    var defaultValuesRef = React.useRef(defaultValues);
    var isUnMount = React.useRef(false);
    var isWatchAllRef = React.useRef(false);
    var handleChangeRef = React.useRef();
    var shallowFieldsStateRef = React.useRef({});
    var resetFieldArrayFunctionRef = React.useRef({});
    var contextRef = React.useRef(context);
    var resolverRef = React.useRef(resolver);
    var fieldArrayNamesRef = React.useRef(new Set());
    var modeRef = React.useRef(modeChecker(mode));
    var _h = modeRef.current, isOnSubmit = _h.isOnSubmit, isOnTouch = _h.isOnTouch;
    var isValidateAllFieldCriteria = criteriaMode === VALIDATION_MODE.all;
    var _j = __read(React.useState({
        isDirty: false,
        isValidating: false,
        dirtyFields: {},
        isSubmitted: false,
        submitCount: 0,
        touched: {},
        isSubmitting: false,
        isSubmitSuccessful: false,
        isValid: !isOnSubmit,
        errors: {},
    }), 2), formState = _j[0], setFormState = _j[1];
    var readFormStateRef = React.useRef({
        isDirty: !isProxyEnabled,
        dirtyFields: !isProxyEnabled,
        touched: !isProxyEnabled || isOnTouch,
        isValidating: !isProxyEnabled,
        isSubmitting: !isProxyEnabled,
        isValid: !isProxyEnabled,
    });
    var formStateRef = React.useRef(formState);
    var observerRef = React.useRef();
    var _k = React.useRef(modeChecker(reValidateMode)).current, isReValidateOnBlur = _k.isOnBlur, isReValidateOnChange = _k.isOnChange;
    contextRef.current = context;
    resolverRef.current = resolver;
    formStateRef.current = formState;
    shallowFieldsStateRef.current = shouldUnregister
        ? {}
        : isEmptyObject(shallowFieldsStateRef.current)
            ? cloneObject(defaultValues)
            : shallowFieldsStateRef.current;
    var updateFormState = React.useCallback(function (state) {
        if (state === void 0) { state = {}; }
        if (!isUnMount.current) {
            formStateRef.current = __assign(__assign({}, formStateRef.current), state);
            setFormState(formStateRef.current);
        }
    }, []);
    var updateIsValidating = function () {
        return readFormStateRef.current.isValidating &&
            updateFormState({
                isValidating: true,
            });
    };
    var shouldRenderBaseOnError = React.useCallback(function (name, error, shouldRender, state, isValid) {
        if (shouldRender === void 0) { shouldRender = false; }
        if (state === void 0) { state = {}; }
        var shouldReRender = shouldRender ||
            isErrorStateChanged({
                errors: formStateRef.current.errors,
                error: error,
                name: name,
                validFields: validFieldsRef.current,
                fieldsWithValidation: fieldsWithValidationRef.current,
            });
        var previousError = get(formStateRef.current.errors, name);
        if (error) {
            unset(validFieldsRef.current, name);
            shouldReRender =
                shouldReRender ||
                    !previousError ||
                    !deepEqual(previousError, error, true);
            set(formStateRef.current.errors, name, error);
        }
        else {
            if (get(fieldsWithValidationRef.current, name) || resolverRef.current) {
                set(validFieldsRef.current, name, true);
                shouldReRender = shouldReRender || previousError;
            }
            unset(formStateRef.current.errors, name);
        }
        if ((shouldReRender && !isNullOrUndefined(shouldRender)) ||
            !isEmptyObject(state) ||
            readFormStateRef.current.isValidating) {
            updateFormState(__assign(__assign(__assign({}, state), (resolverRef.current ? { isValid: !!isValid } : {})), { isValidating: false }));
        }
    }, []);
    var setFieldValue = React.useCallback(function (name, rawValue) {
        var _a = fieldsRef.current[name], ref = _a.ref, options = _a.options;
        var value = isWeb && isHTMLElement(ref) && isNullOrUndefined(rawValue)
            ? ''
            : rawValue;
        if (isRadioInput(ref)) {
            (options || []).forEach(function (_a) {
                var radioRef = _a.ref;
                return (radioRef.checked = radioRef.value === value);
            });
        }
        else if (isFileInput(ref) && !isString(value)) {
            ref.files = value;
        }
        else if (isMultipleSelect(ref)) {
            __spread(ref.options).forEach(function (selectRef) {
                return (selectRef.selected = value.includes(selectRef.value));
            });
        }
        else if (isCheckBoxInput(ref) && options) {
            options.length > 1
                ? options.forEach(function (_a) {
                    var checkboxRef = _a.ref;
                    return (checkboxRef.checked = Array.isArray(value)
                        ? !!value.find(function (data) { return data === checkboxRef.value; })
                        : value === checkboxRef.value);
                })
                : (options[0].ref.checked = !!value);
        }
        else {
            ref.value = value;
        }
    }, []);
    var isFormDirty = React.useCallback(function (name, data) {
        if (readFormStateRef.current.isDirty) {
            var formValues = getValues();
            name && data && set(formValues, name, data);
            return !deepEqual(formValues, defaultValuesRef.current);
        }
        return false;
    }, []);
    var updateAndGetDirtyState = React.useCallback(function (name, shouldRender) {
        if (shouldRender === void 0) { shouldRender = true; }
        if (readFormStateRef.current.isDirty ||
            readFormStateRef.current.dirtyFields) {
            var isFieldDirty = !deepEqual(get(defaultValuesRef.current, name), getFieldValue(fieldsRef, name, shallowFieldsStateRef));
            var isDirtyFieldExist = get(formStateRef.current.dirtyFields, name);
            var previousIsDirty = formStateRef.current.isDirty;
            isFieldDirty
                ? set(formStateRef.current.dirtyFields, name, true)
                : unset(formStateRef.current.dirtyFields, name);
            var state = {
                isDirty: isFormDirty(),
                dirtyFields: formStateRef.current.dirtyFields,
            };
            var isChanged = (readFormStateRef.current.isDirty &&
                previousIsDirty !== state.isDirty) ||
                (readFormStateRef.current.dirtyFields &&
                    isDirtyFieldExist !== get(formStateRef.current.dirtyFields, name));
            isChanged && shouldRender && updateFormState(state);
            return isChanged ? state : {};
        }
        return {};
    }, []);
    var executeValidation = React.useCallback(function (name, skipReRender) { return __awaiter(_this, void 0, void 0, function () {
        var error;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    {
                        if (!fieldsRef.current[name]) {
                            console.warn('📋 Field is missing with `name` attribute: ', name);
                            return [2 /*return*/, false];
                        }
                    }
                    return [4 /*yield*/, validateField(fieldsRef, isValidateAllFieldCriteria, fieldsRef.current[name], shallowFieldsStateRef)];
                case 1:
                    error = (_a.sent())[name];
                    shouldRenderBaseOnError(name, error, skipReRender);
                    return [2 /*return*/, isUndefined(error)];
            }
        });
    }); }, [shouldRenderBaseOnError, isValidateAllFieldCriteria]);
    var executeSchemaOrResolverValidation = React.useCallback(function (names) { return __awaiter(_this, void 0, void 0, function () {
        var errors, previousFormIsValid, isInputsValid, error;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0: return [4 /*yield*/, resolverRef.current(getValues(), contextRef.current, isValidateAllFieldCriteria)];
                case 1:
                    errors = (_a.sent()).errors;
                    previousFormIsValid = formStateRef.current.isValid;
                    if (Array.isArray(names)) {
                        isInputsValid = names
                            .map(function (name) {
                            var error = get(errors, name);
                            error
                                ? set(formStateRef.current.errors, name, error)
                                : unset(formStateRef.current.errors, name);
                            return !error;
                        })
                            .every(Boolean);
                        updateFormState({
                            isValid: isEmptyObject(errors),
                            isValidating: false,
                        });
                        return [2 /*return*/, isInputsValid];
                    }
                    else {
                        error = get(errors, names);
                        shouldRenderBaseOnError(names, error, previousFormIsValid !== isEmptyObject(errors), {}, isEmptyObject(errors));
                        return [2 /*return*/, !error];
                    }
            }
        });
    }); }, [shouldRenderBaseOnError, isValidateAllFieldCriteria]);
    var trigger = React.useCallback(function (name) { return __awaiter(_this, void 0, void 0, function () {
        var fields, result;
        var _this = this;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    fields = name || Object.keys(fieldsRef.current);
                    updateIsValidating();
                    if (resolverRef.current) {
                        return [2 /*return*/, executeSchemaOrResolverValidation(fields)];
                    }
                    if (!Array.isArray(fields)) return [3 /*break*/, 2];
                    !name && (formStateRef.current.errors = {});
                    return [4 /*yield*/, Promise.all(fields.map(function (data) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
                            switch (_a.label) {
                                case 0: return [4 /*yield*/, executeValidation(data, null)];
                                case 1: return [2 /*return*/, _a.sent()];
                            }
                        }); }); }))];
                case 1:
                    result = _a.sent();
                    updateFormState({
                        isValidating: false,
                    });
                    return [2 /*return*/, result.every(Boolean)];
                case 2: return [4 /*yield*/, executeValidation(fields)];
                case