avoid-nodes-edge 0.1.0

package/dist/index.js

@@ -0,0 +1,558 @@
+import {
+  DEBOUNCE_ROUTING_MS,
+  DEV_LOG_WEB_WORKER_MESSAGES,
+  EDGE_BORDER_RADIUS,
+  SHOULD_START_EDGE_AT_HANDLE_BORDER,
+  __publicField,
+  useAvoidNodesPath,
+  useAvoidRouterActionsStore,
+  useAvoidRoutesStore
+} from "./chunk-VPHZVUPR.js";
+
+// src/router.ts
+var LIBAVOID_WASM_URL = "/libavoid.wasm";
+var WASM_RETRY_DELAY_MS = 2e3;
+var WASM_MAX_RETRIES = 5;
+var _AvoidRouter = class _AvoidRouter {
+  // Loads the libavoid WASM module with retry logic.
+  // Retries up to WASM_MAX_RETRIES times with a delay between attempts.
+  // Returns true if the library loaded successfully, false otherwise.
+  static async load(wasmUrl = LIBAVOID_WASM_URL) {
+    if (_AvoidRouter.lib != null) return true;
+    if (typeof globalThis === "undefined") return false;
+    for (let attempt = 1; attempt <= WASM_MAX_RETRIES; attempt++) {
+      const ok = await _AvoidRouter.loadOnce(wasmUrl);
+      if (ok) return true;
+      if (attempt < WASM_MAX_RETRIES) {
+        await new Promise((r) => setTimeout(r, WASM_RETRY_DELAY_MS));
+      }
+    }
+    return false;
+  }
+  // Single attempt to load the WASM module.
+  // Resolves the WASM URL to an absolute path, dynamically imports libavoid-js,
+  // calls its load() to initialize the WASM, then stores the library instance.
+  static async loadOnce(wasmUrl) {
+    const origin = globalThis.location?.origin;
+    const absoluteWasmUrl = origin && wasmUrl.startsWith("/") ? `${origin}${wasmUrl}` : wasmUrl;
+    try {
+      const mod = await import("libavoid-js");
+      const AvoidLib = mod.AvoidLib ?? mod.default;
+      if (!AvoidLib?.load) return false;
+      await AvoidLib.load(absoluteWasmUrl);
+      const lib = AvoidLib.getInstance?.();
+      if (lib == null) return false;
+      _AvoidRouter.lib = lib;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // Returns the singleton AvoidRouter instance.
+  // Throws if the WASM library hasn't been loaded yet via load().
+  static getInstance() {
+    if (_AvoidRouter.instance == null) _AvoidRouter.instance = new _AvoidRouter();
+    if (_AvoidRouter.lib == null) throw new Error("AvoidRouter.load() must be called first.");
+    return _AvoidRouter.instance;
+  }
+  // Main routing method — takes all nodes and edges, computes obstacle-avoiding
+  // orthogonal paths for every edge, and returns a map of edgeId -> AvoidRoute.
+  //
+  // Steps:
+  // 1. Filter out group nodes (only real nodes are obstacles)
+  // 2. Create a libavoid Router and configure its parameters
+  // 3. Register each node as a rectangular obstacle shape with connection pins
+  // 4. Create a connector (ConnRef) for each edge between source/target pins
+  // 5. Run the routing algorithm (processTransaction)
+  // 6. Extract the routed polyline for each edge and convert to SVG path
+  // 7. Clean up all libavoid objects to free WASM memory
+  routeAll(nodes, edges, options) {
+    const Avoid = _AvoidRouter.lib;
+    if (!Avoid) return {};
+    const shapeBuffer = options?.shapeBufferDistance ?? 8;
+    const idealNudging = options?.idealNudgingDistance ?? 10;
+    const cornerRadius = options?.edgeRounding ?? 0;
+    const gridSize = options?.diagramGridSize ?? 0;
+    const obstacleNodes = nodes.filter((n) => n.type !== "group");
+    const nodeById = new Map(nodes.map((n) => [n.id, n]));
+    const nodeBounds = new Map(obstacleNodes.map((n) => [n.id, this.getNodeBoundsAbsolute(n, nodeById)]));
+    const router = new Avoid.Router(Avoid.OrthogonalRouting);
+    router.setRoutingParameter(Avoid.shapeBufferDistance, shapeBuffer);
+    router.setRoutingParameter(Avoid.idealNudgingDistance, idealNudging);
+    router.setRoutingOption(Avoid.nudgeOrthogonalSegmentsConnectedToShapes, true);
+    router.setRoutingOption(Avoid.nudgeSharedPathsWithCommonEndPoint, true);
+    router.setRoutingOption(Avoid.performUnifyingNudgingPreprocessingStep, true);
+    const PIN_CENTER = 1;
+    const PIN_TOP = 2;
+    const PIN_BOTTOM = 3;
+    const PIN_LEFT = 4;
+    const PIN_RIGHT = 5;
+    const pinIdForPosition = {
+      top: PIN_TOP,
+      bottom: PIN_BOTTOM,
+      left: PIN_LEFT,
+      right: PIN_RIGHT
+    };
+    const pinProportions = {
+      [PIN_CENTER]: { x: 0.5, y: 0.5, dir: Avoid.ConnDirAll },
+      [PIN_TOP]: { x: 0.5, y: 0, dir: Avoid.ConnDirUp },
+      [PIN_BOTTOM]: { x: 0.5, y: 1, dir: Avoid.ConnDirDown },
+      [PIN_LEFT]: { x: 0, y: 0.5, dir: Avoid.ConnDirLeft },
+      [PIN_RIGHT]: { x: 1, y: 0.5, dir: Avoid.ConnDirRight }
+    };
+    const shapeRefMap = /* @__PURE__ */ new Map();
+    const shapeRefs = [];
+    for (const node of obstacleNodes) {
+      const b = nodeBounds.get(node.id);
+      const topLeft = new Avoid.Point(b.x, b.y);
+      const bottomRight = new Avoid.Point(b.x + b.w, b.y + b.h);
+      const rect = new Avoid.Rectangle(topLeft, bottomRight);
+      const shapeRef = new Avoid.ShapeRef(router, rect);
+      shapeRefs.push({ ref: shapeRef });
+      shapeRefMap.set(node.id, shapeRef);
+      for (const pinId of [PIN_CENTER, PIN_TOP, PIN_BOTTOM, PIN_LEFT, PIN_RIGHT]) {
+        const p = pinProportions[pinId];
+        const pin = new Avoid.ShapeConnectionPin(shapeRef, pinId, p.x, p.y, true, 0, p.dir);
+        pin.setExclusive(false);
+      }
+    }
+    const connRefs = [];
+    for (const edge of edges) {
+      const src = nodeById.get(edge.source);
+      const tgt = nodeById.get(edge.target);
+      if (!src || !tgt) continue;
+      const srcShapeRef = shapeRefMap.get(edge.source);
+      const tgtShapeRef = shapeRefMap.get(edge.target);
+      const sourcePos = this.getHandlePosition(src, "source");
+      const targetPos = this.getHandlePosition(tgt, "target");
+      let srcEnd;
+      let tgtEnd;
+      if (srcShapeRef) {
+        const pinId = pinIdForPosition[sourcePos] ?? PIN_CENTER;
+        srcEnd = new Avoid.ConnEnd(srcShapeRef, pinId);
+      } else {
+        const sb = this.getNodeBoundsAbsolute(src, nodeById);
+        const sourcePt = this.getHandlePoint(sb, sourcePos);
+        srcEnd = new Avoid.ConnEnd(new Avoid.Point(sourcePt.x, sourcePt.y));
+      }
+      if (tgtShapeRef) {
+        const pinId = pinIdForPosition[targetPos] ?? PIN_CENTER;
+        tgtEnd = new Avoid.ConnEnd(tgtShapeRef, pinId);
+      } else {
+        const tb = this.getNodeBoundsAbsolute(tgt, nodeById);
+        const targetPt = this.getHandlePoint(tb, targetPos);
+        tgtEnd = new Avoid.ConnEnd(new Avoid.Point(targetPt.x, targetPt.y));
+      }
+      const connRef = new Avoid.ConnRef(router, srcEnd, tgtEnd);
+      connRef.setRoutingType(Avoid.ConnType_Orthogonal);
+      connRefs.push({ edgeId: edge.id, connRef });
+    }
+    try {
+      router.processTransaction();
+    } catch {
+      this.cleanup(router, connRefs, shapeRefs);
+      return {};
+    }
+    const result = {};
+    for (const { edgeId, connRef } of connRefs) {
+      try {
+        const route = connRef.displayRoute();
+        const size = route.size();
+        if (size < 2) continue;
+        const path = this.polylineToPath(size, (i) => {
+          const p = route.get_ps(i);
+          return { x: p.x, y: p.y };
+        }, { gridSize: gridSize || void 0, cornerRadius });
+        const mid = Math.floor(size / 2);
+        const midP = route.get_ps(mid);
+        const labelP = gridSize > 0 ? this.snapToGrid(midP.x, midP.y, gridSize) : { x: midP.x, y: midP.y };
+        result[edgeId] = { path, labelX: labelP.x, labelY: labelP.y };
+      } catch {
+      }
+    }
+    this.cleanup(router, connRefs, shapeRefs);
+    return result;
+  }
+  // Gets the local position and dimensions of a node.
+  // Tries measured size first, then explicit width/height, then style, with fallback defaults.
+  getNodeBounds(node) {
+    const x = node.position?.x ?? 0;
+    const y = node.position?.y ?? 0;
+    const w = Number(node.measured?.width ?? node.width ?? node.style?.width ?? 150);
+    const h = Number(node.measured?.height ?? node.height ?? node.style?.height ?? 50);
+    return { x, y, w, h };
+  }
+  // Computes the absolute (world-space) bounds of a node by walking up
+  // the parent chain and accumulating parent positions. This is needed
+  // because child nodes have positions relative to their parent.
+  getNodeBoundsAbsolute(node, nodeById) {
+    const b = this.getNodeBounds(node);
+    let current = node;
+    while (current?.parentId) {
+      const parent = nodeById.get(current.parentId);
+      if (!parent) break;
+      b.x += parent.position?.x ?? 0;
+      b.y += parent.position?.y ?? 0;
+      current = parent;
+    }
+    return b;
+  }
+  // Determines which side of a node a handle is on (left/right/top/bottom).
+  // Checks both the node's direct properties and its data object.
+  // Defaults to "right" for source handles and "left" for target handles.
+  getHandlePosition(node, kind) {
+    const raw = kind === "source" ? node.sourcePosition ?? node.data?.sourcePosition : node.targetPosition ?? node.data?.targetPosition;
+    const s = String(raw ?? "").toLowerCase();
+    if (s === "left" || s === "right" || s === "top" || s === "bottom") return s;
+    return kind === "source" ? "right" : "left";
+  }
+  // Converts a handle position (left/right/top/bottom) into an actual x/y coordinate
+  // on the node's boundary. The point is at the center of the respective edge.
+  getHandlePoint(bounds, position) {
+    const { x, y, w, h } = bounds;
+    const cx = x + w / 2;
+    const cy = y + h / 2;
+    switch (position) {
+      case "left":
+        return { x, y: cy };
+      case "right":
+        return { x: x + w, y: cy };
+      case "top":
+        return { x: cx, y };
+      case "bottom":
+        return { x: cx, y: y + h };
+      default:
+        return { x: x + w, y: cy };
+    }
+  }
+  // Snaps x/y coordinates to the nearest grid point (rounds to nearest multiple of gridSize)
+  snapToGrid(x, y, gridSize) {
+    if (gridSize <= 0) return { x, y };
+    return { x: Math.round(x / gridSize) * gridSize, y: Math.round(y / gridSize) * gridSize };
+  }
+  // Converts a polyline (series of waypoints) into an SVG path string.
+  // If cornerRadius > 0, adds quadratic bezier curves (Q commands) at each bend
+  // to create smooth rounded corners instead of sharp right angles.
+  // If cornerRadius is 0, produces a simple M/L path with straight segments.
+  polylineToPath(size, getPoint, options = {}) {
+    if (size < 2) return "";
+    const gridSize = options.gridSize ?? 0;
+    const r = Math.max(0, options.cornerRadius ?? 0);
+    const pt = (i) => {
+      const p = getPoint(i);
+      return gridSize > 0 ? this.snapToGrid(p.x, p.y, gridSize) : p;
+    };
+    if (r <= 0) {
+      let d2 = `M ${pt(0).x} ${pt(0).y}`;
+      for (let i = 1; i < size; i++) {
+        const p = pt(i);
+        d2 += ` L ${p.x} ${p.y}`;
+      }
+      return d2;
+    }
+    const dist = (a, b) => Math.hypot(b.x - a.x, b.y - a.y);
+    const unit = (a, b) => {
+      const d2 = dist(a, b);
+      if (d2 < 1e-6) return { x: 0, y: 0 };
+      return { x: (b.x - a.x) / d2, y: (b.y - a.y) / d2 };
+    };
+    let d = `M ${pt(0).x} ${pt(0).y}`;
+    for (let i = 1; i < size - 1; i++) {
+      const prev = pt(i - 1);
+      const curr = pt(i);
+      const next = pt(i + 1);
+      const dirIn = unit(curr, prev);
+      const dirOut = unit(curr, next);
+      const lenIn = dist(curr, prev);
+      const lenOut = dist(curr, next);
+      const rIn = Math.min(r, lenIn / 2, lenOut / 2);
+      const rOut = Math.min(r, lenIn / 2, lenOut / 2);
+      const endPrev = { x: curr.x + dirIn.x * rIn, y: curr.y + dirIn.y * rIn };
+      const startNext = { x: curr.x + dirOut.x * rOut, y: curr.y + dirOut.y * rOut };
+      d += ` L ${endPrev.x} ${endPrev.y} Q ${curr.x} ${curr.y} ${startNext.x} ${startNext.y}`;
+    }
+    const last = pt(size - 1);
+    d += ` L ${last.x} ${last.y}`;
+    return d;
+  }
+  // Frees all libavoid objects (connectors and shapes) from the router.
+  // This is important to prevent WASM memory leaks since libavoid
+  // allocates memory in the WASM heap that isn't garbage collected by JS.
+  cleanup(router, connRefs, shapeRefs) {
+    try {
+      for (const { connRef } of connRefs) router.deleteConnector(connRef);
+      for (const { ref } of shapeRefs) router.deleteShape(ref);
+    } catch {
+    }
+  }
+};
+// Singleton references — the WASM library and the single router instance
+__publicField(_AvoidRouter, "lib", null);
+__publicField(_AvoidRouter, "instance", null);
+var AvoidRouter = _AvoidRouter;
+async function loadAvoidRouter() {
+  return AvoidRouter.load();
+}
+function routeAll(nodes, edges, options) {
+  try {
+    return AvoidRouter.getInstance().routeAll(nodes, edges, options);
+  } catch {
+    return {};
+  }
+}
+
+// src/useAvoidNodesRouterFromWorker.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useRef as useRef2 } from "react";
+
+// src/useAvoidWorker.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+
+// src/worker-listener.ts
+function attachAvoidWorkerListener(worker, options = {}) {
+  const { onRouted, onLoaded } = options;
+  const setLoaded = useAvoidRoutesStore.getState().setLoaded;
+  const setRoutes = useAvoidRoutesStore.getState().setRoutes;
+  const handler = (e) => {
+    const msg = e.data;
+    if (!msg || typeof msg !== "object" || !("command" in msg)) return;
+    switch (msg.command) {
+      case "loaded":
+        setLoaded(msg.success);
+        onLoaded?.(msg.success);
+        break;
+      case "routed":
+        setRoutes(msg.routes);
+        onRouted?.(msg.routes);
+        break;
+      default:
+        break;
+    }
+  };
+  worker.addEventListener("message", handler);
+  return () => worker.removeEventListener("message", handler);
+}
+
+// src/useAvoidWorker.ts
+function useAvoidWorker(options) {
+  const workerRef = useRef(null);
+  const [workerLoaded, setWorkerLoaded] = useState(false);
+  const onRoutedRef = useRef(options?.onRouted);
+  const onLoadedRef = useRef(options?.onLoaded);
+  onRoutedRef.current = options?.onRouted;
+  onLoadedRef.current = options?.onLoaded;
+  const createWorker = options?.create !== false;
+  useEffect(() => {
+    if (!createWorker) {
+      workerRef.current = null;
+      setWorkerLoaded(false);
+      return;
+    }
+    let worker;
+    try {
+      worker = new Worker(new URL("./workers/avoid-router.worker.js", import.meta.url), { type: "module" });
+    } catch (e) {
+      console.error("[avoid-worker] Failed to create worker:", e);
+      return;
+    }
+    workerRef.current = worker;
+    worker.addEventListener("error", (e) => {
+      console.error("[avoid-worker] Worker error:", e.message);
+    });
+    const cleanup = attachAvoidWorkerListener(worker, {
+      onRouted: (routes) => onRoutedRef.current?.(routes),
+      onLoaded: (success) => {
+        setWorkerLoaded(success);
+        onLoadedRef.current?.(success);
+      }
+    });
+    return () => {
+      cleanup();
+      worker.postMessage({ command: "close" });
+      worker.terminate();
+      workerRef.current = null;
+      setWorkerLoaded(false);
+    };
+  }, [createWorker]);
+  const post = useCallback((cmd) => {
+    if (workerRef.current) {
+      workerRef.current.postMessage(cmd);
+    }
+  }, []);
+  const close = useCallback(() => {
+    if (workerRef.current) {
+      workerRef.current.postMessage({ command: "close" });
+      workerRef.current.terminate();
+      workerRef.current = null;
+      setWorkerLoaded(false);
+    }
+  }, []);
+  return { workerLoaded, post, close };
+}
+
+// src/useAvoidNodesRouterFromWorker.ts
+var DEFAULT_OPTIONS = {
+  edgeToEdgeSpacing: 10,
+  edgeToNodeSpacing: 8
+};
+function toRouterOptions(opts) {
+  return {
+    idealNudgingDistance: opts?.edgeToEdgeSpacing ?? DEFAULT_OPTIONS.edgeToEdgeSpacing,
+    shapeBufferDistance: opts?.edgeToNodeSpacing ?? DEFAULT_OPTIONS.edgeToNodeSpacing,
+    edgeRounding: opts?.edgeRounding,
+    diagramGridSize: opts?.diagramGridSize,
+    shouldSplitEdgesNearHandle: opts?.shouldSplitEdgesNearHandle
+  };
+}
+function useAvoidNodesRouterFromWorker(nodes, edges, options) {
+  const nodesRef = useRef2(nodes);
+  const edgesRef = useRef2(edges);
+  const opts = toRouterOptions(options);
+  const optsRef = useRef2(opts);
+  useEffect2(() => {
+    nodesRef.current = nodes;
+  }, [nodes]);
+  useEffect2(() => {
+    edgesRef.current = edges;
+  }, [edges]);
+  useEffect2(() => {
+    optsRef.current = opts;
+  });
+  const setRoutes = useAvoidRoutesStore((s) => s.setRoutes);
+  const setActions = useAvoidRouterActionsStore((s) => s.setActions);
+  const { post, workerLoaded } = useAvoidWorker({ create: true });
+  const didResetRef = useRef2(false);
+  const nodesMeasuredRef = useRef2(false);
+  const sendReset = useCallback2(() => {
+    if (!workerLoaded) return;
+    const nodes2 = nodesRef.current;
+    const hasMeasured = nodes2.length === 0 || nodes2.some((n) => n.measured?.width != null);
+    if (!hasMeasured) return;
+    nodesMeasuredRef.current = true;
+    const avoidEdges = edgesRef.current.filter((e) => e.type === "avoidNodes");
+    if (avoidEdges.length === 0) {
+      setRoutes({});
+      return;
+    }
+    post({
+      command: "reset",
+      nodes: nodes2,
+      edges: avoidEdges,
+      options: optsRef.current
+    });
+    didResetRef.current = true;
+  }, [post, setRoutes, workerLoaded]);
+  const sendIncrementalChanges = useCallback2(
+    (nodeIds) => {
+      if (!workerLoaded || !didResetRef.current) return;
+      const nodeMap = new Map(nodesRef.current.map((n) => [n.id, n]));
+      const changedNodes = nodeIds.map((id) => nodeMap.get(id)).filter((n) => n != null);
+      if (changedNodes.length === 0) return;
+      post({ command: "updateNodes", nodes: changedNodes });
+    },
+    [post, workerLoaded]
+  );
+  const debounceRef = useRef2(null);
+  const pendingChangeIdsRef = useRef2(/* @__PURE__ */ new Set());
+  const resetRouting = useCallback2(() => {
+    sendReset();
+  }, [sendReset]);
+  const refreshRouting = useCallback2(() => {
+    sendReset();
+  }, [sendReset]);
+  const updateRoutingForNodeIds = useCallback2(
+    (nodeIds) => {
+      sendIncrementalChanges(nodeIds);
+    },
+    [sendIncrementalChanges]
+  );
+  const updateRoutingOnNodesChange = useCallback2(
+    (changes) => {
+      if (!workerLoaded) return;
+      let hasPosition = false;
+      let hasDimensions = false;
+      let hasAddOrRemove = false;
+      for (const c of changes) {
+        if (c.type === "position") {
+          hasPosition = true;
+          pendingChangeIdsRef.current.add(c.id);
+        } else if (c.type === "dimensions") {
+          hasDimensions = true;
+          pendingChangeIdsRef.current.add(c.id);
+        } else if (c.type === "add" || c.type === "remove") {
+          hasAddOrRemove = true;
+        }
+      }
+      if (!hasPosition && !hasDimensions && !hasAddOrRemove) return;
+      const needsFullReset = hasAddOrRemove || hasDimensions && !nodesMeasuredRef.current;
+      if (needsFullReset) {
+        if (debounceRef.current) {
+          clearTimeout(debounceRef.current);
+          debounceRef.current = null;
+        }
+        pendingChangeIdsRef.current.clear();
+        debounceRef.current = setTimeout(() => {
+          debounceRef.current = null;
+          requestAnimationFrame(() => sendReset());
+        }, DEBOUNCE_ROUTING_MS);
+        return;
+      }
+      if (!didResetRef.current) return;
+      if (debounceRef.current) clearTimeout(debounceRef.current);
+      debounceRef.current = setTimeout(() => {
+        debounceRef.current = null;
+        requestAnimationFrame(() => {
+          const ids = Array.from(pendingChangeIdsRef.current);
+          pendingChangeIdsRef.current.clear();
+          if (ids.length > 0) {
+            sendIncrementalChanges(ids);
+          }
+        });
+      }, DEBOUNCE_ROUTING_MS);
+    },
+    [workerLoaded, sendReset, sendIncrementalChanges]
+  );
+  useEffect2(() => {
+    setActions({
+      resetRouting,
+      updateRoutesForNodeId: (nodeId) => updateRoutingForNodeIds([nodeId])
+    });
+    return () => setActions({ resetRouting: () => {
+    }, updateRoutesForNodeId: () => {
+    } });
+  }, [resetRouting, updateRoutingForNodeIds, setActions]);
+  useEffect2(() => {
+    if (workerLoaded) sendReset();
+  }, [
+    workerLoaded,
+    nodes.length,
+    edges.length,
+    opts.shapeBufferDistance,
+    opts.idealNudgingDistance,
+    opts.edgeRounding,
+    opts.diagramGridSize,
+    opts.shouldSplitEdgesNearHandle,
+    sendReset
+  ]);
+  return {
+    updateRoutingOnNodesChange,
+    resetRouting,
+    refreshRouting,
+    updateRoutingForNodeIds
+  };
+}
+export {
+  AvoidRouter,
+  DEBOUNCE_ROUTING_MS,
+  DEV_LOG_WEB_WORKER_MESSAGES,
+  EDGE_BORDER_RADIUS,
+  SHOULD_START_EDGE_AT_HANDLE_BORDER,
+  attachAvoidWorkerListener,
+  loadAvoidRouter,
+  routeAll,
+  useAvoidNodesPath,
+  useAvoidNodesRouterFromWorker,
+  useAvoidRouterActionsStore,
+  useAvoidRoutesStore,
+  useAvoidWorker
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/router.ts","../src/useAvoidNodesRouterFromWorker.ts","../src/useAvoidWorker.ts","../src/worker-listener.ts"],"sourcesContent":["/**\n * React Flow integration for libavoid-js: route edges so they avoid nodes (excluding group nodes).\n * Use AvoidRouter.load() once, then AvoidRouter.getInstance().routeAll(nodes, edges).\n */\n\n// Import React Flow types for nodes and edges used throughout the router\nimport type { Node, Edge } from \"@xyflow/react\";\n\n// Represents the routed result for a single edge — the SVG path string and the x/y position for a label\nexport type AvoidRoute = { path: string; labelX: number; labelY: number };\n\n// Configuration options that control how edges are routed around nodes\nexport type AvoidRouterOptions = {\n  shapeBufferDistance?: number;       // Extra padding around each node that edges must avoid\n  idealNudgingDistance?: number;      // How far apart parallel edge segments should be nudged\n  edgeRounding?: number;             // Corner radius for rounded orthogonal bends\n  diagramGridSize?: number;          // Snap edge waypoints to a grid of this size\n  shouldSplitEdgesNearHandle?: boolean;\n};\n\n// Which side of a node a handle (connection point) is on\nexport type HandlePosition = \"left\" | \"right\" | \"top\" | \"bottom\";\n\n// Default URL to load the libavoid WebAssembly binary from\nconst LIBAVOID_WASM_URL = \"/libavoid.wasm\";\n// How long to wait between retries if WASM loading fails (in milliseconds)\nconst WASM_RETRY_DELAY_MS = 2000;\n// Maximum number of times to retry loading the WASM module\nconst WASM_MAX_RETRIES = 5;\n\n// Type definition for the libavoid-js WASM library instance.\n// Maps all the constructors (Router, Point, Rectangle, etc.) and constants\n// (direction flags, routing options) that we use from the C++ libavoid library.\ntype AvoidLibInstance = {\n  Router: new (flags: number) => unknown;\n  Point: new (x: number, y: number) => { x: number; y: number };\n  Rectangle: new (a: unknown, b: unknown) => unknown;\n  ShapeRef: new (router: unknown, poly: unknown) => unknown;\n  ShapeConnectionPin: new (\n    shapeRef: unknown,\n    classId: number,\n    xProportion: number,\n    yProportion: number,\n    proportional: boolean,\n    insideOffset: number,\n    directions: number\n  ) => { setExclusive: (exclusive: boolean) => void };\n  ConnEnd: new (shapeRefOrPoint: unknown, pinClassId?: number) => unknown;\n  ConnRef: new (router: unknown, src?: unknown, dst?: unknown) => {\n    setRoutingType: (t: number) => void;\n    displayRoute: () => { size: () => number; get_ps: (i: number) => { x: number; y: number } };\n  };\n  OrthogonalRouting: number;\n  ConnType_Orthogonal: number;\n  ConnDirUp: number;\n  ConnDirDown: number;\n  ConnDirLeft: number;\n  ConnDirRight: number;\n  ConnDirAll: number;\n  shapeBufferDistance: number;\n  idealNudgingDistance: number;\n  nudgeOrthogonalSegmentsConnectedToShapes: number;\n  nudgeSharedPathsWithCommonEndPoint: number;\n  performUnifyingNudgingPreprocessingStep: number;\n};\n\n/**\n * AvoidRouter: routes diagram edges around nodes using libavoid-js (WASM).\n * Use static load() once, then getInstance().routeAll(nodes, edges).\n */\nexport class AvoidRouter {\n  // Singleton references — the WASM library and the single router instance\n  private static lib: AvoidLibInstance | null = null;\n  private static instance: AvoidRouter | null = null;\n\n  // Loads the libavoid WASM module with retry logic.\n  // Retries up to WASM_MAX_RETRIES times with a delay between attempts.\n  // Returns true if the library loaded successfully, false otherwise.\n  static async load(wasmUrl: string = LIBAVOID_WASM_URL): Promise<boolean> {\n    if (AvoidRouter.lib != null) return true;\n    if (typeof globalThis === \"undefined\") return false;\n    for (let attempt = 1; attempt <= WASM_MAX_RETRIES; attempt++) {\n      const ok = await AvoidRouter.loadOnce(wasmUrl);\n      if (ok) return true;\n      if (attempt < WASM_MAX_RETRIES) {\n        await new Promise((r) => setTimeout(r, WASM_RETRY_DELAY_MS));\n      }\n    }\n    return false;\n  }\n\n  // Single attempt to load the WASM module.\n  // Resolves the WASM URL to an absolute path, dynamically imports libavoid-js,\n  // calls its load() to initialize the WASM, then stores the library instance.\n  private static async loadOnce(wasmUrl: string): Promise<boolean> {\n    const origin = (globalThis as unknown as { location?: { origin?: string } }).location?.origin;\n    const absoluteWasmUrl = origin && wasmUrl.startsWith(\"/\") ? `${origin}${wasmUrl}` : wasmUrl;\n\n    try {\n      const mod = (await import(\"libavoid-js\")) as unknown as {\n        default?: { load?: (filePath?: string) => Promise<void>; getInstance?: () => AvoidLibInstance };\n        AvoidLib?: { load?: (filePath?: string) => Promise<void>; getInstance?: () => AvoidLibInstance };\n      };\n      const AvoidLib = mod.AvoidLib ?? mod.default;\n      if (!AvoidLib?.load) return false;\n      await AvoidLib.load(absoluteWasmUrl);\n      const lib = AvoidLib.getInstance?.();\n      if (lib == null) return false;\n      AvoidRouter.lib = lib;\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  // Returns the singleton AvoidRouter instance.\n  // Throws if the WASM library hasn't been loaded yet via load().\n  static getInstance(): AvoidRouter {\n    if (AvoidRouter.instance == null) AvoidRouter.instance = new AvoidRouter();\n    if (AvoidRouter.lib == null) throw new Error(\"AvoidRouter.load() must be called first.\");\n    return AvoidRouter.instance;\n  }\n\n  // Main routing method — takes all nodes and edges, computes obstacle-avoiding\n  // orthogonal paths for every edge, and returns a map of edgeId -> AvoidRoute.\n  //\n  // Steps:\n  // 1. Filter out group nodes (only real nodes are obstacles)\n  // 2. Create a libavoid Router and configure its parameters\n  // 3. Register each node as a rectangular obstacle shape with connection pins\n  // 4. Create a connector (ConnRef) for each edge between source/target pins\n  // 5. Run the routing algorithm (processTransaction)\n  // 6. Extract the routed polyline for each edge and convert to SVG path\n  // 7. Clean up all libavoid objects to free WASM memory\n  routeAll(nodes: Node[], edges: Edge[], options?: AvoidRouterOptions): Record<string, AvoidRoute> {\n    const Avoid = AvoidRouter.lib;\n    if (!Avoid) return {};\n\n    // Extract options with defaults\n    const shapeBuffer = options?.shapeBufferDistance ?? 8;\n    const idealNudging = options?.idealNudgingDistance ?? 10;\n    const cornerRadius = options?.edgeRounding ?? 0;\n    const gridSize = options?.diagramGridSize ?? 0;\n\n    // Filter out group nodes — they aren't obstacles, only containers.\n    // Build lookup maps for quick node access and pre-compute absolute bounds.\n    const obstacleNodes = nodes.filter((n) => n.type !== \"group\");\n    const nodeById = new Map(nodes.map((n) => [n.id, n]));\n    const nodeBounds = new Map(obstacleNodes.map((n) => [n.id, this.getNodeBoundsAbsolute(n, nodeById)]));\n\n    // Create the libavoid orthogonal router and configure its routing parameters\n    const router = new Avoid.Router(Avoid.OrthogonalRouting) as {\n      setRoutingParameter: (p: number, v: number) => void;\n      setRoutingOption: (o: number, v: boolean) => void;\n      processTransaction: () => void;\n      deleteConnector: (c: unknown) => void;\n      deleteShape: (s: unknown) => void;\n    };\n    router.setRoutingParameter(Avoid.shapeBufferDistance, shapeBuffer);\n    router.setRoutingParameter(Avoid.idealNudgingDistance, idealNudging);\n    router.setRoutingOption(Avoid.nudgeOrthogonalSegmentsConnectedToShapes, true);\n    router.setRoutingOption(Avoid.nudgeSharedPathsWithCommonEndPoint, true);\n    router.setRoutingOption(Avoid.performUnifyingNudgingPreprocessingStep, true);\n\n    // Pin class IDs — each represents a connection point position on a shape.\n    // These IDs are used by libavoid to know where edges can attach to nodes.\n    const PIN_CENTER = 1;\n    const PIN_TOP = 2;\n    const PIN_BOTTOM = 3;\n    const PIN_LEFT = 4;\n    const PIN_RIGHT = 5;\n\n    // Maps handle positions (top/bottom/left/right) to their pin class IDs\n    const pinIdForPosition: Record<HandlePosition, number> = {\n      top: PIN_TOP,\n      bottom: PIN_BOTTOM,\n      left: PIN_LEFT,\n      right: PIN_RIGHT,\n    };\n\n    // Defines the proportional x/y position on the shape boundary and\n    // the allowed connection direction for each pin type.\n    // e.g. PIN_TOP is at (0.5, 0) = top-center, only allows upward connections.\n    const pinProportions: Record<number, { x: number; y: number; dir: number }> = {\n      [PIN_CENTER]: { x: 0.5, y: 0.5, dir: Avoid.ConnDirAll },\n      [PIN_TOP]: { x: 0.5, y: 0, dir: Avoid.ConnDirUp },\n      [PIN_BOTTOM]: { x: 0.5, y: 1, dir: Avoid.ConnDirDown },\n      [PIN_LEFT]: { x: 0, y: 0.5, dir: Avoid.ConnDirLeft },\n      [PIN_RIGHT]: { x: 1, y: 0.5, dir: Avoid.ConnDirRight },\n    };\n\n    // Register each obstacle node as a rectangle shape in the libavoid router.\n    // For each shape, create 5 connection pins (center, top, bottom, left, right)\n    // so edges can attach at any of these positions.\n    const shapeRefMap = new Map<string, unknown>();\n    const shapeRefs: { ref: unknown }[] = [];\n    for (const node of obstacleNodes) {\n      const b = nodeBounds.get(node.id)!;\n      const topLeft = new Avoid.Point(b.x, b.y);\n      const bottomRight = new Avoid.Point(b.x + b.w, b.y + b.h);\n      const rect = new Avoid.Rectangle(topLeft, bottomRight);\n      const shapeRef = new Avoid.ShapeRef(router, rect);\n      shapeRefs.push({ ref: shapeRef });\n      shapeRefMap.set(node.id, shapeRef);\n\n      for (const pinId of [PIN_CENTER, PIN_TOP, PIN_BOTTOM, PIN_LEFT, PIN_RIGHT]) {\n        const p = pinProportions[pinId];\n        const pin = new Avoid.ShapeConnectionPin(shapeRef, pinId, p.x, p.y, true, 0, p.dir);\n        pin.setExclusive(false);\n      }\n    }\n\n    // Create a connector (ConnRef) for each edge.\n    // Determines the source and target connection points:\n    // - If the node is an obstacle, connect via its shape pin (attached routing)\n    // - If the node is a group (not an obstacle), connect via a free-floating point\n    // Each connector is set to orthogonal routing (right-angle segments only).\n    const connRefs: { edgeId: string; connRef: unknown }[] = [];\n    for (const edge of edges) {\n      const src = nodeById.get(edge.source);\n      const tgt = nodeById.get(edge.target);\n      if (!src || !tgt) continue;\n\n      const srcShapeRef = shapeRefMap.get(edge.source);\n      const tgtShapeRef = shapeRefMap.get(edge.target);\n\n      const sourcePos = this.getHandlePosition(src, \"source\");\n      const targetPos = this.getHandlePosition(tgt, \"target\");\n\n      let srcEnd: unknown;\n      let tgtEnd: unknown;\n\n      if (srcShapeRef) {\n        const pinId = pinIdForPosition[sourcePos] ?? PIN_CENTER;\n        srcEnd = new Avoid.ConnEnd(srcShapeRef, pinId);\n      } else {\n        const sb = this.getNodeBoundsAbsolute(src, nodeById);\n        const sourcePt = this.getHandlePoint(sb, sourcePos);\n        srcEnd = new Avoid.ConnEnd(new Avoid.Point(sourcePt.x, sourcePt.y));\n      }\n\n      if (tgtShapeRef) {\n        const pinId = pinIdForPosition[targetPos] ?? PIN_CENTER;\n        tgtEnd = new Avoid.ConnEnd(tgtShapeRef, pinId);\n      } else {\n        const tb = this.getNodeBoundsAbsolute(tgt, nodeById);\n        const targetPt = this.getHandlePoint(tb, targetPos);\n        tgtEnd = new Avoid.ConnEnd(new Avoid.Point(targetPt.x, targetPt.y));\n      }\n\n      const connRef = new Avoid.ConnRef(router, srcEnd, tgtEnd);\n      connRef.setRoutingType(Avoid.ConnType_Orthogonal);\n      connRefs.push({ edgeId: edge.id, connRef });\n    }\n\n    // Run the libavoid routing algorithm — this computes all edge paths at once,\n    // finding routes that avoid overlapping with obstacle shapes.\n    try {\n      router.processTransaction();\n    } catch {\n      this.cleanup(router, connRefs, shapeRefs);\n      return {};\n    }\n\n    // Extract the computed route for each edge.\n    // Convert the polyline (list of waypoints) into an SVG path string,\n    // and pick the midpoint as the label position.\n    const result: Record<string, AvoidRoute> = {};\n    for (const { edgeId, connRef } of connRefs) {\n      try {\n        const route = (connRef as { displayRoute(): { size(): number; get_ps(i: number): { x: number; y: number } } }).displayRoute();\n        const size = route.size();\n        if (size < 2) continue;\n        const path = this.polylineToPath(size, (i) => {\n          const p = route.get_ps(i);\n          return { x: p.x, y: p.y };\n        }, { gridSize: gridSize || undefined, cornerRadius });\n        const mid = Math.floor(size / 2);\n        const midP = route.get_ps(mid);\n        const labelP = gridSize > 0 ? this.snapToGrid(midP.x, midP.y, gridSize) : { x: midP.x, y: midP.y };\n        result[edgeId] = { path, labelX: labelP.x, labelY: labelP.y };\n      } catch {\n        // skip\n      }\n    }\n\n    this.cleanup(router, connRefs, shapeRefs);\n    return result;\n  }\n\n  // Gets the local position and dimensions of a node.\n  // Tries measured size first, then explicit width/height, then style, with fallback defaults.\n  private getNodeBounds(node: Node): { x: number; y: number; w: number; h: number } {\n    const x = node.position?.x ?? 0;\n    const y = node.position?.y ?? 0;\n    const w = Number((node.measured?.width ?? node.width ?? (node.style as { width?: number })?.width) ?? 150);\n    const h = Number((node.measured?.height ?? node.height ?? (node.style as { height?: number })?.height) ?? 50);\n    return { x, y, w, h };\n  }\n\n  // Computes the absolute (world-space) bounds of a node by walking up\n  // the parent chain and accumulating parent positions. This is needed\n  // because child nodes have positions relative to their parent.\n  private getNodeBoundsAbsolute(\n    node: Node,\n    nodeById: Map<string, Node>\n  ): { x: number; y: number; w: number; h: number } {\n    const b = this.getNodeBounds(node);\n    let current: Node | undefined = node;\n    while (current?.parentId) {\n      const parent = nodeById.get(current.parentId);\n      if (!parent) break;\n      b.x += parent.position?.x ?? 0;\n      b.y += parent.position?.y ?? 0;\n      current = parent;\n    }\n    return b;\n  }\n\n  // Determines which side of a node a handle is on (left/right/top/bottom).\n  // Checks both the node's direct properties and its data object.\n  // Defaults to \"right\" for source handles and \"left\" for target handles.\n  private getHandlePosition(node: Node, kind: \"source\" | \"target\"): HandlePosition {\n    const raw =\n      kind === \"source\"\n        ? (node.sourcePosition as string | undefined) ?? (node as { data?: { sourcePosition?: string } }).data?.sourcePosition\n        : (node.targetPosition as string | undefined) ?? (node as { data?: { targetPosition?: string } }).data?.targetPosition;\n    const s = String(raw ?? \"\").toLowerCase();\n    if (s === \"left\" || s === \"right\" || s === \"top\" || s === \"bottom\") return s;\n    return kind === \"source\" ? \"right\" : \"left\";\n  }\n\n  // Converts a handle position (left/right/top/bottom) into an actual x/y coordinate\n  // on the node's boundary. The point is at the center of the respective edge.\n  private getHandlePoint(\n    bounds: { x: number; y: number; w: number; h: number },\n    position: HandlePosition\n  ): { x: number; y: number } {\n    const { x, y, w, h } = bounds;\n    const cx = x + w / 2;\n    const cy = y + h / 2;\n    switch (position) {\n      case \"left\":\n        return { x, y: cy };\n      case \"right\":\n        return { x: x + w, y: cy };\n      case \"top\":\n        return { x: cx, y };\n      case \"bottom\":\n        return { x: cx, y: y + h };\n      default:\n        return { x: x + w, y: cy };\n    }\n  }\n\n  // Snaps x/y coordinates to the nearest grid point (rounds to nearest multiple of gridSize)\n  private snapToGrid(x: number, y: number, gridSize: number): { x: number; y: number } {\n    if (gridSize <= 0) return { x, y };\n    return { x: Math.round(x / gridSize) * gridSize, y: Math.round(y / gridSize) * gridSize };\n  }\n\n  // Converts a polyline (series of waypoints) into an SVG path string.\n  // If cornerRadius > 0, adds quadratic bezier curves (Q commands) at each bend\n  // to create smooth rounded corners instead of sharp right angles.\n  // If cornerRadius is 0, produces a simple M/L path with straight segments.\n  private polylineToPath(\n    size: number,\n    getPoint: (i: number) => { x: number; y: number },\n    options: { gridSize?: number; cornerRadius?: number } = {}\n  ): string {\n    if (size < 2) return \"\";\n    const gridSize = options.gridSize ?? 0;\n    const r = Math.max(0, options.cornerRadius ?? 0);\n    const pt = (i: number) => {\n      const p = getPoint(i);\n      return gridSize > 0 ? this.snapToGrid(p.x, p.y, gridSize) : p;\n    };\n    if (r <= 0) {\n      let d = `M ${pt(0).x} ${pt(0).y}`;\n      for (let i = 1; i < size; i++) {\n        const p = pt(i);\n        d += ` L ${p.x} ${p.y}`;\n      }\n      return d;\n    }\n    const dist = (a: { x: number; y: number }, b: { x: number; y: number }) =>\n      Math.hypot(b.x - a.x, b.y - a.y);\n    const unit = (a: { x: number; y: number }, b: { x: number; y: number }) => {\n      const d = dist(a, b);\n      if (d < 1e-6) return { x: 0, y: 0 };\n      return { x: (b.x - a.x) / d, y: (b.y - a.y) / d };\n    };\n    let d = `M ${pt(0).x} ${pt(0).y}`;\n    for (let i = 1; i < size - 1; i++) {\n      const prev = pt(i - 1);\n      const curr = pt(i);\n      const next = pt(i + 1);\n      const dirIn = unit(curr, prev);\n      const dirOut = unit(curr, next);\n      const lenIn = dist(curr, prev);\n      const lenOut = dist(curr, next);\n      const rIn = Math.min(r, lenIn / 2, lenOut / 2);\n      const rOut = Math.min(r, lenIn / 2, lenOut / 2);\n      const endPrev = { x: curr.x + dirIn.x * rIn, y: curr.y + dirIn.y * rIn };\n      const startNext = { x: curr.x + dirOut.x * rOut, y: curr.y + dirOut.y * rOut };\n      d += ` L ${endPrev.x} ${endPrev.y} Q ${curr.x} ${curr.y} ${startNext.x} ${startNext.y}`;\n    }\n    const last = pt(size - 1);\n    d += ` L ${last.x} ${last.y}`;\n    return d;\n  }\n\n  // Frees all libavoid objects (connectors and shapes) from the router.\n  // This is important to prevent WASM memory leaks since libavoid\n  // allocates memory in the WASM heap that isn't garbage collected by JS.\n  private cleanup(\n    router: { deleteConnector: (c: unknown) => void; deleteShape: (s: unknown) => void },\n    connRefs: { connRef: unknown }[],\n    shapeRefs: { ref: unknown }[]\n  ): void {\n    try {\n      for (const { connRef } of connRefs) router.deleteConnector(connRef);\n      for (const { ref } of shapeRefs) router.deleteShape(ref);\n    } catch {\n      // ignore\n    }\n  }\n}\n\n// Convenience function to load the WASM module — wraps AvoidRouter.load()\nexport async function loadAvoidRouter(): Promise<boolean> {\n  return AvoidRouter.load();\n}\n\n// Convenience function to route all edges — wraps AvoidRouter.getInstance().routeAll().\n// Returns an empty object if routing fails for any reason.\nexport function routeAll(\n  nodes: Node[],\n  edges: Edge[],\n  options?: AvoidRouterOptions\n): Record<string, AvoidRoute> {\n  try {\n    return AvoidRouter.getInstance().routeAll(nodes, edges, options);\n  } catch {\n    return {};\n  }\n}\n","/**\n * useAvoidNodesRouterFromWorker\n * ---------------------------------------------------------------------------\n * Routes edges around nodes using a Web Worker running WASM.\n *\n * How it works:\n * 1. On load, sends ALL nodes + edges to the worker (\"reset\").\n * 2. On drag/resize, sends ONLY that node (\"updateNodes\") — much faster.\n * 3. On add/remove, does a full reset (graph structure changed).\n * 4. On settings change (spacing, rounding), does a full reset.\n *\n * The worker batches rapid changes (debounce) so dragging doesn't flood it.\n */\n\nimport { useCallback, useEffect, useRef } from \"react\";\nimport type { Node, NodeChange, Edge } from \"@xyflow/react\";\nimport { useAvoidRoutesStore, useAvoidRouterActionsStore } from \"./store\";\nimport { DEBOUNCE_ROUTING_MS } from \"./constants\";\nimport type { AvoidRouterOptions } from \"./router\";\nimport { useAvoidWorker } from \"./useAvoidWorker\";\n\nexport interface UseAvoidNodesRouterOptions {\n  shouldSplitEdgesNearHandle?: boolean;\n  edgeToEdgeSpacing?: number;\n  edgeToNodeSpacing?: number;\n  edgeRounding?: number;\n  diagramGridSize?: number;\n}\n\nexport interface UseAvoidNodesRouterResult {\n  updateRoutingOnNodesChange: (changes: NodeChange<Node>[]) => void;\n  resetRouting: () => void;\n  refreshRouting: () => void;\n  updateRoutingForNodeIds: (nodeIds: string[]) => void;\n}\n\nconst DEFAULT_OPTIONS: UseAvoidNodesRouterOptions = {\n  edgeToEdgeSpacing: 10,\n  edgeToNodeSpacing: 8,\n};\n\nfunction toRouterOptions(opts?: UseAvoidNodesRouterOptions): AvoidRouterOptions {\n  return {\n    idealNudgingDistance: opts?.edgeToEdgeSpacing ?? DEFAULT_OPTIONS.edgeToEdgeSpacing,\n    shapeBufferDistance: opts?.edgeToNodeSpacing ?? DEFAULT_OPTIONS.edgeToNodeSpacing,\n    edgeRounding: opts?.edgeRounding,\n    diagramGridSize: opts?.diagramGridSize,\n    shouldSplitEdgesNearHandle: opts?.shouldSplitEdgesNearHandle,\n  };\n}\n\n/**\n * Drop-in replacement for useAvoidNodesRouter — same API, but all heavy\n * routing calculations happen on a separate thread so the UI stays smooth.\n */\nexport function useAvoidNodesRouterFromWorker(\n  nodes: Node[],\n  edges: Edge[],\n  options?: UseAvoidNodesRouterOptions\n): UseAvoidNodesRouterResult {\n  const nodesRef = useRef<Node[]>(nodes);\n  const edgesRef = useRef<Edge[]>(edges);\n  const opts = toRouterOptions(options);\n  const optsRef = useRef<AvoidRouterOptions>(opts);\n\n  useEffect(() => { nodesRef.current = nodes; }, [nodes]);\n  useEffect(() => { edgesRef.current = edges; }, [edges]);\n  useEffect(() => { optsRef.current = opts; });\n\n  const setRoutes = useAvoidRoutesStore((s) => s.setRoutes);\n  const setActions = useAvoidRouterActionsStore((s) => s.setActions);\n\n  const { post, workerLoaded } = useAvoidWorker({ create: true });\n\n  const didResetRef = useRef(false);\n  const nodesMeasuredRef = useRef(false);\n\n  const sendReset = useCallback(() => {\n    if (!workerLoaded) return;\n    // Don't route until React Flow has measured at least some nodes —\n    // without measured data, obstacles get wrong sizes and edges clip through.\n    const nodes = nodesRef.current;\n    const hasMeasured = nodes.length === 0 || nodes.some((n) => n.measured?.width != null);\n    if (!hasMeasured) return;\n    nodesMeasuredRef.current = true;\n    const avoidEdges = edgesRef.current.filter((e) => e.type === \"avoidNodes\");\n    if (avoidEdges.length === 0) {\n      setRoutes({});\n      return;\n    }\n    post({\n      command: \"reset\",\n      nodes,\n      edges: avoidEdges,\n      options: optsRef.current,\n    });\n    didResetRef.current = true;\n  }, [post, setRoutes, workerLoaded]);\n\n  const sendIncrementalChanges = useCallback(\n    (nodeIds: string[]) => {\n      if (!workerLoaded || !didResetRef.current) return;\n      const nodeMap = new Map(nodesRef.current.map((n) => [n.id, n]));\n      const changedNodes = nodeIds\n        .map((id) => nodeMap.get(id))\n        .filter((n): n is Node => n != null);\n      if (changedNodes.length === 0) return;\n      post({ command: \"updateNodes\", nodes: changedNodes });\n    },\n    [post, workerLoaded]\n  );\n\n  const debounceRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n  const pendingChangeIdsRef = useRef<Set<string>>(new Set());\n\n  const resetRouting = useCallback(() => { sendReset(); }, [sendReset]);\n  const refreshRouting = useCallback(() => { sendReset(); }, [sendReset]);\n  const updateRoutingForNodeIds = useCallback(\n    (nodeIds: string[]) => { sendIncrementalChanges(nodeIds); },\n    [sendIncrementalChanges]\n  );\n\n  const updateRoutingOnNodesChange = useCallback(\n    (changes: NodeChange<Node>[]) => {\n      if (!workerLoaded) return;\n\n      let hasPosition = false;\n      let hasDimensions = false;\n      let hasAddOrRemove = false;\n\n      for (const c of changes) {\n        if (c.type === \"position\") {\n          hasPosition = true;\n          pendingChangeIdsRef.current.add(c.id);\n        } else if (c.type === \"dimensions\") {\n          hasDimensions = true;\n          pendingChangeIdsRef.current.add(c.id);\n        } else if (c.type === \"add\" || c.type === \"remove\") {\n          hasAddOrRemove = true;\n        }\n      }\n\n      if (!hasPosition && !hasDimensions && !hasAddOrRemove) return;\n\n      // On first dimensions change (initial measurement) or structural changes,\n      // do a full reset so all nodes get correct measured bounds.\n      const needsFullReset = hasAddOrRemove || (hasDimensions && !nodesMeasuredRef.current);\n\n      if (needsFullReset) {\n        if (debounceRef.current) { clearTimeout(debounceRef.current); debounceRef.current = null; }\n        pendingChangeIdsRef.current.clear();\n        // Use rAF to ensure React has flushed state (nodesRef is up to date).\n        debounceRef.current = setTimeout(() => {\n          debounceRef.current = null;\n          requestAnimationFrame(() => sendReset());\n        }, DEBOUNCE_ROUTING_MS);\n        return;\n      }\n\n      if (!didResetRef.current) return;\n\n      if (debounceRef.current) clearTimeout(debounceRef.current);\n      debounceRef.current = setTimeout(() => {\n        debounceRef.current = null;\n        // Use rAF to ensure React has flushed state before reading nodesRef.\n        requestAnimationFrame(() => {\n          const ids = Array.from(pendingChangeIdsRef.current);\n          pendingChangeIdsRef.current.clear();\n          if (ids.length > 0) {\n            sendIncrementalChanges(ids);\n          }\n        });\n      }, DEBOUNCE_ROUTING_MS);\n    },\n    [workerLoaded, sendReset, sendIncrementalChanges]\n  );\n\n  useEffect(() => {\n    setActions({\n      resetRouting,\n      updateRoutesForNodeId: (nodeId) => updateRoutingForNodeIds([nodeId]),\n    });\n    return () => setActions({ resetRouting: () => {}, updateRoutesForNodeId: () => {} });\n  }, [resetRouting, updateRoutingForNodeIds, setActions]);\n\n  useEffect(() => {\n    if (workerLoaded) sendReset();\n  }, [\n    workerLoaded,\n    nodes.length,\n    edges.length,\n    opts.shapeBufferDistance,\n    opts.idealNudgingDistance,\n    opts.edgeRounding,\n    opts.diagramGridSize,\n    opts.shouldSplitEdgesNearHandle,\n    sendReset,\n  ]);\n\n  return {\n    updateRoutingOnNodesChange,\n    resetRouting,\n    refreshRouting,\n    updateRoutingForNodeIds,\n  };\n}\n","import { useCallback, useEffect, useRef, useState } from \"react\";\nimport type { AvoidRouterWorkerCommand } from \"./worker-messages\";\nimport type { AvoidRoute } from \"./router\";\nimport { attachAvoidWorkerListener } from \"./worker-listener\";\n\nexport interface UseAvoidWorkerOptions {\n  create?: boolean;\n  onRouted?: (routes: Record<string, AvoidRoute>) => void;\n  onLoaded?: (success: boolean) => void;\n}\n\nexport interface UseAvoidWorkerResult {\n  workerLoaded: boolean;\n  post: (cmd: AvoidRouterWorkerCommand) => void;\n  close: () => void;\n}\n\n/**\n * Creates the avoid-router Web Worker and waits for it to load WASM.\n * WASM loads exclusively in the worker thread — never on the main thread.\n */\nexport function useAvoidWorker(options?: UseAvoidWorkerOptions): UseAvoidWorkerResult {\n  const workerRef = useRef<Worker | null>(null);\n  const [workerLoaded, setWorkerLoaded] = useState(false);\n  const onRoutedRef = useRef(options?.onRouted);\n  const onLoadedRef = useRef(options?.onLoaded);\n  onRoutedRef.current = options?.onRouted;\n  onLoadedRef.current = options?.onLoaded;\n\n  const createWorker = options?.create !== false;\n\n  useEffect(() => {\n    if (!createWorker) {\n      workerRef.current = null;\n      setWorkerLoaded(false);\n      return;\n    }\n    let worker: Worker;\n    try {\n      worker = new Worker(new URL(\"./workers/avoid-router.worker.js\", import.meta.url), { type: \"module\" });\n    } catch (e) {\n      console.error(\"[avoid-worker] Failed to create worker:\", e);\n      return;\n    }\n\n    workerRef.current = worker;\n\n    worker.addEventListener(\"error\", (e) => {\n      console.error(\"[avoid-worker] Worker error:\", e.message);\n    });\n\n    const cleanup = attachAvoidWorkerListener(worker, {\n      onRouted: (routes) => onRoutedRef.current?.(routes),\n      onLoaded: (success) => {\n        setWorkerLoaded(success);\n        onLoadedRef.current?.(success);\n      },\n    });\n\n    return () => {\n      cleanup();\n      worker.postMessage({ command: \"close\" } as AvoidRouterWorkerCommand);\n      worker.terminate();\n      workerRef.current = null;\n      setWorkerLoaded(false);\n    };\n  }, [createWorker]);\n\n  const post = useCallback((cmd: AvoidRouterWorkerCommand) => {\n    if (workerRef.current) {\n      workerRef.current.postMessage(cmd);\n    }\n  }, []);\n\n  const close = useCallback(() => {\n    if (workerRef.current) {\n      workerRef.current.postMessage({ command: \"close\" } as AvoidRouterWorkerCommand);\n      workerRef.current.terminate();\n      workerRef.current = null;\n      setWorkerLoaded(false);\n    }\n  }, []);\n\n  return { workerLoaded, post, close };\n}\n","/**\n * Listener for avoid-router Web Worker messages.\n * Syncs \"loaded\" / \"routed\" into the avoid store.\n */\n\nimport type { AvoidRouterWorkerResponse } from \"./worker-messages\";\nimport { useAvoidRoutesStore } from \"./store\";\n\nexport interface AttachAvoidWorkerListenerOptions {\n  onRouted?: (routes: Record<string, { path: string; labelX: number; labelY: number }>) => void;\n  onLoaded?: (success: boolean) => void;\n}\n\n/**\n * Attach a message listener to an avoid-router worker so the app stays in sync.\n * @returns Cleanup function (removeEventListener).\n */\nexport function attachAvoidWorkerListener(\n  worker: Worker,\n  options: AttachAvoidWorkerListenerOptions = {}\n): () => void {\n  const { onRouted, onLoaded } = options;\n  const setLoaded = useAvoidRoutesStore.getState().setLoaded;\n  const setRoutes = useAvoidRoutesStore.getState().setRoutes;\n\n  const handler = (e: MessageEvent<AvoidRouterWorkerResponse>) => {\n    const msg = e.data;\n    if (!msg || typeof msg !== \"object\" || !(\"command\" in msg)) return;\n\n    switch (msg.command) {\n      case \"loaded\":\n        setLoaded(msg.success);\n        onLoaded?.(msg.success);\n        break;\n      case \"routed\":\n        setRoutes(msg.routes);\n        onRouted?.(msg.routes);\n        break;\n      default:\n        break;\n    }\n  };\n\n  worker.addEventListener(\"message\", handler);\n  return () => worker.removeEventListener(\"message\", handler);\n}\n"],"mappings":"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","names":["d","useCallback","useEffect","useRef","useRef","useEffect","useCallback","nodes"]}