@hitachivantara/uikit-react-core/dist/cjs/TreeView/internals/hooks/plugins/useTreeViewFocus.cjs

Core React components for the NEXT Design System.

"use strict";
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const React = require("react");
const utils = require("@mui/material/utils");
const useInstanceEventHandler = require("../useInstanceEventHandler.cjs");
const utils$1 = require("../utils.cjs");
function _interopNamespace(e) {
  if (e && e.__esModule) return e;
  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
  if (e) {
    for (const k in e) {
      if (k !== "default") {
        const d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: () => e[k]
        });
      }
    }
  }
  n.default = e;
  return Object.freeze(n);
}
const React__namespace = /* @__PURE__ */ _interopNamespace(React);
const useTreeViewFocus = ({
  instance,
  params,
  state,
  setState,
  models,
  rootRef
}) => {
  const setFocusedNodeId = utils.useEventCallback(
    (nodeId) => {
      const cleanNodeId = typeof nodeId === "function" ? nodeId(state.focusedNodeId) : nodeId;
      setState((prevState) => ({ ...prevState, focusedNodeId: cleanNodeId }));
    }
  );
  const isNodeFocused = React__namespace.useCallback(
    (nodeId) => state.focusedNodeId === nodeId,
    [state.focusedNodeId]
  );
  const focusNode = utils.useEventCallback(
    (event, nodeId) => {
      if (nodeId) {
        setFocusedNodeId(nodeId);
        if (params.onNodeFocus) {
          params.onNodeFocus(event, nodeId);
        }
      }
    }
  );
  utils$1.populateInstance(instance, {
    isNodeFocused,
    focusNode
  });
  useInstanceEventHandler.useInstanceEventHandler(instance, "removeNode", ({ id }) => {
    setFocusedNodeId((oldFocusedNodeId) => {
      if (oldFocusedNodeId === id && rootRef.current === utils.ownerDocument(rootRef.current).activeElement) {
        return instance.getChildrenIds(null)[0];
      }
      return oldFocusedNodeId;
    });
  });
  const createHandleFocus = (otherHandlers) => (event) => {
    otherHandlers.onFocus?.(event);
    if (event.target === event.currentTarget) {
      const isNodeVisible = (nodeId) => {
        const node = instance.getNode(nodeId);
        return node && (node.parentId == null || instance.isNodeExpanded(node.parentId));
      };
      let nodeToFocusId;
      if (Array.isArray(models.selected.value)) {
        nodeToFocusId = models.selected.value.find(isNodeVisible);
      } else if (models.selected.value != null && isNodeVisible(models.selected.value)) {
        nodeToFocusId = models.selected.value;
      }
      if (nodeToFocusId == null) {
        nodeToFocusId = instance.getNavigableChildrenIds(null)[0];
      }
      instance.focusNode(event, nodeToFocusId);
    }
  };
  const createHandleBlur = (otherHandlers) => (event) => {
    otherHandlers.onBlur?.(event);
    setFocusedNodeId(null);
  };
  const focusedNode = instance.getNode(state.focusedNodeId);
  const activeDescendant = focusedNode ? focusedNode.idAttribute : null;
  return {
    getRootProps: (otherHandlers) => ({
      onFocus: createHandleFocus(otherHandlers),
      onBlur: createHandleBlur(otherHandlers),
      "aria-activedescendant": activeDescendant ?? void 0
    })
  };
};
useTreeViewFocus.getInitialState = () => ({ focusedNodeId: null });
useTreeViewFocus.getDefaultizedParams = (params) => ({
  ...params,
  disabledItemsFocusable: params.disabledItemsFocusable ?? false
});
exports.useTreeViewFocus = useTreeViewFocus;