@dnb/eufemia 10.22.0 → 10.24.0

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

@@ -0,0 +1,749 @@
+"use client";
+
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+const _excluded = ["name", "error", "warning", "info", "hasError", "isChanged", "htmlAttributes", "setHasFocus", "handleFocus", "handleBlur", "handleChange", "updateValue", "forceUpdate", "autoComplete", "dataContext", "fieldState"];
+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; }
+import { useRef, useEffect, useContext, useCallback, useMemo, useReducer } from 'react';
+import pointer from 'json-pointer';
+import { errorChanged } from '../utils';
+import { ajvErrorsToOneFormError } from '../utils/ajv';
+import { FormError } from '../types';
+import { Context as DataContext } from '../DataContext';
+import { combineDescribedBy } from '../../../shared/component-helper';
+import useId from '../../../shared/helpers/useId';
+import useUpdateEffect from '../../../shared/helpers/useUpdateEffect';
+import useMountEffect from '../../../shared/helpers/useMountEffect';
+import useUnmountEffect from '../../../shared/helpers/useUnmountEffect';
+import SharedContext from '../../../shared/Context';
+import FieldBlockContext from '../FieldBlock/FieldBlockContext';
+import IterateElementContext from '../Iterate/IterateElementContext';
+import useProcessManager from './useProcessManager';
+import { createSharedState, useSharedState } from '../../../shared/helpers/useSharedState';
+import { isAsync } from '../../../shared/helpers/isAsync';
+export default function useFieldProps(props) {
+  var _props$disabled, _dataContext$props, _dataContext$ajvInsta, _localErrorRef$curren, _ref, _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, {
+      emptyValue,
+      required,
+      error
+    }) => {
+      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] = useReducer(() => ({}), {});
+  const {
+    startProcess
+  } = useProcessManager();
+  const id = useId(props.id);
+  const dataContext = useContext(DataContext);
+  const fieldBlockContext = useContext(FieldBlockContext);
+  const iterateElementContext = useContext(IterateElementContext);
+  const sharedContext = useContext(SharedContext);
+  const tr = sharedContext === null || sharedContext === void 0 ? void 0 : sharedContext.translation.Forms;
+  const transformers = 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 = useMemo(() => {
+    return path !== null && path !== void 0 ? path : id;
+  }, [path, id]);
+  const externalValue = useMemo(() => {
+    if (props.value !== emptyValue) {
+      return transformers.current.fromExternal(props.value);
+    }
+    if (inIterate && itemPath) {
+      if (itemPath === '/') {
+        return iterateElementValue;
+      }
+      return pointer.has(iterateElementValue, itemPath) ? pointer.get(iterateElementValue, itemPath) : emptyValue;
+    }
+    if (dataContext.data && path) {
+      if (path === '/') {
+        return dataContext.data;
+      }
+      return pointer.has(dataContext.data, path) ? pointer.get(dataContext.data, path) : emptyValue;
+    }
+    return emptyValue;
+  }, [props.value, emptyValue, inIterate, itemPath, dataContext.data, path, iterateElementValue]);
+  const valueRef = useRef(externalValue);
+  const changedRef = useRef(false);
+  const hasFocusRef = useRef(false);
+  const showErrorRef = useRef(Boolean(validateInitially || errorProp));
+  const errorMethodRef = useRef({});
+  const localErrorRef = useRef();
+  const contextErrorRef = useRef(dataContextError);
+  const validatorRef = useRef(validator);
+  useUpdateEffect(() => {
+    validatorRef.current = validator;
+  }, [validator]);
+  const onBlurValidatorRef = useRef(onBlurValidator);
+  useUpdateEffect(() => {
+    onBlurValidatorRef.current = onBlurValidator;
+  }, [onBlurValidator]);
+  const schemaValidatorRef = useRef(schema ? (_dataContext$ajvInsta = dataContext.ajvInstance) === null || _dataContext$ajvInsta === void 0 ? void 0 : _dataContext$ajvInsta.compile(schema) : undefined);
+  const asyncBehaviorIsEnabled = useMemo(() => {
+    return isAsync(onChange) || isAsync(onChangeContext);
+  }, [onChangeContext, onChange]);
+  const validatedWithValue = useRef();
+  const changeEventResultRef = useRef(null);
+  const currentAsyncProcessRef = useRef(null);
+  const setCurrentAsyncProcess = useCallback(name => {
+    currentAsyncProcessRef.current = name;
+  }, []);
+  const asyncBufferRef = 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 = useRef({
+    validator: null,
+    onBlurValidator: null,
+    onChangeContext: null,
+    onChangeLocal: null
+  });
+  const addToPool = useCallback((name, fn, runAsync) => {
+    if (!eventPool.current[name]) {
+      eventPool.current[name] = {
+        fn,
+        runAsync
+      };
+    }
+  }, []);
+  const runPool = useCallback(async (cb = 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 = useRef();
+  const setFieldState = useCallback(state => {
+    fieldStateRef.current = state;
+    setFieldStateDataContext(identifier, resolveValidatingState(state));
+    if (!validateInitially) {
+      forceUpdate();
+    }
+  }, [setFieldStateDataContext, identifier, validateInitially]);
+  const showError = useCallback(() => {
+    showErrorRef.current = true;
+    showFieldErrorFieldBlock === null || showFieldErrorFieldBlock === void 0 ? void 0 : showFieldErrorFieldBlock(identifier, true);
+  }, [showFieldErrorFieldBlock, identifier]);
+  const hideError = 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' ? (_ref = errorProp !== null && errorProp !== void 0 ? errorProp : localErrorRef.current) !== null && _ref !== void 0 ? _ref : contextErrorRef.current : undefined;
+  const hasVisibleError = Boolean(error) || inFieldBlock && fieldBlockContext.hasErrorProp;
+  const hasError = useCallback(() => {
+    var _ref2;
+    return Boolean((_ref2 = errorProp !== null && errorProp !== void 0 ? errorProp : localErrorRef.current) !== null && _ref2 !== void 0 ? _ref2 : contextErrorRef.current);
+  }, [errorProp]);
+  const errorMessagesRef = useRef(null);
+  errorMessagesRef.current = useMemo(() => {
+    return _objectSpread({
+      required: tr.fieldErrorRequired
+    }, errorMessages);
+  }, [errorMessages, tr.fieldErrorRequired]);
+  const prepareError = useCallback(error => {
+    if (error instanceof 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, [key, value]) => {
+        return message.replace(`{${key}}`, value);
+      }, message);
+      error.message = messageWithValues;
+      return error;
+    }
+    return error;
+  }, []);
+  const stateId = useId();
+  const persistErrorState = useCallback((method, errorArg = undefined) => {
+    const error = prepareError(errorArg);
+    if (!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 = useCallback(() => {
+    persistErrorState('wipe');
+  }, [persistErrorState]);
+  const callValidator = useCallback(async () => {
+    if (typeof validatorRef.current !== 'function') {
+      return;
+    }
+    const runAsync = 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 = useCallback(async ({
+    valueOverride = null
+  } = {}) => {
+    if (typeof onBlurValidatorRef.current !== 'function') {
+      return;
+    }
+    const value = transformers.current.toEvent(valueOverride !== null && valueOverride !== void 0 ? valueOverride : valueRef.current, 'onBlurValidator');
+    const runAsync = 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 = 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 FormError('The value is required', {
+          validationRule: 'required'
+        })
+      });
+      if (requiredError instanceof Error) {
+        throw requiredError;
+      }
+      if (schemaValidatorRef.current && value !== undefined && !schemaValidatorRef.current(value)) {
+        const error = 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 = useCallback(() => {
+    if (continuousValidation || continuousValidation !== false && !hasFocusRef.current) {
+      showError();
+    } else {
+      hideError();
+    }
+  }, [continuousValidation, hideError, showError]);
+  const setHasFocus = 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
+      }), isAsync(onBlurValidatorRef.current));
+      await runPool(() => {
+        showError();
+        forceUpdate();
+      });
+    }
+  }, [addToPool, callOnBlurValidator, onBlur, onFocus, runPool, showError, validateUnchanged]);
+  const yieldAsyncProcess = useCallback(async ({
+    name,
+    waitFor,
+    withValidatedValueOf
+  }) => {
+    return new Promise(resolve => {
+      const fulfill = () => {
+        if (typeof withValidatedValueOf === 'undefined' || withValidatedValueOf === validatedWithValue.current) {
+          resolve();
+        }
+      };
+      const hasAsyncProcesses = () => {
+        return waitFor.some(({
+          processName,
+          withStates
+        }) => {
+          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 = 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 = useCallback(result => {
+    if (result instanceof Error) {
+      result = {
+        error: result
+      };
+    }
+    changeEventResultRef.current = _objectSpread(_objectSpread({}, changeEventResultRef.current), result);
+    handleChangeEventResult();
+  }, [handleChangeEventResult]);
+  const callOnChangeContext = 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 (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 = useCallback(async newValue => {
+    if (newValue === valueRef.current) {
+      return;
+    }
+    valueRef.current = newValue;
+    addToPool('validator', validateValue, isAsync(validatorRef.current));
+    addToPool('onChangeContext', callOnChangeContext, isAsync(onChangeContext));
+    await runPool(() => {
+      handleError();
+    });
+  }, [addToPool, callOnChangeContext, handleError, onChangeContext, runPool, validateValue]);
+  const handleChange = useCallback(async (argFromInput, additionalArgs = 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 (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 = useCallback(() => setHasFocus(true), [setHasFocus]);
+  const handleBlur = useCallback(() => setHasFocus(false), [setHasFocus]);
+  useMountEffect(() => {
+    dataContext === null || dataContext === void 0 ? void 0 : dataContext.handleMountField(identifier);
+    validateValue();
+  });
+  useUnmountEffect(() => {
+    dataContext === null || dataContext === void 0 ? void 0 : dataContext.handleUnMountField(identifier);
+  });
+  useUpdateEffect(() => {
+    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]);
+  useUpdateEffect(() => {
+    if (valueRef.current !== externalValue) {
+      valueRef.current = externalValue;
+      validateValue();
+    }
+    forceUpdate();
+  }, [externalValue, validateValue]);
+  useEffect(() => {
+    const error = prepareError(dataContextError);
+    if (errorChanged(error, contextErrorRef.current)) {
+      contextErrorRef.current = error;
+      forceUpdate();
+    }
+  }, [dataContextError, prepareError]);
+  useEffect(() => {
+    if (path) {
+      let value = props.value;
+      const hasValue = pointer.has(dataContext.data, path);
+      const existingValue = hasValue ? pointer.get(dataContext.data, path) : undefined;
+      if (dataContext.id && !hasValue && typeof existingValue === 'undefined' && typeof value === 'undefined') {
+        const sharedState = createSharedState(dataContext.id);
+        const hasValue = pointer.has(sharedState.data, path);
+        if (hasValue) {
+          const sharedValue = pointer.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]);
+  useEffect(() => {
+    if (dataContext.showAllErrors) {
+      showError();
+      forceUpdate();
+    }
+  }, [dataContext.showAllErrors, showError]);
+  useEffect(() => {
+    if (dataContext.formState === 'pending' && (validatorRef.current || onBlurValidatorRef.current)) {
+      hideError();
+      forceUpdate();
+    }
+  }, [dataContext.formState, hideError]);
+  const onSubmitHandler = useCallback(async () => {
+    if (hasError()) {
+      return;
+    }
+    addToPool('validator', callValidator, isAsync(validatorRef.current));
+    addToPool('onBlurValidator', callOnBlurValidator, isAsync(onBlurValidatorRef.current));
+    await runPool();
+  }, [addToPool, callOnBlurValidator, callValidator, hasError, runPool]);
+  useMountEffect(() => {
+    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);
+  });
+  useMountEffect(() => {
+    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 = useRef(info);
+  const warningRef = useRef(warning);
+  useUpdateEffect(() => {
+    infoRef.current = info;
+    warningRef.current = warning;
+    forceUpdate();
+  }, [info, warning]);
+  const htmlAttributes = 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'] = 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'] = 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 = 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
+  });
+}
+export 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