@nodius/layouting 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1086 @@
+// src/types.ts
+function resolveOptions(options) {
+  return {
+    direction: options?.direction ?? "TB",
+    nodeSpacing: options?.nodeSpacing ?? 40,
+    layerSpacing: options?.layerSpacing ?? 60,
+    crossingMinimizationIterations: options?.crossingMinimizationIterations ?? 24,
+    coordinateOptimizationIterations: options?.coordinateOptimizationIterations ?? 8,
+    edgeMargin: options?.edgeMargin ?? 20
+  };
+}
+
+// src/graph.ts
+var Graph = class {
+  constructor() {
+    this.nodes = /* @__PURE__ */ new Map();
+    this.edges = /* @__PURE__ */ new Map();
+    this.outEdges = /* @__PURE__ */ new Map();
+    this.inEdges = /* @__PURE__ */ new Map();
+  }
+  addNode(node) {
+    this.nodes.set(node.id, node);
+    if (!this.outEdges.has(node.id)) this.outEdges.set(node.id, /* @__PURE__ */ new Set());
+    if (!this.inEdges.has(node.id)) this.inEdges.set(node.id, /* @__PURE__ */ new Set());
+  }
+  addEdge(edge) {
+    this.edges.set(edge.id, edge);
+    if (!this.outEdges.has(edge.from)) this.outEdges.set(edge.from, /* @__PURE__ */ new Set());
+    if (!this.inEdges.has(edge.to)) this.inEdges.set(edge.to, /* @__PURE__ */ new Set());
+    this.outEdges.get(edge.from).add(edge.id);
+    this.inEdges.get(edge.to).add(edge.id);
+  }
+  removeEdge(edgeId) {
+    const edge = this.edges.get(edgeId);
+    if (!edge) return;
+    this.outEdges.get(edge.from)?.delete(edgeId);
+    this.inEdges.get(edge.to)?.delete(edgeId);
+    this.edges.delete(edgeId);
+  }
+  removeNode(nodeId) {
+    const outEdgeIds = [...this.outEdges.get(nodeId) || []];
+    const inEdgeIds = [...this.inEdges.get(nodeId) || []];
+    for (const eid of outEdgeIds) this.removeEdge(eid);
+    for (const eid of inEdgeIds) this.removeEdge(eid);
+    this.nodes.delete(nodeId);
+    this.outEdges.delete(nodeId);
+    this.inEdges.delete(nodeId);
+  }
+  predecessors(nodeId) {
+    const result = [];
+    const inEdgeIds = this.inEdges.get(nodeId);
+    if (inEdgeIds) {
+      for (const eid of inEdgeIds) {
+        const edge = this.edges.get(eid);
+        if (edge) result.push(edge.from);
+      }
+    }
+    return result;
+  }
+  successors(nodeId) {
+    const result = [];
+    const outEdgeIds = this.outEdges.get(nodeId);
+    if (outEdgeIds) {
+      for (const eid of outEdgeIds) {
+        const edge = this.edges.get(eid);
+        if (edge) result.push(edge.to);
+      }
+    }
+    return result;
+  }
+};
+function buildGraph(nodes, edges) {
+  const graph = new Graph();
+  for (const node of nodes) {
+    graph.addNode({
+      id: node.id,
+      width: node.width,
+      height: node.height,
+      handles: node.handles.map((h) => ({ ...h, offset: h.offset ?? 0.5 })),
+      isDummy: false,
+      layer: -1,
+      order: -1,
+      x: 0,
+      y: 0
+    });
+  }
+  for (const edge of edges) {
+    graph.addEdge({
+      id: edge.id,
+      from: edge.from,
+      to: edge.to,
+      fromHandle: edge.fromHandle,
+      toHandle: edge.toHandle,
+      reversed: false,
+      originalId: edge.id
+    });
+  }
+  return graph;
+}
+function getHandlePosition(node, handleId) {
+  const handle = node.handles.find((h) => h.id === handleId);
+  if (!handle) {
+    return { x: node.x + node.width / 2, y: node.y + node.height / 2 };
+  }
+  const offset = handle.offset ?? 0.5;
+  switch (handle.position) {
+    case "top":
+      return { x: node.x + offset * node.width, y: node.y };
+    case "bottom":
+      return { x: node.x + offset * node.width, y: node.y + node.height };
+    case "left":
+      return { x: node.x, y: node.y + offset * node.height };
+    case "right":
+      return { x: node.x + node.width, y: node.y + offset * node.height };
+  }
+}
+function getHandleDirection(side) {
+  switch (side) {
+    case "top":
+      return { x: 0, y: -1 };
+    case "bottom":
+      return { x: 0, y: 1 };
+    case "left":
+      return { x: -1, y: 0 };
+    case "right":
+      return { x: 1, y: 0 };
+  }
+}
+
+// src/algorithms/cycle-breaking.ts
+function breakCycles(graph) {
+  const WHITE = 0, GRAY = 1, BLACK = 2;
+  const state = /* @__PURE__ */ new Map();
+  const reversed = /* @__PURE__ */ new Set();
+  for (const nodeId of graph.nodes.keys()) {
+    state.set(nodeId, WHITE);
+  }
+  const nodeIds = [...graph.nodes.keys()].sort((a, b) => {
+    const aDiff = (graph.outEdges.get(a)?.size || 0) - (graph.inEdges.get(a)?.size || 0);
+    const bDiff = (graph.outEdges.get(b)?.size || 0) - (graph.inEdges.get(b)?.size || 0);
+    return bDiff - aDiff;
+  });
+  function dfs(nodeId) {
+    state.set(nodeId, GRAY);
+    const outEdgeIds = graph.outEdges.get(nodeId);
+    if (outEdgeIds) {
+      for (const edgeId of outEdgeIds) {
+        const edge = graph.edges.get(edgeId);
+        if (!edge) continue;
+        const targetState = state.get(edge.to);
+        if (targetState === GRAY) {
+          reversed.add(edgeId);
+        } else if (targetState === WHITE) {
+          dfs(edge.to);
+        }
+      }
+    }
+    state.set(nodeId, BLACK);
+  }
+  for (const nodeId of nodeIds) {
+    if (state.get(nodeId) === WHITE) {
+      dfs(nodeId);
+    }
+  }
+  for (const edgeId of reversed) {
+    const edge = graph.edges.get(edgeId);
+    if (!edge) continue;
+    graph.removeEdge(edgeId);
+    graph.addEdge({
+      ...edge,
+      from: edge.to,
+      to: edge.from,
+      fromHandle: edge.toHandle,
+      toHandle: edge.fromHandle,
+      reversed: !edge.reversed
+    });
+  }
+  return reversed;
+}
+
+// src/algorithms/layer-assignment.ts
+function assignLayers(graph) {
+  const layers = /* @__PURE__ */ new Map();
+  const visiting = /* @__PURE__ */ new Set();
+  function computeLayer(nodeId) {
+    if (layers.has(nodeId)) return layers.get(nodeId);
+    if (visiting.has(nodeId)) return 0;
+    visiting.add(nodeId);
+    const preds = graph.predecessors(nodeId);
+    let maxPredLayer = -1;
+    for (const pred of preds) {
+      maxPredLayer = Math.max(maxPredLayer, computeLayer(pred));
+    }
+    const layer = maxPredLayer + 1;
+    layers.set(nodeId, layer);
+    const node = graph.nodes.get(nodeId);
+    if (node) node.layer = layer;
+    visiting.delete(nodeId);
+    return layer;
+  }
+  for (const nodeId of graph.nodes.keys()) {
+    computeLayer(nodeId);
+  }
+  let maxLayer = 0;
+  for (const layer of layers.values()) {
+    maxLayer = Math.max(maxLayer, layer);
+  }
+  const layersArray = Array.from({ length: maxLayer + 1 }, () => []);
+  for (const [nodeId, layer] of layers) {
+    layersArray[layer].push(nodeId);
+  }
+  return layersArray;
+}
+function insertDummyNodes(graph, layers) {
+  let dummyCounter = 0;
+  const edgesToProcess = [...graph.edges.values()];
+  for (const edge of edgesToProcess) {
+    const fromNode = graph.nodes.get(edge.from);
+    const toNode = graph.nodes.get(edge.to);
+    if (!fromNode || !toNode) continue;
+    const fromLayer = fromNode.layer;
+    const toLayer = toNode.layer;
+    const span = toLayer - fromLayer;
+    if (span <= 1) continue;
+    graph.removeEdge(edge.id);
+    let prevNodeId = edge.from;
+    let prevHandleId = edge.fromHandle;
+    for (let l = fromLayer + 1; l < toLayer; l++) {
+      const dummyId = `__dummy_${dummyCounter++}`;
+      graph.addNode({
+        id: dummyId,
+        width: 0,
+        height: 0,
+        handles: [
+          { id: "in", type: "input", position: "top", offset: 0.5 },
+          { id: "out", type: "output", position: "bottom", offset: 0.5 }
+        ],
+        isDummy: true,
+        layer: l,
+        order: -1,
+        x: 0,
+        y: 0
+      });
+      layers[l].push(dummyId);
+      graph.addEdge({
+        id: `__dedge_${dummyCounter}_${l}_in`,
+        from: prevNodeId,
+        to: dummyId,
+        fromHandle: prevHandleId,
+        toHandle: "in",
+        reversed: edge.reversed,
+        originalId: edge.originalId
+      });
+      prevNodeId = dummyId;
+      prevHandleId = "out";
+    }
+    graph.addEdge({
+      id: `__dedge_${dummyCounter}_final`,
+      from: prevNodeId,
+      to: edge.to,
+      fromHandle: prevHandleId,
+      toHandle: edge.toHandle,
+      reversed: edge.reversed,
+      originalId: edge.originalId
+    });
+  }
+  return layers;
+}
+
+// src/algorithms/crossing-minimization.ts
+function minimizeCrossings(graph, layers, iterations) {
+  if (layers.length <= 1) return layers;
+  const totalNodes = layers.reduce((s, l) => s + l.length, 0);
+  const effectiveIter = totalNodes > 500 ? Math.min(iterations, 6) : totalNodes > 200 ? Math.min(iterations, 12) : iterations;
+  const skipTranspose = totalNodes > 800;
+  for (let l = 0; l < layers.length; l++) {
+    for (let i = 0; i < layers[l].length; i++) {
+      const node = graph.nodes.get(layers[l][i]);
+      if (node) node.order = i;
+    }
+  }
+  let bestLayers = layers.map((l) => [...l]);
+  let bestCrossings = countAllCrossings(graph, layers);
+  let noImprovementCount = 0;
+  for (let iter = 0; iter < effectiveIter; iter++) {
+    for (let l = 1; l < layers.length; l++) {
+      orderByBarycenter(graph, layers, l, "up");
+    }
+    for (let l = layers.length - 2; l >= 0; l--) {
+      orderByBarycenter(graph, layers, l, "down");
+    }
+    if (!skipTranspose) {
+      for (let l = 0; l < layers.length; l++) {
+        if (layers[l].length <= 100) {
+          transposeImprove(graph, layers, l);
+        }
+      }
+    }
+    const crossings = countAllCrossings(graph, layers);
+    if (crossings < bestCrossings) {
+      bestCrossings = crossings;
+      bestLayers = layers.map((l) => [...l]);
+      noImprovementCount = 0;
+    } else {
+      noImprovementCount++;
+    }
+    if (crossings === 0 || noImprovementCount >= 3) break;
+  }
+  for (let l = 0; l < layers.length; l++) {
+    layers[l] = bestLayers[l];
+    for (let i = 0; i < layers[l].length; i++) {
+      const node = graph.nodes.get(layers[l][i]);
+      if (node) node.order = i;
+    }
+  }
+  return layers;
+}
+function orderByBarycenter(graph, layers, layerIndex, direction) {
+  const layer = layers[layerIndex];
+  const adjLayerIndex = direction === "up" ? layerIndex - 1 : layerIndex + 1;
+  if (adjLayerIndex < 0 || adjLayerIndex >= layers.length) return;
+  const adjLayerSet = new Set(layers[adjLayerIndex]);
+  const barycenters = /* @__PURE__ */ new Map();
+  for (let i = 0; i < layer.length; i++) {
+    const nodeId = layer[i];
+    let sum = 0;
+    let count = 0;
+    if (direction === "up") {
+      const inEdgeIds = graph.inEdges.get(nodeId);
+      if (inEdgeIds) {
+        for (const eid of inEdgeIds) {
+          const edge = graph.edges.get(eid);
+          if (edge && adjLayerSet.has(edge.from)) {
+            const neighbor = graph.nodes.get(edge.from);
+            if (neighbor) {
+              sum += neighbor.order;
+              count++;
+            }
+          }
+        }
+      }
+    } else {
+      const outEdgeIds = graph.outEdges.get(nodeId);
+      if (outEdgeIds) {
+        for (const eid of outEdgeIds) {
+          const edge = graph.edges.get(eid);
+          if (edge && adjLayerSet.has(edge.to)) {
+            const neighbor = graph.nodes.get(edge.to);
+            if (neighbor) {
+              sum += neighbor.order;
+              count++;
+            }
+          }
+        }
+      }
+    }
+    barycenters.set(nodeId, count > 0 ? sum / count : i);
+  }
+  layer.sort((a, b) => barycenters.get(a) - barycenters.get(b));
+  for (let i = 0; i < layer.length; i++) {
+    const node = graph.nodes.get(layer[i]);
+    if (node) node.order = i;
+  }
+}
+function transposeImprove(graph, layers, layerIndex) {
+  const layer = layers[layerIndex];
+  if (layer.length <= 1) return;
+  let improved = true;
+  let passes = 0;
+  while (improved && passes < 2) {
+    improved = false;
+    passes++;
+    for (let i = 0; i < layer.length - 1; i++) {
+      const nodeA = layer[i];
+      const nodeB = layer[i + 1];
+      const crossingsBefore = countPairCrossings(graph, layers, layerIndex, nodeA, nodeB);
+      layer[i] = nodeB;
+      layer[i + 1] = nodeA;
+      const nA = graph.nodes.get(nodeA);
+      const nB = graph.nodes.get(nodeB);
+      if (nA) nA.order = i + 1;
+      if (nB) nB.order = i;
+      const crossingsAfter = countPairCrossings(graph, layers, layerIndex, nodeB, nodeA);
+      if (crossingsAfter < crossingsBefore) {
+        improved = true;
+      } else {
+        layer[i] = nodeA;
+        layer[i + 1] = nodeB;
+        if (nA) nA.order = i;
+        if (nB) nB.order = i + 1;
+      }
+    }
+  }
+}
+function countPairCrossings(graph, layers, layerIndex, nodeA, nodeB) {
+  let crossings = 0;
+  if (layerIndex > 0) {
+    const upperLayer = new Set(layers[layerIndex - 1]);
+    const predsA = [];
+    const predsB = [];
+    const inA = graph.inEdges.get(nodeA);
+    if (inA) {
+      for (const eid of inA) {
+        const edge = graph.edges.get(eid);
+        if (edge && upperLayer.has(edge.from)) {
+          const n = graph.nodes.get(edge.from);
+          if (n) predsA.push(n.order);
+        }
+      }
+    }
+    const inB = graph.inEdges.get(nodeB);
+    if (inB) {
+      for (const eid of inB) {
+        const edge = graph.edges.get(eid);
+        if (edge && upperLayer.has(edge.from)) {
+          const n = graph.nodes.get(edge.from);
+          if (n) predsB.push(n.order);
+        }
+      }
+    }
+    for (const pA of predsA) {
+      for (const pB of predsB) {
+        if (pA > pB) crossings++;
+      }
+    }
+  }
+  if (layerIndex < layers.length - 1) {
+    const lowerLayer = new Set(layers[layerIndex + 1]);
+    const succsA = [];
+    const succsB = [];
+    const outA = graph.outEdges.get(nodeA);
+    if (outA) {
+      for (const eid of outA) {
+        const edge = graph.edges.get(eid);
+        if (edge && lowerLayer.has(edge.to)) {
+          const n = graph.nodes.get(edge.to);
+          if (n) succsA.push(n.order);
+        }
+      }
+    }
+    const outB = graph.outEdges.get(nodeB);
+    if (outB) {
+      for (const eid of outB) {
+        const edge = graph.edges.get(eid);
+        if (edge && lowerLayer.has(edge.to)) {
+          const n = graph.nodes.get(edge.to);
+          if (n) succsB.push(n.order);
+        }
+      }
+    }
+    for (const sA of succsA) {
+      for (const sB of succsB) {
+        if (sA > sB) crossings++;
+      }
+    }
+  }
+  return crossings;
+}
+function countAllCrossings(graph, layers) {
+  let total = 0;
+  for (let l = 0; l < layers.length - 1; l++) {
+    total += countLayerCrossings(graph, layers[l], layers[l + 1]);
+  }
+  return total;
+}
+function countLayerCrossings(graph, upperLayer, lowerLayer) {
+  const lowerPos = /* @__PURE__ */ new Map();
+  lowerLayer.forEach((id, pos) => lowerPos.set(id, pos));
+  const edgePairs = [];
+  for (let uPos = 0; uPos < upperLayer.length; uPos++) {
+    const nodeId = upperLayer[uPos];
+    const outEdgeIds = graph.outEdges.get(nodeId);
+    if (!outEdgeIds) continue;
+    for (const eid of outEdgeIds) {
+      const edge = graph.edges.get(eid);
+      if (!edge) continue;
+      const lp = lowerPos.get(edge.to);
+      if (lp !== void 0) {
+        edgePairs.push([uPos, lp]);
+      }
+    }
+  }
+  if (edgePairs.length <= 1) return 0;
+  edgePairs.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  const lowerPositions = edgePairs.map((e) => e[1]);
+  return mergeSortCount(lowerPositions);
+}
+function mergeSortCount(arr) {
+  if (arr.length <= 1) return 0;
+  const mid = arr.length >> 1;
+  const left = arr.slice(0, mid);
+  const right = arr.slice(mid);
+  let count = mergeSortCount(left) + mergeSortCount(right);
+  let i = 0, j = 0, k = 0;
+  while (i < left.length && j < right.length) {
+    if (left[i] <= right[j]) {
+      arr[k++] = left[i++];
+    } else {
+      count += left.length - i;
+      arr[k++] = right[j++];
+    }
+  }
+  while (i < left.length) arr[k++] = left[i++];
+  while (j < right.length) arr[k++] = right[j++];
+  return count;
+}
+
+// src/algorithms/coordinate-assignment.ts
+function assignCoordinates(graph, layers, options) {
+  const isHorizontal = options.direction === "LR" || options.direction === "RL";
+  const isReversed = options.direction === "BT" || options.direction === "RL";
+  assignRankPositions(graph, layers, options, isHorizontal, isReversed);
+  assignOrderPositions(graph, layers, options, isHorizontal);
+  optimizePositions(graph, layers, options, isHorizontal);
+}
+function assignRankPositions(graph, layers, options, isHorizontal, isReversed) {
+  const layerSizes = [];
+  for (const layer of layers) {
+    let maxSize = 0;
+    for (const nodeId of layer) {
+      const node = graph.nodes.get(nodeId);
+      const size = isHorizontal ? node.width : node.height;
+      maxSize = Math.max(maxSize, size);
+    }
+    layerSizes.push(maxSize);
+  }
+  const layerPositions = [];
+  let pos = 0;
+  for (let l = 0; l < layers.length; l++) {
+    layerPositions.push(pos);
+    pos += layerSizes[l] + options.layerSpacing;
+  }
+  if (isReversed) {
+    const totalSize = pos - options.layerSpacing;
+    for (let l = 0; l < layerPositions.length; l++) {
+      layerPositions[l] = totalSize - layerPositions[l] - layerSizes[l];
+    }
+  }
+  for (let l = 0; l < layers.length; l++) {
+    for (const nodeId of layers[l]) {
+      const node = graph.nodes.get(nodeId);
+      const nodeSize = isHorizontal ? node.width : node.height;
+      const offset = (layerSizes[l] - nodeSize) / 2;
+      if (isHorizontal) {
+        node.x = layerPositions[l] + offset;
+      } else {
+        node.y = layerPositions[l] + offset;
+      }
+    }
+  }
+}
+function assignOrderPositions(graph, layers, options, isHorizontal) {
+  for (const layer of layers) {
+    let pos = 0;
+    for (const nodeId of layer) {
+      const node = graph.nodes.get(nodeId);
+      const size = isHorizontal ? node.height : node.width;
+      if (isHorizontal) {
+        node.y = pos;
+      } else {
+        node.x = pos;
+      }
+      pos += size + options.nodeSpacing;
+    }
+    const totalSize = pos - options.nodeSpacing;
+    const centerOffset = -totalSize / 2;
+    for (const nodeId of layer) {
+      const node = graph.nodes.get(nodeId);
+      if (isHorizontal) {
+        node.y += centerOffset;
+      } else {
+        node.x += centerOffset;
+      }
+    }
+  }
+}
+function optimizePositions(graph, layers, options, isHorizontal) {
+  for (let iter = 0; iter < options.coordinateOptimizationIterations; iter++) {
+    for (let l = 0; l < layers.length; l++) {
+      optimizeLayer(graph, layers[l], options, isHorizontal);
+    }
+    for (let l = layers.length - 1; l >= 0; l--) {
+      optimizeLayer(graph, layers[l], options, isHorizontal);
+    }
+  }
+  centerAllLayers(graph, layers, isHorizontal);
+}
+function optimizeLayer(graph, layer, options, isHorizontal) {
+  if (layer.length === 0) return;
+  const desired = /* @__PURE__ */ new Map();
+  for (const nodeId of layer) {
+    const node = graph.nodes.get(nodeId);
+    const connected = [...graph.predecessors(nodeId), ...graph.successors(nodeId)];
+    if (connected.length === 0) {
+      desired.set(nodeId, getOrderPos(node, isHorizontal));
+      continue;
+    }
+    const positions = connected.map((cId) => {
+      const c = graph.nodes.get(cId);
+      return getOrderPos(c, isHorizontal) + getOrderSize(c, isHorizontal) / 2;
+    }).sort((a, b) => a - b);
+    const nodeSize = getOrderSize(node, isHorizontal);
+    const median = positions.length % 2 === 0 ? (positions[positions.length / 2 - 1] + positions[positions.length / 2]) / 2 : positions[Math.floor(positions.length / 2)];
+    desired.set(nodeId, median - nodeSize / 2);
+  }
+  for (let i = 0; i < layer.length; i++) {
+    const nodeId = layer[i];
+    const node = graph.nodes.get(nodeId);
+    let desiredPos = desired.get(nodeId);
+    if (i > 0) {
+      const prevId = layer[i - 1];
+      const prev = graph.nodes.get(prevId);
+      const prevEnd = getOrderPos(prev, isHorizontal) + getOrderSize(prev, isHorizontal);
+      desiredPos = Math.max(desiredPos, prevEnd + options.nodeSpacing);
+    }
+    setOrderPos(node, isHorizontal, desiredPos);
+  }
+  for (let i = layer.length - 2; i >= 0; i--) {
+    const nodeId = layer[i];
+    const node = graph.nodes.get(nodeId);
+    const nextId = layer[i + 1];
+    const next = graph.nodes.get(nextId);
+    const nodeEnd = getOrderPos(node, isHorizontal) + getOrderSize(node, isHorizontal);
+    const nextStart = getOrderPos(next, isHorizontal);
+    if (nodeEnd + options.nodeSpacing > nextStart) {
+      setOrderPos(node, isHorizontal, nextStart - options.nodeSpacing - getOrderSize(node, isHorizontal));
+    }
+  }
+}
+function centerAllLayers(graph, layers, isHorizontal) {
+  if (layers.length === 0) return;
+  let globalMin = Infinity;
+  let globalMax = -Infinity;
+  for (const layer of layers) {
+    for (const nodeId of layer) {
+      const node = graph.nodes.get(nodeId);
+      const pos = getOrderPos(node, isHorizontal);
+      const size = getOrderSize(node, isHorizontal);
+      globalMin = Math.min(globalMin, pos);
+      globalMax = Math.max(globalMax, pos + size);
+    }
+  }
+  const offset = -globalMin;
+  for (const layer of layers) {
+    for (const nodeId of layer) {
+      const node = graph.nodes.get(nodeId);
+      setOrderPos(node, isHorizontal, getOrderPos(node, isHorizontal) + offset);
+    }
+  }
+  let rankMin = Infinity;
+  for (const layer of layers) {
+    for (const nodeId of layer) {
+      const node = graph.nodes.get(nodeId);
+      const pos = isHorizontal ? node.x : node.y;
+      rankMin = Math.min(rankMin, pos);
+    }
+  }
+  if (rankMin !== 0) {
+    for (const layer of layers) {
+      for (const nodeId of layer) {
+        const node = graph.nodes.get(nodeId);
+        if (isHorizontal) {
+          node.x -= rankMin;
+        } else {
+          node.y -= rankMin;
+        }
+      }
+    }
+  }
+}
+function getOrderPos(node, isHorizontal) {
+  return isHorizontal ? node.y : node.x;
+}
+function setOrderPos(node, isHorizontal, value) {
+  if (isHorizontal) {
+    node.y = value;
+  } else {
+    node.x = value;
+  }
+}
+function getOrderSize(node, isHorizontal) {
+  return isHorizontal ? node.height : node.width;
+}
+
+// src/algorithms/edge-routing.ts
+function routeEdges(graph, direction, edgeMargin) {
+  const chains = collectEdgeChains(graph);
+  const routes = [];
+  for (const chain of chains) {
+    routes.push(routeChain(graph, chain, direction, edgeMargin));
+  }
+  return routes;
+}
+function collectEdgeChains(graph) {
+  const chains = [];
+  const visited = /* @__PURE__ */ new Set();
+  for (const [edgeId, edge] of graph.edges) {
+    if (visited.has(edgeId)) continue;
+    const fromNode = graph.nodes.get(edge.from);
+    if (!fromNode || fromNode.isDummy) continue;
+    const dummyNodes = [];
+    let currentEdge = edge;
+    visited.add(edgeId);
+    while (true) {
+      const toNode = graph.nodes.get(currentEdge.to);
+      if (!toNode || !toNode.isDummy) break;
+      dummyNodes.push(currentEdge.to);
+      const outEdgeIds = graph.outEdges.get(currentEdge.to);
+      if (!outEdgeIds || outEdgeIds.size === 0) break;
+      let nextEdge = null;
+      for (const eid of outEdgeIds) {
+        const e = graph.edges.get(eid);
+        if (e && e.originalId === edge.originalId) {
+          nextEdge = e;
+          visited.add(eid);
+          break;
+        }
+      }
+      if (!nextEdge) {
+        const eid = outEdgeIds.values().next().value;
+        if (!eid) break;
+        nextEdge = graph.edges.get(eid);
+        if (!nextEdge) break;
+        visited.add(eid);
+      }
+      currentEdge = nextEdge;
+    }
+    chains.push({
+      originalId: edge.originalId,
+      from: edge.from,
+      to: currentEdge.to,
+      fromHandle: edge.fromHandle,
+      toHandle: currentEdge.toHandle,
+      dummyNodes,
+      reversed: edge.reversed
+    });
+  }
+  return chains;
+}
+function routeChain(graph, chain, direction, margin) {
+  const fromNode = graph.nodes.get(chain.from);
+  const toNode = graph.nodes.get(chain.to);
+  const actualFrom = chain.reversed ? chain.to : chain.from;
+  const actualTo = chain.reversed ? chain.from : chain.to;
+  const actualFromHandle = chain.reversed ? chain.toHandle : chain.fromHandle;
+  const actualToHandle = chain.reversed ? chain.fromHandle : chain.toHandle;
+  const sourceNode = chain.reversed ? toNode : fromNode;
+  const targetNode = chain.reversed ? fromNode : toNode;
+  const sourcePos = getHandlePosition(sourceNode, actualFromHandle);
+  const targetPos = getHandlePosition(targetNode, actualToHandle);
+  const sourceHandle = sourceNode.handles.find((h) => h.id === actualFromHandle);
+  const targetHandle = targetNode.handles.find((h) => h.id === actualToHandle);
+  const sourceSide = sourceHandle?.position || getDefaultSourceSide(direction);
+  const targetSide = targetHandle?.position || getDefaultTargetSide(direction);
+  const rawPoints = [];
+  rawPoints.push(sourcePos);
+  const exitDir = getHandleDirection(sourceSide);
+  rawPoints.push({
+    x: sourcePos.x + exitDir.x * margin,
+    y: sourcePos.y + exitDir.y * margin
+  });
+  const dummies = chain.reversed ? [...chain.dummyNodes].reverse() : chain.dummyNodes;
+  for (const dummyId of dummies) {
+    const dummy = graph.nodes.get(dummyId);
+    rawPoints.push({ x: dummy.x, y: dummy.y });
+  }
+  const entryDir = getHandleDirection(targetSide);
+  rawPoints.push({
+    x: targetPos.x + entryDir.x * margin,
+    y: targetPos.y + entryDir.y * margin
+  });
+  rawPoints.push(targetPos);
+  const points = makeOrthogonal(rawPoints, direction);
+  return {
+    id: chain.originalId,
+    from: actualFrom,
+    to: actualTo,
+    fromHandle: actualFromHandle,
+    toHandle: actualToHandle,
+    points
+  };
+}
+function makeOrthogonal(points, direction) {
+  if (points.length < 2) return points;
+  const result = [points[0]];
+  const isVerticalFlow = direction === "TB" || direction === "BT";
+  for (let i = 1; i < points.length; i++) {
+    const prev = result[result.length - 1];
+    const curr = points[i];
+    const dx = Math.abs(prev.x - curr.x);
+    const dy = Math.abs(prev.y - curr.y);
+    if (dx < 0.01 || dy < 0.01) {
+      result.push(curr);
+      continue;
+    }
+    if (isVerticalFlow) {
+      const midY = (prev.y + curr.y) / 2;
+      result.push({ x: prev.x, y: midY });
+      result.push({ x: curr.x, y: midY });
+    } else {
+      const midX = (prev.x + curr.x) / 2;
+      result.push({ x: midX, y: prev.y });
+      result.push({ x: midX, y: curr.y });
+    }
+    result.push(curr);
+  }
+  return cleanupPoints(result);
+}
+function cleanupPoints(points) {
+  if (points.length <= 2) return points;
+  const result = [points[0]];
+  for (let i = 1; i < points.length - 1; i++) {
+    const prev = result[result.length - 1];
+    const curr = points[i];
+    const next = points[i + 1];
+    const sameX = Math.abs(prev.x - curr.x) < 0.01 && Math.abs(curr.x - next.x) < 0.01;
+    const sameY = Math.abs(prev.y - curr.y) < 0.01 && Math.abs(curr.y - next.y) < 0.01;
+    if (!sameX && !sameY) {
+      result.push(curr);
+    } else if (sameX || sameY) {
+      continue;
+    } else {
+      result.push(curr);
+    }
+  }
+  result.push(points[points.length - 1]);
+  return result;
+}
+function getDefaultSourceSide(direction) {
+  switch (direction) {
+    case "TB":
+      return "bottom";
+    case "BT":
+      return "top";
+    case "LR":
+      return "right";
+    case "RL":
+      return "left";
+  }
+}
+function getDefaultTargetSide(direction) {
+  switch (direction) {
+    case "TB":
+      return "top";
+    case "BT":
+      return "bottom";
+    case "LR":
+      return "left";
+    case "RL":
+      return "right";
+  }
+}
+
+// src/layout.ts
+function layout(input, options) {
+  const resolved = resolveOptions(options);
+  const graph = buildGraph(input.nodes, input.edges);
+  return computeLayout(graph, resolved);
+}
+function computeLayout(graph, options) {
+  if (graph.nodes.size === 0) {
+    return { nodes: [], edges: [] };
+  }
+  breakCycles(graph);
+  let layers = assignLayers(graph);
+  layers = insertDummyNodes(graph, layers);
+  layers = minimizeCrossings(graph, layers, options.crossingMinimizationIterations);
+  assignCoordinates(graph, layers, options);
+  const routedEdges = routeEdges(graph, options.direction, options.edgeMargin);
+  return buildResult(graph, routedEdges);
+}
+function buildResult(graph, routedEdges) {
+  const nodes = [];
+  const edges = [];
+  for (const [, node] of graph.nodes) {
+    if (node.isDummy) continue;
+    const handles = node.handles.map((h) => {
+      const pos = getHandlePosition(node, h.id);
+      return {
+        id: h.id,
+        type: h.type,
+        position: h.position,
+        x: pos.x,
+        y: pos.y
+      };
+    });
+    nodes.push({
+      id: node.id,
+      x: node.x,
+      y: node.y,
+      width: node.width,
+      height: node.height,
+      handles
+    });
+  }
+  for (const route of routedEdges) {
+    edges.push({
+      id: route.id,
+      from: route.from,
+      to: route.to,
+      fromHandle: route.fromHandle,
+      toHandle: route.toHandle,
+      points: route.points
+    });
+  }
+  return { nodes, edges };
+}
+
+// src/incremental.ts
+var IncrementalLayout = class {
+  constructor(options) {
+    this.inputNodes = /* @__PURE__ */ new Map();
+    this.inputEdges = /* @__PURE__ */ new Map();
+    this.lastResult = null;
+    this.nodePositions = /* @__PURE__ */ new Map();
+    this.options = resolveOptions(options);
+  }
+  /**
+   * Set the full graph and compute a complete layout.
+   */
+  setGraph(input) {
+    this.inputNodes.clear();
+    this.inputEdges.clear();
+    for (const node of input.nodes) {
+      this.inputNodes.set(node.id, node);
+    }
+    for (const edge of input.edges) {
+      this.inputEdges.set(edge.id, edge);
+    }
+    return this.recompute();
+  }
+  /**
+   * Add nodes and edges incrementally.
+   * Attempts to minimize layout changes for existing nodes.
+   */
+  addNodes(nodes, edges) {
+    for (const node of nodes) {
+      this.inputNodes.set(node.id, node);
+    }
+    if (edges) {
+      for (const edge of edges) {
+        this.inputEdges.set(edge.id, edge);
+      }
+    }
+    return this.recomputeIncremental(
+      new Set(nodes.map((n) => n.id)),
+      new Set(edges?.map((e) => e.id) || [])
+    );
+  }
+  /**
+   * Remove nodes (and their connected edges) from the layout.
+   */
+  removeNodes(nodeIds) {
+    const removedSet = new Set(nodeIds);
+    for (const id of nodeIds) {
+      this.inputNodes.delete(id);
+    }
+    for (const [edgeId, edge] of this.inputEdges) {
+      if (removedSet.has(edge.from) || removedSet.has(edge.to)) {
+        this.inputEdges.delete(edgeId);
+      }
+    }
+    for (const id of nodeIds) {
+      this.nodePositions.delete(id);
+    }
+    return this.recompute();
+  }
+  /**
+   * Add edges between existing nodes.
+   */
+  addEdges(edges) {
+    for (const edge of edges) {
+      this.inputEdges.set(edge.id, edge);
+    }
+    return this.recomputeIncremental(
+      /* @__PURE__ */ new Set(),
+      new Set(edges.map((e) => e.id))
+    );
+  }
+  /**
+   * Remove edges from the layout.
+   */
+  removeEdges(edgeIds) {
+    for (const id of edgeIds) {
+      this.inputEdges.delete(id);
+    }
+    return this.recompute();
+  }
+  /**
+   * Get the current layout result.
+   */
+  getResult() {
+    return this.lastResult;
+  }
+  recompute() {
+    const input = {
+      nodes: [...this.inputNodes.values()],
+      edges: [...this.inputEdges.values()]
+    };
+    const graph = buildGraph(input.nodes, input.edges);
+    this.lastResult = computeLayout(graph, this.options);
+    this.cachePositions();
+    return this.lastResult;
+  }
+  recomputeIncremental(newNodeIds, newEdgeIds) {
+    const input = {
+      nodes: [...this.inputNodes.values()],
+      edges: [...this.inputEdges.values()]
+    };
+    const graph = buildGraph(input.nodes, input.edges);
+    breakCycles(graph);
+    let layers = assignLayers(graph);
+    layers = insertDummyNodes(graph, layers);
+    layers = minimizeCrossings(graph, layers, this.options.crossingMinimizationIterations);
+    assignCoordinates(graph, layers, this.options);
+    this.applyStability(graph, newNodeIds);
+    const routedEdges = routeEdges(graph, this.options.direction, this.options.edgeMargin);
+    this.lastResult = this.buildResult(graph, routedEdges);
+    this.cachePositions();
+    return this.lastResult;
+  }
+  /**
+   * Apply stability: blend new positions with old positions for existing nodes.
+   * This reduces visual disruption when adding new nodes.
+   */
+  applyStability(graph, newNodeIds) {
+    if (this.nodePositions.size === 0) return;
+    const STABILITY_WEIGHT = 0.3;
+    for (const [nodeId, node] of graph.nodes) {
+      if (node.isDummy || newNodeIds.has(nodeId)) continue;
+      const oldPos = this.nodePositions.get(nodeId);
+      if (!oldPos) continue;
+      node.x = node.x * (1 - STABILITY_WEIGHT) + oldPos.x * STABILITY_WEIGHT;
+      node.y = node.y * (1 - STABILITY_WEIGHT) + oldPos.y * STABILITY_WEIGHT;
+    }
+  }
+  cachePositions() {
+    if (!this.lastResult) return;
+    this.nodePositions.clear();
+    for (const node of this.lastResult.nodes) {
+      this.nodePositions.set(node.id, { x: node.x, y: node.y });
+    }
+  }
+  buildResult(graph, routedEdges) {
+    const nodes = [];
+    const edges = [];
+    for (const [, node] of graph.nodes) {
+      if (node.isDummy) continue;
+      const handles = node.handles.map((h) => {
+        const pos = getHandlePosition(node, h.id);
+        return {
+          id: h.id,
+          type: h.type,
+          position: h.position,
+          x: pos.x,
+          y: pos.y
+        };
+      });
+      nodes.push({
+        id: node.id,
+        x: node.x,
+        y: node.y,
+        width: node.width,
+        height: node.height,
+        handles
+      });
+    }
+    for (const route of routedEdges) {
+      edges.push({
+        id: route.id,
+        from: route.from,
+        to: route.to,
+        fromHandle: route.fromHandle,
+        toHandle: route.toHandle,
+        points: route.points
+      });
+    }
+    return { nodes, edges };
+  }
+};
+export {
+  IncrementalLayout,
+  countAllCrossings,
+  layout
+};
+//# sourceMappingURL=index.mjs.map