@dnb/eufemia/extensions/forms/Form/Visibility/useVisibility.js

DNB Eufemia Design System UI Library

"use client";

import { useCallback, useContext, useRef } from 'react';
import pointer from '../../utils/json-pointer';
import DataContext from '../../DataContext/Context';
import usePath from '../../hooks/usePath';
export default function useVisibility(props) {
  const {
    hasFieldError,
    filterDataHandler,
    mountedFieldsRef,
    data: originalData
  } = useContext(DataContext);
  const {
    makePath,
    makeIteratePath
  } = usePath();
  const propsRef = useRef(props);
  propsRef.current = props;
  const {
    withinIterate
  } = props || {};
  const makeLocalPath = useCallback(path => {
    if (withinIterate) {
      return makeIteratePath(path);
    }
    return makePath(path);
  }, [makeIteratePath, makePath, withinIterate]);
  const check = useCallback(function () {
    let {
      visible,
      visibleWhen,
      visibleWhenNot,
      pathDefined,
      pathUndefined,
      pathTruthy,
      pathFalsy,
      pathTrue,
      pathFalse,
      pathValue,
      whenValue,
      inferData,
      filterData
    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : propsRef.current;
    if (typeof visible === 'boolean') {
      return visible;
    }
    const data = filterData && (filterDataHandler === null || filterDataHandler === void 0 ? void 0 : filterDataHandler(originalData, filterData)) || originalData;
    if (visibleWhen || visibleWhenNot) {
      if (visibleWhenNot) {
        visibleWhen = visibleWhenNot;
      }
      const path = 'itemPath' in visibleWhen ? makeIteratePath(visibleWhen.itemPath) : makePath(visibleWhen.path);
      if ('isValid' in visibleWhen) {
        const item = mountedFieldsRef.current.get(path);
        if (!item || item.isMounted !== true) {
          return visibleWhenNot ? true : false;
        }
        const result = (visibleWhen.continuousValidation || visibleWhen.validateContinuously ? true : item.isFocused !== true) && hasFieldError(path) === false;
        return visibleWhenNot ? !result : result;
      }
      if ('hasValue' in visibleWhen || 'withValue' in visibleWhen) {
        var _visibleWhen, _visibleWhen$hasValue, _visibleWhen2, _visibleWhen3;
        const hasPath = pointer.has(data, path);
        const value = hasPath ? pointer.get(data, path) : undefined;
        if ((_visibleWhen = visibleWhen) !== null && _visibleWhen !== void 0 && _visibleWhen['withValue']) {
          console.warn('VisibleWhen: "withValue" is deprecated, use "hasValue" instead');
        }
        const hasValue = (_visibleWhen$hasValue = (_visibleWhen2 = visibleWhen) === null || _visibleWhen2 === void 0 ? void 0 : _visibleWhen2['hasValue']) !== null && _visibleWhen$hasValue !== void 0 ? _visibleWhen$hasValue : (_visibleWhen3 = visibleWhen) === null || _visibleWhen3 === void 0 ? void 0 : _visibleWhen3['withValue'];
        const result = typeof hasValue === 'function' ? hasValue(value) === false : hasValue !== value;
        if (visibleWhenNot) {
          if (!result) {
            return false;
          }
        } else if (result) {
          return false;
        }
      }
    }
    const getValue = path => {
      if (pointer.has(data, path)) {
        return pointer.get(data, path);
      }
    };
    if (pathDefined) {
      return getValue(makeLocalPath(pathDefined)) !== undefined;
    }
    if (pathUndefined) {
      return getValue(makeLocalPath(pathUndefined)) === undefined;
    }
    if (pathTrue && getValue(makeLocalPath(pathTrue)) !== true) {
      return false;
    }
    if (pathFalse && getValue(makeLocalPath(pathFalse)) !== false) {
      return false;
    }
    if (pathTruthy && Boolean(getValue(makeLocalPath(pathTruthy))) === false) {
      return false;
    }
    if (pathFalsy && Boolean(getValue(makeLocalPath(pathFalsy))) === true) {
      return false;
    }
    if (inferData && !inferData(data)) {
      return false;
    }
    if (pathValue && getValue(makeLocalPath(pathValue)) !== whenValue) {
      return false;
    }
    return true;
  }, [filterDataHandler, originalData, makeLocalPath, makeIteratePath, makePath, mountedFieldsRef, hasFieldError]);
  return {
    check
  };
}
//# sourceMappingURL=useVisibility.js.map