@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/diagram/orthogonal-router.js

@@ -1,568 +0,0 @@
-/**
- * Orthogonal connection router for SVG diagram rendering.
- *
- * Ported from the original React-based editor's orthogonalRouter.ts.
- * Removed gl-matrix dependency — uses plain [number, number] tuples.
- *
- * Features:
- * - L-shape and S-shape routing with rounded corners
- * - Node collision avoidance via inflated bounding boxes
- * - Track allocator prevents parallel connections from overlapping
- * - Crossing minimization (evaluates up to 11 candidates per allocation)
- * - Per-port-index stub spacing
- * - Waypoint simplification (collinear removal, jog collapse)
- * - Backward/self connection escape routing
- */
-// Minimum spacing between parallel horizontal segments (px)
-const TRACK_SPACING = 15;
-// Clearance from inflated box edges when routing around nodes (px).
-const EDGE_OFFSET = 5;
-// ─── Track allocator ───
-// Maximum free candidates to evaluate in each direction for crossing minimization.
-const MAX_CANDIDATES = 5;
-export class TrackAllocator {
-    claims = [];
-    verticalClaims = [];
-    /** Check if a Y value is too close to any claimed segment whose X range overlaps. */
-    isOccupied(xMin, xMax, y) {
-        for (const c of this.claims) {
-            if (c.xMin < xMax && c.xMax > xMin && Math.abs(c.y - y) < TRACK_SPACING) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /** Check if an X value is too close to any claimed vertical segment whose Y range overlaps. */
-    isOccupiedVertical(yMin, yMax, x) {
-        for (const c of this.verticalClaims) {
-            if (c.yMin < yMax && c.yMax > yMin && Math.abs(c.x - x) < TRACK_SPACING) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /** Check if a horizontal segment at Y passes through any inflated node box. */
-    isBlockedByNode(xMin, xMax, y, boxes) {
-        for (const box of boxes) {
-            if (xMin < box.right && xMax > box.left && y >= box.top && y <= box.bottom) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /** Check if a vertical segment at X passes through any inflated node box. */
-    isBlockedByNodeVertical(yMin, yMax, x, boxes) {
-        for (const box of boxes) {
-            if (x >= box.left && x <= box.right && yMin < box.bottom && yMax > box.top) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /** Count claimed vertical segments that a horizontal segment at Y would cross. */
-    countHorizontalCrossings(xMin, xMax, y) {
-        let count = 0;
-        for (const c of this.verticalClaims) {
-            if (c.x > xMin && c.x < xMax && y >= c.yMin && y <= c.yMax) {
-                count++;
-            }
-        }
-        return count;
-    }
-    /** Count claimed horizontal segments that a vertical segment at X would cross. */
-    countVerticalCrossings(yMin, yMax, x) {
-        let count = 0;
-        for (const c of this.claims) {
-            if (c.y > yMin && c.y < yMax && x >= c.xMin && x <= c.xMax) {
-                count++;
-            }
-        }
-        return count;
-    }
-    /**
-     * Find the nearest free Y to candidateY in the given X range, preferring fewer crossings.
-     * When nodeBoxes is provided, candidates inside inflated node boxes are rejected (hard constraint).
-     */
-    findFreeY(xMin, xMax, candidateY, nodeBoxes) {
-        const isFree = (y) => !this.isOccupied(xMin, xMax, y) &&
-            (!nodeBoxes || !this.isBlockedByNode(xMin, xMax, y, nodeBoxes));
-        if (isFree(candidateY))
-            return candidateY;
-        const candidates = [];
-        for (let offset = TRACK_SPACING; offset < 800 && candidates.length < MAX_CANDIDATES * 2; offset += TRACK_SPACING) {
-            const above = candidateY - offset;
-            if (isFree(above)) {
-                candidates.push({ y: above, dist: offset });
-            }
-            const below = candidateY + offset;
-            if (isFree(below)) {
-                candidates.push({ y: below, dist: offset });
-            }
-        }
-        if (candidates.length === 0)
-            return candidateY;
-        let bestY = candidates[0].y;
-        let bestCrossings = this.countHorizontalCrossings(xMin, xMax, candidates[0].y);
-        let bestDist = candidates[0].dist;
-        for (let i = 1; i < candidates.length; i++) {
-            const c = candidates[i];
-            const crossings = this.countHorizontalCrossings(xMin, xMax, c.y);
-            if (crossings < bestCrossings || (crossings === bestCrossings && c.dist < bestDist)) {
-                bestY = c.y;
-                bestCrossings = crossings;
-                bestDist = c.dist;
-            }
-        }
-        return bestY;
-    }
-    /**
-     * Find the nearest free X to candidateX in the given Y range, preferring fewer crossings.
-     * When nodeBoxes is provided, candidates inside inflated node boxes are rejected (hard constraint).
-     */
-    findFreeX(yMin, yMax, candidateX, nodeBoxes) {
-        const isFree = (x) => !this.isOccupiedVertical(yMin, yMax, x) &&
-            (!nodeBoxes || !this.isBlockedByNodeVertical(yMin, yMax, x, nodeBoxes));
-        if (isFree(candidateX))
-            return candidateX;
-        const candidates = [];
-        for (let offset = TRACK_SPACING; offset < 800 && candidates.length < MAX_CANDIDATES * 2; offset += TRACK_SPACING) {
-            const left = candidateX - offset;
-            if (isFree(left)) {
-                candidates.push({ x: left, dist: offset });
-            }
-            const right = candidateX + offset;
-            if (isFree(right)) {
-                candidates.push({ x: right, dist: offset });
-            }
-        }
-        if (candidates.length === 0)
-            return candidateX;
-        let bestX = candidates[0].x;
-        let bestCrossings = this.countVerticalCrossings(yMin, yMax, candidates[0].x);
-        let bestDist = candidates[0].dist;
-        for (let i = 1; i < candidates.length; i++) {
-            const c = candidates[i];
-            const crossings = this.countVerticalCrossings(yMin, yMax, c.x);
-            if (crossings < bestCrossings || (crossings === bestCrossings && c.dist < bestDist)) {
-                bestX = c.x;
-                bestCrossings = crossings;
-                bestDist = c.dist;
-            }
-        }
-        return bestX;
-    }
-    /** Claim a horizontal segment so later connections avoid it. */
-    claim(xMin, xMax, y) {
-        this.claims.push({ xMin, xMax, y });
-    }
-    /** Claim a vertical segment so later connections avoid it. */
-    claimVertical(yMin, yMax, x) {
-        this.verticalClaims.push({ yMin, yMax, x });
-    }
-}
-// ─── Node avoidance helpers ───
-function inflateBox(box, padding) {
-    return {
-        left: box.x - padding,
-        right: box.x + box.width + padding,
-        top: box.y - padding,
-        bottom: box.y + box.height + padding,
-    };
-}
-function segmentOverlapsBox(xMin, xMax, y, box) {
-    return xMin < box.right && xMax > box.left && y >= box.top && y <= box.bottom;
-}
-/** Check if a vertical segment at a given X is clear of all inflated boxes. */
-function verticalSegmentClear(x, yMin, yMax, boxes) {
-    return !boxes.some((box) => x >= box.left && x <= box.right && yMin < box.bottom && yMax > box.top);
-}
-/**
- * Find a Y clear of node boxes for a horizontal segment spanning [xMin, xMax].
- */
-function findClearY(xMin, xMax, candidateY, boxes) {
-    const isBlocked = (y) => boxes.some((box) => segmentOverlapsBox(xMin, xMax, y, box));
-    if (!isBlocked(candidateY))
-        return candidateY;
-    const edges = [];
-    for (const box of boxes) {
-        if (xMin < box.right && xMax > box.left) {
-            edges.push(box.top);
-            edges.push(box.bottom);
-        }
-    }
-    if (edges.length === 0)
-        return candidateY;
-    edges.sort((a, b) => a - b);
-    let bestY = candidateY;
-    let bestDist = Infinity;
-    for (const edge of edges) {
-        for (const y of [edge - EDGE_OFFSET, edge + EDGE_OFFSET]) {
-            if (!isBlocked(y)) {
-                const dist = Math.abs(y - candidateY);
-                if (dist < bestDist) {
-                    bestDist = dist;
-                    bestY = y;
-                }
-            }
-        }
-    }
-    if (bestDist === Infinity) {
-        const allMin = Math.min(...edges) - EDGE_OFFSET * 2;
-        const allMax = Math.max(...edges) + EDGE_OFFSET * 2;
-        bestY = Math.abs(allMin - candidateY) <= Math.abs(allMax - candidateY) ? allMin : allMax;
-        if (isBlocked(bestY)) {
-            for (let offset = TRACK_SPACING; offset < 800; offset += TRACK_SPACING) {
-                if (!isBlocked(bestY - offset)) {
-                    bestY -= offset;
-                    break;
-                }
-                if (!isBlocked(bestY + offset)) {
-                    bestY += offset;
-                    break;
-                }
-            }
-        }
-    }
-    return bestY;
-}
-/**
- * Find an X clear of node boxes for a vertical segment spanning [yMin, yMax].
- */
-function findClearX(yMin, yMax, candidateX, boxes) {
-    const isBlocked = (x) => boxes.some((box) => x >= box.left && x <= box.right && yMin < box.bottom && yMax > box.top);
-    if (!isBlocked(candidateX))
-        return candidateX;
-    const edges = [];
-    for (const box of boxes) {
-        if (yMin < box.bottom && yMax > box.top) {
-            edges.push(box.left);
-            edges.push(box.right);
-        }
-    }
-    if (edges.length === 0)
-        return candidateX;
-    edges.sort((a, b) => a - b);
-    let bestX = candidateX;
-    let bestDist = Infinity;
-    for (const edge of edges) {
-        for (const x of [edge - EDGE_OFFSET, edge + EDGE_OFFSET]) {
-            if (!isBlocked(x)) {
-                const dist = Math.abs(x - candidateX);
-                if (dist < bestDist) {
-                    bestDist = dist;
-                    bestX = x;
-                }
-            }
-        }
-    }
-    if (bestDist === Infinity) {
-        const allMin = Math.min(...edges) - EDGE_OFFSET * 2;
-        const allMax = Math.max(...edges) + EDGE_OFFSET * 2;
-        bestX = Math.abs(allMin - candidateX) <= Math.abs(allMax - candidateX) ? allMin : allMax;
-        if (isBlocked(bestX)) {
-            for (let offset = TRACK_SPACING; offset < 800; offset += TRACK_SPACING) {
-                if (!isBlocked(bestX - offset)) {
-                    bestX -= offset;
-                    break;
-                }
-                if (!isBlocked(bestX + offset)) {
-                    bestX += offset;
-                    break;
-                }
-            }
-        }
-    }
-    return bestX;
-}
-// ─── Waypoint utilities ───
-const MIN_SEGMENT_LENGTH = 3;
-const JOG_THRESHOLD = 10;
-/** Remove collinear, duplicate, tiny-jog, and very-short-segment waypoints. */
-function simplifyWaypoints(waypoints) {
-    if (waypoints.length <= 2)
-        return waypoints;
-    // Pass 1: Collapse small rectangular jogs.
-    let pts = waypoints;
-    let jogFound = true;
-    while (jogFound) {
-        jogFound = false;
-        for (let i = 0; i < pts.length - 3; i++) {
-            const a = pts[i], b = pts[i + 1], c = pts[i + 2], d = pts[i + 3];
-            // Small vertical jog
-            const jogH = Math.abs(b[1] - c[1]);
-            if (Math.abs(a[1] - b[1]) < 0.5 &&
-                Math.abs(b[0] - c[0]) < 0.5 &&
-                Math.abs(c[1] - d[1]) < 0.5 &&
-                jogH > 0.5 && jogH < JOG_THRESHOLD) {
-                const jogMid = (b[1] + c[1]) / 2;
-                const snapY = Math.abs(a[1] - jogMid) <= Math.abs(d[1] - jogMid) ? a[1] : d[1];
-                const newPts = pts.slice();
-                newPts[i + 1] = [b[0], snapY];
-                newPts[i + 2] = [c[0], snapY];
-                pts = newPts;
-                jogFound = true;
-                break;
-            }
-            // Small horizontal jog
-            const jogW = Math.abs(b[0] - c[0]);
-            if (Math.abs(a[0] - b[0]) < 0.5 &&
-                Math.abs(b[1] - c[1]) < 0.5 &&
-                Math.abs(c[0] - d[0]) < 0.5 &&
-                jogW > 0.5 && jogW < JOG_THRESHOLD) {
-                const jogMid = (b[0] + c[0]) / 2;
-                const snapX = Math.abs(a[0] - jogMid) <= Math.abs(d[0] - jogMid) ? a[0] : d[0];
-                const newPts = pts.slice();
-                newPts[i + 1] = [snapX, b[1]];
-                newPts[i + 2] = [snapX, c[1]];
-                pts = newPts;
-                jogFound = true;
-                break;
-            }
-        }
-    }
-    // Pass 2: Remove near-duplicates and collinear points
-    const result = [pts[0]];
-    for (let i = 1; i < pts.length - 1; i++) {
-        const prev = result[result.length - 1];
-        const curr = pts[i];
-        const next = pts[i + 1];
-        const distToPrev = Math.abs(prev[0] - curr[0]) + Math.abs(prev[1] - curr[1]);
-        if (distToPrev < MIN_SEGMENT_LENGTH)
-            continue;
-        const sameX = Math.abs(prev[0] - curr[0]) < 0.01 && Math.abs(curr[0] - next[0]) < 0.01;
-        const sameY = Math.abs(prev[1] - curr[1]) < 0.01 && Math.abs(curr[1] - next[1]) < 0.01;
-        if (!sameX && !sameY) {
-            result.push(curr);
-        }
-    }
-    result.push(pts[pts.length - 1]);
-    return result;
-}
-/** Convert waypoints to an SVG path with rounded corners. */
-function waypointsToSvgPath(waypoints, cornerRadius) {
-    if (waypoints.length < 2)
-        return '';
-    if (waypoints.length === 2) {
-        return `M ${waypoints[0][0]},${waypoints[0][1]} L ${waypoints[1][0]},${waypoints[1][1]}`;
-    }
-    // Pre-compute arc radii so adjacent corners sharing a segment never overlap
-    const radii = new Array(waypoints.length).fill(0);
-    for (let i = 1; i < waypoints.length - 1; i++) {
-        const prev = waypoints[i - 1];
-        const curr = waypoints[i];
-        const next = waypoints[i + 1];
-        const lenPrev = Math.sqrt((prev[0] - curr[0]) ** 2 + (prev[1] - curr[1]) ** 2);
-        const lenNext = Math.sqrt((next[0] - curr[0]) ** 2 + (next[1] - curr[1]) ** 2);
-        radii[i] =
-            lenPrev < 0.01 || lenNext < 0.01 ? 0 : Math.min(cornerRadius, lenPrev / 2, lenNext / 2);
-    }
-    // Shrink radii so two corners sharing a segment together consume at most the full segment length
-    for (let i = 1; i < waypoints.length - 2; i++) {
-        const curr = waypoints[i];
-        const next = waypoints[i + 1];
-        const segLen = Math.sqrt((next[0] - curr[0]) ** 2 + (next[1] - curr[1]) ** 2);
-        const total = radii[i] + radii[i + 1];
-        if (total > segLen && total > 0) {
-            const scale = segLen / total;
-            radii[i] *= scale;
-            radii[i + 1] *= scale;
-        }
-    }
-    let path = `M ${waypoints[0][0]},${waypoints[0][1]}`;
-    for (let i = 1; i < waypoints.length - 1; i++) {
-        const prev = waypoints[i - 1];
-        const curr = waypoints[i];
-        const next = waypoints[i + 1];
-        const r = radii[i];
-        if (r < 2) {
-            path += ` L ${curr[0]},${curr[1]}`;
-            continue;
-        }
-        const dPrev = [prev[0] - curr[0], prev[1] - curr[1]];
-        const dNext = [next[0] - curr[0], next[1] - curr[1]];
-        const lenPrev = Math.sqrt(dPrev[0] * dPrev[0] + dPrev[1] * dPrev[1]);
-        const lenNext = Math.sqrt(dNext[0] * dNext[0] + dNext[1] * dNext[1]);
-        const uPrev = [dPrev[0] / lenPrev, dPrev[1] / lenPrev];
-        const uNext = [dNext[0] / lenNext, dNext[1] / lenNext];
-        const arcStart = [curr[0] + uPrev[0] * r, curr[1] + uPrev[1] * r];
-        const arcEnd = [curr[0] + uNext[0] * r, curr[1] + uNext[1] * r];
-        const cross = dPrev[0] * dNext[1] - dPrev[1] * dNext[0];
-        const sweep = cross > 0 ? 0 : 1;
-        path += ` L ${arcStart[0]},${arcStart[1]}`;
-        path += ` A ${r} ${r} 0 0 ${sweep} ${arcEnd[0]},${arcEnd[1]}`;
-    }
-    const last = waypoints[waypoints.length - 1];
-    path += ` L ${last[0]},${last[1]}`;
-    return path;
-}
-// ─── Waypoint computation ───
-function computeWaypoints(from, to, nodeBoxes, sourceNodeId, targetNodeId, padding, exitStub, entryStub, allocator) {
-    const isSelfConnection = sourceNodeId === targetNodeId;
-    const inflatedBoxes = nodeBoxes
-        .filter((box) => (isSelfConnection ? true : box.id !== sourceNodeId && box.id !== targetNodeId))
-        .map((box) => inflateBox(box, padding));
-    const stubExit = [from[0] + exitStub, from[1]];
-    const stubEntry = [to[0] - entryStub, to[1]];
-    const xMin = Math.min(stubExit[0], stubEntry[0]);
-    const xMax = Math.max(stubExit[0], stubEntry[0]);
-    if (!isSelfConnection && to[0] > from[0]) {
-        // Forward connection
-        let candidateY = (from[1] + to[1]) / 2;
-        const intermediateBoxes = inflatedBoxes.filter((box) => box.left < xMax && box.right > xMin);
-        if (intermediateBoxes.length >= 2) {
-            const clusterTop = Math.min(...intermediateBoxes.map((b) => b.top));
-            const clusterBottom = Math.max(...intermediateBoxes.map((b) => b.bottom));
-            if (candidateY > clusterTop && candidateY < clusterBottom) {
-                const distToTop = candidateY - clusterTop;
-                const distToBottom = clusterBottom - candidateY;
-                candidateY = distToTop <= distToBottom
-                    ? clusterTop - padding
-                    : clusterBottom + padding;
-            }
-        }
-        let clearY = findClearY(xMin, xMax, candidateY, inflatedBoxes);
-        if (Math.abs(from[1] - to[1]) < JOG_THRESHOLD && Math.abs(clearY - from[1]) < JOG_THRESHOLD) {
-            return null; // Fall back to bezier
-        }
-        // Try center-corner: single vertical turn at the midpoint
-        const midX = (stubExit[0] + stubEntry[0]) / 2;
-        const yMin = Math.min(from[1], to[1]);
-        const yMax = Math.max(from[1], to[1]);
-        const clearMidX = findClearX(yMin, yMax, midX, inflatedBoxes);
-        const freeMidX = allocator.findFreeX(yMin, yMax, clearMidX, inflatedBoxes);
-        if (yMax - yMin >= JOG_THRESHOLD &&
-            freeMidX > stubExit[0] &&
-            freeMidX < stubEntry[0] &&
-            verticalSegmentClear(freeMidX, yMin, yMax, inflatedBoxes) &&
-            allocator.findFreeY(from[0], freeMidX, from[1], inflatedBoxes) === from[1] &&
-            allocator.findFreeY(freeMidX, to[0], to[1], inflatedBoxes) === to[1]) {
-            allocator.claim(from[0], freeMidX, from[1]);
-            allocator.claim(freeMidX, to[0], to[1]);
-            allocator.claimVertical(yMin, yMax, freeMidX);
-            return simplifyWaypoints([from, [freeMidX, from[1]], [freeMidX, to[1]], to]);
-        }
-        // S-shape with horizontal channel
-        clearY = allocator.findFreeY(xMin, xMax, clearY, inflatedBoxes);
-        if (Math.abs(clearY - from[1]) < JOG_THRESHOLD &&
-            !inflatedBoxes.some((box) => segmentOverlapsBox(xMin, xMax, from[1], box))) {
-            clearY = from[1];
-        }
-        else if (Math.abs(clearY - to[1]) < JOG_THRESHOLD &&
-            !inflatedBoxes.some((box) => segmentOverlapsBox(xMin, xMax, to[1], box))) {
-            clearY = to[1];
-        }
-        allocator.claim(xMin, xMax, clearY);
-        // Validate vertical segments
-        const exitYMin = Math.min(from[1], clearY);
-        const exitYMax = Math.max(from[1], clearY);
-        let exitX = findClearX(exitYMin, exitYMax, stubExit[0], inflatedBoxes);
-        exitX = allocator.findFreeX(exitYMin, exitYMax, exitX, inflatedBoxes);
-        if (exitX < from[0]) {
-            exitX = stubExit[0];
-            if (!verticalSegmentClear(exitX, exitYMin, exitYMax, inflatedBoxes)) {
-                exitX = findClearX(exitYMin, exitYMax, stubExit[0] + TRACK_SPACING, inflatedBoxes);
-                exitX = allocator.findFreeX(exitYMin, exitYMax, exitX, inflatedBoxes);
-            }
-        }
-        allocator.claimVertical(exitYMin, exitYMax, exitX);
-        const entryYMin = Math.min(to[1], clearY);
-        const entryYMax = Math.max(to[1], clearY);
-        let entryX = findClearX(entryYMin, entryYMax, stubEntry[0], inflatedBoxes);
-        entryX = allocator.findFreeX(entryYMin, entryYMax, entryX, inflatedBoxes);
-        if (entryX > to[0]) {
-            entryX = stubEntry[0];
-            if (!verticalSegmentClear(entryX, entryYMin, entryYMax, inflatedBoxes)) {
-                entryX = findClearX(entryYMin, entryYMax, stubEntry[0] - TRACK_SPACING, inflatedBoxes);
-                entryX = allocator.findFreeX(entryYMin, entryYMax, entryX, inflatedBoxes);
-            }
-        }
-        allocator.claimVertical(entryYMin, entryYMax, entryX);
-        return simplifyWaypoints([
-            from,
-            [exitX, from[1]],
-            [exitX, clearY],
-            [entryX, clearY],
-            [entryX, to[1]],
-            to,
-        ]);
-    }
-    else {
-        // Backward connection or self-connection — escape vertically, loop around
-        const sourceBox = nodeBoxes.find((b) => b.id === sourceNodeId);
-        const targetBox = nodeBoxes.find((b) => b.id === targetNodeId);
-        const corridorBoxes = inflatedBoxes.filter((box) => box.left < xMax && box.right > xMin);
-        const bottoms = corridorBoxes.map((b) => b.bottom);
-        const tops = corridorBoxes.map((b) => b.top);
-        if (sourceBox) {
-            bottoms.push(sourceBox.y + sourceBox.height + padding);
-            tops.push(sourceBox.y - padding);
-        }
-        if (targetBox) {
-            bottoms.push(targetBox.y + targetBox.height + padding);
-            tops.push(targetBox.y - padding);
-        }
-        const maxBottom = Math.max(...bottoms, from[1] + 50, to[1] + 50);
-        const minTop = Math.min(...tops, from[1] - 50, to[1] - 50);
-        const avgY = (from[1] + to[1]) / 2;
-        const escapeBelow = maxBottom + padding;
-        const escapeAbove = minTop - padding;
-        let escapeY = Math.abs(escapeAbove - avgY) <= Math.abs(escapeBelow - avgY) ? escapeAbove : escapeBelow;
-        escapeY = findClearY(xMin, xMax, escapeY, inflatedBoxes);
-        escapeY = allocator.findFreeY(xMin, xMax, escapeY, inflatedBoxes);
-        allocator.claim(xMin, xMax, escapeY);
-        const bwExitYMin = Math.min(from[1], escapeY);
-        const bwExitYMax = Math.max(from[1], escapeY);
-        let bwExitX = findClearX(bwExitYMin, bwExitYMax, stubExit[0], inflatedBoxes);
-        bwExitX = allocator.findFreeX(bwExitYMin, bwExitYMax, bwExitX, inflatedBoxes);
-        allocator.claimVertical(bwExitYMin, bwExitYMax, bwExitX);
-        const bwEntryYMin = Math.min(to[1], escapeY);
-        const bwEntryYMax = Math.max(to[1], escapeY);
-        let bwEntryX = findClearX(bwEntryYMin, bwEntryYMax, stubEntry[0], inflatedBoxes);
-        bwEntryX = allocator.findFreeX(bwEntryYMin, bwEntryYMax, bwEntryX, inflatedBoxes);
-        allocator.claimVertical(bwEntryYMin, bwEntryYMax, bwEntryX);
-        return simplifyWaypoints([
-            from,
-            [bwExitX, from[1]],
-            [bwExitX, escapeY],
-            [bwEntryX, escapeY],
-            [bwEntryX, to[1]],
-            to,
-        ]);
-    }
-}
-// ─── Public API ───
-/**
- * Calculate an orthogonal SVG path between two ports.
- * Returns null if the path should fall back to bezier (e.g. nearly aligned ports).
- */
-export function calculateOrthogonalPath(from, to, nodeBoxes, sourceNodeId, targetNodeId, options, allocator) {
-    const cornerRadius = options?.cornerRadius ?? 10;
-    const padding = options?.padding ?? 15;
-    const stubLength = options?.stubLength ?? 20;
-    const stubSpacing = options?.stubSpacing ?? 12;
-    const maxStubLength = options?.maxStubLength ?? 80;
-    const fromPortIndex = options?.fromPortIndex ?? 0;
-    const toPortIndex = options?.toPortIndex ?? 0;
-    const exitStub = Math.min(stubLength + fromPortIndex * stubSpacing, maxStubLength);
-    const entryStub = Math.min(stubLength + toPortIndex * stubSpacing, maxStubLength);
-    const alloc = allocator ?? new TrackAllocator();
-    const waypoints = computeWaypoints(from, to, nodeBoxes, sourceNodeId, targetNodeId, padding, exitStub, entryStub, alloc);
-    if (!waypoints)
-        return null;
-    return waypointsToSvgPath(waypoints, cornerRadius);
-}
-/**
- * Safe wrapper — returns null if routing fails, caller falls back to bezier.
- */
-export function calculateOrthogonalPathSafe(from, to, nodeBoxes, sourceNodeId, targetNodeId, options, allocator) {
-    try {
-        const path = calculateOrthogonalPath(from, to, nodeBoxes, sourceNodeId, targetNodeId, options, allocator);
-        if (!path || path.length < 5)
-            return null;
-        return path;
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=orthogonal-router.js.map

package/dist/diagram/renderer.d.ts

@@ -1,3 +0,0 @@
-import type { DiagramGraph, DiagramOptions } from './types.js';
-export declare function renderSVG(graph: DiagramGraph, options?: DiagramOptions): string;
-//# sourceMappingURL=renderer.d.ts.map