@nodius/layouting 0.1.1 → 0.1.4

package/dist/index.mjs

@@ -1,11 +1,32 @@
 // src/types.ts
+var QUALITY_PROFILES = {
+  draft: {
+    crossingMinimizationIterations: 6,
+    coordinateOptimizationIterations: 2,
+    skipTranspose: true
+  },
+  balanced: {
+    crossingMinimizationIterations: 24,
+    coordinateOptimizationIterations: 8,
+    skipTranspose: false
+  },
+  high: {
+    crossingMinimizationIterations: 48,
+    coordinateOptimizationIterations: 16,
+    skipTranspose: false
+  }
+};
 function resolveOptions(options) {
+  const quality = options?.quality ?? "balanced";
+  const profile = QUALITY_PROFILES[quality];
   return {
     direction: options?.direction ?? "TB",
+    quality,
     nodeSpacing: options?.nodeSpacing ?? 40,
     layerSpacing: options?.layerSpacing ?? 60,
-    crossingMinimizationIterations: options?.crossingMinimizationIterations ?? 24,
-    coordinateOptimizationIterations: options?.coordinateOptimizationIterations ?? 8,
+    crossingMinimizationIterations: options?.crossingMinimizationIterations ?? profile.crossingMinimizationIterations,
+    coordinateOptimizationIterations: options?.coordinateOptimizationIterations ?? profile.coordinateOptimizationIterations,
+    skipTranspose: options?.skipTranspose ?? profile.skipTranspose,
     edgeMargin: options?.edgeMargin ?? 20,
     controlWeight: options?.edgeWeights?.control ?? 1,
     dataWeight: options?.edgeWeights?.data ?? 0.25,
@@ -370,11 +391,11 @@ function insertDummyNodes(graph, layers) {
 }
 
 // src/algorithms/crossing-minimization.ts
-function minimizeCrossings(graph, layers, iterations) {
+function minimizeCrossings(graph, layers, iterations, forceSkipTranspose = false) {
   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;
+  const skipTranspose = forceSkipTranspose || 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]);
@@ -421,45 +442,54 @@ 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 n = layer.length;
+  const bary = new Float64Array(n);
+  if (direction === "up") {
+    for (let i = 0; i < n; i++) {
+      const nodeId = layer[i];
+      let sum = 0;
+      let count = 0;
       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++;
-            }
+          if (!edge) continue;
+          const neighbor = graph.nodes.get(edge.from);
+          if (neighbor && neighbor.layer === adjLayerIndex) {
+            sum += neighbor.order;
+            count++;
           }
         }
       }
-    } else {
+      bary[i] = count > 0 ? sum / count : i;
+    }
+  } else {
+    for (let i = 0; i < n; i++) {
+      const nodeId = layer[i];
+      let sum = 0;
+      let count = 0;
       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++;
-            }
+          if (!edge) continue;
+          const neighbor = graph.nodes.get(edge.to);
+          if (neighbor && neighbor.layer === adjLayerIndex) {
+            sum += neighbor.order;
+            count++;
           }
         }
       }
+      bary[i] = count > 0 ? sum / count : i;
     }
-    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 indices = new Array(n);
+  for (let i = 0; i < n; i++) indices[i] = i;
+  indices.sort((a, b) => bary[a] - bary[b]);
+  const reordered = new Array(n);
+  for (let i = 0; i < n; i++) reordered[i] = layer[indices[i]];
+  for (let i = 0; i < n; i++) {
+    layer[i] = reordered[i];
     const node = graph.nodes.get(layer[i]);
     if (node) node.order = i;
   }
@@ -494,65 +524,65 @@ function transposeImprove(graph, layers, layerIndex) {
     }
   }
 }
+var _scratchA = [];
+var _scratchB = [];
 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 upperIdx = layerIndex - 1;
+    _scratchA.length = 0;
+    _scratchB.length = 0;
     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);
-        }
+        if (!edge) continue;
+        const n = graph.nodes.get(edge.from);
+        if (n && n.layer === upperIdx) _scratchA.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);
-        }
+        if (!edge) continue;
+        const n = graph.nodes.get(edge.from);
+        if (n && n.layer === upperIdx) _scratchB.push(n.order);
       }
     }
