@hitachivantara/uikit-react-lab/dist/esm/Flow/hooks/useFlowNode.js

Contributed React components for the NEXT UI Kit.

import { useCallback, useMemo } from "react";
import { useStore, useNodes, useEdges } from "reactflow";
import { shallow } from "zustand/shallow";
import { useFlowInstance } from "./useFlowInstance.js";
import { useNodeId } from "./useNodeId.js";
function relativePosition(positionA, positionB) {
  if (positionA && positionB)
    return {
      x: positionB.x - positionA.x,
      y: positionB.y - positionA.y
    };
  return { x: 0, y: 0 };
}
function useFlowNode(id) {
  const nodeId = useNodeId(id);
  const nodeSelector = useCallback(
    (state) => state.getNodes().find((n) => n.id === nodeId),
    [nodeId]
  );
  return useStore(nodeSelector, shallow);
}
function useFlowNodeInputEdges(id) {
  const nodeId = useNodeId(id);
  const inputEdgesSelector = useCallback(
    (state) => state.edges.filter((e) => e.target === nodeId),
    [nodeId]
  );
  return useStore(inputEdgesSelector, shallow);
}
function useFlowNodeOutputEdges(id) {
  const nodeId = useNodeId(id);
  const outputEdgesSelector = useCallback(
    (state) => state.edges.filter((e) => e.source === nodeId),
    [nodeId]
  );
  return useStore(outputEdgesSelector, shallow);
}
function useFlowNodeEdges(id) {
  const nodeId = useNodeId(id);
  const edgesSelector = useCallback(
    (state) => state.edges.filter(
      (e) => e.source === nodeId || e.target === nodeId
    ),
    [nodeId]
  );
  return useStore(edgesSelector, shallow);
}
function useFlowNodeParents(id) {
  const inputEdges = useFlowNodeInputEdges(id);
  const parentNodesSelector = useCallback(
    (state) => {
      return inputEdges.map((e) => state.getNodes().find((n) => n.id === e.source)).filter((n) => n !== null);
    },
    [inputEdges]
  );
  return useStore(parentNodesSelector, shallow);
}
function useFlowInputNodes(id) {
  const nodeId = useNodeId(id);
  const nodes = useNodes();
  const edges = useEdges();
  return useMemo(() => {
    return edges.filter((e) => e.target === nodeId).map((e) => nodes.find((n) => n.id === e.source)).filter((n) => n !== null);
  }, [edges, nodeId, nodes]);
}
function useFlowOutputNodes(id) {
  const nodeId = useNodeId(id);
  const nodes = useNodes();
  const edges = useEdges();
  return useMemo(() => {
    return edges.filter((e) => e.source === nodeId).map((e) => nodes.find((n) => n.id === e.target)).filter((n) => n !== null);
  }, [edges, nodeId, nodes]);
}
function useFlowNodeUtils(id) {
  const nodeId = useNodeId(id);
  const reactFlowInstance = useFlowInstance();
  const setNodeData = useCallback(
    (setNewData) => {
      if (!nodeId) return;
      reactFlowInstance.setNodes((nodes) => {
        return nodes.map((n) => {
          if (n.id === nodeId) {
            return { ...n, data: setNewData(n.data) };
          }
          return n;
        });
      });
    },
    [nodeId, reactFlowInstance]
  );
  const setNodeParent = useCallback(
    (node, extent) => {
      if (!nodeId) return;
      reactFlowInstance.setNodes((nodes) => {
        return nodes.map((n) => {
          if (n.id === nodeId) {
            return {
              ...n,
              parentId: node ? node.id : void 0,
              extent,
              position: node ? relativePosition(node.position, n.position) : n.positionAbsolute ?? n.position
            };
          }
          return n;
        });
      });
    },
    [nodeId, reactFlowInstance]
  );
  return useMemo(
    () => ({
      setNodeData,
      setNodeParent
    }),
    [setNodeData, setNodeParent]
  );
}
function useFlowNodeIntersections(id) {
  const nodeId = useNodeId(id);
  const node = useFlowNode(nodeId ?? "");
  const reactFlowInstance = useFlowInstance();
  return node ? reactFlowInstance.getIntersectingNodes(node, false) : [];
}
export {
  useFlowInputNodes,
  useFlowNode,
  useFlowNodeEdges,
  useFlowNodeInputEdges,
  useFlowNodeIntersections,
  useFlowNodeOutputEdges,
  useFlowNodeParents,
  useFlowNodeUtils,
  useFlowOutputNodes
};