export function useRemoveFromGraph()

in packages/graph-explorer/src/hooks/useRemoveFromGraph.ts [20:87]
56 lines of code
6 McCabe index (conditional complexity)

export function useRemoveFromGraph() {
  const setVertices = useSetAtom(nodesAtom);
  const setEdges = useSetAtom(edgesAtom);
  const setSelectedVertices = useSetAtom(nodesSelectedIdsAtom);
  const setSelectedEdges = useSetAtom(edgesSelectedIdsAtom);
  const setOutOfFocusVertices = useSetAtom(nodesOutOfFocusIdsAtom);
  const setOutOfFocusEdges = useSetAtom(edgesOutOfFocusIdsAtom);
  const setFilteredVertices = useSetAtom(nodesFilteredIdsAtom);
  const setFilteredEdges = useSetAtom(edgesFilteredIdsAtom);

  const allEdges = useAtomValue(edgesAtom);

  const updateGraphStorage = useUpdateGraphSession();

  return useCallback(
    async (entities: { vertices?: VertexId[]; edges?: EdgeId[] }) => {
      const vertices = new Set(entities.vertices ?? []);
      const edges = new Set(entities.edges ?? []);

      // Ensure there is something to remove
      if (vertices.size === 0 && edges.size === 0) {
        return;
      }

      // Find associated edges for removed vertices
      const associatedEdges = new Set(
        allEdges
          .entries()
          .filter(
            ([_id, edge]) =>
              vertices.has(edge.source) || vertices.has(edge.target)
          )
          .map(([id]) => id)
      );
      const edgesToRemove = edges.union(associatedEdges);

      // Remove vertices
      if (vertices.size > 0) {
        setVertices(prev => deleteFromMap(prev, vertices));
        setSelectedVertices(prev => prev.difference(vertices));
        setOutOfFocusVertices(prev => prev.difference(vertices));
        setFilteredVertices(prev => prev.difference(vertices));
      }

      // Remove edges
      if (edgesToRemove.size > 0) {
        setEdges(prev => deleteFromMap(prev, edgesToRemove));
        setSelectedEdges(prev => prev.difference(edgesToRemove));
        setOutOfFocusEdges(prev => prev.difference(edgesToRemove));
        setFilteredEdges(prev => prev.difference(edgesToRemove));
      }

      await updateGraphStorage();
    },
    [
      allEdges,
      updateGraphStorage,
      setVertices,
      setSelectedVertices,
      setOutOfFocusVertices,
      setFilteredVertices,
      setEdges,
      setSelectedEdges,
      setOutOfFocusEdges,
      setFilteredEdges,
    ]
  );
}