bpmn-elk-layout 1.0.2 → 1.1.2

package/dist/index.mjs

@@ -254,7 +254,6 @@ function isDebugEnabled() {
   if (cliMode) return false;
   return typeof process !== "undefined" && process.env?.["DEBUG"] === "true";
 }
-var DEBUG = typeof process !== "undefined" && process.env?.["DEBUG"] === "true";
 
 // src/layout/edge-routing/edge-fixer.ts
 var EdgeFixer = class {
@@ -325,6 +324,10 @@ var EdgeFixer = class {
         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);
           }
         }
@@ -2450,7 +2453,15 @@ var LaneArranger = class {
         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 });
         }
@@ -2468,6 +2479,109 @@ var LaneArranger = class {
       }
     }
   }
+  /**
+   * 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;
+  }
 };
 
 // src/layout/post-processing/pool-arranger.ts
@@ -2548,7 +2662,7 @@ var PoolArranger = class {
       pool.y = currentY;
       if (isBlackBox) {
         pool.width = maxPoolWidth;
-        pool.height = pool.height ?? 60;
+        pool.height = 60;
       } else if (hasLanes) {
         pool.width = maxPoolWidth;
       } else {
@@ -5060,6 +5174,7 @@ var DiagramBuilder = class {
         }
       }
     }
+    this.ensureOrthogonalWaypoints(waypoints);
     const edgeModel = {
       id: `${edge.id}_di`,
       bpmnElement: edge.id,
@@ -5126,6 +5241,36 @@ var DiagramBuilder = class {
       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++;
+      }
+    }
+  }
 };
 
 // src/transform/model-builder.ts