@grafloria/element 0.3.20 → 0.3.21

package/src/libs/engine/src/routing/algorithms/OrthogonalRouter.js

@@ -1,1092 +0,0 @@
-"use strict";
-// OrthogonalRouter - Right-angle routing with obstacle avoidance
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OrthogonalRouter = void 0;
-const ObstacleIndex_1 = require("../ObstacleIndex");
-/**
- * Wave 8 — Card 6. Below this many obstacles a linear scan beats a hash lookup,
- * and building an index would cost more than it saves. Above it, the scan is
- * what made a one-node drag take 5.5 seconds.
- */
-const INDEX_THRESHOLD = 24;
-/**
- * OrthogonalRouter creates paths with only 90-degree angles
- * Supports obstacle avoidance using A* on a grid
- */
-class OrthogonalRouter {
-    /**
-     * The index for this obstacle set: the caller's if it prepared one (the
-     * engine does), otherwise ours. Returns null for a set small enough that
-     * scanning it is genuinely cheaper.
-     */
-    static indexFor(obstacles, provided) {
-        if (provided)
-            return provided;
-        if (obstacles.length < INDEX_THRESHOLD)
-            return null;
-        let idx = OrthogonalRouter.indexCache.get(obstacles);
-        if (!idx) {
-            idx = new ObstacleIndex_1.ObstacleIndex(obstacles);
-            OrthogonalRouter.indexCache.set(obstacles, idx);
-        }
-        return idx;
-    }
-    getName() {
-        return 'orthogonal';
-    }
-    route(request) {
-        var _a, _b;
-        const { start, end, obstacles = [], options = {}, sourceDirection, targetDirection } = request;
-        const index = OrthogonalRouter.indexFor(obstacles, request.obstacleIndex);
-        // Handle same start and end point
-        if (start.x === end.x && start.y === end.y) {
-            return {
-                points: [{ x: start.x, y: start.y }],
-                totalLength: 0,
-                bendCount: 0,
-                cost: 0,
-                segments: [],
-            };
-        }
-        const bendCost = (_b = (_a = options.costs) === null || _a === void 0 ? void 0 : _a.bends) !== null && _b !== void 0 ? _b : 10;
-        // Card 1: an explicit jetty upgrades the stub contract from best-effort to
-        // GUARANTEED — and lets floating (direction-less) anchors derive exit sides
-        // from the geometry instead of taking the stub-less midline fallback.
-        const jetty = options.jetty;
-        let srcDir = sourceDirection;
-        let tgtDir = targetDirection;
-        if (jetty !== undefined) {
-            if (!srcDir)
-                srcDir = OrthogonalRouter.deriveExitSide(start, end);
-            if (!tgtDir)
-                tgtDir = OrthogonalRouter.deriveExitSide(end, start);
-        }
-        // The jetty guarantee holds on WHICHEVER branch produced the route: simple,
-        // A*-avoidance, or the collision fallback.
-        const withJetty = (path) => jetty !== undefined ? this.enforceJetty(path, start, end, srcDir, tgtDir, jetty, bendCost) : path;
-        // SMART ROUTING: Always calculate a simple orthogonal path first
-        const simplePath = this.simpleOrthogonalRoute(start, end, options.gridSize, bendCost, srcDir, tgtDir, jetty);
-        // If no obstacles provided, return the simple path
-        if (obstacles.length === 0) {
-            return withJetty(simplePath);
-        }
-        // Check if the simple path intersects any obstacles
-        const hasCollision = this.pathIntersectsObstacles(simplePath.points, obstacles, index);
-        if (!hasCollision) {
-            // Path is clear, use the simple routing
-            return withJetty(simplePath);
-        }
-        // Path has collisions - use A* pathfinding for obstacle avoidance
-        if (options.avoidObstacles) {
-            const avoidancePath = this.avoidObstaclesRoute(start, end, obstacles, options, srcDir, tgtDir, index);
-            if (avoidancePath) {
-                return withJetty(avoidancePath);
-            }
-        }
-        // Fallback: return simple path even with collisions
-        // (visual indicator that routing needs manual waypoints)
-        return withJetty(simplePath);
-    }
-    /**
-     * Card 1: the exit side a FLOATING anchor should use, derived from where the
-     * other endpoint is — dominant axis first, ties break horizontal (matching
-     * the midline fallback's own axis choice, so the derived route agrees with
-     * what the undirected route would have preferred).
-     */
-    static deriveExitSide(from, toward) {
-        const dx = toward.x - from.x;
-        const dy = toward.y - from.y;
-        if (Math.abs(dx) >= Math.abs(dy))
-            return dx >= 0 ? 'right' : 'left';
-        return dy >= 0 ? 'bottom' : 'top';
-    }
-    /**
-     * Card 1: guarantee the route leaves/enters PERPENDICULAR to the port side
-     * for at least `jetty` px before the first/after the last bend.
-     *
-     * The simple route's gap logic shrinks stubs on short links (its gapOffset
-     * clamp), and the A* grid can snap the first elbow closer than the stub — so
-     * the guarantee is enforced as a post-pass: if the first segment along the
-     * port direction is shorter than the jetty (or points the wrong way), a stub
-     * point is inserted at start + dir·jetty and the joint is re-orthogonalised
-     * by routing the old interior through the stub's far ordinate. Same for the
-     * target end, mirrored.
-     */
-    enforceJetty(path, start, end, sourceDirection, targetDirection, jetty, bendCost) {
-        if (jetty <= 0 || path.points.length < 2)
-            return path;
-        const fixEnd = (pts, anchor, dir) => {
-            if (!dir || pts.length < 2)
-                return pts;
-            const v = dir === 'left' ? { x: -1, y: 0 }
-                : dir === 'right' ? { x: 1, y: 0 }
-                    : dir === 'top' ? { x: 0, y: -1 }
-                        : { x: 0, y: 1 };
-            const stub = { x: anchor.x + v.x * jetty, y: anchor.y + v.y * jetty };
-            const first = pts[0];
-            const second = pts[1];
-            // Does the existing first segment already satisfy the contract?
-            const seg = { x: second.x - first.x, y: second.y - first.y };
-            const along = seg.x * v.x + seg.y * v.y; // signed length along the port normal
-            const perpendicular = v.x !== 0 ? seg.y === 0 : seg.x === 0;
-            if (perpendicular && along >= jetty)
-                return pts;
-            // Insert the stub, then re-orthogonalise the joint. Points of the old
-            // route lying ON the anchor→stub segment are SUBSUMED by the stub, not
-            // detoured around — otherwise a collinear-but-short stub would rebuild as
-            // an out-and-back run on the same line, which the collinear merge then
-            // collapses straight back to the too-short original (the exact failure
-            // mode the obstacle-avoidance test caught: A* grid-snaps its last elbow
-            // inside the jetty window).
-            let rest = pts.slice(1);
-            const onStubSegment = (q) => {
-                if (v.x !== 0) {
-                    if (q.y !== anchor.y)
-                        return false;
-                    const t = (q.x - anchor.x) * v.x; // signed distance along the stub
-                    return t >= 0 && t <= jetty;
-                }
-                if (q.x !== anchor.x)
-                    return false;
-                const t = (q.y - anchor.y) * v.y;
-                return t >= 0 && t <= jetty;
-            };
-            // never subsume the far anchor itself — a fully-collinear straight link
-            // must keep its endpoint.
-            while (rest.length > 1 && onStubSegment(rest[0]))
-                rest = rest.slice(1);
-            const joint = v.x !== 0
-                ? { x: stub.x, y: rest[0].y } // horizontal stub: drop vertically to the old route
-                : { x: rest[0].x, y: stub.y }; // vertical stub: run horizontally to the old route
-            const rebuilt = [first, stub, joint, ...rest];
-            // Collapse duplicates/collinear runs the insertion may have created.
-            return this.mergeCollinearPoints(this.removeDuplicatePoints(rebuilt));
-        };
-        let pts = fixEnd(path.points.map((p) => (Object.assign({}, p))), start, sourceDirection);
-        pts = fixEnd(pts.slice().reverse(), end, targetDirection).reverse();
-        const totalLength = this.calculatePathLength(pts);
-        const bendCount = Math.max(0, pts.length - 2);
-        return {
-            points: pts,
-            totalLength,
-            bendCount,
-            cost: totalLength + bendCount * bendCost,
-            segments: this.calculateSegments(pts),
-        };
-    }
-    /**
-     * Simple orthogonal route - exact implementation of React Flow's getSmoothStepPath
-     * Based on React Flow's smoothstep-edge.ts getPoints() function
-     * Handles all edge cases: opposite ports, same ports, mixed ports
-     *
-     * CRITICAL: The offset determines how far the line moves away from the port
-     * before making turns. A larger offset creates more spacing from nodes.
-     */
-    simpleOrthogonalRoute(start, end, gridSize, bendCost = 10, sourceDirection, targetDirection, jetty) {
-        // No port directions at all: route through the midline (classic HVH/VHV,
-        // the React Flow default for undirected points). The gap-point logic below
-        // assumes port directions and emits stub artifacts without them.
-        if (!sourceDirection && !targetDirection) {
-            let pts;
-            if (start.x === end.x || start.y === end.y) {
-                pts = [Object.assign({}, start), Object.assign({}, end)];
-            }
-            else if (Math.abs(end.x - start.x) >= Math.abs(end.y - start.y)) {
-                const midX = (start.x + end.x) / 2;
-                pts = [Object.assign({}, start), { x: midX, y: start.y }, { x: midX, y: end.y }, Object.assign({}, end)];
-            }
-            else {
-                const midY = (start.y + end.y) / 2;
-                pts = [Object.assign({}, start), { x: start.x, y: midY }, { x: end.x, y: midY }, Object.assign({}, end)];
-            }
-            if (gridSize && gridSize > 1) {
-                // Interior points share one snapped ordinate, so segments stay orthogonal
-                for (let i = 1; i < pts.length - 1; i++) {
-                    pts[i] = {
-                        x: Math.round(pts[i].x / gridSize) * gridSize,
-                        y: Math.round(pts[i].y / gridSize) * gridSize,
-                    };
-                }
-            }
-            const merged = this.mergeCollinearPoints(this.removeDuplicatePoints(pts));
-            const totalLength = this.calculatePathLength(merged);
-            const bendCount = Math.max(0, merged.length - 2);
-            return {
-                points: merged,
-                totalLength,
-                bendCount,
-                cost: totalLength + bendCount * bendCost,
-                segments: this.calculateSegments(merged),
-            };
-        }
-        // CRITICAL OFFSET: This determines the "breathing room" around nodes
-        // Match React Flow's exact offset value for visual consistency.
-        // Card 1: an explicit jetty replaces it (enforceJetty then GUARANTEES it).
-        const offset = jetty !== null && jetty !== void 0 ? jetty : 20;
-        // Get direction vectors for source and target
-        const sourceDir = this.getDirectionVector(sourceDirection);
-        const targetDir = this.getDirectionVector(targetDirection);
-        // Calculate gapped points (moved away from port in port direction)
-        const sourceGapped = {
-            x: start.x + sourceDir.x * offset,
-            y: start.y + sourceDir.y * offset
-        };
-        const targetGapped = {
-            x: end.x + targetDir.x * offset,
-            y: end.y + targetDir.y * offset
-        };
-        // Determine primary routing direction (React Flow line 86-92)
-        const dir = this.getRoutingDirection(sourceGapped, sourceDirection, targetGapped);
-        const dirAccessor = dir.x !== 0 ? 'x' : 'y';
-        const currDir = dir[dirAccessor];
-        let points = [];
-        const sourceGapOffset = { x: 0, y: 0 };
-        const targetGapOffset = { x: 0, y: 0 };
-        // React Flow line 107: Check if handles are opposite
-        if (sourceDir[dirAccessor] * targetDir[dirAccessor] === -1) {
-            // CASE 1: Opposite handle positions (e.g., Left -> Right, Top -> Bottom)
-            // Use Z-shape routing with center point
-            //
-            // SMART ROUTING: When ports are opposite, we create a "bent" path that routes
-            // around potential node collisions. The bend happens at the midpoint, creating
-            // a visual "elbow" that clearly shows the connection path.
-            let centerX, centerY;
-            if (dirAccessor === 'x') {
-                // Horizontal routing (e.g., Left -> Right, Right -> Left)
-                // CRITICAL FIX: Detect overshoot scenario
-                // When routing right-to-left but sourceGapped is already to the right of targetGapped,
-                // using the midpoint would cause the path to overshoot and penetrate the target node.
-                // Instead, clamp the bend to the source edge to route around the side.
-                const isOvershooting = (sourceDir.x > 0 && sourceGapped.x > targetGapped.x) ||
-                    (sourceDir.x < 0 && sourceGapped.x < targetGapped.x);
-                if (isOvershooting) {
-                    // Overshoot detected: Place bend at source edge, not midpoint
-                    // This makes the path exit the source, turn immediately, and route around the side
-                    centerX = sourceGapped.x;
-                }
-                else {
-                    // Normal case: Use midpoint
-                    centerX = (sourceGapped.x + targetGapped.x) / 2;
-                }
-                // For horizontal routing, we keep Y at source/target levels to create clear steps
-                centerY = (sourceGapped.y + targetGapped.y) / 2;
-            }
-            else {
-                // Vertical routing (e.g., Top -> Bottom, Bottom -> Top)
-                // CRITICAL FIX: Detect overshoot scenario for vertical routing
-                const isOvershooting = (sourceDir.y > 0 && sourceGapped.y > targetGapped.y) ||
-                    (sourceDir.y < 0 && sourceGapped.y < targetGapped.y);
-                if (isOvershooting) {
-                    // Overshoot detected: Place bend at source edge
-                    centerY = sourceGapped.y;
-                }
-                else {
-                    // Normal case: Use midpoint
-                    centerY = (sourceGapped.y + targetGapped.y) / 2;
-                }
-                // For vertical routing, we keep X at source/target levels to create clear steps
-                centerX = (sourceGapped.x + targetGapped.x) / 2;
-            }
-            // React Flow lines 123-140: Choose between vertical and horizontal split
-            // This creates the characteristic "step" pattern
-            const verticalSplit = [
-                { x: centerX, y: sourceGapped.y },
-                { x: centerX, y: targetGapped.y },
-            ];
-            const horizontalSplit = [
-                { x: sourceGapped.x, y: centerY },
-                { x: targetGapped.x, y: centerY },
-            ];
-            if (sourceDir[dirAccessor] === currDir) {
-                points = dirAccessor === 'x' ? verticalSplit : horizontalSplit;
-            }
-            else {
-                points = dirAccessor === 'x' ? horizontalSplit : verticalSplit;
-            }
-        }
-        else {
-            // CASE 2: Same or perpendicular handle positions
-            // Use L-shape routing
-            // React Flow lines 144-145: Define the two L-shape options
-            const sourceTarget = [{ x: sourceGapped.x, y: targetGapped.y }];
-            const targetSource = [{ x: targetGapped.x, y: sourceGapped.y }];
-            // React Flow lines 147-151: Choose L-shape direction
-            if (dirAccessor === 'x') {
-                points = sourceDir.x === currDir ? targetSource : sourceTarget;
-            }
-            else {
-                points = sourceDir.y === currDir ? sourceTarget : targetSource;
-            }
-            // React Flow lines 153-165: Handle same position ports that are too close
-            if (sourceDirection === targetDirection) {
-                const diff = Math.abs(start[dirAccessor] - end[dirAccessor]);
-                if (diff <= offset) {
-                    const gapOffset = Math.min(offset - 1, offset - diff);
-                    if (sourceDir[dirAccessor] === currDir) {
-                        sourceGapOffset[dirAccessor] = (sourceGapped[dirAccessor] > start[dirAccessor] ? -1 : 1) * gapOffset;
-                    }
-                    else {
-                        targetGapOffset[dirAccessor] = (targetGapped[dirAccessor] > end[dirAccessor] ? -1 : 1) * gapOffset;
-                    }
-                }
-            }
-            // React Flow lines 168-180: Handle mixed handle positions (e.g., Right -> Bottom)
-            if (sourceDirection !== targetDirection) {
-                const dirAccessorOpposite = dirAccessor === 'x' ? 'y' : 'x';
-                const isSameDir = sourceDir[dirAccessor] === targetDir[dirAccessorOpposite];
-                const sourceGtTargetOppo = sourceGapped[dirAccessorOpposite] > targetGapped[dirAccessorOpposite];
-                const sourceLtTargetOppo = sourceGapped[dirAccessorOpposite] < targetGapped[dirAccessorOpposite];
-                const flipSourceTarget = (sourceDir[dirAccessor] === 1 && ((!isSameDir && sourceGtTargetOppo) || (isSameDir && sourceLtTargetOppo))) ||
-                    (sourceDir[dirAccessor] !== 1 && ((!isSameDir && sourceLtTargetOppo) || (isSameDir && sourceGtTargetOppo)));
-                if (flipSourceTarget) {
-                    points = dirAccessor === 'x' ? sourceTarget : targetSource;
-                }
-            }
-        }
-        // Build path points
-        const sourceGapPoint = { x: sourceGapped.x + sourceGapOffset.x, y: sourceGapped.y + sourceGapOffset.y };
-        const targetGapPoint = { x: targetGapped.x + targetGapOffset.x, y: targetGapped.y + targetGapOffset.y };
-        // CRITICAL FIX: Ensure first and last segments are orthogonal
-        // Check if start->sourceGapPoint creates a diagonal (non-orthogonal) segment
-        const firstSegmentIsOrthogonal = (start.x === sourceGapPoint.x) || (start.y === sourceGapPoint.y);
-        const lastSegmentIsOrthogonal = (end.x === targetGapPoint.x) || (end.y === targetGapPoint.y);
-        // Build path: only include start/end if they create orthogonal segments
-        const pathPoints = [];
-        if (firstSegmentIsOrthogonal) {
-            pathPoints.push(start);
-        }
-        pathPoints.push(sourceGapPoint);
-        pathPoints.push(...points);
-        pathPoints.push(targetGapPoint);
-        if (lastSegmentIsOrthogonal) {
-            pathPoints.push(end);
-        }
-        // Snap to grid if specified
-        // CRITICAL FIX: Do NOT snap the first and last points (port positions)
-        // Only snap intermediate waypoints to prevent mismatch with port positions
-        if (gridSize && gridSize > 1) {
-            pathPoints.forEach((p, index) => {
-                // Skip first and last points - they must stay at exact port positions
-                if (index === 0 || index === pathPoints.length - 1) {
-                    return;
-                }
-                p.x = Math.round(p.x / gridSize) * gridSize;
-                p.y = Math.round(p.y / gridSize) * gridSize;
-            });
-            // CRITICAL FIX: After grid snapping, ensure first and last segments remain orthogonal
-            // Grid snapping intermediate points can create diagonal segments with unsnapped endpoints
-            if (pathPoints.length >= 2) {
-                // Fix first segment: ensure point[1] is orthogonal to point[0] (start)
-                const start = pathPoints[0];
-                const firstIntermediate = pathPoints[1];
-                const firstIsHorizontal = start.y === firstIntermediate.y;
-                const firstIsVertical = start.x === firstIntermediate.x;
-                if (!firstIsHorizontal && !firstIsVertical) {
-                    // Determine which direction to align based on source direction or infer from geometry
-                    let alignedHorizontally = false;
-                    let alignedVertically = false;
-                    if (sourceDirection === 'left' || sourceDirection === 'right') {
-                        // Horizontal port - make first segment horizontal
-                        firstIntermediate.y = start.y;
-                        alignedHorizontally = true;
-                    }
-                    else if (sourceDirection === 'top' || sourceDirection === 'bottom') {
-                        // Vertical port - make first segment vertical
-                        firstIntermediate.x = start.x;
-                        alignedVertically = true;
-                    }
-                    else {
-                        // Direction unknown - infer from start/end relative positions
-                        const deltaX = Math.abs(end.x - start.x);
-                        const deltaY = Math.abs(end.y - start.y);
-                        if (deltaX > deltaY) {
-                            firstIntermediate.y = start.y;
-                            alignedHorizontally = true;
-                        }
-                        else {
-                            firstIntermediate.x = start.x;
-                            alignedVertically = true;
-                        }
-                    }
-                    // CRITICAL FIX: Propagate alignment to all intermediate points (not just first one)
-                    // This fixes the issue where point 2, 3, etc. still have wrong coordinates after grid snap
-                    if (pathPoints.length > 3) {
-                        for (let i = 2; i < pathPoints.length - 1; i++) {
-                            if (alignedHorizontally && pathPoints[i].y !== start.y) {
-                                pathPoints[i].y = start.y;
-                            }
-                            else if (alignedVertically && pathPoints[i].x !== start.x) {
-                                pathPoints[i].x = start.x;
-                            }
-                        }
-                    }
-                }
-                // Fix last segment: ensure point[n-2] is orthogonal to point[n-1] (end)
-                if (pathPoints.length >= 3) {
-                    const end = pathPoints[pathPoints.length - 1];
-                    const lastIntermediate = pathPoints[pathPoints.length - 2];
-                    const lastIsHorizontal = lastIntermediate.y === end.y;
-                    const lastIsVertical = lastIntermediate.x === end.x;
-                    if (!lastIsHorizontal && !lastIsVertical) {
-                        // Determine which direction to align based on target direction or infer from geometry
-                        if (targetDirection === 'left' || targetDirection === 'right') {
-                            // Horizontal port - make last segment horizontal
-                            lastIntermediate.y = end.y;
-                        }
-                        else if (targetDirection === 'top' || targetDirection === 'bottom') {
-                            // Vertical port - make last segment vertical
-                            lastIntermediate.x = end.x;
-                        }
-                        else {
-                            // Direction unknown - infer from start/end relative positions
-                            const deltaX = Math.abs(end.x - start.x);
-                            const deltaY = Math.abs(end.y - start.y);
-                            if (deltaX > deltaY) {
-                                // Endpoints are more horizontally separated - likely horizontal port
-                                lastIntermediate.y = end.y;
-                            }
-                            else {
-                                // Endpoints are more vertically separated - likely vertical port
-                                lastIntermediate.x = end.x;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        // Remove duplicate consecutive points, then merge collinear runs — the
-        // gap-point construction can emit out-and-back stubs (A→B→A) and split
-        // straight lines into multiple segments
-        const uniquePoints = this.mergeCollinearPoints(this.removeDuplicatePoints(pathPoints));
-        const totalLength = this.calculatePathLength(uniquePoints);
-        const bendCount = uniquePoints.length - 2;
-        return {
-            points: uniquePoints,
-            totalLength,
-            bendCount: Math.max(0, bendCount),
-            cost: totalLength + bendCount * bendCost,
-            segments: this.calculateSegments(uniquePoints),
-        };
-    }
-    /**
-     * Merge collinear consecutive points. Because the kept path lies on the
-     * same line the removed points did, this also collapses out-and-back
-     * excursions (backtracking stubs) without changing route coverage.
-     */
-    mergeCollinearPoints(points) {
-        if (points.length <= 2)
-            return points;
-        const out = [points[0]];
-        for (let i = 1; i < points.length; i++) {
-            const q = points[i];
-            while (out.length >= 2) {
-                const a = out[out.length - 2];
-                const b = out[out.length - 1];
-                const cross = (b.x - a.x) * (q.y - b.y) - (b.y - a.y) * (q.x - b.x);
-                if (Math.abs(cross) < 1e-6)
-                    out.pop();
-                else
-                    break;
-            }
-            const tail = out[out.length - 1];
-            if (Math.abs(q.x - tail.x) > 1e-9 || Math.abs(q.y - tail.y) > 1e-9) {
-                out.push(q);
-            }
-        }
-        return out;
-    }
-    /**
-     * Check if we can use a direct straight line between ports
-     * This happens when ports are aligned and facing each other directly
-     */
-    canUseDirectLine(start, end, sourceDirection, targetDirection, _sourceOffset, _targetOffset) {
-        if (!sourceDirection || !targetDirection)
-            return false;
-        const tolerance = 2; // pixels
-        // Check if horizontally aligned (same Y)
-        const horizontallyAligned = Math.abs(start.y - end.y) < tolerance;
-        // Check if vertically aligned (same X)
-        const verticallyAligned = Math.abs(start.x - end.x) < tolerance;
-        // For horizontal alignment, ports should face left/right
-        if (horizontallyAligned) {
-            const horizontalPorts = ((sourceDirection === 'left' || sourceDirection === 'right') &&
-                (targetDirection === 'left' || targetDirection === 'right'));
-            // Check if they face each other
-            const facingEachOther = ((sourceDirection === 'right' && targetDirection === 'left' && start.x < end.x) ||
-                (sourceDirection === 'left' && targetDirection === 'right' && start.x > end.x));
-            return horizontalPorts && facingEachOther;
-        }
-        // For vertical alignment, ports should face top/bottom
-        if (verticallyAligned) {
-            const verticalPorts = ((sourceDirection === 'top' || sourceDirection === 'bottom') &&
-                (targetDirection === 'top' || targetDirection === 'bottom'));
-            // Check if they face each other
-            const facingEachOther = ((sourceDirection === 'bottom' && targetDirection === 'top' && start.y < end.y) ||
-                (sourceDirection === 'top' && targetDirection === 'bottom' && start.y > end.y));
-            return verticalPorts && facingEachOther;
-        }
-        return false;
-    }
-    /**
-     * Simplify orthogonal path by removing redundant collinear points
-     * ONLY removes points that are on the same straight line (horizontal or vertical)
-     * This preserves proper orthogonal (right-angle) routing
-     */
-    simplifyOrthogonalPath(points) {
-        if (points.length <= 2)
-            return points;
-        const simplified = [points[0]];
-        const tolerance = 0.1; // Very tight tolerance for orthogonal alignment
-        for (let i = 1; i < points.length - 1; i++) {
-            const prev = simplified[simplified.length - 1]; // Use last point in simplified array
-            const curr = points[i];
-            const next = points[i + 1];
-            // Check if prev, curr, next are collinear (on same horizontal or vertical line)
-            const isHorizontalLine = Math.abs(prev.y - curr.y) < tolerance &&
-                Math.abs(curr.y - next.y) < tolerance;
-            const isVerticalLine = Math.abs(prev.x - curr.x) < tolerance &&
-                Math.abs(curr.x - next.x) < tolerance;
-            // Only skip this point if it's truly collinear (on same straight line)
-            // This removes redundant intermediate points but keeps all bends
-            if (!isHorizontalLine && !isVerticalLine) {
-                simplified.push(curr);
-            }
-        }
-        simplified.push(points[points.length - 1]);
-        return simplified;
-    }
-    /**
-     * Apply gap offset in the direction the port points
-     */
-    applyGapOffset(point, direction, offset) {
-        if (!direction)
-            return point;
-        switch (direction) {
-            case 'left':
-                return { x: point.x - offset, y: point.y };
-            case 'right':
-                return { x: point.x + offset, y: point.y };
-            case 'top':
-                return { x: point.x, y: point.y - offset };
-            case 'bottom':
-                return { x: point.x, y: point.y + offset };
-        }
-    }
-    /**
-     * Get direction vector for a port direction (React Flow style)
-     */
-    getDirectionVector(direction) {
-        if (!direction)
-            return { x: 0, y: 0 };
-        switch (direction) {
-            case 'left':
-                return { x: -1, y: 0 };
-            case 'right':
-                return { x: 1, y: 0 };
-            case 'top':
-                return { x: 0, y: -1 };
-            case 'bottom':
-                return { x: 0, y: 1 };
-        }
-    }
-    /**
-     * Determine routing direction based on source/target positions (React Flow logic)
-     */
-    getRoutingDirection(source, sourcePosition, target) {
-        if (!sourcePosition)
-            return { x: 1, y: 0 };
-        // For horizontal ports (left/right), determine X direction
-        if (sourcePosition === 'left' || sourcePosition === 'right') {
-            return source.x < target.x ? { x: 1, y: 0 } : { x: -1, y: 0 };
-        }
-        // For vertical ports (top/bottom), determine Y direction
-        return source.y < target.y ? { x: 0, y: 1 } : { x: 0, y: -1 };
-    }
-    /**
-     * Determine if we need Z-shape routing (vs L-shape)
-     * Z-shape is needed when ports point toward each other or in same direction
-     */
-    needsZShape(sourceDir, targetDir, sourceOffset, targetOffset) {
-        if (!sourceDir || !targetDir)
-            return false;
-        // Ports pointing opposite directions (toward each other)
-        const oppositeDirections = ((sourceDir === 'left' && targetDir === 'right') ||
-            (sourceDir === 'right' && targetDir === 'left') ||
-            (sourceDir === 'top' && targetDir === 'bottom') ||
-            (sourceDir === 'bottom' && targetDir === 'top'));
-        // Ports pointing same direction
-        const sameDirection = sourceDir === targetDir;
-        return oppositeDirections || sameDirection;
-    }
-    /**
-     * Calculate L-shape midpoint (one bend)
-     */
-    calculateLShapeMidpoint(sourceOffset, targetOffset, sourceDir, targetDir) {
-        // For L-shape, decide whether to go horizontal-then-vertical or vertical-then-horizontal
-        // Based on which port direction is dominant
-        const isSourceHorizontal = sourceDir === 'left' || sourceDir === 'right';
-        const isTargetHorizontal = targetDir === 'left' || targetDir === 'right';
-        if (isSourceHorizontal && !isTargetHorizontal) {
-            // Source is horizontal, target is vertical: horizontal first
-            return { x: targetOffset.x, y: sourceOffset.y };
-        }
-        else if (!isSourceHorizontal && isTargetHorizontal) {
-            // Source is vertical, target is horizontal: vertical first
-            return { x: sourceOffset.x, y: targetOffset.y };
-        }
-        else {
-            // Both same orientation - choose based on distance
-            const dx = Math.abs(targetOffset.x - sourceOffset.x);
-            const dy = Math.abs(targetOffset.y - sourceOffset.y);
-            if (dx > dy) {
-                return { x: targetOffset.x, y: sourceOffset.y };
-            }
-            else {
-                return { x: sourceOffset.x, y: targetOffset.y };
-            }
-        }
-    }
-    /**
-     * Calculate Z-shape midpoints (two bends)
-     */
-    calculateZShapeMidpoints(sourceOffset, targetOffset, sourceDir, targetDir) {
-        const isSourceHorizontal = sourceDir === 'left' || sourceDir === 'right';
-        if (isSourceHorizontal) {
-            // Horizontal source: H-V-H routing
-            const midX = (sourceOffset.x + targetOffset.x) / 2;
-            return [
-                { x: midX, y: sourceOffset.y },
-                { x: midX, y: targetOffset.y }
-            ];
-        }
-        else {
-            // Vertical source: V-H-V routing
-            const midY = (sourceOffset.y + targetOffset.y) / 2;
-            return [
-                { x: sourceOffset.x, y: midY },
-                { x: targetOffset.x, y: midY }
-            ];
-        }
-    }
-    /**
-     * Orthogonal routing with obstacle avoidance using A*
-     */
-    avoidObstaclesRoute(start, end, obstacles, options, sourceDirection, targetDirection, index) {
-        var _a, _b, _c, _d, _e, _f, _g;
-        const gridSize = (_a = options.gridSize) !== null && _a !== void 0 ? _a : 10;
-        const margin = (_b = options.obstacleMargin) !== null && _b !== void 0 ? _b : 20; // Margin around obstacles
-        const maxIterations = (_c = options.maxIterations) !== null && _c !== void 0 ? _c : 10000;
-        const gapOffset = 30; // Distance to move away from port (must be > margin to clear obstacle boundary)
-        // Apply gap offset to move away from ports before pathfinding
-        // This ensures paths don't start/end directly on node borders
-        const sourceOffset = this.applyGapOffset(start, sourceDirection, gapOffset);
-        const targetOffset = this.applyGapOffset(end, targetDirection, gapOffset);
-        // Snap offset points to grid for A* pathfinding
-        let gridStart = this.snapToGrid(sourceOffset, gridSize);
-        let gridEnd = this.snapToGrid(targetOffset, gridSize);
-        // CRITICAL FIX: Validate start/end points are not inside obstacles
-        // If grid snapping moved them into an obstacle, adjust outward
-        if (this.collidesWithObstacles(gridStart, obstacles, margin, index)) {
-            console.debug(`⚠️ Grid start point inside obstacle, adjusting...`);
-            gridStart = this.findNearestValidPoint(gridStart, sourceDirection, obstacles, margin, gridSize, index);
-        }
-        if (this.collidesWithObstacles(gridEnd, obstacles, margin, index)) {
-            console.debug(`⚠️ Grid end point inside obstacle, adjusting...`);
-            gridEnd = this.findNearestValidPoint(gridEnd, targetDirection, obstacles, margin, gridSize, index);
-        }
-        // Use A* to find path between offset points
-        const path = this.aStarPathfinding(gridStart, gridEnd, obstacles, gridSize, margin, maxIterations, index);
-        if (!path || path.length === 0) {
-            // IMPROVED: Log why pathfinding failed and what we're doing
-            console.debug(`⚠️ A* pathfinding failed for link routing:`, {
-                start: gridStart,
-                end: gridEnd,
-                obstacleCount: obstacles.length,
-                gridSize,
-                margin
-            });
-            console.debug(`   Falling back to simple orthogonal route (no obstacle avoidance)`);
-            // Fallback to simple route if pathfinding fails
-            return this.simpleOrthogonalRoute(start, end, gridSize, (_e = (_d = options.costs) === null || _d === void 0 ? void 0 : _d.bends) !== null && _e !== void 0 ? _e : 10, sourceDirection, targetDirection);
-        }
-        // Prepend actual start point and append actual end point
-        // This ensures the path connects to the exact port positions
-        const fullPath = [
-            { x: start.x, y: start.y },
-            ...path,
-            { x: end.x, y: end.y }
-        ];
-        // Remove duplicate consecutive points
-        const uniquePath = this.mergeCollinearPoints(this.removeDuplicatePoints(fullPath));
-        const totalLength = this.calculatePathLength(uniquePath);
-        const bendCount = this.countBends(uniquePath);
-        const bendCost = (_g = (_f = options.costs) === null || _f === void 0 ? void 0 : _f.bends) !== null && _g !== void 0 ? _g : 10;
-        return {
-            points: uniquePath,
-            totalLength,
-            bendCount,
-            cost: totalLength + bendCount * bendCost,
-            segments: this.calculateSegments(uniquePath),
-        };
-    }
-    /**
-     * A* pathfinding on a grid with improved obstacle avoidance
-     */
-    aStarPathfinding(start, end, obstacles, gridSize, margin, maxIterations, index) {
-        var _a, _b, _c;
-        const openSet = new Set();
-        const closedSet = new Set();
-        const cameFrom = new Map();
-        const gScore = new Map();
-        const fScore = new Map();
-        const startKey = this.pointToKey(start);
-        const endKey = this.pointToKey(end);
-        openSet.add(startKey);
-        gScore.set(startKey, 0);
-        fScore.set(startKey, this.heuristic(start, end));
-        let iterations = 0;
-        while (openSet.size > 0 && iterations < maxIterations) {
-            iterations++;
-            // Find node with lowest fScore
-            let currentKey = '';
-            let lowestF = Infinity;
-            for (const key of openSet) {
-                const f = (_a = fScore.get(key)) !== null && _a !== void 0 ? _a : Infinity;
-                if (f < lowestF) {
-                    lowestF = f;
-                    currentKey = key;
-                }
-            }
-            if (!currentKey)
-                break;
-            const current = this.keyToPoint(currentKey);
-            // Reached goal
-            if (currentKey === endKey) {
-                const path = this.reconstructPath(cameFrom, current);
-                // Simplify the A* path to remove unnecessary waypoints
-                return this.simplifyOrthogonalPath(path);
-            }
-            openSet.delete(currentKey);
-            closedSet.add(currentKey);
-            // Check neighbors (4-directional: up, down, left, right)
-            const neighbors = this.getOrthogonalNeighbors(current, gridSize);
-            for (const neighbor of neighbors) {
-                const neighborKey = this.pointToKey(neighbor);
-                if (closedSet.has(neighborKey))
-                    continue;
-                // Check if neighbor collides with obstacle
-                if (this.collidesWithObstacles(neighbor, obstacles, margin, index)) {
-                    closedSet.add(neighborKey);
-                    continue;
-                }
-                // Calculate movement cost with penalty for direction changes
-                let movementCost = gridSize;
-                // Add bend penalty if direction changed from previous segment
-                const parent = cameFrom.get(currentKey);
-                if (parent) {
-                    const prevDir = this.getDirection(parent, current);
-                    const nextDir = this.getDirection(current, neighbor);
-                    if (prevDir !== nextDir) {
-                        movementCost += gridSize * 0.5; // Penalty for bends to favor straighter paths
-                    }
-                }
-                const tentativeG = ((_b = gScore.get(currentKey)) !== null && _b !== void 0 ? _b : Infinity) + movementCost;
-                if (!openSet.has(neighborKey)) {
-                    openSet.add(neighborKey);
-                }
-                else if (tentativeG >= ((_c = gScore.get(neighborKey)) !== null && _c !== void 0 ? _c : Infinity)) {
-                    continue;
-                }
-                cameFrom.set(neighborKey, current);
-                gScore.set(neighborKey, tentativeG);
-                fScore.set(neighborKey, tentativeG + this.heuristic(neighbor, end));
-            }
-        }
-        // No path found
-        return null;
-    }
-    /**
-     * Reconstruct path from A* came-from map
-     */
-    reconstructPath(cameFrom, current) {
-        const path = [current];
-        let currentKey = this.pointToKey(current);
-        while (cameFrom.has(currentKey)) {
-            const point = cameFrom.get(currentKey);
-            path.unshift(point);
-            currentKey = this.pointToKey(point);
-        }
-        return path;
-    }
-    /**
-     * Manhattan distance heuristic
-     */
-    heuristic(a, b) {
-        return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-    }
-    /**
-     * Get 4-directional orthogonal neighbors
-     */
-    getOrthogonalNeighbors(point, gridSize) {
-        return [
-            { x: point.x + gridSize, y: point.y }, // Right
-            { x: point.x - gridSize, y: point.y }, // Left
-            { x: point.x, y: point.y + gridSize }, // Down
-            { x: point.x, y: point.y - gridSize }, // Up
-        ];
-    }
-    /**
-     * Check if point collides with any obstacle
-     * FIXED: Use inclusive bounds to prevent paths grazing obstacle edges
-     */
-    collidesWithObstacles(point, obstacles, margin, index) {
-        // Wave 8 — Card 6: THE hot path. A* asks this once per neighbour of every
-        // cell it expands, and the linear scan below made that O(scene) — 1.87
-        // BILLION aabb tests in one measured 5k-node drag frame. The index answers
-        // with the identical predicate, looking only at obstacles near the point.
-        if (index)
-            return index.collides(point.x, point.y, margin);
-        for (const obstacle of obstacles) {
-            // Expand obstacle boundaries by margin to create safe zone around obstacles
-            const minX = obstacle.x - margin;
-            const maxX = obstacle.x + obstacle.width + margin;
-            const minY = obstacle.y - margin;
-            const maxY = obstacle.y + obstacle.height + margin;
-            // FIXED: Use >= and <= (inclusive) instead of > and < (exclusive)
-            // This ensures points ON the boundary are also considered colliding
-            if (point.x >= minX &&
-                point.x <= maxX &&
-                point.y >= minY &&
-                point.y <= maxY) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Check if any segment of the path intersects with obstacles
-     * This determines if we need to use A* pathfinding
-     */
-    pathIntersectsObstacles(points, obstacles, index) {
-        if (obstacles.length === 0)
-            return false;
-        // Check each line segment of the path
-        for (let i = 1; i < points.length; i++) {
-            const p1 = points[i - 1];
-            const p2 = points[i];
-            // Wave 8 — Card 6: only obstacles whose rect can reach this segment's
-            // bounding box are candidates; the exact test below is unchanged, so the
-            // answer is unchanged. (A segment can only meet a rect inside the
-            // segment's own bbox, so the narrowing loses nothing.)
-            const candidates = index
-                ? index.queryBox(Math.min(p1.x, p2.x), Math.min(p1.y, p2.y), Math.max(p1.x, p2.x), Math.max(p1.y, p2.y))
-                : obstacles;
-            // Check if this segment intersects any obstacle
-            for (const obstacle of candidates) {
-                const rect = {
-                    x: obstacle.x,
-                    y: obstacle.y,
-                    width: obstacle.width,
-                    height: obstacle.height
-                };
-                if (this.lineIntersectsRectangle(p1, p2, rect)) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    /**
-     * Check if a line segment intersects with a rectangle
-     */
-    lineIntersectsRectangle(p1, p2, rect) {
-        const left = rect.x;
-        const right = rect.x + rect.width;
-        const top = rect.y;
-        const bottom = rect.y + rect.height;
-        // Check if either endpoint is inside the rectangle
-        if (this.pointInRectangle(p1, rect) || this.pointInRectangle(p2, rect)) {
-            return true;
-        }
-        // Check intersection with each edge of the rectangle
-        const edges = [
-            { x1: left, y1: top, x2: right, y2: top }, // top edge
-            { x1: right, y1: top, x2: right, y2: bottom }, // right edge
-            { x1: left, y1: bottom, x2: right, y2: bottom }, // bottom edge
-            { x1: left, y1: top, x2: left, y2: bottom }, // left edge
-        ];
-        for (const edge of edges) {
-            if (this.lineSegmentsIntersect(p1, p2, { x: edge.x1, y: edge.y1 }, { x: edge.x2, y: edge.y2 })) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Check if a point is inside a rectangle
-     */
-    pointInRectangle(p, rect) {
-        return (p.x >= rect.x &&
-            p.x <= rect.x + rect.width &&
-            p.y >= rect.y &&
-            p.y <= rect.y + rect.height);
-    }
-    /**
-     * Check if two line segments intersect
-     * Using the cross product method
-     */
-    lineSegmentsIntersect(p1, p2, p3, p4) {
-        const ccw = (a, b, c) => {
-            return (c.y - a.y) * (b.x - a.x) > (b.y - a.y) * (c.x - a.x);
-        };
-        return ccw(p1, p3, p4) !== ccw(p2, p3, p4) && ccw(p1, p2, p3) !== ccw(p1, p2, p4);
-    }
-    /**
-     * Snap point to grid
-     */
-    snapToGrid(point, gridSize) {
-        return {
-            x: Math.round(point.x / gridSize) * gridSize,
-            y: Math.round(point.y / gridSize) * gridSize,
-        };
-    }
-    /**
-     * Find nearest valid point outside obstacles
-     * Searches outward from point in the given direction until finding a valid position
-     */
-    findNearestValidPoint(point, direction, obstacles, margin, gridSize, index) {
-        // Try moving outward in the port direction to find a valid point
-        const maxAttempts = 10;
-        let current = Object.assign({}, point);
-        for (let i = 1; i <= maxAttempts; i++) {
-            // Move one grid step in the port direction
-            switch (direction) {
-                case 'left':
-                    current.x -= gridSize;
-                    break;
-                case 'right':
-                    current.x += gridSize;
-                    break;
-                case 'top':
-                    current.y -= gridSize;
-                    break;
-                case 'bottom':
-                    current.y += gridSize;
-                    break;
-                default:
-                    // No direction specified, try moving in all directions
-                    const candidates = [
-                        { x: point.x + i * gridSize, y: point.y },
-                        { x: point.x - i * gridSize, y: point.y },
-                        { x: point.x, y: point.y + i * gridSize },
-                        { x: point.x, y: point.y - i * gridSize },
-                    ];
-                    for (const candidate of candidates) {
-                        if (!this.collidesWithObstacles(candidate, obstacles, margin, index)) {
-                            return candidate;
-                        }
-                    }
-                    continue;
-            }
-            // Check if this position is valid
-            if (!this.collidesWithObstacles(current, obstacles, margin, index)) {
-                return current;
-            }
-        }
-        // If all attempts failed, return original point (pathfinding will fail, but at least we tried)
-        console.debug(`   ✗ Could not find valid point after ${maxAttempts} attempts, using original`);
-        return point;
-    }
-    /**
-     * Convert point to map key
-     */
-    pointToKey(point) {
-        return `${point.x},${point.y}`;
-    }
-    /**
-     * Convert map key to point
-     */
-    keyToPoint(key) {
-        const [x, y] = key.split(',').map(Number);
-        return { x, y };
-    }
-    /**
-     * Calculate total path length
-     */
-    calculatePathLength(points) {
-        let length = 0;
-        for (let i = 0; i < points.length - 1; i++) {
-            const dx = points[i + 1].x - points[i].x;
-            const dy = points[i + 1].y - points[i].y;
-            length += Math.sqrt(dx * dx + dy * dy);
-        }
-        return length;
-    }
-    /**
-     * Count bends in path
-     */
-    countBends(points) {
-        if (points.length < 3)
-            return 0;
-        let bends = 0;
-        for (let i = 1; i < points.length - 1; i++) {
-            const prev = points[i - 1];
-            const curr = points[i];
-            const next = points[i + 1];
-            // Check if direction changed
-            const dir1 = this.getDirection(prev, curr);
-            const dir2 = this.getDirection(curr, next);
-            if (dir1 !== dir2) {
-                bends++;
-            }
-        }
-        return bends;
-    }
-    /**
-     * Get direction between two points ('h' or 'v')
-     */
-    getDirection(a, b) {
-        return Math.abs(b.x - a.x) > Math.abs(b.y - a.y) ? 'h' : 'v';
-    }
-    /**
-     * Remove duplicate consecutive points
-     */
-    removeDuplicatePoints(points) {
-        const result = [];
-        for (let i = 0; i < points.length; i++) {
-            if (i === 0 || points[i].x !== points[i - 1].x || points[i].y !== points[i - 1].y) {
-                result.push(Object.assign({}, points[i]));
-            }
-        }
-        return result;
-    }
-    /**
-     * Calculate segments from points
-     */
-    calculateSegments(points) {
-        const segments = [];
-        for (let i = 0; i < points.length - 1; i++) {
-            const start = points[i];
-            const end = points[i + 1];
-            const dx = end.x - start.x;
-            const dy = end.y - start.y;
-            const length = Math.sqrt(dx * dx + dy * dy);
-            const angle = (Math.atan2(dy, dx) * 180) / Math.PI;
-            segments.push({
-                start: Object.assign({}, start),
-                end: Object.assign({}, end),
-                length,
-                angle,
-            });
-        }
-        return segments;
-    }
-}
-exports.OrthogonalRouter = OrthogonalRouter;
-/**
- * Wave 8 — Card 6: indexes memoised on the obstacle ARRAY's identity, so the
- * whole frame's links share one index instead of rebuilding it per link.
- * Weak, so an obstacle set dies with the frame that made it.
- */
-OrthogonalRouter.indexCache = new WeakMap();
-//# sourceMappingURL=OrthogonalRouter.js.map