@dnb/eufemia 10.22.0 → 10.23.0

package/cjs/extensions/forms/hooks/useFieldProps.js

@@ -0,0 +1,774 @@
+"use strict";
+"use client";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useFieldProps;
+exports.omitFieldProps = omitFieldProps;
+var _react = require("react");
+var _jsonPointer = _interopRequireDefault(require("json-pointer"));
+var _utils = require("../utils");
+var _ajv = require("../utils/ajv");
+var _types = require("../types");
+var _DataContext = require("../DataContext");
+var _componentHelper = require("../../../shared/component-helper");
+var _useId = _interopRequireDefault(require("../../../shared/helpers/useId"));
+var _useUpdateEffect = _interopRequireDefault(require("../../../shared/helpers/useUpdateEffect"));
+var _useMountEffect = _interopRequireDefault(require("../../../shared/helpers/useMountEffect"));
+var _useUnmountEffect = _interopRequireDefault(require("../../../shared/helpers/useUnmountEffect"));
+var _Context = _interopRequireDefault(require("../../../shared/Context"));
+var _FieldBlockContext = _interopRequireDefault(require("../FieldBlock/FieldBlockContext"));
+var _IterateElementContext = _interopRequireDefault(require("../Iterate/IterateElementContext"));
+var _useProcessManager = _interopRequireDefault(require("./useProcessManager"));
+var _useSharedState = require("../../../shared/helpers/useSharedState");
+var _isAsync = require("../../../shared/helpers/isAsync");
+const _excluded = ["name", "error", "warning", "info", "hasError", "isChanged", "htmlAttributes", "setHasFocus", "handleFocus", "handleBlur", "handleChange", "updateValue", "forceUpdate", "autoComplete", "dataContext", "fieldState"];
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function useFieldProps(props) {
+  var _props$disabled,
+    _dataContext$props,
+    _dataContext$ajvInsta,
+    _localErrorRef$curren,
+    _ref2,
+    _this = this,
+    _props$path,
+    _props$autoComplete;
+  const {
+    path,
+    itemPath,
+    emptyValue,
+    required,
+    info,
+    warning,
+    error: errorProp,
+    errorMessages,
+    onFocus,
+    onBlur,
+    onChange,
+    onBlurValidator,
+    validator,
+    schema,
+    validateInitially,
+    validateUnchanged,
+    continuousValidation,
+    toInput = value => value,
+    fromInput = value => value,
+    toEvent = value => value,
+    transformValue = value => value,
+    fromExternal = value => value,
+    validateRequired = (value, _ref) => {
+      let {
+        emptyValue,
+        required,
+        error
+      } = _ref;
+      const res = required && (value === emptyValue || typeof emptyValue === 'undefined' && value === '') ? error : undefined;
+      return res;
+    }
+  } = props;
+  const disabled = (_props$disabled = props.disabled) !== null && _props$disabled !== void 0 ? _props$disabled : props.readOnly;
+  const [, forceUpdate] = (0, _react.useReducer)(() => ({}), {});
+  const {
+    startProcess
+  } = (0, _useProcessManager.default)();
+  const id = (0, _useId.default)(props.id);
+  const dataContext = (0, _react.useContext)(_DataContext.Context);
+  const fieldBlockContext = (0, _react.useContext)(_FieldBlockContext.default);
+  const iterateElementContext = (0, _react.useContext)(_IterateElementContext.default);
+  const sharedContext = (0, _react.useContext)(_Context.default);
+  const tr = sharedContext === null || sharedContext === void 0 ? void 0 : sharedContext.translation.Forms;
+  const transformers = (0, _react.useRef)({
+    toInput,
+    fromInput,
+    toEvent,
+    fromExternal,
+    transformValue,
+    validateRequired
+  });
+  const {
+    handlePathChange: handlePathChangeDataContext,
+    updateDataValue: updateDataValueDataContext,
+    validateData: validateDataDataContext,
+    setFieldState: setFieldStateDataContext,
+    setFieldError: setFieldErrorDataContext,
+    setProps: setPropsDataContext,
+    errors: dataContextErrors,
+    contextErrorMessages
+  } = dataContext !== null && dataContext !== void 0 ? dataContext : {};
+  const onChangeContext = dataContext === null || dataContext === void 0 ? void 0 : (_dataContext$props = dataContext.props) === null || _dataContext$props === void 0 ? void 0 : _dataContext$props.onChange;
+  const dataContextError = path ? dataContextErrors === null || dataContextErrors === void 0 ? void 0 : dataContextErrors[path] : undefined;
+  const inFieldBlock = Boolean(fieldBlockContext);
+  const {
+    setFieldState: setFieldStateFieldBlock,
+    showFieldError: showFieldErrorFieldBlock
+  } = fieldBlockContext !== null && fieldBlockContext !== void 0 ? fieldBlockContext : {};
+  const inIterate = Boolean(iterateElementContext);
+  const {
+    index: iterateElementIndex,
+    value: iterateElementValue,
+    handleChange: handleIterateElementChange
+  } = iterateElementContext !== null && iterateElementContext !== void 0 ? iterateElementContext : {};
+  if (path && path.substring(0, 1) !== '/') {
+    throw new Error('Invalid path. Data value path JSON Pointers must be from root (starting with a /).');
+  }
+  if (itemPath && itemPath.substring(0, 1) !== '/') {
+    throw new Error('Invalid itemPath. Item pathJSON Pointers must be from root of iterate element (starting with a /).');
+  }
+  if (itemPath && !iterateElementContext) {
+    throw new Error('itemPath cannot be used when not inside an iterate element context. Wrap the component in an Iterate.Loop.');
+  }
+  const identifier = (0, _react.useMemo)(() => {
+    return path !== null && path !== void 0 ? path : id;
+  }, [path, id]);
+  const externalValue = (0, _react.useMemo)(() => {
+    if (props.value !== emptyValue) {
+      return transformers.current.fromExternal(props.value);
+    }
+    if (inIterate && itemPath) {
+      if (itemPath === '/') {
+        return iterateElementValue;
+      }
+      return _jsonPointer.default.has(iterateElementValue, itemPath) ? _jsonPointer.default.get(iterateElementValue, itemPath) : emptyValue;
+    }
+    if (dataContext.data && path) {
+      if (path === '/') {
+        return dataContext.data;
+      }
+      return _jsonPointer.default.has(dataContext.data, path) ? _jsonPointer.default.get(dataContext.data, path) : emptyValue;
+    }
+    return emptyValue;
+  }, [props.value, emptyValue, inIterate, itemPath, dataContext.data, path, iterateElementValue]);
+  const valueRef = (0, _react.useRef)(externalValue);
+  const changedRef = (0, _react.useRef)(false);
+  const hasFocusRef = (0, _react.useRef)(false);
+  const showErrorRef = (0, _react.useRef)(Boolean(validateInitially || errorProp));
+  const errorMethodRef = (0, _react.useRef)({});
+  const localErrorRef = (0, _react.useRef)();
+  const contextErrorRef = (0, _react.useRef)(dataContextError);
+  const validatorRef = (0, _react.useRef)(validator);
+  (0, _useUpdateEffect.default)(() => {
+    validatorRef.current = validator;
+  }, [validator]);
+  const onBlurValidatorRef = (0, _react.useRef)(onBlurValidator);
+  (0, _useUpdateEffect.default)(() => {
+    onBlurValidatorRef.current = onBlurValidator;
+  }, [onBlurValidator]);
+  const schemaValidatorRef = (0, _react.useRef)(schema ? (_dataContext$ajvInsta = dataContext.ajvInstance) === null || _dataContext$ajvInsta === void 0 ? void 0 : _dataContext$ajvInsta.compile(schema) : undefined);
+  const asyncBehaviorIsEnabled = (0, _react.useMemo)(() => {
+    return (0, _isAsync.isAsync)(onChange) || (0, _isAsync.isAsync)(onChangeContext);
+  }, [onChangeContext, onChange]);
+  const validatedWithValue = (0, _react.useRef)();
+  const changeEventResultRef = (0, _react.useRef)(null);
+  const currentAsyncProcessRef = (0, _react.useRef)(null);
+  const setCurrentAsyncProcess = (0, _react.useCallback)(name => {
+    currentAsyncProcessRef.current = name;
+  }, []);
+  const asyncBufferRef = (0, _react.useRef)({});
+  for (const key in asyncBufferRef.current) {
+    const {
+      fulfill,
+      hasAsyncProcesses
+    } = asyncBufferRef.current[key] || {};
+    if ((hasAsyncProcesses === null || hasAsyncProcesses === void 0 ? void 0 : hasAsyncProcesses()) === false) {
+      delete asyncBufferRef.current[key];
+      if (typeof fulfill === 'function') {
+        window.requestAnimationFrame(fulfill);
+      }
+    }
+  }
+  const eventPool = (0, _react.useRef)({
+    validator: null,
+    onBlurValidator: null,
+    onChangeContext: null,
+    onChangeLocal: null
+  });
+  const addToPool = (0, _react.useCallback)((name, fn, runAsync) => {
+    if (!eventPool.current[name]) {
+      eventPool.current[name] = {
+        fn,
+        runAsync
+      };
+    }
+  }, []);
+  const runPool = (0, _react.useCallback)(async function () {
+    let cb = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    for (const key in eventPool.current) {
+      if (!eventPool.current[key] || eventPool.current[key].pending) {
+        continue;
+      }
+      const {
+        fn,
+        runAsync
+      } = eventPool.current[key] || {};
+      if (fn) {
+        eventPool.current[key].pending = true;
+        eventPool.current[key] = null;
+        if (runAsync) {
+          await fn();
+        } else {
+          fn();
+        }
+      }
+    }
+    cb === null || cb === void 0 ? void 0 : cb();
+  }, []);
+  setPropsDataContext === null || setPropsDataContext === void 0 ? void 0 : setPropsDataContext(identifier, props);
+  const fieldStateRef = (0, _react.useRef)();
+  const setFieldState = (0, _react.useCallback)(state => {
+    fieldStateRef.current = state;
+    setFieldStateDataContext(identifier, resolveValidatingState(state));
+    if (!validateInitially) {
+      forceUpdate();
+    }
+  }, [setFieldStateDataContext, identifier, validateInitially]);
+  const showError = (0, _react.useCallback)(() => {
+    showErrorRef.current = true;
+    showFieldErrorFieldBlock === null || showFieldErrorFieldBlock === void 0 ? void 0 : showFieldErrorFieldBlock(identifier, true);
+  }, [showFieldErrorFieldBlock, identifier]);
+  const hideError = (0, _react.useCallback)(() => {
+    showErrorRef.current = false;
+    showFieldErrorFieldBlock === null || showFieldErrorFieldBlock === void 0 ? void 0 : showFieldErrorFieldBlock(identifier, false);
+  }, [showFieldErrorFieldBlock, identifier]);
+  const error = showErrorRef.current || ((_localErrorRef$curren = localErrorRef.current) === null || _localErrorRef$curren === void 0 ? void 0 : _localErrorRef$curren['validationRule']) === 'type' ? (_ref2 = errorProp !== null && errorProp !== void 0 ? errorProp : localErrorRef.current) !== null && _ref2 !== void 0 ? _ref2 : contextErrorRef.current : undefined;
+  const hasVisibleError = Boolean(error) || inFieldBlock && fieldBlockContext.hasErrorProp;
+  const hasError = (0, _react.useCallback)(() => {
+    var _ref3;
+    return Boolean((_ref3 = errorProp !== null && errorProp !== void 0 ? errorProp : localErrorRef.current) !== null && _ref3 !== void 0 ? _ref3 : contextErrorRef.current);
+  }, [errorProp]);
+  const errorMessagesRef = (0, _react.useRef)(null);
+  errorMessagesRef.current = (0, _react.useMemo)(() => {
+    return _objectSpread({
+      required: tr.fieldErrorRequired
+    }, errorMessages);
+  }, [errorMessages, tr.fieldErrorRequired]);
+  const prepareError = (0, _react.useCallback)(error => {
+    if (error instanceof _types.FormError) {
+      var _error$messageValues;
+      let message = error.message;
+      const {
+        validationRule
+      } = error;
+      if (typeof validationRule === 'string') {
+        var _errorMessagesRef$cur;
+        const fieldMessage = (_errorMessagesRef$cur = errorMessagesRef.current) === null || _errorMessagesRef$cur === void 0 ? void 0 : _errorMessagesRef$cur[validationRule];
+        if (fieldMessage) {
+          message = fieldMessage;
+        }
+      }
+      const messageWithValues = Object.entries((_error$messageValues = error.messageValues) !== null && _error$messageValues !== void 0 ? _error$messageValues : {}).reduce((message, _ref4) => {
+        let [key, value] = _ref4;
+        return message.replace(`{${key}}`, value);
+      }, message);
+      error.message = messageWithValues;
+      return error;
+    }
+    return error;
+  }, []);
+  const stateId = (0, _useId.default)();
+  const persistErrorState = (0, _react.useCallback)(function (method) {
+    let errorArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
+    const error = prepareError(errorArg);
+    if (!(0, _utils.errorChanged)(error, localErrorRef.current)) {
+      return;
+    }
+    if (method === 'wipe') {
+      errorMethodRef.current = {};
+    } else {
+      errorMethodRef.current[method] = error;
+    }
+    if (!error && method === 'gracefully' && Object.keys(errorMethodRef.current).filter(Boolean).length > 0) {
+      return;
+    }
+    localErrorRef.current = error;
+    setFieldErrorDataContext === null || setFieldErrorDataContext === void 0 ? void 0 : setFieldErrorDataContext(identifier, error);
+    setFieldStateDataContext === null || setFieldStateDataContext === void 0 ? void 0 : setFieldStateDataContext(identifier, error ? 'error' : undefined);
+    setFieldStateFieldBlock === null || setFieldStateFieldBlock === void 0 ? void 0 : setFieldStateFieldBlock({
+      stateId,
+      identifier,
+      type: 'error',
+      content: error,
+      showInitially: Boolean(inFieldBlock && validateInitially)
+    });
+    forceUpdate();
+  }, [prepareError, setFieldErrorDataContext, identifier, setFieldStateDataContext, setFieldStateFieldBlock, stateId, inFieldBlock, validateInitially]);
+  const clearErrorState = (0, _react.useCallback)(() => {
+    persistErrorState('wipe');
+  }, [persistErrorState]);
+  const callValidator = (0, _react.useCallback)(async () => {
+    if (typeof validatorRef.current !== 'function') {
+      return;
+    }
+    const runAsync = (0, _isAsync.isAsync)(validatorRef.current);
+    if (runAsync) {
+      setCurrentAsyncProcess('validator');
+      setFieldState('validating');
+      hideError();
+    }
+    const opts = _objectSpread(_objectSpread({}, contextErrorMessages), errorMessagesRef.current);
+    const result = await validatorRef.current(valueRef.current, opts);
+    persistErrorState('gracefully', result);
+    if (runAsync) {
+      setFieldState(result instanceof Error ? 'error' : 'complete');
+    }
+    if (continuousValidation || runAsync) {
+      window.requestAnimationFrame(() => {
+        showError();
+        forceUpdate();
+      });
+    }
+    return result;
+  }, [contextErrorMessages, continuousValidation, hideError, persistErrorState, setCurrentAsyncProcess, setFieldState, showError]);
+  const callOnBlurValidator = (0, _react.useCallback)(async function () {
+    let {
+      valueOverride = null
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    if (typeof onBlurValidatorRef.current !== 'function') {
+      return;
+    }
+    const value = transformers.current.toEvent(valueOverride !== null && valueOverride !== void 0 ? valueOverride : valueRef.current, 'onBlurValidator');
+    const runAsync = (0, _isAsync.isAsync)(onBlurValidatorRef.current);
+    if (runAsync) {
+      setCurrentAsyncProcess('onBlurValidator');
+      setFieldState('validating');
+    }
+    const result = await onBlurValidatorRef.current(value);
+    persistErrorState('gracefully', result);
+    if (runAsync) {
+      setFieldState(result instanceof Error ? 'error' : 'complete');
+    }
+    showError();
+    forceUpdate();
+  }, [persistErrorState, setCurrentAsyncProcess, setFieldState, showError]);
+  const validateValue = (0, _react.useCallback)(async () => {
+    const isProcessActive = startProcess();
+    if (disabled) {
+      if (isProcessActive()) {
+        clearErrorState();
+      }
+      hideError();
+      setFieldState(undefined);
+      return;
+    }
+    const value = valueRef.current;
+    changeEventResultRef.current = null;
+    validatedWithValue.current = null;
+    try {
+      const requiredError = transformers.current.validateRequired(value, {
+        emptyValue,
+        required,
+        isChanged: changedRef.current,
+        error: new _types.FormError('The value is required', {
+          validationRule: 'required'
+        })
+      });
+      if (requiredError instanceof Error) {
+        throw requiredError;
+      }
+      if (schemaValidatorRef.current && value !== undefined && !schemaValidatorRef.current(value)) {
+        const error = (0, _ajv.ajvErrorsToOneFormError)(schemaValidatorRef.current.errors, valueRef.current);
+        throw error;
+      }
+      if (validatorRef.current && (changedRef.current || validateInitially)) {
+        const result = await callValidator();
+        if (result instanceof Error) {
+          throw result;
+        }
+      }
+      if (isProcessActive()) {
+        clearErrorState();
+      }
+      validatedWithValue.current = value;
+    } catch (error) {
+      if (isProcessActive()) {
+        persistErrorState('weak', error);
+      }
+    }
+  }, [startProcess, disabled, hideError, setFieldState, clearErrorState, emptyValue, required, validateInitially, callValidator, persistErrorState]);
+  const handleError = (0, _react.useCallback)(() => {
+    if (continuousValidation || continuousValidation !== false && !hasFocusRef.current) {
+      showError();
+    } else {
+      hideError();
+    }
+  }, [continuousValidation, hideError, showError]);
+  const setHasFocus = (0, _react.useCallback)(async (hasFocus, valueOverride) => {
+    if (hasFocus) {
+      hasFocusRef.current = true;
+      const value = transformers.current.toEvent(valueOverride !== null && valueOverride !== void 0 ? valueOverride : valueRef.current, 'onFocus');
+      onFocus === null || onFocus === void 0 ? void 0 : onFocus(value);
+    } else {
+      hasFocusRef.current = false;
+      const value = transformers.current.toEvent(valueOverride !== null && valueOverride !== void 0 ? valueOverride : valueRef.current, 'onBlur');
+      onBlur === null || onBlur === void 0 ? void 0 : onBlur(value);
+      if (!changedRef.current && !validateUnchanged) {
+        return;
+      }
+      addToPool('onBlurValidator', async () => await callOnBlurValidator({
+        valueOverride
+      }), (0, _isAsync.isAsync)(onBlurValidatorRef.current));
+      await runPool(() => {
+        showError();
+        forceUpdate();
+      });
+    }
+  }, [addToPool, callOnBlurValidator, onBlur, onFocus, runPool, showError, validateUnchanged]);
+  const yieldAsyncProcess = (0, _react.useCallback)(async _ref5 => {
+    let {
+      name,
+      waitFor,
+      withValidatedValueOf
+    } = _ref5;
+    return new Promise(resolve => {
+      const fulfill = () => {
+        if (typeof withValidatedValueOf === 'undefined' || withValidatedValueOf === validatedWithValue.current) {
+          resolve();
+        }
+      };
+      const hasAsyncProcesses = () => {
+        return waitFor.some(_ref6 => {
+          let {
+            processName,
+            withStates
+          } = _ref6;
+          return (processName ? processName === currentAsyncProcessRef.current : true) && withStates.some(state => {
+            return state === fieldStateRef.current;
+          });
+        });
+      };
+      if (hasAsyncProcesses() === true) {
+        asyncBufferRef.current[name] = {
+          fulfill,
+          hasAsyncProcesses
+        };
+      } else {
+        fulfill();
+        setFieldState('pending');
+      }
+    });
+  }, [setFieldState]);
+  const handleChangeEventResult = (0, _react.useCallback)(async () => {
+    const result = changeEventResultRef.current;
+    if (typeof (result === null || result === void 0 ? void 0 : result.error) !== 'undefined') {
+      persistErrorState('gracefully', result.error);
+      showError();
+    }
+    if (typeof (result === null || result === void 0 ? void 0 : result.warning) !== 'undefined') {
+      warningRef.current = result.warning;
+    }
+    if (typeof (result === null || result === void 0 ? void 0 : result.info) !== 'undefined') {
+      infoRef.current = result.info;
+    }
+    if (asyncBehaviorIsEnabled) {
+      await yieldAsyncProcess({
+        name: 'onSubmitContext',
+        waitFor: [{
+          withStates: ['validating']
+        }]
+      });
+    }
+    if ((result === null || result === void 0 ? void 0 : result.success) === 'saved') {
+      setFieldState('success');
+    } else if (result !== null && result !== void 0 && result.error) {
+      setFieldState('error');
+    } else if (asyncBehaviorIsEnabled) {
+      setFieldState('complete');
+    }
+  }, [asyncBehaviorIsEnabled, persistErrorState, setFieldState, showError, yieldAsyncProcess]);
+  const setEventResult = (0, _react.useCallback)(result => {
+    if (result instanceof Error) {
+      result = {
+        error: result
+      };
+    }
+    changeEventResultRef.current = _objectSpread(_objectSpread({}, changeEventResultRef.current), result);
+    handleChangeEventResult();
+  }, [handleChangeEventResult]);
+  const callOnChangeContext = (0, _react.useCallback)(async () => {
+    if (asyncBehaviorIsEnabled) {
+      await yieldAsyncProcess({
+        name: 'onChangeContext',
+        withValidatedValueOf: valueRef.current,
+        waitFor: [{
+          processName: 'validator',
+          withStates: ['validating', 'error']
+        }, {
+          processName: 'onBlurValidator',
+          withStates: ['validating', 'error']
+        }]
+      });
+    }
+    if (path) {
+      if ((0, _isAsync.isAsync)(onChangeContext)) {
+        setCurrentAsyncProcess('onChangeContext');
+        setEventResult(await (handlePathChangeDataContext === null || handlePathChangeDataContext === void 0 ? void 0 : handlePathChangeDataContext(path, valueRef.current)));
+      } else {
+        setEventResult(handlePathChangeDataContext === null || handlePathChangeDataContext === void 0 ? void 0 : handlePathChangeDataContext(path, valueRef.current));
+      }
+    }
+    forceUpdate();
+  }, [asyncBehaviorIsEnabled, path, yieldAsyncProcess, onChangeContext, setCurrentAsyncProcess, setEventResult, handlePathChangeDataContext]);
+  const updateValue = (0, _react.useCallback)(async newValue => {
+    if (newValue === valueRef.current) {
+      return;
+    }
+    valueRef.current = newValue;
+    addToPool('validator', validateValue, (0, _isAsync.isAsync)(validatorRef.current));
+    addToPool('onChangeContext', callOnChangeContext, (0, _isAsync.isAsync)(onChangeContext));
+    await runPool(() => {
+      handleError();
+    });
+  }, [addToPool, callOnChangeContext, handleError, onChangeContext, runPool, validateValue]);
+  const handleChange = (0, _react.useCallback)(async function (argFromInput) {
+    let additionalArgs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
+    const currentValue = valueRef.current;
+    const fromInput = transformers.current.fromInput(argFromInput);
+    if (fromInput === currentValue) {
+      return;
+    }
+    const transformedValue = transformers.current.transformValue(fromInput, currentValue);
+    changedRef.current = true;
+    if (asyncBehaviorIsEnabled) {
+      hideError();
+      await updateValue(transformedValue);
+    } else {
+      updateValue(transformedValue);
+    }
+    const getArgs = () => {
+      const value = transformers.current.toEvent(valueRef.current, 'onChange');
+      return typeof additionalArgs !== 'undefined' ? [value, additionalArgs] : [value];
+    };
+    if ((0, _isAsync.isAsync)(onChange)) {
+      addToPool('onChangeLocal', async () => {
+        const args = getArgs();
+        await yieldAsyncProcess({
+          name: 'onChangeLocal',
+          withValidatedValueOf: args[0],
+          waitFor: [{
+            processName: 'validator',
+            withStates: ['validating', 'error']
+          }, {
+            processName: 'onBlurValidator',
+            withStates: ['validating', 'error']
+          }, {
+            processName: 'onChangeContext',
+            withStates: ['pending', 'error']
+          }]
+        });
+        setCurrentAsyncProcess('onChangeLocal');
+        setEventResult(await (onChange === null || onChange === void 0 ? void 0 : onChange.apply(_this, args)));
+      }, true);
+    } else {
+      setEventResult(onChange === null || onChange === void 0 ? void 0 : onChange.apply(_this, getArgs()));
+    }
+    await runPool(() => {
+      if (itemPath) {
+        const iterateValuePath = `/${iterateElementIndex}${itemPath && itemPath !== '/' ? itemPath : ''}`;
+        handleIterateElementChange === null || handleIterateElementChange === void 0 ? void 0 : handleIterateElementChange(iterateValuePath, valueRef.current);
+      }
+    });
+  }, [addToPool, asyncBehaviorIsEnabled, handleIterateElementChange, hideError, itemPath, iterateElementIndex, onChange, runPool, setCurrentAsyncProcess, setEventResult, updateValue, yieldAsyncProcess]);
+  const handleFocus = (0, _react.useCallback)(() => setHasFocus(true), [setHasFocus]);
+  const handleBlur = (0, _react.useCallback)(() => setHasFocus(false), [setHasFocus]);
+  (0, _useMountEffect.default)(() => {
+    dataContext === null || dataContext === void 0 ? void 0 : dataContext.handleMountField(identifier);
+    validateValue();
+  });
+  (0, _useUnmountEffect.default)(() => {
+    dataContext === null || dataContext === void 0 ? void 0 : dataContext.handleUnMountField(identifier);
+  });
+  (0, _useUpdateEffect.default)(() => {
+    var _dataContext$ajvInsta2;
+    schemaValidatorRef.current = schema ? (_dataContext$ajvInsta2 = dataContext.ajvInstance) === null || _dataContext$ajvInsta2 === void 0 ? void 0 : _dataContext$ajvInsta2.compile(schema) : undefined;
+    validateValue();
+  }, [schema, validateValue]);
+  (0, _useUpdateEffect.default)(() => {
+    if (valueRef.current !== externalValue) {
+      valueRef.current = externalValue;
+      validateValue();
+    }
+    forceUpdate();
+  }, [externalValue, validateValue]);
+  (0, _react.useEffect)(() => {
+    const error = prepareError(dataContextError);
+    if ((0, _utils.errorChanged)(error, contextErrorRef.current)) {
+      contextErrorRef.current = error;
+      forceUpdate();
+    }
+  }, [dataContextError, prepareError]);
+  (0, _react.useEffect)(() => {
+    if (path) {
+      let value = props.value;
+      const hasValue = _jsonPointer.default.has(dataContext.data, path);
+      const existingValue = hasValue ? _jsonPointer.default.get(dataContext.data, path) : undefined;
+      if (dataContext.id && !hasValue && typeof existingValue === 'undefined' && typeof value === 'undefined') {
+        const sharedState = (0, _useSharedState.createSharedState)(dataContext.id);
+        const hasValue = _jsonPointer.default.has(sharedState.data, path);
+        if (hasValue) {
+          const sharedValue = _jsonPointer.default.get(sharedState.data, path);
+          if (sharedValue) {
+            value = sharedValue;
+          }
+        }
+      }
+      if (!hasValue || value !== existingValue && valueRef.current !== existingValue) {
+        updateDataValueDataContext === null || updateDataValueDataContext === void 0 ? void 0 : updateDataValueDataContext(path, value);
+        validateDataDataContext === null || validateDataDataContext === void 0 ? void 0 : validateDataDataContext();
+      }
+    }
+  }, [dataContext.data, dataContext.id, path, props.value, updateDataValueDataContext, validateDataDataContext]);
+  (0, _react.useEffect)(() => {
+    if (dataContext.showAllErrors) {
+      showError();
+      forceUpdate();
+    }
+  }, [dataContext.showAllErrors, showError]);
+  (0, _react.useEffect)(() => {
+    if (dataContext.formState === 'pending' && (validatorRef.current || onBlurValidatorRef.current)) {
+      hideError();
+      forceUpdate();
+    }
+  }, [dataContext.formState, hideError]);
+  const onSubmitHandler = (0, _react.useCallback)(async () => {
+    if (hasError()) {
+      return;
+    }
+    addToPool('validator', callValidator, (0, _isAsync.isAsync)(validatorRef.current));
+    addToPool('onBlurValidator', callOnBlurValidator, (0, _isAsync.isAsync)(onBlurValidatorRef.current));
+    await runPool();
+  }, [addToPool, callOnBlurValidator, callValidator, hasError, runPool]);
+  (0, _useMountEffect.default)(() => {
+    var _dataContext$setField;
+    dataContext === null || dataContext === void 0 ? void 0 : (_dataContext$setField = dataContext.setFieldEventListener) === null || _dataContext$setField === void 0 ? void 0 : _dataContext$setField.call(dataContext, identifier, 'onSubmit', onSubmitHandler);
+  });
+  (0, _useMountEffect.default)(() => {
+    if (inFieldBlock) {
+      if (errorProp) {
+        setFieldStateFieldBlock === null || setFieldStateFieldBlock === void 0 ? void 0 : setFieldStateFieldBlock({
+          identifier,
+          type: 'error',
+          content: errorProp,
+          showInitially: true,
+          show: true
+        });
+      }
+      if (warning) {
+        setFieldStateFieldBlock === null || setFieldStateFieldBlock === void 0 ? void 0 : setFieldStateFieldBlock({
+          identifier,
+          type: 'warning',
+          content: warning,
+          showInitially: true,
+          show: true
+        });
+      }
+      if (info) {
+        setFieldStateFieldBlock === null || setFieldStateFieldBlock === void 0 ? void 0 : setFieldStateFieldBlock({
+          identifier,
+          type: 'info',
+          content: info,
+          showInitially: true,
+          show: true
+        });
+      }
+      return () => {
+        if (fieldBlockContext.mountedFieldsRef) {
+          fieldBlockContext.mountedFieldsRef.current[identifier] = true;
+        }
+      };
+    }
+  });
+  const infoRef = (0, _react.useRef)(info);
+  const warningRef = (0, _react.useRef)(warning);
+  (0, _useUpdateEffect.default)(() => {
+    infoRef.current = info;
+    warningRef.current = warning;
+    forceUpdate();
+  }, [info, warning]);
+  const htmlAttributes = (0, _react.useMemo)(() => {
+    return Object.keys(props).reduce((acc, cur) => {
+      if (cur.startsWith('aria-') || cur.startsWith('data-')) {
+        acc[cur] = props[cur];
+      }
+      return acc;
+    }, {});
+  }, [props]);
+  if (error) {
+    htmlAttributes['aria-invalid'] = error ? 'true' : 'false';
+  }
+  if (required) {
+    htmlAttributes['aria-required'] = required ? 'true' : 'false';
+  }
+  if (inFieldBlock) {
+    var _fieldBlockContext$fi;
+    if (fieldBlockContext.mountedFieldsRef) {
+      fieldBlockContext.mountedFieldsRef.current[identifier] = true;
+    }
+    const stateIds = (_fieldBlockContext$fi = fieldBlockContext.fieldStateIdsRef) === null || _fieldBlockContext$fi === void 0 ? void 0 : _fieldBlockContext$fi.current;
+    if (stateIds) {
+      htmlAttributes['aria-describedby'] = (0, _componentHelper.combineDescribedBy)(htmlAttributes, [error && stateIds.error, warning && stateIds.warning, info && stateIds.info].filter(Boolean));
+    }
+  } else {
+    const ids = [(error || errorProp) && `${id}-form-status--error`, warning && `${id}-form-status--warning`, info && `${id}-form-status--info`].filter(Boolean);
+    if (ids.length) {
+      htmlAttributes['aria-describedby'] = (0, _componentHelper.combineDescribedBy)(htmlAttributes, ids);
+    }
+  }
+  const fieldBlockProps = {
+    info: !inFieldBlock ? infoRef.current : undefined,
+    warning: !inFieldBlock ? warningRef.current : undefined,
+    error: !inFieldBlock ? error : undefined,
+    disabled: onBlurValidator && currentAsyncProcessRef.current === 'onBlurValidator' && fieldStateRef.current === 'validating' ? true : disabled,
+    fieldState: resolveValidatingState(fieldStateRef.current)
+  };
+  const sharedData = (0, _useSharedState.useSharedState)(id);
+  sharedData.set(fieldBlockProps);
+  return _objectSpread(_objectSpread(_objectSpread({}, props), fieldBlockProps), {}, {
+    name: props.name || ((_props$path = props.path) === null || _props$path === void 0 ? void 0 : _props$path.replace('/', '')) || id,
+    autoComplete: (_props$autoComplete = props.autoComplete) !== null && _props$autoComplete !== void 0 ? _props$autoComplete : dataContext.autoComplete === true ? 'on' : undefined,
+    id,
+    value: transformers.current.toInput(valueRef.current),
+    hasError: hasVisibleError,
+    isChanged: changedRef.current,
+    htmlAttributes,
+    setHasFocus,
+    handleFocus,
+    handleBlur,
+    handleChange,
+    updateValue,
+    forceUpdate,
+    dataContext
+  });
+}
+function omitFieldProps(props) {
+  const {
+      name,
+      error,
+      warning,
+      info,
+      hasError,
+      isChanged,
+      htmlAttributes,
+      setHasFocus,
+      handleFocus,
+      handleBlur,
+      handleChange,
+      updateValue,
+      forceUpdate,
+      autoComplete,
+      dataContext,
+      fieldState
+    } = props,
+    restProps = _objectWithoutProperties(props, _excluded);
+  return restProps;
+}
+function resolveValidatingState(state) {
+  return state === 'validating' ? 'pending' : state;
+}
+//# sourceMappingURL=useFieldProps.js.map