@dnb/eufemia
Version:
DNB Eufemia Design System UI Library
114 lines (113 loc) • 3.69 kB
JavaScript
"use client";
import { useCallback, useContext, useRef } from 'react';
import pointer from "../../utils/json-pointer/index.js";
import DataContext from "../../DataContext/Context.js";
import usePath from "../../hooks/usePath.js";
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(({
visible,
visibleWhen,
visibleWhenNot,
pathDefined,
pathUndefined,
pathTruthy,
pathFalsy,
pathTrue,
pathFalse,
pathValue,
whenValue,
inferData,
filterData
} = propsRef.current) => {
if (typeof visible === 'boolean') {
return visible;
}
const data = filterData && 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 Boolean(visibleWhenNot);
}
const result = (visibleWhen.continuousValidation || visibleWhen.validateContinuously ? true : item.isFocused !== true) && !hasFieldError(path);
return visibleWhenNot ? !result : result;
}
if ('hasValue' in visibleWhen || 'withValue' in visibleWhen) {
var _visibleWhen$hasValue;
const hasPath = pointer.has(data, path);
const value = hasPath ? pointer.get(data, path) : undefined;
if (visibleWhen?.['withValue']) {
console.warn('VisibleWhen: "withValue" is deprecated, use "hasValue" instead');
}
const hasValue = (_visibleWhen$hasValue = visibleWhen?.['hasValue']) !== null && _visibleWhen$hasValue !== void 0 ? _visibleWhen$hasValue : visibleWhen?.['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 && !getValue(makeLocalPath(pathTruthy))) {
return false;
}
if (pathFalsy && getValue(makeLocalPath(pathFalsy))) {
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