@crazyhappyone/auto-graph 0.2.7 → 0.2.9

package/dist/cli/index.js

@@ -1391,6 +1391,28 @@ function applyLayoutConstraints(input) {
   if (input.distributeContainedChildren) {
     yieldFixedPositionLocks(input, boxes, locks);
   }
+  if (input.swimlanes !== void 0 && input.swimlanes.length > 0 && input.distributeSwimlaneChildren) {
+    for (const swimlane of input.swimlanes) {
+      if (swimlane.layout === "contract") continue;
+      for (const lane of swimlane.lanes) {
+        const fixedChildren = [];
+        let participantCount = 0;
+        for (const childId of lane.children) {
+          const lock = locks.get(childId);
+          if (lock === void 0) {
+            participantCount += 1;
+          } else if (lock.source === "fixed-position") {
+            participantCount += 1;
+            fixedChildren.push(childId);
+          }
+        }
+        if (participantCount < 2) continue;
+        for (const childId of fixedChildren) {
+          locks.delete(childId);
+        }
+      }
+    }
+  }
   applyContainment(input.constraints, boxes, locks, diagnostics, false);
   applyRelative(input.constraints, boxes, locks, diagnostics);
   applyAlign(input.constraints, boxes, locks, diagnostics);
@@ -1410,6 +1432,9 @@ function applyLayoutConstraints(input) {
     applyDistributeContained(input, boxes, locks, diagnostics);
     dedupReplayDiagnostics(diagnostics, diagBefore);
   }
+  if (input.swimlanes !== void 0 && input.swimlanes.length > 0 && input.distributeSwimlaneChildren) {
+    distributeSwimlaneChildren(input, boxes, locks, diagnostics);
+  }
   removeResolvedConstraintDiagnostics(input.constraints, boxes, diagnostics);
   reportOverlaps(
     boxes,
@@ -2249,9 +2274,6 @@ function applyDistributeContained(input, boxes, locks, diagnostics) {
       }
     });
   }
