@nodius/layouting 0.1.3 → 0.1.4

package/dist/index.mjs

@@ -1473,17 +1473,23 @@ function applyRelocateProposals(input, preview, options) {
   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);
+    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) {
+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);
@@ -1491,54 +1497,125 @@ function computeRelocateProposal(node, edges, inputIndex, previewIndex) {
   }
   if (usedHandleIds.size === 0) return null;
   const votesByHandle = /* @__PURE__ */ new Map();
-  const selfCenter = {
-    x: selfPreview.x + selfPreview.width / 2,
-    y: selfPreview.y + selfPreview.height / 2
-  };
   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 neighborPreview = previewIndex.get(neighborId);
-    if (!neighborPreview) continue;
-    const neighborCenter = {
-      x: neighborPreview.x + neighborPreview.width / 2,
-      y: neighborPreview.y + neighborPreview.height / 2
-    };
-    const dx = neighborCenter.x - selfCenter.x;
-    const dy = neighborCenter.y - selfCenter.y;
-    const side = Math.abs(dx) >= Math.abs(dy) ? dx >= 0 ? "right" : "left" : dy >= 0 ? "bottom" : "top";
-    const dist = Math.hypot(dx, dy);
+    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({ side, weight });
+    arr.push({ weight, isFlow, flowSide, perpSide, orderCoord: nbrOrderC, rankCoord: nbrRankC, beyond });
     votesByHandle.set(handleId, arr);
   }
-  const changes = {};
-  const newHandles = node.handles.map((h) => {
-    const votes = votesByHandle.get(h.id);
-    if (!votes || votes.length === 0) return h;
+  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 };
-    for (const v of votes) tallies[v.side] += v.weight;
-    const best = Object.entries(tallies).reduce((acc, cur) => cur[1] > acc[1] ? cur : acc, ["top", -Infinity])[0];
-    if (best !== h.position) {
-      changes[h.id] = { from: h.position, to: best };
-      return { ...h, position: best };
+    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 (Object.keys(changes).length === 0) return null;
+  if (!changed) return null;
   const proposed = { ...node, handles: newHandles };
-  const summary = Object.entries(changes).map(([id, c]) => `${id}: ${c.from}\u2192${c.to}`).join(", ");
+  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,
-    reason: `${Object.keys(changes).length} handle(s) point away from their neighbor (${summary})`
+    changes: sideChanges,
+    reason
   };
 }
 function rotateHandles(handles, rot) {