fix(edges): Cancel edge update if connection exists

package/src/components/Edges/EdgeWrapper.vue

@@ -2,7 +2,7 @@
 import { CSSProperties } from 'vue'
 import { useHandle, useVueFlow } from '../../composables'
 import { ConnectionMode, EdgeComponent, GraphEdge, Position } from '../../types'
-import { getEdgePositions, getHandle, getMarkerId } from '../../utils'
+import { connectionExists, getEdgePositions, getHandle, getMarkerId } from '../../utils'
 import EdgeAnchor from './EdgeAnchor'
 
 interface EdgeWrapper {
@@ -16,12 +16,14 @@ interface EdgeWrapper {
 
 const { id, edge, name, selectable, updatable, type } = defineProps<EdgeWrapper>()
 
-const { emits, connectionMode, edgeUpdaterRadius, noPanClassName, setState, getEdge, getNode, addSelectedEdges } = $(useVueFlow())
+const { emits, connectionMode, edgeUpdaterRadius, noPanClassName, setState, getEdges, getEdge, getNode, addSelectedEdges } = $(
+  useVueFlow(),
+)
 
 let updating = $ref(false)
 
-const sourceNode = $computed(() => getNode(edge.source)!)
+const sourceNode = $computed(() => getNode(edge.source))
-const targetNode = $computed(() => getNode(edge.target)!)
+const targetNode = $computed(() => getNode(edge.target))
 
 const { onMouseDown } = useHandle()
 
@@ -68,46 +70,38 @@ const handleEdgeUpdater = (event: MouseEvent, isSourceHandle: boolean) => {
     isSourceHandle,
     undefined,
     isSourceHandle ? 'target' : 'source',
-    (connection) => emits.edgeUpdate({ edge, connection }),
+    (connection) => {
+      if (!connectionExists(edge, getEdges)) emits.edgeUpdate({ edge, connection })
+    },
     () => emits.edgeUpdateEnd({ event, edge }),
   )
 }
 
-const sourceHandle = $(
+const sourceHandle = $computed(() => {
-  controlledComputed(
+  if (!sourceNode) return
-    () => sourceNode,
-    () => {
-      if (!sourceNode) return
 
-      let sourceNodeHandles
+  let sourceNodeHandles
-      if (connectionMode === ConnectionMode.Strict) {
+  if (connectionMode === ConnectionMode.Strict) {
-        sourceNodeHandles = sourceNode.handleBounds.source
+    sourceNodeHandles = sourceNode.handleBounds.source
-      } else {
+  } else {
-        sourceNodeHandles = sourceNode.handleBounds.source ?? sourceNode.handleBounds.target
+    sourceNodeHandles = sourceNode.handleBounds.source ?? sourceNode.handleBounds.target
-      }
+  }
 
-      return getHandle(sourceNodeHandles, edge.sourceHandle)
+  return getHandle(sourceNodeHandles, edge.sourceHandle)
-    },
+})
-  ),
-)
 
-const targetHandle = $(
+const targetHandle = $computed(() => {
-  controlledComputed(
+  if (!targetNode) return
-    () => targetNode,
-    () => {
-      if (!targetNode) return
 
-      let targetNodeHandles
+  let targetNodeHandles
-      if (connectionMode === ConnectionMode.Strict) {
+  if (connectionMode === ConnectionMode.Strict) {
-        targetNodeHandles = targetNode.handleBounds.target
+    targetNodeHandles = targetNode.handleBounds.target
-      } else {
+  } else {
-        targetNodeHandles = targetNode.handleBounds.target ?? targetNode.handleBounds.source
+    targetNodeHandles = targetNode.handleBounds.target ?? targetNode.handleBounds.source
-      }
+  }
 
-      return getHandle(targetNodeHandles, edge.targetHandle)
+  return getHandle(targetNodeHandles, edge.targetHandle)
-    },
+})
-  ),
-)
 
 const sourcePosition = $(controlledComputed($$(sourceHandle), () => (sourceHandle ? sourceHandle.position : Position.Bottom)))
 
@@ -118,26 +112,30 @@ onMounted(() => {
     [
       $$(sourcePosition),
       $$(targetPosition),
-      () => sourceNode.computedPosition,
+      () => sourceNode?.computedPosition,
-      () => targetNode.computedPosition,
+      () => targetNode?.computedPosition,
-      () => sourceNode.dimensions,
+      () => sourceNode?.dimensions,
-      () => targetNode.dimensions,
+      () => targetNode?.dimensions,
     ],
     () => {
-      const { sourceX, sourceY, targetY, targetX } = getEdgePositions(
+      if (sourceNode && targetNode) {
-        sourceNode,
+        const { sourceX, sourceY, targetY, targetX } = getEdgePositions(
-        sourceHandle,
+          sourceNode,
-        sourcePosition,
+          sourceHandle,
-        targetNode,
+          sourcePosition,
-        targetHandle,
+          targetNode,
-        targetPosition,
+          targetHandle,
-      )
+          targetPosition,
+        )
 
-      const storedEdge = getEdge(id)!
+        const storedEdge = getEdge(id)!
-      if (edge.sourceX !== sourceX) storedEdge.sourceX = sourceX
+        if (storedEdge) {
-      if (edge.sourceY !== sourceY) storedEdge.sourceY = sourceY
+          if (edge.sourceX !== sourceX) storedEdge.sourceX = sourceX
-      if (edge.targetX !== targetX) storedEdge.targetX = targetX
+          if (edge.sourceY !== sourceY) storedEdge.sourceY = sourceY
-      if (edge.targetY !== targetY) storedEdge.targetY = targetY
+          if (edge.targetX !== targetX) storedEdge.targetX = targetX
+          if (edge.targetY !== targetY) storedEdge.targetY = targetY
+        }
+      }
     },
     { immediate: true, flush: 'pre' },
   )

package/src/container/EdgeRenderer/EdgeRenderer.vue

@@ -75,7 +75,7 @@ const getType = (edge: GraphEdge) => {
       }
     }
   }
-  if (typeof edgeType !== 'string') return edgeType
+  if (edgeType && typeof edgeType !== 'string') return edgeType
 
   const slot = slots?.[`edge-${name}`]
   if (!slot?.({})) {