@eclipse-glsp/client 2.7.0-next.3 → 2.7.0

package/lib/features/routing/sticky-manhattan-edge-router.js

@@ -0,0 +1,626 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var GLSPStickyManhattanEdgeRouter_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GLSPStickyManhattanEdgeRouter = void 0;
+/********************************************************************************
+ * Copyright (c) 2022-2026 Imixs Software Solutions GmbH.
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+const sprotty_1 = require("@eclipse-glsp/sprotty");
+const inversify_1 = require("inversify");
+const edge_router_1 = require("./edge-router");
+/**
+ * An alternative Manhattan-style edge router that preserves existing bend points.
+ *
+ * In contrast to the standard {@link GLSPManhattanEdgeRouter} which recomputes the
+ * full route whenever a connected node moves, this router only adjusts the corner
+ * adjacent to the moved endpoint. Intermediate bend points are kept in place, which
+ * results in more predictable routing when users reposition nodes in complex
+ * diagrams.
+ *
+ * Opt-in per edge by setting `edge.routerKind = 'sticky-manhattan'`.
+ *
+ * @experimental The API surface and implementation details of this router may
+ * change in future releases, potentially in breaking ways, as we iterate on the
+ * initial implementation.
+ *
+ * Based on the original `BPMNManhattanRouter` by Ralph Soika (Imixs Software
+ * Solutions GmbH), contributed via https://github.com/eclipse-glsp/glsp/discussions/1642.
+ */
+let GLSPStickyManhattanEdgeRouter = GLSPStickyManhattanEdgeRouter_1 = class GLSPStickyManhattanEdgeRouter extends edge_router_1.GLSPAbstractEdgeRouter {
+    constructor() {
+        super(...arguments);
+        /** Move-detection baseline: source/target bounds at the last persistence. */
+        this.elementPositions = new WeakMap();
+    }
+    get kind() {
+        return GLSPStickyManhattanEdgeRouter_1.KIND;
+    }
+    getOptions(edge) {
+        return {
+            standardDistance: 20,
+            minimalPointDistance: 3,
+            selfEdgeOffset: 0.25,
+            axisTolerance: 1
+        };
+    }
+    route(edge) {
+        var _a, _b;
+        if (!edge.source || !edge.target || !edge.source.bounds || !edge.target.bounds) {
+            return [];
+        }
+        const routedCorners = this.createRoutedCorners(edge);
+        const sourceRefPoint = (_a = routedCorners[0]) !== null && _a !== void 0 ? _a : sprotty_1.Bounds.center(edge.target.bounds);
+        const targetRefPoint = (_b = routedCorners[routedCorners.length - 1]) !== null && _b !== void 0 ? _b : sprotty_1.Bounds.center(edge.source.bounds);
+        const sourceAnchor = this.getTranslatedAnchor(edge.source, sourceRefPoint, edge.parent, edge, edge.sourceAnchorCorrection);
+        const targetAnchor = this.getTranslatedAnchor(edge.target, targetRefPoint, edge.parent, edge, edge.targetAnchorCorrection);
+        if (!sourceAnchor || !targetAnchor) {
+            return [];
+        }
+        const result = [];
+        result.push({ kind: 'source', ...sourceAnchor });
+        routedCorners.forEach(corner => result.push(corner));
+        result.push({ kind: 'target', ...targetAnchor });
+        // Guard against NaN coordinates which would break path rendering downstream.
+        const sanitized = result.filter(p => !isNaN(p.x) && !isNaN(p.y));
+        if (sanitized.length < 2) {
+            return [];
+        }
+        return sanitized;
+    }
+    commitRoute(edge, routedPoints) {
+        super.commitRoute(edge, routedPoints);
+        this.captureBaseline(edge);
+    }
+    /** Snapshots current source/target bounds as the move-detection baseline. */
+    captureBaseline(edge) {
+        var _a, _b;
+        if (((_a = edge.source) === null || _a === void 0 ? void 0 : _a.bounds) && ((_b = edge.target) === null || _b === void 0 ? void 0 : _b.bounds)) {
+            this.elementPositions.set(edge, {
+                sourceX: edge.source.bounds.x,
+                sourceY: edge.source.bounds.y,
+                targetX: edge.target.bounds.x,
+                targetY: edge.target.bounds.y
+            });
+        }
+    }
+    /**
+     * Computes the intermediate corner points between source and target anchors.
+     *
+     * If the edge already has routing points and the connected nodes have moved
+     * since the previous route, the existing corners are preserved and only the
+     * endpoints closest to the moved node(s) slide along their constrained axis.
+     * Otherwise the corners are recomputed from scratch based on the current node
+     * geometry.
+     */
+    createRoutedCorners(edge) {
+        var _a, _b;
+        if (!((_a = edge.source) === null || _a === void 0 ? void 0 : _a.bounds) || !((_b = edge.target) === null || _b === void 0 ? void 0 : _b.bounds)) {
+            return [];
+        }
+        if (edge.routingPoints && edge.routingPoints.length > 0) {
+            const srcBounds = edge.source.bounds;
+            const tgtBounds = edge.target.bounds;
+            const lastPos = this.elementPositions.get(edge);
+            const elementMoved = lastPos !== undefined &&
+                (lastPos.sourceX !== srcBounds.x ||
+                    lastPos.sourceY !== srcBounds.y ||
+                    lastPos.targetX !== tgtBounds.x ||
+                    lastPos.targetY !== tgtBounds.y);
+            // Seed the baseline on first sight; later refreshes happen in
+            // commitRoute / cleanupRoutingPoints to keep route() pure.
+            if (lastPos === undefined) {
+                this.elementPositions.set(edge, {
+                    sourceX: srcBounds.x,
+                    sourceY: srcBounds.y,
+                    targetX: tgtBounds.x,
+                    targetY: tgtBounds.y
+                });
+            }
+            const points = edge.routingPoints.slice();
+            const sourceAnchors = new sprotty_1.DefaultAnchors(edge.source, edge.parent, 'source');
+            const targetAnchors = new sprotty_1.DefaultAnchors(edge.target, edge.parent, 'target');
+            if (elementMoved) {
+                // Follow-adjust endpoints; rendering-only, edge.routingPoints
+                // is persisted via commitRoute.
+                this.applyFollowLogic(points, edge, sourceAnchors);
+                this.cleanupRoutingPoints(edge, points, false, false, sourceAnchors, targetAnchors);
+            }
+            else {
+                this.cleanupRoutingPoints(edge, points, false, true, sourceAnchors, targetAnchors);
+            }
+            if (points.length > 0) {
+                return points.map((rp, index) => ({
+                    kind: 'linear',
+                    pointIndex: index,
+                    x: rp.x,
+                    y: rp.y
+                }));
+            }
+        }
+        // Fresh-default fallback: drop the baseline so the next real route re-seeds.
+        this.elementPositions.delete(edge);
+        const sourceAnchors = new sprotty_1.DefaultAnchors(edge.source, edge.parent, 'source');
+        const targetAnchors = new sprotty_1.DefaultAnchors(edge.target, edge.parent, 'target');
+        const options = this.getOptions(edge);
+        const bestAnchors = this.getBestConnectionAnchors(sourceAnchors, targetAnchors, options);
+        const corners = this.calculateCorners(sourceAnchors, targetAnchors, bestAnchors, options);
+        return corners.map((corner, index) => ({
+            kind: 'linear',
+            pointIndex: index,
+            x: corner.x,
+            y: corner.y
+        }));
+    }
+    /**
+     * Adjusts the endpoints of the existing route so they follow the moved node(s).
+     * The corner adjacent to a moved endpoint slides along its constrained axis so
+     * that the route stays orthogonal without discarding intermediate bend points.
+     */
+    applyFollowLogic(points, edge, sourceAnchors) {
+        const sourceAnchor = this.getTranslatedAnchor(edge.source, points[0], edge.parent, edge, edge.sourceAnchorCorrection);
+        const targetAnchor = this.getTranslatedAnchor(edge.target, points[points.length - 1], edge.parent, edge, edge.targetAnchorCorrection);
+        if (!sourceAnchor || !targetAnchor) {
+            return;
+        }
+        const { axisTolerance } = this.getOptions(edge);
+        if (points.length === 1) {
+            // Classify the first segment via the source side closest to the bend — this
+            // matches how the Manhattan anchor computer picks the source anchor.
+            sourceAnchors !== null && sourceAnchors !== void 0 ? sourceAnchors : (sourceAnchors = new sprotty_1.DefaultAnchors(edge.source, edge.parent, 'source'));
+            const side = sourceAnchors.getNearestSide(points[0]);
+            const isVertical = side === sprotty_1.Side.TOP || side === sprotty_1.Side.BOTTOM;
+            if (isVertical) {
+                points[0] = { x: sourceAnchor.x, y: sprotty_1.Bounds.center(edge.target.bounds).y };
+            }
+            else {
+                points[0] = { x: sprotty_1.Bounds.center(edge.target.bounds).x, y: sourceAnchor.y };
+            }
+            return;
+        }
+        // First corner follows the source element.
+        if (sprotty_1.Point.isVerticalAligned(points[0], points[1], axisTolerance)) {
+            points[0] = { x: points[0].x, y: sprotty_1.Bounds.center(edge.source.bounds).y };
+        }
+        else {
+            points[0] = { x: sprotty_1.Bounds.center(edge.source.bounds).x, y: points[0].y };
+        }
+        // Last corner follows the target element.
+        const last = points.length - 1;
+        if (sprotty_1.Point.isVerticalAligned(points[last], points[last - 1], axisTolerance)) {
+            points[last] = { x: points[last].x, y: sprotty_1.Bounds.center(edge.target.bounds).y };
+        }
+        else {
+            points[last] = { x: sprotty_1.Bounds.center(edge.target.bounds).x, y: points[last].y };
+        }
+    }
+    createRoutingHandles(edge) {
+        const routedPoints = this.route(edge);
+        this.commitRoute(edge, routedPoints);
+        if (routedPoints.length > 0) {
+            this.addHandle(edge, 'source', 'routing-point', -2);
+            for (let i = 0; i < routedPoints.length - 1; i++) {
+                this.addHandle(edge, 'manhattan-50%', 'volatile-routing-point', i - 1);
+            }
+            this.addHandle(edge, 'target', 'routing-point', routedPoints.length - 2);
+        }
+    }
+    getInnerHandlePosition(edge, route, handle) {
+        if (handle.kind === 'manhattan-50%') {
+            const { start, end } = this.findRouteSegment(edge, route, handle.pointIndex);
+            if (start !== undefined && end !== undefined) {
+                return sprotty_1.Point.linear(start, end, 0.5);
+            }
+        }
+        return undefined;
+    }
+    applyInnerHandleMoves(edge, moves) {
+        const route = this.route(edge);
+        const routingPoints = edge.routingPoints;
+        const { minimalPointDistance, axisTolerance } = this.getOptions(edge);
+        moves.forEach(move => {
+            const handle = move.handle;
+            const index = handle.pointIndex;
+            if (handle.kind !== 'manhattan-50%') {
+                return;
+            }
+            const correctedX = this.correctX(routingPoints, index, move.toPosition.x, minimalPointDistance);
+            const correctedY = this.correctY(routingPoints, index, move.toPosition.y, minimalPointDistance);
+            if (index < 0) {
+                // First segment: source anchor → first corner.
+                if (routingPoints.length === 0) {
+                    routingPoints.push({ x: correctedX, y: correctedY });
+                    handle.pointIndex = 0;
+                }
+                else if (sprotty_1.Point.isVerticalAligned(route[0], route[1], axisTolerance)) {
+                    this.alignX(routingPoints, 0, correctedX);
+                }
+                else {
+                    this.alignY(routingPoints, 0, correctedY);
+                }
+            }
+            else if (index < routingPoints.length - 1) {
+                // Inner segment: move both endpoints of the segment in lockstep.
+                if (sprotty_1.Point.isVerticalAligned(routingPoints[index], routingPoints[index + 1], axisTolerance)) {
+                    this.alignX(routingPoints, index, correctedX);
+                    this.alignX(routingPoints, index + 1, correctedX);
+                }
+                else {
+                    this.alignY(routingPoints, index, correctedY);
+                    this.alignY(routingPoints, index + 1, correctedY);
+                }
+            }
+            else {
+                // Last segment: last corner → target anchor.
+                if (routingPoints.length === 0) {
+                    routingPoints.push({ x: correctedX, y: correctedY });
+                    handle.pointIndex = 0;
+                }
+                else if (sprotty_1.Point.isVerticalAligned(route[route.length - 2], route[route.length - 1], axisTolerance)) {
+                    this.alignX(routingPoints, routingPoints.length - 1, correctedX);
+                }
+                else {
+                    this.alignY(routingPoints, routingPoints.length - 1, correctedY);
+                }
+            }
+        });
+    }
+    cleanupRoutingPoints(edge, routingPoints, updateHandles, addRoutingPoints, sourceAnchors, targetAnchors) {
+        if (!(0, edge_router_1.ensureBounds)(edge.source) || !(0, edge_router_1.ensureBounds)(edge.target)) {
+            return;
+        }
+        sourceAnchors !== null && sourceAnchors !== void 0 ? sourceAnchors : (sourceAnchors = new sprotty_1.DefaultAnchors(edge.source, edge.parent, 'source'));
+        targetAnchors !== null && targetAnchors !== void 0 ? targetAnchors : (targetAnchors = new sprotty_1.DefaultAnchors(edge.target, edge.parent, 'target'));
+        const options = this.getOptions(edge);
+        // Persistence-style cleanup (applyHandleMoves / applyReconnect): refresh
+        // baseline so route() doesn't re-follow the committed coordinates.
+        if (updateHandles) {
+            this.captureBaseline(edge);
+        }
+        if (this.resetRoutingPointsOnReconnect(edge, routingPoints, updateHandles, sourceAnchors, targetAnchors)) {
+            return;
+        }
+        // Remove leading routing points that fall inside the source bounds.
+        for (let i = 0; i < routingPoints.length; i++) {
+            if (sprotty_1.Bounds.includes(sourceAnchors.bounds, routingPoints[i])) {
+                routingPoints.splice(0, 1);
+                if (updateHandles) {
+                    this.removeHandle(edge, -1);
+                }
+                i--;
+            }
+            else {
+                break;
+            }
+        }
+        // Remove trailing routing points that fall inside the target bounds.
+        for (let i = routingPoints.length - 1; i >= 0; i--) {
+            if (sprotty_1.Bounds.includes(targetAnchors.bounds, routingPoints[i])) {
+                routingPoints.splice(i, 1);
+                if (updateHandles) {
+                    this.removeHandle(edge, i);
+                }
+            }
+            else {
+                break;
+            }
+        }
+        // Collapse degenerate segments shorter than minimalPointDistance.
+        if (routingPoints.length >= 2) {
+            for (let i = routingPoints.length - 2; i >= 0; i--) {
+                if (sprotty_1.Point.manhattanDistance(routingPoints[i], routingPoints[i + 1]) < options.minimalPointDistance) {
+                    routingPoints.splice(i, 2);
+                    i--;
+                    if (updateHandles) {
+                        this.removeHandle(edge, i - 1);
+                        this.removeHandle(edge, i);
+                    }
+                }
+            }
+        }
+        if (addRoutingPoints) {
+            this.addAdditionalCorner(edge, routingPoints, sourceAnchors, targetAnchors, updateHandles);
+            this.addAdditionalCorner(edge, routingPoints, targetAnchors, sourceAnchors, updateHandles);
+            this.manhattanify(routingPoints, edge);
+        }
+    }
+    removeHandle(edge, pointIndex) {
+        const toBeRemoved = [];
+        edge.children.forEach(child => {
+            if (child instanceof sprotty_1.GRoutingHandle) {
+                if (child.pointIndex > pointIndex) {
+                    child.pointIndex--;
+                }
+                else if (child.pointIndex === pointIndex) {
+                    toBeRemoved.push(child);
+                }
+            }
+        });
+        toBeRemoved.forEach(child => edge.remove(child));
+    }
+    /**
+     * Inserts an additional corner when the first/last routing point is outside
+     * the node bounds in the direction of the adjacent segment. This keeps the
+     * route orthogonal after routing points have been dragged outside the node.
+     */
+    addAdditionalCorner(edge, points, currentAnchors, otherAnchors, updateHandles) {
+        if (points.length === 0) {
+            return;
+        }
+        const isSource = currentAnchors.kind === 'source';
+        const refPoint = isSource ? points[0] : points[points.length - 1];
+        const insertIndex = isSource ? 0 : points.length;
+        const shiftIndex = insertIndex - (isSource ? 1 : 0);
+        const { axisTolerance } = this.getOptions(edge);
+        let isHorizontal;
+        if (points.length > 1) {
+            isHorizontal = isSource
+                ? sprotty_1.Point.isVerticalAligned(points[0], points[1], axisTolerance)
+                : sprotty_1.Point.isVerticalAligned(points[points.length - 1], points[points.length - 2], axisTolerance);
+        }
+        else {
+            const nearestSide = otherAnchors.getNearestSide(refPoint);
+            isHorizontal = nearestSide === sprotty_1.Side.TOP || nearestSide === sprotty_1.Side.BOTTOM;
+        }
+        if (isHorizontal) {
+            const topY = currentAnchors.get(sprotty_1.Side.TOP).y;
+            const bottomY = currentAnchors.get(sprotty_1.Side.BOTTOM).y;
+            if (refPoint.y < topY || refPoint.y > bottomY) {
+                const newPoint = { x: currentAnchors.get(sprotty_1.Side.TOP).x, y: refPoint.y };
+                points.splice(insertIndex, 0, newPoint);
+                if (updateHandles) {
+                    edge.children.forEach(child => {
+                        if (child instanceof sprotty_1.GRoutingHandle && child.pointIndex >= shiftIndex) {
+                            child.pointIndex++;
+                        }
+                    });
+                    this.addHandle(edge, 'manhattan-50%', 'volatile-routing-point', shiftIndex);
+                }
+            }
+        }
+        else {
+            const leftX = currentAnchors.get(sprotty_1.Side.LEFT).x;
+            const rightX = currentAnchors.get(sprotty_1.Side.RIGHT).x;
+            if (refPoint.x < leftX || refPoint.x > rightX) {
+                const newPoint = { x: refPoint.x, y: currentAnchors.get(sprotty_1.Side.LEFT).y };
+                points.splice(insertIndex, 0, newPoint);
+                if (updateHandles) {
+                    edge.children.forEach(child => {
+                        if (child instanceof sprotty_1.GRoutingHandle && child.pointIndex >= shiftIndex) {
+                            child.pointIndex++;
+                        }
+                    });
+                    this.addHandle(edge, 'manhattan-50%', 'volatile-routing-point', shiftIndex);
+                }
+            }
+        }
+    }
+    /** Inserts intermediate corner points so every segment is strictly orthogonal. */
+    manhattanify(points, edge) {
+        const { axisTolerance } = this.getOptions(edge);
+        for (let i = 1; i < points.length; i++) {
+            if (!sprotty_1.Point.isAxisAligned(points[i - 1], points[i], axisTolerance)) {
+                points.splice(i, 0, { x: points[i - 1].x, y: points[i].y });
+                i++;
+            }
+        }
+    }
+    /**
+     * Picks the sides on source and target for a fresh default route, preferring
+     * (in order) direct, one-corner, and finally two-corner connections.
+     */
+    getBestConnectionAnchors(sourceAnchors, targetAnchors, options) {
+        const sd = options.standardDistance;
+        // Direct connections (no corners).
+        if (targetAnchors.get(sprotty_1.Side.LEFT).x - sourceAnchors.get(sprotty_1.Side.RIGHT).x > sd) {
+            return { source: sprotty_1.Side.RIGHT, target: sprotty_1.Side.LEFT };
+        }
+        if (sourceAnchors.get(sprotty_1.Side.LEFT).x - targetAnchors.get(sprotty_1.Side.RIGHT).x > sd) {
+            return { source: sprotty_1.Side.LEFT, target: sprotty_1.Side.RIGHT };
+        }
+        if (sourceAnchors.get(sprotty_1.Side.TOP).y - targetAnchors.get(sprotty_1.Side.BOTTOM).y > sd) {
+            return { source: sprotty_1.Side.TOP, target: sprotty_1.Side.BOTTOM };
+        }
+        if (targetAnchors.get(sprotty_1.Side.TOP).y - sourceAnchors.get(sprotty_1.Side.BOTTOM).y > sd) {
+            return { source: sprotty_1.Side.BOTTOM, target: sprotty_1.Side.TOP };
+        }
+        // One-corner connections.
+        if (targetAnchors.get(sprotty_1.Side.TOP).x - sourceAnchors.get(sprotty_1.Side.RIGHT).x > 0.5 * sd &&
+            targetAnchors.get(sprotty_1.Side.TOP).y - sourceAnchors.get(sprotty_1.Side.RIGHT).y > sd) {
+            return { source: sprotty_1.Side.RIGHT, target: sprotty_1.Side.TOP };
+        }
+        if (targetAnchors.get(sprotty_1.Side.BOTTOM).x - sourceAnchors.get(sprotty_1.Side.RIGHT).x > 0.5 * sd &&
+            sourceAnchors.get(sprotty_1.Side.RIGHT).y - targetAnchors.get(sprotty_1.Side.BOTTOM).y > sd) {
+            return { source: sprotty_1.Side.RIGHT, target: sprotty_1.Side.BOTTOM };
+        }
+        if (sourceAnchors.get(sprotty_1.Side.LEFT).x - targetAnchors.get(sprotty_1.Side.BOTTOM).x > 0.5 * sd &&
+            sourceAnchors.get(sprotty_1.Side.LEFT).y - targetAnchors.get(sprotty_1.Side.BOTTOM).y > sd) {
+            return { source: sprotty_1.Side.LEFT, target: sprotty_1.Side.BOTTOM };
+        }
+        if (sourceAnchors.get(sprotty_1.Side.LEFT).x - targetAnchors.get(sprotty_1.Side.TOP).x > 0.5 * sd &&
+            targetAnchors.get(sprotty_1.Side.TOP).y - sourceAnchors.get(sprotty_1.Side.LEFT).y > sd) {
+            return { source: sprotty_1.Side.LEFT, target: sprotty_1.Side.TOP };
+        }
+        if (targetAnchors.get(sprotty_1.Side.RIGHT).y - sourceAnchors.get(sprotty_1.Side.BOTTOM).y > 0.5 * sd &&
+            sourceAnchors.get(sprotty_1.Side.BOTTOM).x - targetAnchors.get(sprotty_1.Side.RIGHT).x > sd) {
+            return { source: sprotty_1.Side.BOTTOM, target: sprotty_1.Side.RIGHT };
+        }
+        if (targetAnchors.get(sprotty_1.Side.LEFT).y - sourceAnchors.get(sprotty_1.Side.BOTTOM).y > 0.5 * sd &&
+            targetAnchors.get(sprotty_1.Side.LEFT).x - sourceAnchors.get(sprotty_1.Side.BOTTOM).x > sd) {
+            return { source: sprotty_1.Side.BOTTOM, target: sprotty_1.Side.LEFT };
+        }
+        // Two-corner fallback. Simpler than sprotty's equivalent: no distance
+        // gate on same-side candidates, no diagonal fallbacks.
+        const srcTop = sourceAnchors.get(sprotty_1.Side.TOP);
+        const tgtTop = targetAnchors.get(sprotty_1.Side.TOP);
+        if (!sprotty_1.Bounds.includes(targetAnchors.bounds, srcTop) && !sprotty_1.Bounds.includes(sourceAnchors.bounds, tgtTop)) {
+            return { source: sprotty_1.Side.TOP, target: sprotty_1.Side.TOP };
+        }
+        const srcRight = sourceAnchors.get(sprotty_1.Side.RIGHT);
+        const tgtRight = targetAnchors.get(sprotty_1.Side.RIGHT);
+        if (!sprotty_1.Bounds.includes(targetAnchors.bounds, srcRight) && !sprotty_1.Bounds.includes(sourceAnchors.bounds, tgtRight)) {
+            return { source: sprotty_1.Side.RIGHT, target: sprotty_1.Side.RIGHT };
+        }
+        return { source: sprotty_1.Side.RIGHT, target: sprotty_1.Side.LEFT };
+    }
+    /** Computes 0, 1, or 2 corner points for a fresh default route between the given sides. */
+    calculateCorners(sourceAnchors, targetAnchors, sides, options) {
+        const src = sourceAnchors.get(sides.source);
+        const tgt = targetAnchors.get(sides.target);
+        const sd = options.standardDistance;
+        switch (sides.source) {
+            case sprotty_1.Side.RIGHT:
+                switch (sides.target) {
+                    case sprotty_1.Side.LEFT: {
+                        if (src.y !== tgt.y) {
+                            const midX = (src.x + tgt.x) / 2;
+                            return [
+                                { x: midX, y: src.y },
+                                { x: midX, y: tgt.y }
+                            ];
+                        }
+                        return [];
+                    }
+                    case sprotty_1.Side.TOP:
+                    case sprotty_1.Side.BOTTOM:
+                        return [{ x: tgt.x, y: src.y }];
+                    case sprotty_1.Side.RIGHT: {
+                        const maxX = Math.max(src.x, tgt.x) + 1.5 * sd;
+                        return [
+                            { x: maxX, y: src.y },
+                            { x: maxX, y: tgt.y }
+                        ];
+                    }
+                }
+                break;
+            case sprotty_1.Side.LEFT:
+                switch (sides.target) {
+                    case sprotty_1.Side.RIGHT: {
+                        if (src.y !== tgt.y) {
+                            const midX = (src.x + tgt.x) / 2;
+                            return [
+                                { x: midX, y: src.y },
+                                { x: midX, y: tgt.y }
+                            ];
+                        }
+                        return [];
+                    }
+                    case sprotty_1.Side.TOP:
+                    case sprotty_1.Side.BOTTOM:
+                        return [{ x: tgt.x, y: src.y }];
+                    default: {
+                        const minX = Math.min(src.x, tgt.x) - 1.5 * sd;
+                        return [
+                            { x: minX, y: src.y },
+                            { x: minX, y: tgt.y }
+                        ];
+                    }
+                }
+            case sprotty_1.Side.TOP:
+                switch (sides.target) {
+                    case sprotty_1.Side.BOTTOM: {
+                        if (src.x !== tgt.x) {
+                            const midY = (src.y + tgt.y) / 2;
+                            return [
+                                { x: src.x, y: midY },
+                                { x: tgt.x, y: midY }
+                            ];
+                        }
+                        return [];
+                    }
+                    case sprotty_1.Side.TOP: {
+                        const minY = Math.min(src.y, tgt.y) - 1.5 * sd;
+                        return [
+                            { x: src.x, y: minY },
+                            { x: tgt.x, y: minY }
+                        ];
+                    }
+                    case sprotty_1.Side.RIGHT:
+                    case sprotty_1.Side.LEFT:
+                        return [{ x: src.x, y: tgt.y }];
+                }
+                break;
+            case sprotty_1.Side.BOTTOM:
+                switch (sides.target) {
+                    case sprotty_1.Side.TOP: {
+                        if (src.x !== tgt.x) {
+                            const midY = (src.y + tgt.y) / 2;
+                            return [
+                                { x: src.x, y: midY },
+                                { x: tgt.x, y: midY }
+                            ];
+                        }
+                        return [];
+                    }
+                    case sprotty_1.Side.BOTTOM: {
+                        const maxY = Math.max(src.y, tgt.y) + 1.5 * sd;
+                        return [
+                            { x: src.x, y: maxY },
+                            { x: tgt.x, y: maxY }
+                        ];
+                    }
+                    case sprotty_1.Side.RIGHT:
+                    case sprotty_1.Side.LEFT:
+                        return [{ x: src.x, y: tgt.y }];
+                }
+                break;
+        }
+        const midX = (src.x + tgt.x) / 2;
+        return [
+            { x: midX, y: src.y },
+            { x: midX, y: tgt.y }
+        ];
+    }
+    correctX(routingPoints, index, x, minimalPointDistance) {
+        if (index > 0 && Math.abs(x - routingPoints[index - 1].x) < minimalPointDistance) {
+            return routingPoints[index - 1].x;
+        }
+        if (index < routingPoints.length - 2 && Math.abs(x - routingPoints[index + 2].x) < minimalPointDistance) {
+            return routingPoints[index + 2].x;
+        }
+        return x;
+    }
+    correctY(routingPoints, index, y, minimalPointDistance) {
+        if (index > 0 && Math.abs(y - routingPoints[index - 1].y) < minimalPointDistance) {
+            return routingPoints[index - 1].y;
+        }
+        if (index < routingPoints.length - 2 && Math.abs(y - routingPoints[index + 2].y) < minimalPointDistance) {
+            return routingPoints[index + 2].y;
+        }
+        return y;
+    }
+    alignX(points, index, x) {
+        if (index >= 0 && index < points.length) {
+            points[index] = { x, y: points[index].y };
+        }
+    }
+    alignY(points, index, y) {
+        if (index >= 0 && index < points.length) {
+            points[index] = { x: points[index].x, y };
+        }
+    }
+};
+exports.GLSPStickyManhattanEdgeRouter = GLSPStickyManhattanEdgeRouter;
+GLSPStickyManhattanEdgeRouter.KIND = 'sticky-manhattan';
+exports.GLSPStickyManhattanEdgeRouter = GLSPStickyManhattanEdgeRouter = GLSPStickyManhattanEdgeRouter_1 = __decorate([
+    (0, inversify_1.injectable)()
+], GLSPStickyManhattanEdgeRouter);
+//# sourceMappingURL=sticky-manhattan-edge-router.js.map