-  if (input.swimlanes !== void 0 && input.swimlanes.length > 0 && input.distributeSwimlaneChildren) {
-    distributeSwimlaneChildren(input, boxes, locks, diagnostics);
-  }
 }
 function distributeSwimlaneChildren(input, boxes, locks, diagnostics) {
   const spread = input.distributeSwimlaneChildren === "spread";
@@ -2291,6 +2313,7 @@ function distributeSwimlaneChildren(input, boxes, locks, diagnostics) {
         effectiveGap = minGap + remaining / (unlocked.length - 1);
       }
       unlocked.sort((a, b) => a.box[axis] - b.box[axis]);
+      reserved.sort((a, b) => a.start - b.start);
       let pos = contentStart;
       for (const child of unlocked) {
         pos = advancePastReserved(pos, child.box[mainSize], reserved, minGap);
@@ -4082,15 +4105,12 @@ var BinaryHeap = class {
       let smallestIdx = idx;
       const leftIdx = (idx << 1) + 1;
       const rightIdx = leftIdx + 1;
-      if (leftIdx < size && this._less(
-        this._data[leftIdx],
-        this._data[smallestIdx]
-      )) {
+      if (leftIdx < size && this._less(this._data[leftIdx], entry)) {
         smallestIdx = leftIdx;
       }
       if (rightIdx < size && this._less(
         this._data[rightIdx],
-        this._data[smallestIdx]
+        smallestIdx === leftIdx ? this._data[leftIdx] : entry
       )) {
         smallestIdx = rightIdx;
       }
@@ -4157,8 +4177,59 @@ function findObstacleFreePath(source, target, obstacles, options = {}, diagnosti
     turnPenalty,
     segmentPenalty
   );
-  if (path === null) return null;
-  return simplifyRoute(path);
+  if (path !== null) {
+    const simplified = simplifyRoute(path);
+    const filteredSet = new Set(filtered);
+    if (useCorridor && obstacles.some((o) => !filteredSet.has(o))) {
+      let crossesExcluded = false;
+      for (let i = 0; i < simplified.length - 1; i++) {
+        const a = simplified[i];
+        const b = simplified[i + 1];
+        for (const obs of obstacles) {
+          if (filteredSet.has(obs)) continue;
+          if (segmentCrossesBoxStrict(a, b, obs, margin)) {
+            crossesExcluded = true;
+            break;
+          }
+        }
+        if (crossesExcluded) break;
+      }
+      if (!crossesExcluded) return simplified;
+    } else {
+      return simplified;
+    }
+  }
+  if (!useCorridor) return null;
+  const xsFull = collectXs(source, target, obstacles, margin);
+  const ysFull = collectYs(source, target, obstacles, margin);
+  if (xsFull.length * ysFull.length > maxNodes) {
+    diagnostics?.push({
+      severity: "warning",
+      code: "routing.astar.grid_overflow",
+      message: `A* full-retry grid overflow: ${xsFull.length * ysFull.length} nodes > ${maxNodes} limit. Falling back to heuristic routing.`,
+      detail: { xsCount: xsFull.length, ysCount: ysFull.length, maxNodes }
+    });
+    return null;
+  }
+  const { nodes: nodesFull, nodeIndex: idxFull } = buildGraph(xsFull, ysFull);
+  connectHorizontalEdges(
+    nodesFull,
+    ysFull,
+    obstacles,
+    endpointObstacles,
+    margin
+  );
+  connectVerticalEdges(nodesFull, xsFull, obstacles, endpointObstacles, margin);
+  const pathFull = aStarSearch(
+    nodesFull,
+    idxFull,
+    source,
+    target,
+    turnPenalty,
+    segmentPenalty
+  );
+  if (pathFull === null) return null;
+  return simplifyRoute(pathFull);
 }
 function filterObstaclesByCorridor(source, target, obstacles, endpointObstacles, margin) {
   const cx1 = Math.min(source.x, target.x) - margin;
@@ -4385,7 +4456,7 @@ function findCornerGraphPath(source, target, obstacles, options = {}, diagnostic
   const turnPenalty = options.turnPenalty ?? 50;
   const segmentPenalty = options.segmentPenalty ?? 1;
   const endpointObstacles = options.endpointObstacles ?? [];
-  const maxCorners = options.maxCorners ?? 300;
+  const maxCorners = options.maxCorners ?? 600;
   const vertices = collectCornerVertices(source, target, obstacles, margin);
   if (vertices.length > maxCorners) {
     diagnostics?.push({
@@ -4754,17 +4825,36 @@ function routeEdge(input) {
         input.source.center,
         targetAnchor
       );
-      const cornerPath = findCornerGraphPath(
+      const allObstacles = [...softObstacles, ...hardObstacles];
+      const corridorObstacles = filterObstaclesByCorridor(
         source,
         target,
-        [...softObstacles, ...hardObstacles],
+        allObstacles,
+        [],
+        // endpointObstacles passed separately via options
+        32
+      );
+      const cornerObstacles = corridorObstacles.length === 0 && allObstacles.length > 0 ? allObstacles : corridorObstacles;
+      let cornerPath = findCornerGraphPath(
+        source,
+        target,
+        cornerObstacles,
         { endpointObstacles, margin: 2 },
         diagnostics
       );
+      if (cornerPath === null && cornerObstacles.length < allObstacles.length) {
+        cornerPath = findCornerGraphPath(
+          source,
+          target,
+          allObstacles,
+          { endpointObstacles, margin: 2 },
+          diagnostics
+        );
+      }
       const path = cornerPath ?? findObstacleFreePath(
         source,
         target,
-        [...softObstacles, ...hardObstacles],
+        allObstacles,
         { endpointObstacles, margin: 0 },
         diagnostics
       );
@@ -4785,6 +4875,66 @@ function routeEdge(input) {
           checkBacktracking(finalized, source, target, diagnostics);
           return { points: finalized, diagnostics };
         }
+        if (cornerPath !== null) {
+          const fullCornerPath = cornerObstacles.length < allObstacles.length ? findCornerGraphPath(
+            source,
+            target,
+            allObstacles,
+            { endpointObstacles, margin: 2 },
+            diagnostics
+          ) : null;
+          if (fullCornerPath !== null && fullCornerPath.length >= 2) {
+            const fullFinalized = finalizeRoute(
+              fullCornerPath,
+              softObstacles,
+              hardObstacles,
+              diagnostics,
+              softObstacleIndex,
+              hardObstacleIndex
+            );
+            if (!routeIntersectsObstacles(
+              fullFinalized,
+              softObstacles,
+              softObstacleIndex
+            ) && !routeIntersectsObstacles(
+              fullFinalized,
+              hardObstacles,
+              hardObstacleIndex
+            )) {
+              checkBacktracking(fullFinalized, source, target, diagnostics);
+              return { points: fullFinalized, diagnostics };
+            }
+          }
+          const gridPath = findObstacleFreePath(
+            source,
+            target,
+            allObstacles,
+            { endpointObstacles, margin: 0 },
+            diagnostics
+          );
+          if (gridPath !== null && gridPath.length >= 2) {
+            const gridFinalized = finalizeRoute(
+              gridPath,
+              softObstacles,
+              hardObstacles,
+              diagnostics,
+              softObstacleIndex,
+              hardObstacleIndex
+            );
+            if (!routeIntersectsObstacles(
+              gridFinalized,
+              softObstacles,
+              softObstacleIndex
+            ) && !routeIntersectsObstacles(
+              gridFinalized,
+              hardObstacles,
+              hardObstacleIndex
+            )) {
+              checkBacktracking(gridFinalized, source, target, diagnostics);
+              return { points: gridFinalized, diagnostics };
+            }
+          }
+        }
       }
     }
   }
@@ -5674,7 +5824,7 @@ function solveDiagram(diagram, options = {}) {
     edges: styledEdges
   });
   diagnostics.push(...layout2.diagnostics);
-  const initialNodeBoxes = initialLayoutMode === "positions" ? layout2.boxes : wrapVerticalStackIfNeeded(
+  const initialNodeBoxes = initialLayoutMode === "positions" || diagram.direction !== "LR" && diagram.direction !== "RL" ? layout2.boxes : wrapVerticalStackIfNeeded(
     layout2.boxes,
     styledNodes,
     styledEdges,
@@ -5682,7 +5832,8 @@ function solveDiagram(diagram, options = {}) {
     options,
     diagnostics
   );
-  if ((diagram.direction === "TB" || diagram.direction === "BT") && options.maxRowDepth !== void 0) {
+  if ((diagram.direction === "TB" || diagram.direction === "BT") && (options.maxRowDepth !== void 0 || options.targetAspectRatio !== void 0)) {
+    const diagCountBefore = diagnostics.length;
     const rewrapped = wrapHorizontalStackIfNeeded(
       initialNodeBoxes,
       styledNodes,
@@ -5693,6 +5844,20 @@ function solveDiagram(diagram, options = {}) {
     for (const [id, box] of rewrapped) {
       initialNodeBoxes.set(id, box);
     }
+    if (diagnostics.length > diagCountBefore) {
+      for (const node of styledNodes) {
+        if (node.position !== void 0 && rewrapped.has(node.id)) {
+          const rwBox = rewrapped.get(node.id);
+          const idx = styledNodes.indexOf(node);
+          if (idx !== -1) {
+            styledNodes[idx] = {
+              ...node,
+              position: { x: rwBox.x, y: rwBox.y }
+            };
+          }
+        }
+      }
+    }
   }
   if (useRecursive && "groupBoxes" in layout2) {
     const recursiveLayout = layout2;
@@ -5706,7 +5871,7 @@ function solveDiagram(diagram, options = {}) {
     overlapSpacing: options?.overlapSpacing ?? 40,
     ...options.minSiblingGap === void 0 ? {} : { minSiblingGap: options.minSiblingGap },
     distributeContainedChildren: options.distributeContainedChildren ?? true,
-    distributeSwimlaneChildren: options.distributeSwimlaneChildren ?? "spread",
+    ...options.distributeSwimlaneChildren !== void 0 ? { distributeSwimlaneChildren: options.distributeSwimlaneChildren } : {},
     swimlanes: styledSwimlanes,
     boxes: initialNodeBoxes,
     nodes: styledNodes,
@@ -6422,9 +6587,14 @@ function wrapHorizontalStackIfNeeded(boxes, nodes, direction, options, diagnosti
   if (!isStackRunaway(boxes, nodes, direction, options)) {
     return new Map(boxes);
   }
-  const maxRowDepth = options.maxRowDepth;
-  if (maxRowDepth === void 0 || nodes.length <= maxRowDepth) {
-    return new Map(boxes);
+  let maxRowDepth = options.maxRowDepth;
+  if (maxRowDepth === void 0 || maxRowDepth <= 0 || nodes.length <= maxRowDepth) {
+    if (maxRowDepth === void 0 && options.targetAspectRatio !== void 0) {
+      maxRowDepth = Math.ceil(Math.sqrt(nodes.length));
+      if (nodes.length <= maxRowDepth) return new Map(boxes);
+    } else {
+      return new Map(boxes);
+    }
   }
   const ordered = [...nodes].sort((a, b) => {
     const ba = boxes.get(a.id);
@@ -6485,10 +6655,10 @@ function reportVerticalRunaway(boxes, nodes, edges, direction, options, diagnost
   });
 }
 function isStackRunaway(boxes, nodes, direction, options) {
-  if (options.maxStackDepth === void 0 && options.preferredAspectRatio === void 0) {
+  if (options.maxStackDepth === void 0 && options.preferredAspectRatio === void 0 && options.targetAspectRatio === void 0 && options.maxRowDepth === void 0) {
     return false;
   }
-  if (nodes.length < 2 || direction !== "LR" && direction !== "RL") {
+  if (nodes.length < 2) {
     return false;
   }
   const nodeBoxes = nodes.map((node) => boxes.get(node.id)).filter((box) => box !== void 0);
@@ -6496,11 +6666,18 @@ function isStackRunaway(boxes, nodes, direction, options) {
     return false;
   }
   const bounds = unionBoxes(nodeBoxes);
-  const aspectRatio = bounds.width <= 0 ? Number.POSITIVE_INFINITY : bounds.height / bounds.width;
-  const preferred = options.preferredAspectRatio ?? 3;
-  if (aspectRatio < preferred) {
+  const isHorizontal = direction === "TB" || direction === "BT";
+  const aspectRatio = isHorizontal ? bounds.height <= 0 ? Number.POSITIVE_INFINITY : bounds.width / bounds.height : bounds.width <= 0 ? Number.POSITIVE_INFINITY : bounds.height / bounds.width;
+  const preferred = isHorizontal ? options.targetAspectRatio ?? options.preferredAspectRatio ?? 3 : options.preferredAspectRatio ?? 3;
+  if ((options.preferredAspectRatio !== void 0 || options.targetAspectRatio !== void 0) && aspectRatio < preferred) {
     return false;
   }
+  if (isHorizontal) {
+    const yCenters = nodeBoxes.map((box) => box.y + box.height / 2);
+    const ySpread = Math.max(...yCenters) - Math.min(...yCenters);
+    const maxHeight = Math.max(...nodeBoxes.map((box) => box.height));
+    return ySpread <= Math.max(maxHeight, options.overlapSpacing ?? 40);
+  }
   const xCenters = nodeBoxes.map((box) => box.x + box.width / 2);
   const xSpread = Math.max(...xCenters) - Math.min(...xCenters);
   const maxWidth = Math.max(...nodeBoxes.map((box) => box.width));
@@ -6564,7 +6741,17 @@ function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBox
   );
   const rankSpacing = Math.max(96, maxRankStackHeight + padding);
   const contentHeight = maxRank === 0 ? maxChildHeight : maxRankStackHeight + maxRank * rankSpacing;
-  const slotWidth = Math.max(...populatedBounds.map((box) => box.width)) + padding * 2;
+  const spreadWidth = maxCrossAxisSpreadWidth(
+    swimlane,
+    nodeBoxes,
+    flowRanks,
+    locks,
+    rankStackGap
+  );
+  const slotWidth = Math.max(
+    Math.max(...populatedBounds.map((box) => box.width)),
+    spreadWidth
+  ) + padding * 2;
   const laneStep = slotWidth + laneGutter;
   const laneContentTop = top + headerHeight + padding;
   for (let index = 0; index < swimlane.lanes.length; index += 1) {
@@ -6578,6 +6765,24 @@ function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBox
       y: laneContentTop
     };
     if (maxRank === 0) {
+      const distributable = lane.children.filter(
+        (childId) => !locks.has(childId)
+      );
+      if (distributable.length >= CROSS_AXIS_SPREAD_THRESHOLD) {
+        moveRankedVerticalLaneChildren(
+          lane.children,
+          nodeBoxes,
+          locks,
+          diagnostics,
+          movedChildIds,
+          flowRanks,
+          rankSpacing,
+          rankStackGap,
+          { x: target.x, y: laneContentTop },
+          slotWidth - padding * 2
+        );
+        continue;
+      }
       moveLaneChildren(
         lane.children,
         nodeBoxes,
@@ -6600,10 +6805,8 @@ function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBox
       flowRanks,
       rankSpacing,
       rankStackGap,
-      {
-        x: target.x - bounds.x,
-        y: laneContentTop
-      }
+      { x: target.x, y: laneContentTop },
+      slotWidth - padding * 2
     );
   }
   return {
@@ -6712,31 +6915,99 @@ function maxVerticalRankStackHeight(swimlane, nodeBoxes, flowRanks, gap) {
   }
   return maxHeight;
 }
-function moveRankedVerticalLaneChildren(childIds, nodeBoxes, locks, diagnostics, movedChildIds, flowRanks, rankSpacing, rankStackGap, target) {
+var CROSS_AXIS_SPREAD_THRESHOLD = 3;
+function crossAxisSpreadWidth(items, gap) {
+  return items.reduce(
+    (sum, item, index) => sum + item.box.width + (index === 0 ? 0 : gap),
+    0
+  );
+}
+function maxCrossAxisSpreadWidth(swimlane, nodeBoxes, flowRanks, locks, gap) {
+  let maxWidth = 0;
+  for (const lane of swimlane.lanes) {
+    for (const stack of rankStacks(
+      lane.children,
+      nodeBoxes,
+      flowRanks
+    ).values()) {
+      const unlocked = stack.filter((item) => !locks.has(item.childId));
+      if (unlocked.length < CROSS_AXIS_SPREAD_THRESHOLD) continue;
+      maxWidth = Math.max(maxWidth, crossAxisSpreadWidth(unlocked, gap));
+    }
+  }
+  return maxWidth;
+}
+function moveRankedVerticalLaneChildren(childIds, nodeBoxes, locks, diagnostics, movedChildIds, flowRanks, rankSpacing, rankStackGap, target, contentWidth) {
   for (const [rank, stack] of rankStacks(childIds, nodeBoxes, flowRanks)) {
-    let yOffset = 0;
+    const unlocked = [];
     for (const item of stack) {
-      const { childId, box } = item;
-      if (locks.has(childId)) {
+      if (locks.has(item.childId)) {
         diagnostics.push({
           severity: "warning",
           code: "constraints.locked-target-not-moved",
-          message: `Locked child ${childId} was not moved into contract swimlane slot.`,
+          message: `Locked child ${item.childId} was not moved into contract swimlane slot.`,
           path: ["swimlanes"],
-          detail: { nodeId: childId }
+          detail: { nodeId: item.childId }
         });
-        continue;
+      } else {
+        unlocked.push(item);
       }
+    }
+    if (unlocked.length === 0) continue;
+    if (unlocked.length === 1) {
+      const { childId, box } = unlocked[0];
       const next = {
         ...box,
-        x: box.x + target.x,
-        y: target.y + rank * rankSpacing + yOffset
+        x: target.x + (contentWidth - box.width) / 2,
+        y: target.y + rank * rankSpacing
       };
       if (next.x !== box.x || next.y !== box.y) {
         movedChildIds.add(childId);
       }
       nodeBoxes.set(childId, next);
-      yOffset += box.height + rankStackGap;
+    } else {
+      const shouldSpread = unlocked.length >= CROSS_AXIS_SPREAD_THRESHOLD;
+      if (!shouldSpread) {
+        let yOffset = 0;
+        for (const { childId, box } of unlocked) {
+          const next = {
+            ...box,
+            x: target.x + (contentWidth - box.width) / 2,
+            y: target.y + rank * rankSpacing + yOffset
+          };
+          if (next.x !== box.x || next.y !== box.y) {
+            movedChildIds.add(childId);
+          }
+          nodeBoxes.set(childId, next);
+          yOffset += box.height + rankStackGap;
+        }
+      } else {
+        const packedWidth = crossAxisSpreadWidth(unlocked, rankStackGap);
+        let xCursor = target.x + Math.max(0, (contentWidth - packedWidth) / 2);
+        for (const { childId, box } of unlocked) {
+          const next = {
+            ...box,
+            x: xCursor,
+            y: target.y + rank * rankSpacing
+          };
+          if (next.x !== box.x || next.y !== box.y) {
+            movedChildIds.add(childId);
+          }
+          nodeBoxes.set(childId, next);
+          xCursor += box.width + rankStackGap;
+        }
+        diagnostics.push({
+          severity: "info",
+          code: "swimlane_contract.cross_axis_distributed",
+          message: `Spread ${unlocked.length} same-rank children horizontally in contract lane (rank ${rank}).`,
+          path: ["swimlanes"],
+          detail: {
+            rank,
+            childCount: unlocked.length,
+            contentWidth
+          }
+        });
+      }
     }
   }
 }
@@ -7075,7 +7346,7 @@ function coordinateNodes(nodes, boxes, options, diagnostics) {
       });
       continue;
     }
-    const ports = node.ports === void 0 ? void 0 : coordinatePorts(node, box, options.portShifting, diagnostics);
+    const ports = node.ports === void 0 ? void 0 : coordinatePorts(node, box, options.portShifting);
     const geometry = computeShapeGeometry({
       shape: node.shape,
       box,
@@ -7169,7 +7440,7 @@ function expandNodeBoxesForPorts(nodes, boxes, options, diagnostics) {
     }
   }
 }
-function coordinatePorts(node, nodeBox, portShifting, diagnostics) {
+function coordinatePorts(node, nodeBox, portShifting) {
   const portsBySide = /* @__PURE__ */ new Map();
   for (const port of node.ports ?? []) {
     const ports = portsBySide.get(port.side) ?? [];
@@ -7192,9 +7463,7 @@ function coordinatePorts(node, nodeBox, portShifting, diagnostics) {
         side,
         index,
         sorted.length,
-        portShifting,
-        diagnostics,
-        node.id
+        portShifting
       );
       const box = portBox(anchor);
       coordinated.push({ ...port, box, anchor });
@@ -7202,32 +7471,16 @@ function coordinatePorts(node, nodeBox, portShifting, diagnostics) {
   }
   return coordinated.sort((a, b) => a.id.localeCompare(b.id));
 }
-function portAnchor(nodeBox, side, index, count, portShifting, diagnostics, nodeId) {
+function portAnchor(nodeBox, side, index, count, portShifting) {
   const shiftingEnabled = portShifting?.enabled ?? true;
   const requestedSpacing = portShifting?.spacing ?? 24;
   const maxOffset = side === "left" || side === "right" ? nodeBox.height / 2 : nodeBox.width / 2;
   const availableSpan = 2 * maxOffset;
   const minSpacing = PORT_BOX_SIZE + MIN_PORT_EDGE_GAP;
-  const effectiveSpacing = shiftingEnabled && count > 1 ? Math.max(
+  const spacing = shiftingEnabled && count > 1 ? Math.max(
     Math.min(requestedSpacing, availableSpan / (count - 1)),
     minSpacing
   ) : requestedSpacing;
-  if (shiftingEnabled && count > 1 && effectiveSpacing < requestedSpacing && diagnostics !== void 0 && nodeId !== void 0) {
-    diagnostics.push({
-      severity: "warning",
-      code: "port_constraint_overlap",
-      message: `Port spacing on ${nodeId} ${side} compressed from ${requestedSpacing}px to ${Math.round(effectiveSpacing)}px for ${count} ports.`,
-      path: ["nodes", nodeId, "ports"],
-      detail: {
-        nodeId,
-        side,
-        requestedSpacing,
-        effectiveSpacing: Math.round(effectiveSpacing),
-        portCount: count
-      }
-    });
-  }
-  const spacing = effectiveSpacing;
   const centeredOffset = shiftingEnabled ? (index - (count - 1) / 2) * spacing : 0;
   switch (side) {
     case "left":