refactoring

frontend/src/components/nodes/render/useRenderingNodeState.ts

@@ -20,7 +20,7 @@ import {
     processSvgDisplay,
     stripTemplateSyntax,
 } from '@/lib/graph/rendering'
-import { isReachable, resolveExtendsRef, getTemplateRefs } from '@/lib/graph/templateRefs'
+import { buildSourceSignatures } from '@/lib/graph/renderingSignatures'
 import type { ConfigTypeId, SourceRenderingLogicContext } from '@/lib/graph/rendering'
 
 export type RenderingNodeData = {
@@ -136,101 +136,25 @@ export function useRenderingNodeState(
               ? agentOutputMarkdown
               : ''
 
-    const connectedNodeIds = useMemo(() => {
-        const edgeList = edges as { source: string; target: string }[]
-        const nodeList = nodes as { id: string; type?: string; data?: unknown }[]
-        const out = new Set<string>()
-        const addConfigRefs = (nodeId: string, visited: Set<string>) => {
-            if (visited.has(nodeId)) return
-            const node = nodeList.find((n) => n.id === nodeId && n.type === 'config')
-            if (!node) return
-            visited.add(nodeId)
-            out.add(nodeId)
-            const content = getConfigContent((node.data ?? undefined) as Record<string, unknown> | undefined)
-            for (const ref of getTemplateRefs(content)) {
-                const refId = resolveExtendsRef(nodeList, ref)
-                if (
-                    refId &&
-                    nodeList.some((n) => n.id === refId && n.type === 'config') &&
-                    isReachable(edgeList, refId, id)
-                ) {
-                    addConfigRefs(refId, visited)
-                }
-            }
-        }
-        const configVisited = new Set<string>()
-        for (const nid of incomingIds) {
-            const node = nodeList.find((n) => n.id === nid)
-            if (node?.type === 'config') addConfigRefs(nid, configVisited)
-            else out.add(nid)
-        }
-        for (const e of edgeList) {
-            if (out.has(e.target)) out.add(e.source)
-        }
-        return out
-    }, [nodes, edges, id, incomingIds])
-
-    const configSignature = useMemo(
+    const signatures = useMemo(
         () =>
-            (nodes as { id: string; type?: string; data?: unknown }[])
-                .filter((n) => n.type === 'config' && connectedNodeIds.has(n.id))
-                .map((n) => `${n.id}:${(n.data as { title?: string })?.title ?? ''}:${getConfigContent(n.data as Record<string, unknown>)}`)
-                .sort()
-                .join('|'),
-        [nodes, connectedNodeIds]
-    )
-    const edgesSignature = useMemo(
-        () =>
-            (edges as { source: string; target: string }[])
-                .filter(
-                    (e) =>
-                        connectedNodeIds.has(e.source) &&
-                        (connectedNodeIds.has(e.target) || e.target === id)
-                )
-                .map((e) => `${e.source}->${e.target}`)
-                .sort()
-                .join('|'),
-        [edges, connectedNodeIds, id]
-    )
-    const variablesSignature = useMemo(
-        () =>
-            (nodes as { id: string; type?: string; data?: { value?: unknown } }[])
-                .filter((n) => n.type === 'variable' && connectedNodeIds.has(n.id))
-                .map((n) => `${n.id}:${n.data?.value}`)
-                .sort()
-                .join('|'),
-        [nodes, connectedNodeIds]
-    )
-    const functionsSignature = useMemo(
-        () =>
-            (nodes as { id: string; type?: string; data?: { body?: string } }[])
-                .filter((n) => n.type === 'function' && connectedNodeIds.has(n.id))
-                .map((n) => `${n.id}:${n.data?.body ?? ''}`)
-                .sort()
-                .join('|'),
-        [nodes, connectedNodeIds]
-    )
-    const dataSignature = useMemo(
-        () =>
-            (nodes as { id: string; type?: string; data?: { rows?: unknown[]; hiddenColumns?: unknown[] } }[])
-                .filter((n) => n.type === 'data' && connectedNodeIds.has(n.id))
-                .map((n) => `${n.id}:${JSON.stringify(n.data?.rows ?? [])}:${JSON.stringify(n.data?.hiddenColumns ?? [])}`)
-                .sort()
-                .join('|'),
-        [nodes, connectedNodeIds]
-    )
-
-    const sourceSignature = useMemo(
-        () =>
-            JSON.stringify({
-                configSignature,
-                edgesSignature,
-                variablesSignature,
-                functionsSignature,
-                dataSignature,
-            }),
-        [configSignature, edgesSignature, variablesSignature, functionsSignature, dataSignature]
+            buildSourceSignatures(
+                nodes as { id: string; type?: string; data?: unknown }[],
+                edges as { source: string; target: string }[],
+                id,
+                incomingIds
+            ),
+        [nodes, edges, id, incomingIds]
     )
+    const {
+        connectedNodeIds,
+        configSignature,
+        edgesSignature,
+        variablesSignature,
+        functionsSignature,
+        dataSignature,
+        sourceSignature,
+    } = signatures
 
     const lastRunSourceSignature = data?.lastRunSourceSignature