-    for (const pA of predsA) {
-      for (const pB of predsB) {
-        if (pA > pB) crossings++;
+    for (let i = 0; i < _scratchA.length; i++) {
+      const pA = _scratchA[i];
+      for (let j = 0; j < _scratchB.length; j++) {
+        if (pA > _scratchB[j]) crossings++;
       }
     }
   }
   if (layerIndex < layers.length - 1) {
-    const lowerLayer = new Set(layers[layerIndex + 1]);
-    const succsA = [];
-    const succsB = [];
+    const lowerIdx = layerIndex + 1;
+    _scratchA.length = 0;
+    _scratchB.length = 0;
     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);
-        }
+        if (!edge) continue;
+        const n = graph.nodes.get(edge.to);
+        if (n && n.layer === lowerIdx) _scratchA.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);
-        }
+        if (!edge) continue;
+        const n = graph.nodes.get(edge.to);
+        if (n && n.layer === lowerIdx) _scratchB.push(n.order);
       }
     }
-    for (const sA of succsA) {
-      for (const sB of succsB) {
-        if (sA > sB) crossings++;
+    for (let i = 0; i < _scratchA.length; i++) {
+      const sA = _scratchA[i];
+      for (let j = 0; j < _scratchB.length; j++) {
+        if (sA > _scratchB[j]) crossings++;
       }
     }
   }
@@ -588,22 +618,36 @@ function countLayerCrossings(graph, upperLayer, lowerLayer) {
   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++];
+  const n = arr.length;
+  if (n <= 1) return 0;
+  let buf = new Array(n);
+  let src = arr;
+  let dst = buf;
+  let count = 0;
+  for (let width = 1; width < n; width <<= 1) {
+    for (let i = 0; i < n; i += width << 1) {
+      const left = i;
+      const mid = Math.min(i + width, n);
+      const right = Math.min(i + (width << 1), n);
+      let a = left, b = mid, k = left;
+      while (a < mid && b < right) {
+        if (src[a] <= src[b]) {
+          dst[k++] = src[a++];
+        } else {
+          count += mid - a;
+          dst[k++] = src[b++];
+        }
+      }
+      while (a < mid) dst[k++] = src[a++];
+      while (b < right) dst[k++] = src[b++];
     }
+    const tmp = src;
+    src = dst;
+    dst = tmp;
+  }
+  if (src !== arr) {
+    for (let i = 0; i < n; i++) arr[i] = src[i];
   }
-  while (i < left.length) arr[k++] = left[i++];
-  while (j < right.length) arr[k++] = right[j++];
   return count;
 }
 
@@ -687,37 +731,69 @@ function optimizePositions(graph, layers, options, isHorizontal) {
   }
   centerAllLayers(graph, layers, isHorizontal);
 }
