react-hook-form
Version:
Performant, flexible and extensible forms library for React Hooks
1,167 lines (1,102 loc) • 98.9 kB
JavaScript
'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 VALUE = 'value';
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 isArray = (function (value) { return Array.isArray(value); });
var isObjectType = function (value) { return typeof value === 'object'; };
var isObject = (function (value) {
return !isNullOrUndefined(value) &&
!isArray(value) &&
isObjectType(value) &&
!(value instanceof Date);
});
var isKey = (function (value) {
return !isArray(value) &&
(/^\w*$/.test(value) ||
!/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/.test(value));
});
var stringToPath = (function (input) {
var result = [];
input.replace(/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g, function (match, mathNumber, mathQuote, originalString) {
result.push(mathQuote
? originalString.replace(/\\(\\)?/g, '$1')
: mathNumber || match);
});
return result;
});
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) || isArray(objValue)
? objValue
: !isNaN(+tempPath[index + 1])
? []
: {};
}
object[key] = newValue;
object = object[key];
}
return object;
}
var transformToNestObject = (function (data) {
return Object.entries(data).reduce(function (previous, _a) {
var _b;
var _c = __read(_a, 2), key = _c[0], value = _c[1];
if (!isKey(key)) {
set(previous, key, value);
return previous;
}
return __assign(__assign({}, previous), (_b = {}, _b[key] = value, _b));
}, {});
});
var isUndefined = (function (val) { return val === undefined; });
var filterOutFalsy = (function (value) { return value.filter(Boolean); });
var get = (function (obj, path, defaultValue) {
var result = filterOutFalsy(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) {
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: '',
};
var getRadioValue = (function (options) {
return 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 (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, unmountFieldsStateRef) {
var field = fieldsRef.current[name];
if (field) {
var _a = field.ref, value = _a.value, disabled = _a.disabled, ref = field.ref;
if (disabled) {
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 value;
}
if (unmountFieldsStateRef) {
return get(unmountFieldsStateRef.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 path = updatePath.slice(0, -1);
var length = path.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 = undefined;
if (childObject) {
delete childObject[key];
}
for (var k = 0; k < updatePath.slice(0, -1).length; k++) {
var index = -1;
var objectRef = undefined;
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)) ||
(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, unmountFieldsStateRef, shouldUnregister, forceDelete) {
var ref = field.ref, _a = field.ref, name = _a.name, type = _a.type;
var fieldRef = fieldsRef.current[name];
if (!shouldUnregister) {
var value = getFieldValue(fieldsRef, name, unmountFieldsStateRef);
if (!isUndefined(value)) {
set(unmountFieldsStateRef.current, name, value);
}
}
if (!type) {
delete fieldsRef.current[name];
return;
}
if ((isRadioInput(ref) || isCheckBoxInput(ref)) && fieldRef) {
var options_1 = fieldRef.options;
if (isArray(options_1) && options_1.length) {
filterOutFalsy(options_1).forEach(function (option, index) {
var ref = option.ref;
if ((ref && isDetached(ref) && isSameRef(option, ref)) || forceDelete) {
removeAllEventListeners(ref, handleChange);
unset(options_1, "[" + index + "]");
}
});
if (options_1 && !filterOutFalsy(options_1).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 isString = (function (value) { return typeof value === 'string'; });
function deepMerge(target, source) {
if (!isObject(target) || !isObject(source)) {
return source;
}
for (var key in source) {
var targetValue = target[key];
var sourceValue = source[key];
try {
if (isObject(targetValue) && isObject(sourceValue)) {
target[key] = deepMerge(targetValue, sourceValue);
}
else {
target[key] = sourceValue;
}
}
catch (_a) { }
}
return target;
}
var getFieldsValues = (function (fieldsRef, unmountFieldsStateRef, search) {
var output = {};
var _loop_1 = function (name_1) {
if (isUndefined(search) ||
(isString(search)
? name_1.startsWith(search)
: isArray(search) && search.find(function (data) { return name_1.startsWith(data); }))) {
output[name_1] = getFieldValue(fieldsRef, name_1);
}
};
for (var name_1 in fieldsRef.current) {
_loop_1(name_1);
}
return deepMerge(__assign({}, ((unmountFieldsStateRef || {}).current || {})), transformToNestObject(output));
});
var isSameError = (function (error, _a) {
var type = _a.type, _b = _a.types, types = _b === void 0 ? {} : _b, message = _a.message;
return isObject(error) &&
error.type === type &&
error.message === message &&
Object.keys(error.types || {}).length === Object.keys(types).length &&
Object.entries(error.types || {}).every(function (_a) {
var _b = __read(_a, 2), key = _b[0], value = _b[1];
return types[key] === value;
});
});
function shouldRenderBasedOnError(_a) {
var errors = _a.errors, name = _a.name, error = _a.error, validFields = _a.validFields, fieldsWithValidation = _a.fieldsWithValidation;
var isFieldValid = isEmptyObject(error);
var isFormValid = isEmptyObject(errors);
var currentFieldError = get(error, name);
var existFieldError = get(errors, name);
if (isFieldValid && get(validFields, name)) {
return false;
}
if (isFormValid !== isFieldValid ||
(!isFormValid && !existFieldError) ||
(isFieldValid && get(fieldsWithValidation, name) && !get(validFields, name))) {
return true;
}
return currentFieldError && !isSameError(existFieldError, currentFieldError);
}
var isRegex = (function (value) { return value instanceof RegExp; });
var isValueMessage = function (value) { return isObject(value) && !isRegex(value); };
var getValueAndMessage = (function (validationData) {
return isValueMessage(validationData)
? validationData
: {
value: validationData,
message: '',
};
});
var isFunction = (function (value) {
return typeof value === 'function';
});
var isMessage = (function (value) {
return isString(value) || (isObject(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;
if (validateAllFieldCriteria) {
var error = errors[name];
return __assign(__assign({}, error), { types: __assign(__assign({}, (error && error.types ? error.types : {})), (_a = {}, _a[type] = message || true, _a)) });
}
return {};
});
var validateField = (function (fieldsRef, validateAllFieldCriteria, _a, unmountFieldsStateRef) {
var ref = _a.ref, _b = _a.ref, type = _b.type, value = _b.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 fields, name, error, isRadio, isCheckBox, isRadioOrCheckbox, isEmpty, appendErrorsCurry, getMinMaxMessage, _c, requiredValue, requiredMessage, exceedMax, exceedMin, _d, maxValue, maxMessage, _e, minValue, minMessage, valueNumber, valueDate, _f, maxLengthValue, maxLengthMessage, _g, minLengthValue, minLengthMessage, inputLength, exceedMax, exceedMin, _h, patternValue, patternMessage, fieldValue, validateRef, result, validateError, validationResult, _j, _k, _l, key, validateFunction, validateResult, validateError, e_1_1;
var e_1, _m;
return __generator(this, function (_o) {
switch (_o.label) {
case 0:
fields = fieldsRef.current;
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))) {
_c = isMessage(required)
? { value: !!required, message: required }
: getValueAndMessage(required), requiredValue = _c.value, requiredMessage = _c.message;
if (requiredValue) {
error[name] = __assign({ type: INPUT_VALIDATION_RULES.required, message: requiredMessage, ref: isRadioOrCheckbox
? (fields[name].options || [])[0].ref
: ref }, appendErrorsCurry(INPUT_VALIDATION_RULES.required, requiredMessage));
if (!validateAllFieldCriteria) {
return [2 /*return*/, error];
}
}
}
if (!isNullOrUndefined(min) || !isNullOrUndefined(max)) {
exceedMax = void 0;
exceedMin = void 0;
_d = getValueAndMessage(max), maxValue = _d.value, maxMessage = _d.message;
_e = getValueAndMessage(min), minValue = _e.value, minMessage = _e.message;
if (type === 'number' || (!type && !isNaN(value))) {
valueNumber = ref.valueAsNumber || parseFloat(value);
if (!isNullOrUndefined(maxValue)) {
exceedMax = valueNumber > maxValue;
}
if (!isNullOrUndefined(minValue)) {
exceedMin = valueNumber < minValue;
}
}
else {
valueDate = ref.valueAsDate || new Date(value);
if (isString(maxValue)) {
exceedMax = valueDate > new Date(maxValue);
}
if (isString(minValue)) {
exceedMin = valueDate < new Date(minValue);
}
}
if (exceedMax || exceedMin) {
getMinMaxMessage(!!exceedMax, maxMessage, minMessage, INPUT_VALIDATION_RULES.max, INPUT_VALIDATION_RULES.min);
if (!validateAllFieldCriteria) {
return [2 /*return*/, error];
}
}
}
if (isString(value) && !isEmpty && (maxLength || minLength)) {
_f = getValueAndMessage(maxLength), maxLengthValue = _f.value, maxLengthMessage = _f.message;
_g = getValueAndMessage(minLength), minLengthValue = _g.value, minLengthMessage = _g.message;
inputLength = value.toString().length;
exceedMax = !isNullOrUndefined(maxLengthValue) && inputLength > maxLengthValue;
exceedMin = !isNullOrUndefined(minLengthValue) && inputLength < minLengthValue;
if (exceedMax || exceedMin) {
getMinMaxMessage(!!exceedMax, maxLengthMessage, minLengthMessage);
if (!validateAllFieldCriteria) {
return [2 /*return*/, error];
}
}
}
if (pattern && !isEmpty) {
_h = getValueAndMessage(pattern), patternValue = _h.value, patternMessage = _h.message;
if (isRegex(patternValue) && !patternValue.test(value)) {
error[name] = __assign({ type: INPUT_VALIDATION_RULES.pattern, message: patternMessage, ref: ref }, appendErrorsCurry(INPUT_VALIDATION_RULES.pattern, patternMessage));
if (!validateAllFieldCriteria) {
return [2 /*return*/, error];
}
}
}
if (!validate) return [3 /*break*/, 11];
fieldValue = getFieldValue(fieldsRef, name, unmountFieldsStateRef);
validateRef = isRadioOrCheckbox && options ? options[0].ref : ref;
if (!isFunction(validate)) return [3 /*break*/, 2];
return [4 /*yield*/, validate(fieldValue)];
case 1:
result = _o.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 = {};
_o.label = 3;
case 3:
_o.trys.push([3, 8, 9, 10]);
_j = __values(Object.entries(validate)), _k = _j.next();
_o.label = 4;
case 4:
if (!!_k.done) return [3 /*break*/, 7];
_l = __read(_k.value, 2), key = _l[0], validateFunction = _l[1];
if (!isEmptyObject(validationResult) && !validateAllFieldCriteria) {
return [3 /*break*/, 7];
}
return [4 /*yield*/, validateFunction(fieldValue)];
case 5:
validateResult = _o.sent();
validateError = getValidateError(validateResult, validateRef, key);
if (validateError) {
validationResult = __assign(__assign({}, validateError), appendErrorsCurry(key, validateError.message));
if (validateAllFieldCriteria) {
error[name] = validationResult;
}
}
_o.label = 6;
case 6:
_k = _j.next();
return [3 /*break*/, 4];
case 7: return [3 /*break*/, 10];
case 8:
e_1_1 = _o.sent();
e_1 = { error: e_1_1 };
return [3 /*break*/, 10];
case 9:
try {
if (_k && !_k.done && (_m = _j.return)) _m.call(_j);
}
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];
}
}
_o.label = 11;
case 11: return [2 /*return*/, error];
}
});
});
});
var isPrimitive = (function (value) {
return isNullOrUndefined(value) || !isObjectType(value);
});
var getPath = function (path, values) {
var getInnerPath = function (value, key, isObject) {
var pathWithIndex = isObject ? path + "." + key : path + "[" + key + "]";
return isPrimitive(value) ? pathWithIndex : getPath(pathWithIndex, value);
};
return Object.entries(values)
.map(function (_a) {
var _b = __read(_a, 2), key = _b[0], value = _b[1];
return getInnerPath(value, key, isObject(values));
})
.flat(Infinity);
};
var assignWatchFields = (function (fieldValues, fieldName, watchFields, inputValue, isSingleField) {
var value;
watchFields.add(fieldName);
if (isEmptyObject(fieldValues)) {
value = undefined;
}
else {
value = get(fieldValues, fieldName);
if (isObject(value) || 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('[')); });
function deepEqual(object1, object2) {
var e_1, _a;
if (object1 === void 0) { object1 = []; }
if (object2 === void 0) { object2 = []; }
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];
var val2 = object2[key];
if ((isObject(val1) || isArray(val1)) && (isObject(val2) || isArray(val2))
? !deepEqual(val1, val2)
: 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;
}
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 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 isWeb = typeof document !== UNDEFINED &&
!isWindowUndefined &&
!isUndefined(window.HTMLElement);
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 fieldArrayDefaultValues = React.useRef({});
var watchFieldsRef = React.useRef(new Set());
var watchFieldsHookRef = React.useRef({});
var watchFieldsHookRenderRef = React.useRef({});
var fieldsWithValidationRef = React.useRef({});
var validFieldsRef = React.useRef({});
var defaultValuesRef = React.useRef(defaultValues);
var defaultValuesAtRenderRef = React.useRef({});
var isUnMount = React.useRef(false);
var isWatchAllRef = React.useRef(false);
var handleChangeRef = React.useRef();
var unmountFieldsStateRef = 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,
dirtyFields: {},
isSubmitted: false,
submitCount: 0,
touched: {},
isSubmitting: false,
isValid: !isOnSubmit,
errors: {},
}), 2), formState = _j[0], setFormState = _j[1];
var readFormStateRef = React.useRef({
isDirty: !isProxyEnabled,
dirtyFields: !isProxyEnabled,
isSubmitted: isOnSubmit,
submitCount: !isProxyEnabled,
touched: !isProxyEnabled || isOnTouch,
isSubmitting: !isProxyEnabled,
isValid: !isProxyEnabled,
errors: !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;
var updateFormState = React.useCallback(function (state) {
if (state === void 0) { state = {}; }
return !isUnMount.current &&
setFormState(__assign(__assign({}, formStateRef.current), state));
}, []);
var shouldRenderBaseOnError = React.useCallback(function (name, error, shouldRender, state, isValid) {
if (shouldRender === void 0) { shouldRender = false; }
if (state === void 0) { state = {}; }
var shouldReRender = shouldRender ||
shouldRenderBasedOnError({
errors: formStateRef.current.errors,
error: error,
name: name,
validFields: validFieldsRef.current,
fieldsWithValidation: fieldsWithValidationRef.current,
});
var previousError = get(formStateRef.current.errors, name);
if (isEmptyObject(error)) {
if (get(fieldsWithValidationRef.current, name) || resolverRef.current) {
set(validFieldsRef.current, name, true);
shouldReRender = shouldReRender || previousError;
}
unset(formStateRef.current.errors, name);
}
else {
unset(validFieldsRef.current, name);
shouldReRender =
shouldReRender ||
!previousError ||
!isSameError(previousError, error[name]);
set(formStateRef.current.errors, name, error[name]);
}
if (shouldReRender || !isEmptyObject(state)) {
updateFormState(__assign(__assign(__assign({}, state), { errors: formStateRef.current.errors }), (resolverRef.current ? { isValid: !!isValid } : {})));
}
}, []);
var setFieldValue = React.useCallback(function (_a, rawValue) {
var ref = _a.ref, options = _a.options;
var value = isWeb && isHTMLElement(ref) && isNullOrUndefined(rawValue)
? ''
: rawValue;
if (isRadioInput(ref) && options) {
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 = String(value).includes(checkboxRef.value));
})
: (options[0].ref.checked = !!value);
}
else {
ref.value = value;
}
}, []);
var updateAndGetDirtyState = React.useCallback(function (name, shouldRender) {
if (shouldRender === void 0) { shouldRender = true; }
if (!fieldsRef.current[name] ||
(!readFormStateRef.current.isDirty &&
!readFormStateRef.current.dirtyFields)) {
return {};
}
var isFieldDirty = defaultValuesAtRenderRef.current[name] !==
getFieldValue(fieldsRef, name, unmountFieldsStateRef);
var isDirtyFieldExist = get(formStateRef.current.dirtyFields, name);
var isFieldArray = isNameInFieldArray(fieldArrayNamesRef.current, name);
var previousIsDirty = formStateRef.current.isDirty;
isFieldDirty
? set(formStateRef.current.dirtyFields, name, true)
: unset(formStateRef.current.dirtyFields, name);
var state = {
isDirty: (isFieldArray &&
!deepEqual(get(getValues(), getFieldArrayParentName(name)), get(defaultValuesRef.current, getFieldArrayParentName(name)))) ||
!isEmptyObject(formStateRef.current.dirtyFields),
dirtyFields: formStateRef.current.dirtyFields,
};
var isChanged = (readFormStateRef.current.isDirty &&
previousIsDirty !== state.isDirty) ||
(readFormStateRef.current.dirtyFields &&
isDirtyFieldExist !== get(formStateRef.current.dirtyFields, name));
if (isChanged && shouldRender) {
formStateRef.current = __assign(__assign({}, formStateRef.current), state);
updateFormState(__assign({}, state));
}
return isChanged ? state : {};
}, []);
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]) return [3 /*break*/, 2];
return [4 /*yield*/, validateField(fieldsRef, isValidateAllFieldCriteria, fieldsRef.current[name], unmountFieldsStateRef)];
case 1:
error = _a.sent();
shouldRenderBaseOnError(name, error, skipReRender);
return [2 /*return*/, isEmptyObject(error)];
case 2: return [2 /*return*/, false];
}
});
}); }, [shouldRenderBaseOnError, isValidateAllFieldCriteria]);
var executeSchemaOrResolverValidation = React.useCallback(function (payload) { return __awaiter(_this, void 0, void 0, function () {
var errors, previousFormIsValid, isInputsValid, error;
var _a;
return __generator(this, function (_b) {
switch (_b.label) {
case 0: return [4 /*yield*/, resolverRef.current(getValues(), contextRef.current, isValidateAllFieldCriteria)];
case 1:
errors = (_b.sent()).errors;
previousFormIsValid = formStateRef.current.isValid;
if (isArray(payload)) {
isInputsValid = payload
.map(function (name) {
var error = get(errors, name);
error
? set(formState.errors, name, error)
: unset(formState.errors, name);
return !error;
})
.every(Boolean);
updateFormState({
isValid: isEmptyObject(errors),
errors: formState.errors,
});
return [2 /*return*/, isInputsValid];
}
else {
error = get(errors, payload);
shouldRenderBaseOnError(payload, (error ? (_a = {}, _a[payload] = error, _a) : {}), 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);
if (resolverRef.current) {
return [2 /*return*/, executeSchemaOrResolverValidation(fields)];
}
if (!isArray(fields)) return [3 /*break*/, 2];
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, true)];
case 1: return [2 /*return*/, _a.sent()];
}
}); }); }))];
case 1:
result = _a.sent();
return [2 /*return*/, result.every(Boolean)];
case 2: return [4 /*yield*/, executeValidation(fields)];
case 3: return [2 /*return*/, _a.sent()];
}
});
}); }, [executeSchemaOrResolverValidation, executeValidation]);
var setInternalValues = React.useCallback(function (name, value, _a) {
var shouldDirty = _a.shouldDirty, shouldValidate = _a.shouldValidate;
getPath(name, value).forEach(function (fieldName) {
var data = {};
var field = fieldsRef.current[fieldName];
if (field) {
set(data, name, value);
setFieldValue(field, get(data, fieldName));
if (shouldDirty) {
updateAndGetDirtyState(fieldName);
}
if (shouldValidate) {
trigger(fieldName);
}
}
});
}, [trigger, setFieldValue, updateAndGetDirtyState]);
var setInternalValue = React.useCallback(function (name, value, config) {
if (fieldsRef.current[name]) {
setFieldValue(fieldsRef.current[name], value);
config.shouldDirty && updateAndGetDirtyState(name);
}
else if (!isPrimitive(value)) {
setInternalValues(name, value, config);
}
set(unmountFieldsStateRef.current, name, value);
}, [updateAndGetDirtyState, setFieldValue, setInternalValues]);
var isFieldWatched = function (name) {
return isWatchAllRef.current ||
watchFieldsRef.current.has(name) ||
watchFieldsRef.current.has((name.match(/\w+/) || [])[0]);
};
var renderWatchedInputs = function (name, found) {
if (found === void 0) { found = true; }
if (!isEmptyObject(watchFieldsHookRef.current)) {
for (var key in watchFieldsHookRef.current) {
if (!name ||
watchFieldsHookRef.current[key].has(name) ||
watchFieldsHookRef.current[key].has(getFieldArrayParentName(name)) ||
!watchFieldsHookRef.current[key].size) {
watchFieldsHookRenderRef.current[key]();
found = false;
}
}
}
return found;
};
function setValue(name, value, config) {
if (config === void 0) { config = {}; }
setInternalValue(name, value, config);
if (isFieldWatched(name)) {
updateFormState();
}
renderWatchedInputs(name);
if (config.shouldValidate) {
trigger(name);
}
}
handleChangeRef.current = handleChangeRef.current
? handleChangeRef.current
: function (_a) {
var type = _a.type, target = _a.target;
return __awaiter(_this, void 0, void 0, function () {
var name, field, error, isValid, isBlurEvent, shouldSkipValidation, state, shouldRender, errors, previousFormIsValid;
var _b;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
name = target.name;