@lupinum/board-connections 0.1.0 → 1.0.0-beta.2

package/dist/connection-actions.d.ts

@@ -1,5 +1,5 @@
 import { type Ref } from 'vue';
-import { type BoardEngine, type BoardNode } from '@lupinum/board-core';
+import { type BoardEngine, type BoardNode, type CanvasColor } from '@lupinum/board-core';
 import type { ConnectionNodeHandle } from './hit-testing.js';
 import type { ConnectionDragState, DragEnd } from './controller.js';
 import type { BoardEdge, ConnectionEndpointMode, ConnectionsApi, ConnectionsEventMap, CreateNodeForConnectionContext } from './types.js';
@@ -12,8 +12,10 @@ interface ConnectionActionsState {
     selectedEdgeId: Ref<string | null>;
     editingEdgeId: Ref<string | null>;
     labelDraft: Ref<string>;
-    colorMenuEdgeId: Ref<string | null>;
-    directionMenuEdgeId: Ref<string | null>;
+    openMenu: Ref<{
+        kind: 'color' | 'direction';
+        edgeId: string;
+    } | null>;
 }
 interface ConnectionActionsDeps {
     getEngine(): ConnectionEngine;
@@ -33,7 +35,7 @@ export declare function createConnectionActions(deps: ConnectionActionsDeps): {
     clearLabel: (edgeId: string) => void;
     cancelLabelEdit: () => void;
     setDirectionality: (edgeId: string, direction: "none" | "to" | "both") => void;
-    applyEdgeColor: (edgeId: string, color: string | undefined) => void;
+    applyEdgeColor: (edgeId: string, color: CanvasColor | undefined) => void;
     resetEndpointAnchor: (edgeId: string, end: DragEnd | "both") => void;
     deleteEdge: (edgeId: string) => void;
     commitDrag: (active: ConnectionDragState) => void;

package/dist/connection-drag.d.ts

@@ -0,0 +1,25 @@
+import { type ComputedRef, type Ref } from 'vue';
+import type { NodeId } from '@lupinum/board-core';
+import type { useBoardEngine } from '@lupinum/vue-board';
+import { type ConnectionDragState, type DragEnd, type PendingConnectionDrag } from './controller.js';
+import type { AnchorSide } from './types.js';
+import type { ConnectionEngine } from './connection-engine.js';
+import type { EdgeRenderEntry } from './connection-render-state.js';
+import type { createConnectionSelectionState } from './connection-selection.js';
+type BoardContext = ReturnType<typeof useBoardEngine>;
+interface ConnectionDragOptions {
+    injected: BoardContext;
+    engine: ComputedRef<ConnectionEngine>;
+    selection: ReturnType<typeof createConnectionSelectionState>;
+    pendingDrag: Ref<PendingConnectionDrag | null>;
+    dragState: Ref<ConnectionDragState | null>;
+    hotspotThickness: ComputedRef<number>;
+    hotspotCornerClearance: ComputedRef<number>;
+    commitDrag(active: ConnectionDragState): void;
+}
+/** Own the complete pointer lifecycle for create and reconnect drags. */
+export declare function useConnectionDrag(options: ConnectionDragOptions): {
+    beginReconnectDrag: (entry: EdgeRenderEntry, end: DragEnd, event: PointerEvent) => void;
+    beginCreateDrag: (nodeId: NodeId, side: AnchorSide, event: PointerEvent) => void;
+};
+export {};

package/dist/connection-engine.d.ts

@@ -0,0 +1,7 @@
+import type { BoardEngine } from '@lupinum/board-core';
+import type { ConnectionsApi, ConnectionsEventMap } from './types.js';
+export type ConnectionEngine = BoardEngine<{
+    connections: ConnectionsApi;
+}, ConnectionsEventMap>;
+/** Resolve the installed API at the package boundary with an actionable error. */
+export declare function resolveConnectionEngine(engine: BoardEngine): ConnectionEngine;

package/dist/connection-render-state.d.ts

@@ -0,0 +1,38 @@
+import { type ComputedRef, type Ref } from 'vue';
+import { type BoardNode } from '@lupinum/board-core';
+import type { useBoardEngine } from '@lupinum/vue-board';
+import { resolveEdgeRenderState } from './geometry.js';
+import type { ConnectionDragState } from './controller.js';
+import type { BoardEdge, ConnectionEndpointMode, ConnectionRouting } from './types.js';
+import type { ConnectionEngine } from './connection-engine.js';
+type BoardContext = ReturnType<typeof useBoardEngine>;
+export type EdgeRenderEntry = ReturnType<typeof resolveEdgeRenderState> & {
+    edge: BoardEdge;
+};
+interface ConnectionRenderStateOptions {
+    injected: BoardContext;
+    engine: ComputedRef<ConnectionEngine>;
+    routing: () => ConnectionRouting | undefined;
+    endpointMode: ComputedRef<ConnectionEndpointMode>;
+    selectedEdgeId: Ref<string | null>;
+    dragState: Ref<ConnectionDragState | null>;
+}
+/** Own edge subscription, identity-based geometry caching, culling, and preview. */
+export declare function useConnectionRenderState(options: ConnectionRenderStateOptions): {
+    entries: ComputedRef<EdgeRenderEntry[]>;
+    entryById: ComputedRef<Map<string, EdgeRenderEntry>>;
+    preview: ComputedRef<{
+        edge: BoardEdge<import("@lupinum/board-core").JsonObject>;
+        source: import("./types.js").ResolvedConnectionEndpoint;
+        target: import("./types.js").ResolvedConnectionEndpoint;
+        route: import("./types.js").ConnectionRoute;
+        candidateNode: BoardNode | undefined;
+    } | {
+        edge: null;
+        source: import("./types.js").ResolvedConnectionEndpoint;
+        target: import("./types.js").ResolvedConnectionEndpoint;
+        route: import("./types.js").ConnectionRoute;
+        candidateNode: BoardNode | undefined;
+    } | null>;
+};
+export {};

package/dist/connection-selection.d.ts

@@ -0,0 +1,33 @@
+import { type ComputedRef, type Ref } from 'vue';
+import type { NodeId } from '@lupinum/board-core';
+import type { useBoardEngine } from '@lupinum/vue-board';
+import { type ConnectionNodeHandle } from './hit-testing.js';
+import type { ConnectionDragState, PendingConnectionDrag } from './controller.js';
+import type { ConnectionEngine } from './connection-engine.js';
+type BoardContext = ReturnType<typeof useBoardEngine>;
+type ConnectionMenu = {
+    kind: 'color' | 'direction';
+    edgeId: string;
+};
+export declare function createConnectionSelectionState(): {
+    hoveredEdgeId: import("vue").ShallowRef<string | null, string | null>;
+    hoveredNodeId: import("vue").ShallowRef<NodeId | null, NodeId | null>;
+    hoveredNodeHandle: import("vue").ShallowRef<ConnectionNodeHandle | null, ConnectionNodeHandle | null>;
+    selectedEdgeId: import("vue").ShallowRef<string | null, string | null>;
+    openMenu: import("vue").ShallowRef<ConnectionMenu | null, ConnectionMenu | null>;
+};
+interface ConnectionSelectionEventsOptions {
+    injected: BoardContext;
+    engine: ComputedRef<ConnectionEngine>;
+    state: ReturnType<typeof createConnectionSelectionState>;
+    pendingDrag: Ref<PendingConnectionDrag | null>;
+    dragState: Ref<ConnectionDragState | null>;
+    editingEdgeId: Ref<string | null>;
+    hotspotThickness: ComputedRef<number>;
+    hotspotCornerClearance: ComputedRef<number>;
+    commitLabelEdit(): void;
+    deleteEdge(edgeId: string): void;
+}
+/** Bind hover, selection, menus, and keyboard ownership to the exact board root. */
+export declare function useConnectionSelectionEvents(options: ConnectionSelectionEventsOptions): void;
+export {};

package/dist/connection-toolbar.d.ts

@@ -1,5 +1,5 @@
 import { type VNode } from 'vue';
-import type { Point } from '@lupinum/board-core';
+import type { CanvasColor, Point } from '@lupinum/board-core';
 import type { BoardEdge } from './types.js';
 export interface ConnectionToolbarOptions {
     edge: BoardEdge;
@@ -9,7 +9,7 @@ export interface ConnectionToolbarOptions {
     onDelete: () => void;
     onToggleColorMenu: () => void;
     onToggleDirectionMenu: () => void;
-    onSetColor: (color: string | undefined) => void;
+    onSetColor: (color: CanvasColor | undefined) => void;
     onSetDirectionality: (direction: 'none' | 'to' | 'both') => void;
     onResetAnchor: (end: 'from' | 'to' | 'both') => void;
     onClearLabel: () => void;

package/dist/index.d.ts

@@ -14,4 +14,4 @@ export { EDGE_COLOR_PRESETS, colorForPreset, presetForColor, resolvePresetColor,
 /** Types for custom edge colors and preset names. */
 export type { EdgeColorOption, EdgeColorPreset } from './colors.js';
 /** Core edge model types and the connections engine API contract. */
-export type { AnchorPosition, AnchorSide, BoardEdge, BoardEdgePatch, ConnectionConfig, ConnectionEndpointMode, ConnectionPluginOptions, ConnectionRoute, ConnectionRouteSegment, ConnectionRouting, ConnectionsApi, ConnectionsEventMap, CreateNodeForConnectionContext, EdgeEnd, ResolvedConnectionEndpoint, } from './types.js';
+export type { AnchorPosition, AnchorSide, BoardEdge, BoardEdgeInput, BoardEdgePatch, ConnectionConfig, ConnectionEndpointMode, ConnectionPluginOptions, ConnectionRoute, ConnectionRouteSegment, ConnectionRouting, ConnectionsApi, ConnectionsEventMap, CreateNodeForConnectionContext, EdgeEnd, ResolvedConnectionEndpoint, } from './types.js';

package/dist/index.js

@@ -1,96 +1,113 @@
-import { asNodeId as S, asEdgeId as C, BoardNotFoundError as h, BoardConflictError as z, BoardInputError as b } from "@lupinum/board-core";
-import { defineInternalBoardPlugin as T } from "@lupinum/board-core/internal";
-import { e as $ } from "./colors-CI4AZ9tI.js";
-import { E as Z, b as L, a as k, c as H, g as J, p as V, r as q, d as K, f as Q, h as W, i as X, j as Y } from "./colors-CI4AZ9tI.js";
-const F = "connections", P = /* @__PURE__ */ new Set(["top", "right", "bottom", "left"]);
-function w(r, f) {
-  if (r) {
-    if (!P.has(r.side))
-      throw new b(
-        `Cannot use ${f}: anchor side "${String(r.side)}" is unsupported.`
+import { asNodeId as y, asEdgeId as S, BoardNotFoundError as x, BoardConflictError as U, BoardInputError as N } from "@lupinum/board-core";
+import { defineInternalBoardPlugin as B, readonlyMapView as O, collectJsonObjectExtras as J, freezeJsonObject as T } from "@lupinum/board-core/internal";
+import { e as L } from "./colors-CI4AZ9tI.js";
+import { E as re, b as te, a as ne, c as de, g as se, p as ce, r as fe, d as ie, f as ae, h as le, i as me, j as Ee } from "./colors-CI4AZ9tI.js";
+const Z = "connections", k = /* @__PURE__ */ new Set(["top", "right", "bottom", "left"]), V = /* @__PURE__ */ new Set([
+  "id",
+  "fromNode",
+  "fromSide",
+  "fromEnd",
+  "toNode",
+  "toSide",
+  "toEnd",
+  "color",
+  "label"
+]);
+function D(o, c) {
+  if (o) {
+    if (!k.has(o.side))
+      throw new N(
+        `Cannot use ${c}: anchor side "${String(o.side)}" is unsupported.`
       );
-    if (!Number.isFinite(r.offset) || r.offset < 0 || r.offset > 1)
-      throw new b(
-        `Cannot use ${f}: anchor offset must be a finite number from 0 to 1.`
+    if (!Number.isFinite(o.offset) || o.offset < 0 || o.offset > 1)
+      throw new N(
+        `Cannot use ${c}: anchor offset must be a finite number from 0 to 1.`
       );
   }
 }
-function v(r) {
-  if (r !== void 0 && !/^[1-6]$/.test(r) && !/^#[0-9a-fA-F]{6}$/.test(r))
-    throw new b(
-      `Cannot use edge color "${r}": expected a preset from 1 to 6 or a six-digit hex color.`
+function _(o) {
+  if (o !== void 0 && !/^[1-6]$/.test(o) && !/^#[0-9a-fA-F]{6}$/.test(o))
+    throw new N(
+      `Cannot use edge color "${o}": expected a preset from 1 to 6 or a six-digit hex color.`
     );
 }
-const _ = {
+const H = {
   edges: /* @__PURE__ */ new Map(),
   nextZIndex: 1
 };
-function N(r, f, A) {
-  switch (f.type) {
+function F(o, c, h) {
+  switch (c.type) {
     case "EDGE_CREATED": {
-      const a = A ?? new Map(r.edges);
-      return a.set(f.edge.id, f.edge), {
+      const a = h ?? new Map(o.edges);
+      return a.set(c.edge.id, c.edge), {
+        ...o,
         edges: a,
-        nextZIndex: Math.max(r.nextZIndex, f.edge.zIndex + 1)
+        nextZIndex: Math.max(o.nextZIndex, c.edge.zIndex + 1)
       };
     }
     case "EDGE_UPDATED": {
-      const a = A ?? new Map(r.edges);
-      return a.set(f.id, f.after), { ...r, edges: a };
+      const a = h ?? new Map(o.edges);
+      return a.set(c.id, c.after), { ...o, edges: a };
     }
     case "EDGE_DELETED": {
-      if (!r.edges.has(f.id)) return r;
-      const a = A ?? new Map(r.edges);
-      return a.delete(f.id), { ...r, edges: a };
+      if (!o.edges.has(c.id)) return o;
+      const a = h ?? new Map(o.edges);
+      return a.delete(c.id), { ...o, edges: a };
     }
   }
 }
-function m(r) {
-  return {
-    ...r,
-    data: structuredClone(r.data)
-  };
+function I(o) {
+  return o ? Object.freeze({ ...o }) : void 0;
+}
+function M(o) {
+  return Object.freeze(o);
+}
+function P(o, c) {
+  return o === c || o?.side === c?.side && o?.offset === c?.offset;
 }
-function M(r) {
+function W(o, c) {
   return {
-    id: r.id,
-    fromNode: r.from,
-    ...r.fromAnchor?.side ? { fromSide: r.fromAnchor.side } : {},
-    ...r.fromEnd ? { fromEnd: r.fromEnd } : {},
-    toNode: r.to,
-    ...r.toAnchor?.side ? { toSide: r.toAnchor.side } : {},
-    ...r.toEnd ? { toEnd: r.toEnd } : {},
-    ...r.color ? { color: r.color } : {},
-    ...r.label ? { label: r.label } : {}
+    ...c ?? {},
+    id: o.id,
+    fromNode: o.from,
+    ...o.fromAnchor?.side ? { fromSide: o.fromAnchor.side } : {},
+    ...o.fromEnd ? { fromEnd: o.fromEnd } : {},
+    toNode: o.to,
+    ...o.toAnchor?.side ? { toSide: o.toAnchor.side } : {},
+    ...o.toEnd ? { toEnd: o.toEnd } : {},
+    ...o.color ? { color: o.color } : {},
+    ...o.label ? { label: o.label } : {}
   };
 }
-function B(r = {}) {
-  const f = r.routing ?? "bezier", A = r.endpointMode ?? "auto", a = r.defaultArrow ?? "end", y = {
-    routing: f,
-    endpointMode: A,
+function Y(o = {}) {
+  const c = o.routing ?? "bezier", h = o.endpointMode ?? "auto", a = o.defaultArrow ?? "end", j = {
+    routing: c,
+    endpointMode: h,
     defaultArrow: a
-  }, D = $(a);
-  return T({
-    name: F,
+  }, v = L(a), w = /* @__PURE__ */ new WeakMap();
+  return B({
+    name: Z,
     slice: {
-      initial: _
+      initial: H
     },
-    nodeDeleted(d, c) {
+    nodeDeleted(d, f) {
       d.updatePluginState((s) => {
         const l = new Map(s.edges);
         for (const [E, n] of l)
-          (n.from === c || n.to === c) && l.delete(E);
+          (n.from === f || n.to === f) && l.delete(E);
         return l.size === s.edges.size ? s : { ...s, edges: l };
       });
     },
     persistence: {
       exportDocument(d) {
-        const c = d.plugins.connections.getEdges();
-        return c.length === 0 ? {} : {
-          edges: c.map(M),
-          "x-vue-board": {
+        const f = d.plugins.connections.getEdges();
+        return f.length === 0 ? {} : {
+          edges: f.map(
+            (s) => W(s, w.get(s))
+          ),
+          "x-lupinum-board": {
             edges: Object.fromEntries(
-              c.map((s) => [
+              f.map((s) => [
                 s.id,
                 {
                   zIndex: s.zIndex,
@@ -101,130 +118,143 @@ function B(r = {}) {
           }
         };
       },
-      loadDocument(d, c, s, l) {
+      loadDocument(d, f, s, l) {
         const E = d.plugins.connections;
         if (s === "replace")
           for (const n of E.getEdges())
             E.deleteEdge(n.id);
-        for (const n of c.edges ?? []) {
-          const u = S(n.fromNode), x = S(n.toNode), e = l.get(u) ?? u, o = l.get(x) ?? x;
-          if (!d.hasNode(e) || !d.hasNode(o))
+        for (const n of f.edges ?? []) {
+          const b = y(n.fromNode), z = y(n.toNode), u = l.get(b) ?? b, A = l.get(z) ?? z;
+          if (!d.hasNode(u) || !d.hasNode(A))
             continue;
-          const t = c["x-vue-board"]?.edges?.[n.id], i = s === "merge" && E.getEdge(C(n.id)) ? C(crypto.randomUUID()) : C(n.id);
-          E.createEdge({
-            id: i,
-            from: e,
-            to: o,
+          const C = f["x-lupinum-board"]?.edges?.[n.id], e = s === "merge" && E.getEdge(S(n.id)) ? S(crypto.randomUUID()) : S(n.id), r = E.createEdge({
+            id: e,
+            from: u,
+            to: A,
             ...n.fromSide ? { fromAnchor: { side: n.fromSide, offset: 0.5 } } : {},
             ...n.toSide ? { toAnchor: { side: n.toSide, offset: 0.5 } } : {},
             ...n.fromEnd ? { fromEnd: n.fromEnd } : {},
             ...n.toEnd ? { toEnd: n.toEnd } : {},
             ...n.color ? { color: n.color } : {},
             ...n.label ? { label: n.label } : {},
-            data: t?.data ?? {},
-            ...t?.zIndex !== void 0 ? { zIndex: t.zIndex } : {}
-          });
+            data: C?.data ?? {},
+            ...C?.zIndex !== void 0 ? { zIndex: C.zIndex } : {}
+          }), t = J(
+            n,
+            V,
+            `Invalid board document: edge "${n.id}"`
+          );
+          Object.keys(t).length > 0 && w.set(r, t);
         }
       }
     },
     install(d) {
-      const c = () => d.getPluginState();
+      const f = () => d.getPluginState();
       let s = null;
-      const l = (e) => d.updatePluginState((o) => d.isBatching() ? (o.edges !== s && (s = new Map(o.edges)), N(o, e, s)) : (s = null, N(o, e)));
-      function E(e, o) {
-        const t = c().edges.get(e);
+      const l = (e) => d.updatePluginState((r) => d.isBatching() ? (r.edges !== s && (s = new Map(r.edges)), F(r, e, s)) : (s = null, F(r, e)));
+      function E(e, r) {
+        const t = f().edges.get(e);
         if (!t)
-          throw new h(
-            `Cannot ${o} edge: edge "${e}" does not exist.`
+          throw new x(
+            `Cannot ${r} edge: edge "${e}" does not exist.`
           );
         return t;
       }
-      const n = {
+      let n = f().edges, b = O(n);
+      const u = {
+        $edges: d.createCommitSubscribable(() => {
+          const e = f().edges;
+          return e !== n && (n = e, b = O(e)), b;
+        }, "connections.$edges"),
         createEdge(e) {
           return d.runCommand(
             "edge:create",
             [e],
             () => {
               if (!d.hasNode(e.from))
-                throw new h(
+                throw new x(
                   `Cannot create edge: source node "${e.from}" does not exist.`
                 );
               if (!d.hasNode(e.to))
-                throw new h(
+                throw new x(
                   `Cannot create edge: target node "${e.to}" does not exist.`
                 );
-              const o = c(), t = e.id ?? C(crypto.randomUUID());
-              if (o.edges.has(t))
-                throw new z(
+              const r = f(), t = e.id ?? S(crypto.randomUUID());
+              if (r.edges.has(t))
+                throw new U(
                   `Cannot create edge: edge "${t}" already exists.`
                 );
-              if (w(e.fromAnchor, "fromAnchor"), w(e.toAnchor, "toAnchor"), v(e.color), e.zIndex !== void 0 && !Number.isFinite(e.zIndex))
-                throw new b(
+              if (D(e.fromAnchor, "fromAnchor"), D(e.toAnchor, "toAnchor"), _(e.color), e.zIndex !== void 0 && !Number.isFinite(e.zIndex))
+                throw new N(
                   "Cannot create edge: zIndex must be a finite number."
                 );
-              const i = {
+              const m = M({
                 id: t,
                 from: e.from,
                 to: e.to,
-                fromAnchor: e.fromAnchor,
-                toAnchor: e.toAnchor,
-                fromEnd: e.fromEnd ?? D.fromEnd,
-                toEnd: e.toEnd ?? D.toEnd,
+                fromAnchor: I(e.fromAnchor),
+                toAnchor: I(e.toAnchor),
+                fromEnd: e.fromEnd ?? v.fromEnd,
+                toEnd: e.toEnd ?? v.toEnd,
                 label: e.label,
                 color: e.color,
-                data: structuredClone(e.data ?? {}),
-                zIndex: e.zIndex ?? o.nextZIndex
-              };
-              return l({ type: "EDGE_CREATED", edge: i }), m(i);
+                data: T(e.data ?? {}, "edge data"),
+                zIndex: e.zIndex ?? r.nextZIndex
+              });
+              return l({ type: "EDGE_CREATED", edge: m }), m;
             },
             { history: "record" }
           );
         },
-        updateEdge(e, o) {
+        updateEdge(e, r) {
           const t = E(e, "update");
           return d.runCommand(
             "edge:update",
-            [e, o],
+            [e, r],
             () => {
-              const i = "from" in o ? o.from : t.from, g = "to" in o ? o.to : t.to;
-              if (!i || !d.hasNode(i))
-                throw new h(
-                  `Cannot update edge: source node "${i}" does not exist.`
+              const m = "from" in r ? r.from : t.from, g = "to" in r ? r.to : t.to;
+              if (!m || !d.hasNode(m))
+                throw new x(
+                  `Cannot update edge: source node "${m}" does not exist.`
                 );
               if (!g || !d.hasNode(g))
-                throw new h(
+                throw new x(
                   `Cannot update edge: target node "${g}" does not exist.`
                 );
-              w(
-                "fromAnchor" in o ? o.fromAnchor : t.fromAnchor,
+              D(
+                "fromAnchor" in r ? r.fromAnchor : t.fromAnchor,
                 "fromAnchor"
-              ), w(
-                "toAnchor" in o ? o.toAnchor : t.toAnchor,
+              ), D(
+                "toAnchor" in r ? r.toAnchor : t.toAnchor,
                 "toAnchor"
-              ), v("color" in o ? o.color : t.color);
-              const I = {
+              ), _("color" in r ? r.color : t.color);
+              const R = "fromAnchor" in r ? P(r.fromAnchor, t.fromAnchor) ? t.fromAnchor : I(r.fromAnchor) : t.fromAnchor, p = "toAnchor" in r ? P(r.toAnchor, t.toAnchor) ? t.toAnchor : I(r.toAnchor) : t.toAnchor, G = "data" in r ? r.data === t.data ? t.data : T(r.data ?? {}, "edge data") : t.data, i = M({
                 ...t,
-                from: i,
+                from: m,
                 to: g,
-                fromAnchor: "fromAnchor" in o ? o.fromAnchor : t.fromAnchor,
-                toAnchor: "toAnchor" in o ? o.toAnchor : t.toAnchor,
-                fromEnd: "fromEnd" in o ? o.fromEnd : t.fromEnd,
-                toEnd: "toEnd" in o ? o.toEnd : t.toEnd,
-                label: "label" in o ? o.label : t.label,
-                color: "color" in o ? o.color : t.color,
-                data: "data" in o ? structuredClone(o.data ?? {}) : structuredClone(t.data)
-              };
-              return l({
+                fromAnchor: R,
+                toAnchor: p,
+                fromEnd: "fromEnd" in r ? r.fromEnd : t.fromEnd,
+                toEnd: "toEnd" in r ? r.toEnd : t.toEnd,
+                label: "label" in r ? r.label : t.label,
+                color: "color" in r ? r.color : t.color,
+                data: G
+              });
+              if (i.from === t.from && i.to === t.to && i.fromAnchor === t.fromAnchor && i.toAnchor === t.toAnchor && i.fromEnd === t.fromEnd && i.toEnd === t.toEnd && i.label === t.label && i.color === t.color && i.data === t.data)
+                return t;
+              l({
                 type: "EDGE_UPDATED",
                 id: e,
-                after: I
-              }), m(I);
+                after: i
+              });
+              const $ = w.get(t);
+              return $ && w.set(i, $), i;
             },
             { history: "record" }
           );
         },
         deleteEdge(e) {
-          c().edges.get(e) && d.runCommand(
+          f().edges.get(e) && d.runCommand(
             "edge:delete",
             [e],
             () => {
@@ -234,65 +264,57 @@ function B(r = {}) {
           );
         },
         getEdge(e) {
-          const o = c().edges.get(e);
-          return o ? m(o) : void 0;
+          return f().edges.get(e);
         },
         getEdges() {
-          return Array.from(
-            c().edges.values(),
-            (e) => m(e)
-          );
+          return Array.from(f().edges.values());
         },
         getEdgesFrom(e) {
-          return n.getEdges().filter((o) => o.from === e);
+          return u.getEdges().filter((r) => r.from === e);
         },
         getEdgesTo(e) {
-          return n.getEdges().filter((o) => o.to === e);
+          return u.getEdges().filter((r) => r.to === e);
         },
-        getEdgesBetween(e, o) {
-          return n.getEdges().filter((t) => t.from === e && t.to === o);
+        getEdgesBetween(e, r) {
+          return u.getEdges().filter((t) => t.from === e && t.to === r);
         },
         getConfig() {
-          return d.assertActive(), { ...y };
+          return d.assertActive(), { ...j };
         }
       };
-      d.extend("connections", n);
-      let u = c().edges;
-      const x = d.projectCommit(() => {
-        const e = c().edges;
-        if (e === u) return () => {
+      d.extend("connections", u);
+      let A = f().edges;
+      return d.projectCommit(() => {
+        const e = f().edges;
+        if (e === A) return () => {
         };
-        const o = u;
+        const r = A;
         return () => {
-          s = null;
-          for (const [t, i] of e) {
-            const g = o.get(t);
-            g ? g !== i && d.emit("edge:updated", m(i), m(g)) : d.emit("edge:created", m(i));
+          s = null, A = e;
+          for (const [t, m] of e) {
+            const g = r.get(t);
+            g ? g !== m && d.emit("edge:updated", m, g) : d.emit("edge:created", m);
           }
-          for (const [t] of o)
+          for (const [t] of r)
             e.has(t) || d.emit("edge:deleted", t);
-          u = e;
         };
       });
-      return () => {
-        x();
-      };
     }
   });
 }
 export {
-  Z as EDGE_COLOR_PRESETS,
-  L as buildArcRoute,
-  k as buildConnectionRoute,
-  H as colorForPreset,
-  B as connectionsPlugin,
-  $ as edgeEndsForDirectionality,
-  J as getVisibleEdges,
-  V as presetForColor,
-  q as resolveAnchorPoint,
-  K as resolveAutoAnchorSide,
-  Q as resolveConnectionEndpoint,
-  W as resolveEdgeRenderState,
-  X as resolveFloatingEndpoint,
-  Y as resolvePresetColor
+  re as EDGE_COLOR_PRESETS,
+  te as buildArcRoute,
+  ne as buildConnectionRoute,
+  de as colorForPreset,
+  Y as connectionsPlugin,
+  L as edgeEndsForDirectionality,
+  se as getVisibleEdges,
+  ce as presetForColor,
+  fe as resolveAnchorPoint,
+  ie as resolveAutoAnchorSide,
+  ae as resolveConnectionEndpoint,
+  le as resolveEdgeRenderState,
+  me as resolveFloatingEndpoint,
+  Ee as resolvePresetColor
 };