+var _neighborBuf = new Float64Array(64);
+var _desiredBuf = new Float64Array(64);
+function ensureBufSize(size) {
+  if (_neighborBuf.length < size) _neighborBuf = new Float64Array(size * 2);
+  if (_desiredBuf.length < size) _desiredBuf = new Float64Array(size * 2);
+}
 function optimizeLayer(graph, layer, options, isHorizontal) {
-  if (layer.length === 0) return;
-  const desired = /* @__PURE__ */ new Map();
-  for (const nodeId of layer) {
+  const n = layer.length;
+  if (n === 0) return;
+  let maxDegree = 0;
+  for (let i = 0; i < n; i++) {
+    const id = layer[i];
+    const d = (graph.inEdges.get(id)?.size ?? 0) + (graph.outEdges.get(id)?.size ?? 0);
+    if (d > maxDegree) maxDegree = d;
+  }
+  ensureBufSize(Math.max(n, maxDegree));
+  const desired = _desiredBuf;
+  for (let i = 0; i < n; i++) {
+    const nodeId = layer[i];
     const node = graph.nodes.get(nodeId);
-    const connected = [...graph.predecessors(nodeId), ...graph.successors(nodeId)];
-    if (connected.length === 0) {
-      desired.set(nodeId, getOrderPos(node, isHorizontal));
+    let nbCount = 0;
+    const inEdgeIds = graph.inEdges.get(nodeId);
+    if (inEdgeIds) {
+      for (const eid of inEdgeIds) {
+        const edge = graph.edges.get(eid);
+        if (!edge) continue;
+        const c = graph.nodes.get(edge.from);
+        if (!c) continue;
+        _neighborBuf[nbCount++] = getOrderPos(c, isHorizontal) + getOrderSize(c, isHorizontal) / 2;
+      }
+    }
+    const outEdgeIds = graph.outEdges.get(nodeId);
+    if (outEdgeIds) {
+      for (const eid of outEdgeIds) {
+        const edge = graph.edges.get(eid);
+        if (!edge) continue;
+        const c = graph.nodes.get(edge.to);
+        if (!c) continue;
+        _neighborBuf[nbCount++] = getOrderPos(c, isHorizontal) + getOrderSize(c, isHorizontal) / 2;
+      }
+    }
+    if (nbCount === 0) {
+      desired[i] = 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);
+    sortPrefix(_neighborBuf, nbCount);
     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);
+    const median = (nbCount & 1) === 0 ? (_neighborBuf[(nbCount >> 1) - 1] + _neighborBuf[nbCount >> 1]) / 2 : _neighborBuf[nbCount >> 1];
+    desired[i] = median - nodeSize / 2;
   }
-  for (let i = 0; i < layer.length; i++) {
+  for (let i = 0; i < n; i++) {
     const nodeId = layer[i];
     const node = graph.nodes.get(nodeId);
-    let desiredPos = desired.get(nodeId);
+    let desiredPos = desired[i];
     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);
+      if (desiredPos < prevEnd + options.nodeSpacing) desiredPos = prevEnd + options.nodeSpacing;
     }
     setOrderPos(node, isHorizontal, desiredPos);
   }
-  for (let i = layer.length - 2; i >= 0; i--) {
+  for (let i = n - 2; i >= 0; i--) {
     const nodeId = layer[i];
     const node = graph.nodes.get(nodeId);
     const nextId = layer[i + 1];
@@ -729,6 +805,17 @@ function optimizeLayer(graph, layer, options, isHorizontal) {
     }
   }
 }
+function sortPrefix(arr, count) {
+  for (let i = 1; i < count; i++) {
+    const x = arr[i];
+    let j = i - 1;
+    while (j >= 0 && arr[j] > x) {
+      arr[j + 1] = arr[j];
+      j--;
+    }
+    arr[j + 1] = x;
+  }
+}
 function centerAllLayers(graph, layers, isHorizontal) {
   if (layers.length === 0) return;
   let globalMin = Infinity;
@@ -1381,6 +1468,156 @@ function score(handles, expected) {
   }
   return { matched, total, matchRatio: total === 0 ? 1 : matched / total };
 }
+function applyRelocateProposals(input, preview, options) {
+  if (!options.onProposal) return input;
+  const previewIndex = new Map(preview.nodes.map((n) => [n.id, n]));
+  const inputIndex = new Map(input.nodes.map((n) => [n.id, n]));
+  const newNodes = input.nodes.map((node) => {
+    const proposal = computeRelocateProposal(node, input.edges, inputIndex, previewIndex, options.direction);
+    if (!proposal) return node;
+    const accepted = options.onProposal(proposal);
+    return accepted ?? node;
+  });
+  return { nodes: newNodes, edges: input.edges };
+}
+function computeRelocateProposal(node, edges, inputIndex, previewIndex, direction) {
+  const selfPreview = previewIndex.get(node.id);
+  if (!selfPreview) return null;
+  if (node.handles.length === 0) return null;
+  const isHorizontal = direction === "LR" || direction === "RL";
+  const rankMin = isHorizontal ? selfPreview.x : selfPreview.y;
+  const rankMax = isHorizontal ? selfPreview.x + selfPreview.width : selfPreview.y + selfPreview.height;
+  const orderMin = isHorizontal ? selfPreview.y : selfPreview.x;
+  const orderMax = isHorizontal ? selfPreview.y + selfPreview.height : selfPreview.x + selfPreview.width;
+  const orderCenter = (orderMin + orderMax) / 2;
+  const usedHandleIds = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    if (e.from === node.id) usedHandleIds.add(e.fromHandle);
+    if (e.to === node.id) usedHandleIds.add(e.toHandle);
+  }
+  if (usedHandleIds.size === 0) return null;
+  const votesByHandle = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    const isFrom = e.from === node.id;
+    const isTo = e.to === node.id;
+    if (!isFrom && !isTo) continue;
+    const handleId = isFrom ? e.fromHandle : e.toHandle;
+    const neighborId = isFrom ? e.to : e.from;
+    const np = previewIndex.get(neighborId);
+    if (!np) continue;
+    const nbrRankMin = isHorizontal ? np.x : np.y;
+    const nbrRankMax = isHorizontal ? np.x + np.width : np.y + np.height;
+    const overlap = Math.min(rankMax, nbrRankMax) - Math.max(rankMin, nbrRankMin);
+    const isFlow = overlap <= 0;
+    const nbrOrderC = isHorizontal ? np.y + np.height / 2 : np.x + np.width / 2;
+    const nbrRankC = isHorizontal ? np.x + np.width / 2 : np.y + np.height / 2;
+    const selfRankC = isHorizontal ? selfPreview.x + selfPreview.width / 2 : selfPreview.y + selfPreview.height / 2;
+    const nbrIsBefore = nbrRankMax <= rankMin || overlap <= 0 && nbrRankC < selfRankC;
+    const flowSide = isHorizontal ? nbrIsBefore ? "left" : "right" : nbrIsBefore ? "top" : "bottom";
+    const d = nbrOrderC - orderCenter;
+    const perpSide = isHorizontal ? d >= 0 ? "bottom" : "top" : d >= 0 ? "right" : "left";
+    const beyond = nbrOrderC > orderMax ? 1 : nbrOrderC < orderMin ? -1 : 0;
+    const dist = Math.hypot(nbrRankC - selfRankC, nbrOrderC - orderCenter);
+    const weight = dist > 0 ? 1 / dist : 1;
+    const arr = votesByHandle.get(handleId) ?? [];
+    arr.push({ weight, isFlow, flowSide, perpSide, orderCoord: nbrOrderC, rankCoord: nbrRankC, beyond });
+    votesByHandle.set(handleId, arr);
+  }
+  const resolved = /* @__PURE__ */ new Map();
+  for (const [handleId, votes] of votesByHandle) {
+    if (votes.length === 0) continue;
+    const tallies = { top: 0, right: 0, bottom: 0, left: 0 };
+    let dom = votes[0];
+    for (const v of votes) {
+      tallies[v.isFlow ? v.flowSide : v.perpSide] += v.weight;
+      if (v.weight > dom.weight) dom = v;
+    }
+    const side = Object.entries(tallies).reduce((acc, cur) => cur[1] > acc[1] ? cur : acc, ["top", -Infinity])[0];
+    resolved.set(handleId, {
+      side,
+      isFlow: dom.isFlow,
+      flowSide: dom.flowSide,
+      perpSide: dom.perpSide,
+      orderCoord: dom.orderCoord,
+      rankCoord: dom.rankCoord,
+      beyond: dom.beyond
+    });
+  }
+  for (const flowSide of ["top", "bottom", "left", "right"]) {
+    const group = [...resolved.entries()].filter(([, r]) => r.isFlow && r.side === flowSide);
+    if (group.length < 2) continue;
+    let hasLeft = false, hasRight = false;
+    for (const [, r] of group) {
+      if (r.orderCoord < orderCenter) hasLeft = true;
+      else if (r.orderCoord > orderCenter) hasRight = true;
+    }
+    if (hasLeft && hasRight) continue;
+    const distOf = (oc) => oc > orderMax ? oc - orderMax : orderMin - oc;
+    const distinctCoords = [...new Set(group.filter(([, r]) => r.beyond !== 0).map(([, r]) => r.orderCoord))].sort((a, b) => distOf(a) - distOf(b));
+    if (distinctCoords.length >= 2) {
+      const keep = distinctCoords[0];
+      for (const [, r] of group) {
+        if (r.beyond !== 0 && r.orderCoord !== keep) r.side = r.perpSide;
+      }
+    }
+  }
+  const sideChanges = {};
+  const newSideById = /* @__PURE__ */ new Map();
+  for (const h of node.handles) {
+    const r = resolved.get(h.id);
+    if (!r) continue;
+    newSideById.set(h.id, r.side);
+    if (r.side !== h.position) sideChanges[h.id] = { from: h.position, to: r.side };
+  }
+  const newOffsetById = /* @__PURE__ */ new Map();
+  const bySide = /* @__PURE__ */ new Map();
+  for (const [hid, r] of resolved) {
+    const arr = bySide.get(r.side) ?? [];
+    arr.push(hid);
+    bySide.set(r.side, arr);
+  }
+  for (const [side, handleIds] of bySide) {
+    if (handleIds.length < 2) continue;
+    const offsets = handleIds.map((hid) => node.handles.find((h) => h.id === hid).offset ?? 0.5).sort((a, b) => a - b);
+    const horizontalSide = side === "top" || side === "bottom";
+    const sortKey = (hid) => {
+      const r = resolved.get(hid);
+      if (isHorizontal) {
+        return horizontalSide ? r.rankCoord : r.orderCoord;
+      }
+      return horizontalSide ? r.orderCoord : r.rankCoord;
+    };
+    const sortedHandles = [...handleIds].sort((a, b) => {
+      const ra = sortKey(a), rb = sortKey(b);
+      return ra - rb || (a < b ? -1 : a > b ? 1 : 0);
+    });
+    for (let i = 0; i < sortedHandles.length; i++) {
+      newOffsetById.set(sortedHandles[i], offsets[i]);
+    }
+  }
+  let changed = false;
+  const newHandles = node.handles.map((h) => {
+    const side = newSideById.get(h.id) ?? h.position;
+    const offset = newOffsetById.has(h.id) ? newOffsetById.get(h.id) : h.offset ?? 0.5;
+    if (side !== h.position || offset !== (h.offset ?? 0.5)) {
+      changed = true;
+      return { ...h, position: side, offset };
+    }
+    return h;
+  });
+  if (!changed) return null;
+  const proposed = { ...node, handles: newHandles };
+  const sideSummary = Object.entries(sideChanges).map(([id, c]) => `${id}: ${c.from}\u2192${c.to}`).join(", ");
+  const reason = sideSummary ? `${Object.keys(sideChanges).length} handle(s) repositioned toward their neighbor (${sideSummary})` : `handles on a shared side reordered to match neighbor order`;
+  return {
+    type: "relocate-handles",
+    nodeId: node.id,
+    current: node,
+    proposed,
+    changes: sideChanges,
+    reason
+  };
+}
 function rotateHandles(handles, rot) {
   const rotateSide = (s) => {
     if (rot === 180) {
@@ -1399,7 +1636,12 @@ var COMPOUND_HEADER = 28;
 function layout(input, options) {
   const resolved = resolveOptions(options);
   if (input.nodes.length === 0) return { nodes: [], edges: [] };
-  const adjusted = applyRotationProposals(input, resolved);
+  let adjusted = applyRotationProposals(input, resolved);
+  if (resolved.onProposal) {
+    const previewOptions = { ...resolved, onProposal: void 0 };
+    const preview = layoutCompound(adjusted, previewOptions);
+    adjusted = applyRelocateProposals(adjusted, preview, resolved);
+  }
   return layoutCompound(adjusted, resolved);
 }
 function computeLayout(graph, options) {
@@ -1408,7 +1650,12 @@ function computeLayout(graph, options) {
   let layers = assignLayers(graph);
   layers = insertDummyNodes(graph, layers);
   let rail = railLayers(layers, graph);
-  rail = minimizeCrossings(graph, rail, options.crossingMinimizationIterations);
+  rail = minimizeCrossings(
+    graph,
+    rail,
+    options.crossingMinimizationIterations,
+    options.skipTranspose
+  );
   assignCoordinates(graph, rail, options);
   placeValueSidecars(graph, layers, options);
   const routedEdges = routeEdges(graph, options.direction, options.edgeMargin);