@bian-womp/spark-graph 0.3.59 → 0.3.61

package/lib/cjs/index.cjs

@@ -877,18 +877,10 @@ class Graph {
         const edge = this.edges.find((e) => e.id === edgeId);
         if (!edge)
             return;
-        if (updates.dstDeclared !== undefined) {
-            edge.dstDeclared = updates.dstDeclared;
-        }
-        if (updates.srcUnionTypes !== undefined) {
-            edge.srcUnionTypes = updates.srcUnionTypes;
-        }
-        if (updates.convert !== undefined) {
-            edge.convert = updates.convert;
-        }
-        if (updates.convertAsync !== undefined) {
-            edge.convertAsync = updates.convertAsync;
-        }
+        edge.dstDeclared = updates.dstDeclared;
+        edge.srcUnionTypes = updates.srcUnionTypes;
+        edge.convert = updates.convert;
+        edge.convertAsync = updates.convertAsync;
     }
     /**
      * Update edge stats
@@ -919,14 +911,6 @@ class Graph {
     setResolvedHandles(nodeId, handles) {
         this.resolvedByNode.set(nodeId, handles);
     }
-    /**
-     * Iterate over resolved handles safely
-     */
-    forEachResolvedHandles(callback) {
-        for (const [nodeId, handles] of this.resolvedByNode.entries()) {
-            callback(handles, nodeId);
-        }
-    }
     // ==================== Utility Methods ====================
     /**
      * Check if all inbound edges for a node have values
@@ -2128,11 +2112,11 @@ function tryHandleResolving(def, registry, environment) {
     }
     return { resolved: out, pending };
 }
-function buildEdges(def, registry, resolvedByNode) {
+function buildEdges(def, registry, graph) {
     return def.edges.map((e) => {
         const srcNode = def.nodes.find((n) => n.nodeId === e.source.nodeId);
         const dstNode = def.nodes.find((n) => n.nodeId === e.target.nodeId);
-        const { srcDeclared, dstDeclared } = extractEdgeTypes(e.source.nodeId, e.source.handle, e.target.nodeId, e.target.handle, resolvedByNode);
+        const { srcDeclared, dstDeclared } = extractEdgeTypes(e.source.nodeId, e.source.handle, e.target.nodeId, e.target.handle, registry, graph);
         const { convert, convertAsync } = buildEdgeConverters(srcDeclared, dstDeclared, registry, `buildEdges: ${srcNode?.typeId || ""}.${e.source.nodeId}.${e.source.handle} -> ${dstNode?.typeId || ""}.${e.target.nodeId}.${e.target.handle}`);
         return {
             id: e.id,
@@ -2152,15 +2136,13 @@ function buildEdges(def, registry, resolvedByNode) {
  * Used by both buildEdges and updateNodeHandles to avoid duplication
  * Now supports union types on both source (output) and destination (input) handles
  */
-function extractEdgeTypes(sourceNodeId, sourceHandle, targetNodeId, targetHandle, resolvedByNode) {
-    const srcResolved = resolvedByNode.get(sourceNodeId);
-    const dstResolved = resolvedByNode.get(targetNodeId);
+function extractEdgeTypes(sourceNodeId, sourceHandle, targetNodeId, targetHandle, registry, graph) {
+    const srcResolved = graph.getResolvedHandles(sourceNodeId);
+    const dstResolved = graph.getResolvedHandles(targetNodeId);
     const srcDeclared = srcResolved
         ? srcResolved.outputs[sourceHandle]
-        : undefined;
-    const dstDeclared = dstResolved
-        ? getInputDeclaredTypes(dstResolved.inputs, targetHandle)
-        : undefined;
+        : registry.nodes.get(sourceNodeId)?.outputs[sourceHandle];
+    const dstDeclared = getInputDeclaredTypes(dstResolved ? dstResolved.inputs : registry.nodes.get(targetNodeId)?.inputs, targetHandle);
     return {
         srcDeclared,
         dstDeclared,
@@ -2426,10 +2408,6 @@ class HandleResolver {
         if (!node)
             return;
         this.graph.setResolvedHandles(nodeId, handles);
-        const resolvedByNode = new Map();
-        this.graph.forEachResolvedHandles((handles, nodeId) => {
-            resolvedByNode.set(nodeId, handles);
-        });
         const registry = this.registry; // Store for use in callback
         this.graph.forEachEdge((e, _index) => {
             // Only update edges that touch the changed node
@@ -2440,7 +2418,7 @@ class HandleResolver {
             const dstNode = this.graph.getNode(e.target.nodeId);
             const oldDstDeclared = e.dstDeclared;
             // Extract edge types using shared helper (handles both source and target updates)
-            const { srcDeclared, dstDeclared } = extractEdgeTypes(e.source.nodeId, e.source.handle, e.target.nodeId, e.target.handle, resolvedByNode);
+            const { srcDeclared, dstDeclared } = extractEdgeTypes(e.source.nodeId, e.source.handle, e.target.nodeId, e.target.handle, registry, this.graph);
             // Update converters
             const conv = buildEdgeConverters(srcDeclared, dstDeclared, registry, `updateNodeHandles: ${srcNode?.typeId || ""}.${e.source.nodeId}.${e.source.handle} -> ${dstNode?.typeId || ""}.${e.target.nodeId}.${e.target.handle}`);
             // Update edge properties via Graph
@@ -3737,11 +3715,7 @@ class GraphRuntime {
             gr.graph.setNode(n.nodeId, rn);
         }
         // Instantiate edges
-        const resolvedByNode = new Map();
-        gr.graph.forEachResolvedHandles((handles, nodeId) => {
-            resolvedByNode.set(nodeId, handles);
-        });
-        const edges = buildEdges(def, registry, resolvedByNode);
+        const edges = buildEdges(def, registry, gr.graph);
         gr.graph.setEdges(edges);
         // Schedule async recompute only for nodes that indicated Promise-based resolveHandles
         for (const nodeId of initial.pending) {
@@ -4249,11 +4223,7 @@ class GraphRuntime {
                 for (const [nodeId, handles] of result.resolved) {
                     this.graph.setResolvedHandles(nodeId, handles);
                 }
-                const resolvedByNode = new Map();
-                this.graph.forEachResolvedHandles((handles, nodeId) => {
-                    resolvedByNode.set(nodeId, handles);
-                });
-                const afterEdges = buildEdges(def, registry, resolvedByNode);
+                const afterEdges = buildEdges(def, registry, this.graph);
                 this.graph.setEdges(afterEdges);
                 for (const nodeId of result.pending) {
                     this.handleResolver.scheduleRecomputeHandles(nodeId);