bpmn-elk-layout 1.0.2 → 1.1.2

package/dist/bin/bpmn-elk-layout.js

@@ -44,13 +44,12 @@ function isDebugEnabled() {
   if (cliMode) return false;
   return typeof process !== "undefined" && process.env?.["DEBUG"] === "true";
 }
-var cliMode, DEBUG;
+var cliMode;
 var init_debug = __esm({
   "src/utils/debug.ts"() {
     "use strict";
     init_cjs_shims();
     cliMode = false;
-    DEBUG = typeof process !== "undefined" && process.env?.["DEBUG"] === "true";
   }
 });
 
@@ -390,6 +389,10 @@ var init_edge_fixer = __esm({
             const containerNodes = nodesByContainer.get(currentContainerId) ?? /* @__PURE__ */ new Map();
             for (const edge of node.edges) {
               if (edge.sections && edge.sections.length > 0) {
+                const hasPoolRelativeCoords = edge._poolRelativeCoords === true;
+                if (hasPoolRelativeCoords) {
+                  continue;
+                }
                 this.fixEdgeIfCrossing(edge, containerNodes, containerOffsetX, containerOffsetY);
               }
             }
@@ -2564,7 +2567,15 @@ var init_lane_arranger = __esm({
             const waypoints = [];
             waypoints.push({ x: startX, y: startY });
             if (Math.abs(startY - endY) > 10) {
-              const midX = (startX + endX) / 2;
+              const midX = this.findClearMidX(
+                startX,
+                endX,
+                startY,
+                endY,
+                sourceId,
+                targetId,
+                nodePositions
+              );
               waypoints.push({ x: midX, y: startY });
               waypoints.push({ x: midX, y: endY });
             }
@@ -2582,6 +2593,109 @@ var init_lane_arranger = __esm({
           }
         }
       }
+      /**
+       * Find a clear X position for vertical edge segment that avoids obstacles.
+       * Checks all three segments of the L-shaped path:
+       * 1. Horizontal from (startX, startY) to (midX, startY)
+       * 2. Vertical from (midX, startY) to (midX, endY)
+       * 3. Horizontal from (midX, endY) to (endX, endY)
+       */
+      findClearMidX(startX, endX, startY, endY, sourceId, targetId, nodePositions) {
+        const margin = 15;
+        const minY = Math.min(startY, endY);
+        const maxY = Math.max(startY, endY);
+        const rangeMinX = Math.min(startX, endX);
+        const rangeMaxX = Math.max(startX, endX);
+        if (isDebugEnabled()) {
+          console.log(`[BPMN]   findClearMidX: startX=${startX}, endX=${endX}, startY=${startY}, endY=${endY}`);
+        }
+        const allObstacles = [];
+        for (const [nodeId, pos] of nodePositions) {
+          if (nodeId === sourceId || nodeId === targetId) continue;
+          const nodeLeft = pos.x;
+          const nodeRight = pos.x + pos.width;
+          const nodeTop = pos.y;
+          const nodeBottom = pos.y + pos.height;
+          const xOverlap = nodeRight > rangeMinX && nodeLeft < rangeMaxX;
+          const yOverlapVertical = nodeBottom > minY && nodeTop < maxY;
+          const yContainsStartY = nodeTop <= startY && nodeBottom >= startY;
+          const yContainsEndY = nodeTop <= endY && nodeBottom >= endY;
+          if (xOverlap && (yOverlapVertical || yContainsStartY || yContainsEndY)) {
+            allObstacles.push({
+              x: nodeLeft,
+              y: nodeTop,
+              width: pos.width,
+              height: pos.height,
+              right: nodeRight,
+              bottom: nodeBottom,
+              id: nodeId
+            });
+            if (isDebugEnabled()) {
+              console.log(`[BPMN]   findClearMidX: obstacle ${nodeId}: x=[${nodeLeft}, ${nodeRight}], y=[${nodeTop}, ${nodeBottom}]`);
+            }
+          }
+        }
+        if (allObstacles.length === 0) {
+          return (startX + endX) / 2;
+        }
+        const isValidMidX = (midX) => {
+          for (const obs of allObstacles) {
+            const seg1MinX = Math.min(startX, midX);
+            const seg1MaxX = Math.max(startX, midX);
+            if (obs.y <= startY && obs.bottom >= startY && // Y range contains startY
+            obs.right > seg1MinX && obs.x < seg1MaxX) {
+              return false;
+            }
+            if (obs.x <= midX && obs.right >= midX && // X range contains midX
+            obs.bottom > minY && obs.y < maxY) {
+              return false;
+            }
+            const seg2MinX = Math.min(midX, endX);
+            const seg2MaxX = Math.max(midX, endX);
+            if (obs.y <= endY && obs.bottom >= endY && // Y range contains endY
+            obs.right > seg2MinX && obs.x < seg2MaxX) {
+              return false;
+            }
+          }
+          return true;
+        };
+        const candidates = [];
+        candidates.push((startX + endX) / 2);
+        candidates.push(startX + margin);
+        candidates.push(endX - margin);
+        for (const obs of allObstacles) {
+          candidates.push(obs.x - margin);
+          candidates.push(obs.right + margin);
+        }
+        const simpleMidX = (startX + endX) / 2;
+        const validCandidates = candidates.filter((x) => x >= rangeMinX && x <= rangeMaxX).sort((a, b) => Math.abs(a - simpleMidX) - Math.abs(b - simpleMidX));
+        for (const candidate of validCandidates) {
+          if (isValidMidX(candidate)) {
+            if (isDebugEnabled()) {
+              console.log(`[BPMN]   findClearMidX: found valid position ${candidate}`);
+            }
+            return candidate;
+          }
+        }
+        const leftMost = Math.min(...allObstacles.map((o) => o.x)) - margin;
+        const rightMost = Math.max(...allObstacles.map((o) => o.right)) + margin;
+        if (leftMost >= rangeMinX && isValidMidX(leftMost)) {
+          if (isDebugEnabled()) {
+            console.log(`[BPMN]   findClearMidX: routing left of all obstacles at ${leftMost}`);
+          }
+          return leftMost;
+        }
+        if (rightMost <= rangeMaxX && isValidMidX(rightMost)) {
+          if (isDebugEnabled()) {
+            console.log(`[BPMN]   findClearMidX: routing right of all obstacles at ${rightMost}`);
+          }
+          return rightMost;
+        }
+        if (isDebugEnabled()) {
+          console.log(`[BPMN]   findClearMidX: no valid route found, using midpoint ${simpleMidX}`);
+        }
+        return simpleMidX;
+      }
     };
   }
 });
