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

Contributed React components for the NEXT UI Kit.

"use strict";
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const react = require("react");
const reactflow = require("reactflow");
const shallow = require("zustand/shallow");
const useFlowInstance = require("./useFlowInstance.cjs");
const useNodeId = require("./useNodeId.cjs");
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.useNodeId(id);
  const nodeSelector = react.useCallback(
    (state) => state.getNodes().find((n) => n.id === nodeId),
    [nodeId]
  );
  return reactflow.useStore(nodeSelector, shallow.shallow);
}
function useFlowNodeInputEdges(id) {
  const nodeId = useNodeId.useNodeId(id);
  const inputEdgesSelector = react.useCallback(
    (state) => state.edges.filter((e) => e.target === nodeId),
    [nodeId]
  );
  return reactflow.useStore(inputEdgesSelector, shallow.shallow);
}
function useFlowNodeOutputEdges(id) {
  const nodeId = useNodeId.useNodeId(id);
  const outputEdgesSelector = react.useCallback(
    (state) => state.edges.filter((e) => e.source === nodeId),
    [nodeId]
  );
  return reactflow.useStore(outputEdgesSelector, shallow.shallow);
}
function useFlowNodeEdges(id) {
  const nodeId = useNodeId.useNodeId(id);
  const edgesSelector = react.useCallback(
    (state) => state.edges.filter(
      (e) => e.source === nodeId || e.target === nodeId
    ),
    [nodeId]
  );
  return reactflow.useStore(edgesSelector, shallow.shallow);
}
function useFlowNodeParents(id) {
  const inputEdges = useFlowNodeInputEdges(id);
  const parentNodesSelector = react.useCallback(
    (state) => {
      return inputEdges.map((e) => state.getNodes().find((n) => n.id === e.source)).filter((n) => n !== null);
    },
    [inputEdges]
  );
  return reactflow.useStore(parentNodesSelector, shallow.shallow);
}
function useFlowInputNodes(id) {
  const nodeId = useNodeId.useNodeId(id);
  const nodes = reactflow.useNodes();
  const edges = reactflow.useEdges();
  return react.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.useNodeId(id);
  const nodes = reactflow.useNodes();
  const edges = reactflow.useEdges();
  return react.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.useNodeId(id);
  const reactFlowInstance = useFlowInstance.useFlowInstance();
  const setNodeData = react.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 = react.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 react.useMemo(
    () => ({
      setNodeData,
      setNodeParent
    }),
    [setNodeData, setNodeParent]
  );
}
function useFlowNodeIntersections(id) {
  const nodeId = useNodeId.useNodeId(id);
  const node = useFlowNode(nodeId ?? "");
  const reactFlowInstance = useFlowInstance.useFlowInstance();
  return node ? reactFlowInstance.getIntersectingNodes(node, false) : [];
}
exports.useFlowInputNodes = useFlowInputNodes;
exports.useFlowNode = useFlowNode;
exports.useFlowNodeEdges = useFlowNodeEdges;
exports.useFlowNodeInputEdges = useFlowNodeInputEdges;
exports.useFlowNodeIntersections = useFlowNodeIntersections;
exports.useFlowNodeOutputEdges = useFlowNodeOutputEdges;
exports.useFlowNodeParents = useFlowNodeParents;
exports.useFlowNodeUtils = useFlowNodeUtils;
exports.useFlowOutputNodes = useFlowOutputNodes;