@@ -2670,7 +2784,7 @@ var init_pool_arranger = __esm({
           pool.y = currentY;
           if (isBlackBox) {
             pool.width = maxPoolWidth;
-            pool.height = pool.height ?? 60;
+            pool.height = 60;
           } else if (hasLanes) {
             pool.width = maxPoolWidth;
           } else {
@@ -5305,6 +5419,7 @@ var init_diagram_builder = __esm({
             }
           }
         }
+        this.ensureOrthogonalWaypoints(waypoints);
         const edgeModel = {
           id: `${edge.id}_di`,
           bpmnElement: edge.id,
@@ -5371,6 +5486,36 @@ var init_diagram_builder = __esm({
           y: (lastPoint?.y ?? 0) - labelHeight - 4
         };
       }
+      /**
+       * Ensure all waypoint segments are orthogonal (horizontal or vertical)
+       * If a diagonal segment is found, insert intermediate bend points to create
+       * an L-shaped orthogonal path.
+       *
+       * Strategy: For diagonal segments, we use "horizontal first" - go horizontally
+       * to the target X, then vertically to the target Y.
+       */
+      ensureOrthogonalWaypoints(waypoints) {
+        if (waypoints.length < 2) return;
+        const tolerance = 1;
+        let i = 0;
+        while (i < waypoints.length - 1) {
+          const current = waypoints[i];
+          const next = waypoints[i + 1];
+          if (!current || !next) {
+            i++;
+            continue;
+          }
+          const dx = Math.abs(next.x - current.x);
+          const dy = Math.abs(next.y - current.y);
+          if (dx > tolerance && dy > tolerance) {
+            const bendPoint = { x: next.x, y: current.y };
+            waypoints.splice(i + 1, 0, bendPoint);
+            i++;
+          } else {
+            i++;
+          }
+        }
+      }
     };
   }
 });