@eclipse-glsp/client 2.7.0-next.1 → 2.7.0-next.11

package/src/features/tool-palette/tool-palette.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2025 EclipseSource and others.
+ * Copyright (c) 2019-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
@@ -580,12 +580,10 @@ export function createToolGroup(item: PaletteItem): HTMLElement {
 }
 
 export function changeCSSClass(element: Element, css: string): void {
-    // eslint-disable-next-line chai-friendly/no-unused-expressions
     element.classList.contains(css) ? element.classList.remove(css) : element.classList.add(css);
 }
 
 export function changeCodiconClass(element: Element, codiconId: string): void {
-    // eslint-disable-next-line chai-friendly/no-unused-expressions
     element.classList.contains(codiconCSSClasses(codiconId)[1])
         ? element.classList.remove(codiconCSSClasses(codiconId)[1])
         : element.classList.add(codiconCSSClasses(codiconId)[1]);

package/src/index.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2024-2025 EclipseSource and others.
+ * Copyright (c) 2024-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
@@ -165,6 +165,8 @@ export * from './features/navigation/navigation-target-resolver';
 export * from './features/reconnect/model';
 export * from './features/routing/edge-router';
 export * from './features/routing/routing-module';
+export * from './features/routing/sticky-manhattan-anchors';
+export * from './features/routing/sticky-manhattan-edge-router';
 export * from './features/save/save-keylistener';
 export * from './features/save/save-module';
 export * from './features/search-palette/search-palette';
@@ -243,9 +245,11 @@ export * from './utils/viewpoint-util';
 export * from './views/base-view-module';
 export * from './views/compartments';
 export * from './views/gedge-view';
+export * from './views/gedge-view-with-gaps-on-intersections';
 export * from './views/ggraph-view';
 export * from './views/glsp-projection-view';
 export * from './views/issue-marker-view';
 export * from './views/rounded-corner';
+export * from './views/rounded-corner-manhattan-edge-view';
 export * from './views/rounded-corner-view';
 export * from './views/routing-point-handle-view';

package/src/views/gedge-view-with-gaps-on-intersections.tsx

@@ -0,0 +1,99 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+/** @jsx svg */
+import {
+    IViewArgs,
+    Point,
+    PolylineEdgeViewWithGapsOnIntersections,
+    RenderingContext,
+    isIntersectingRoutedPoint,
+    svg
+} from '@eclipse-glsp/sprotty';
+import { injectable } from 'inversify';
+import { Classes, VNode } from 'snabbdom';
+import { GEdge } from '../model';
+import { EdgePadding } from '../utils/argument-utils';
+
+/**
+ * Gap-rendering counterpart to {@link GEdgeView}: extends
+ * {@link PolylineEdgeViewWithGapsOnIntersections} and re-adds the GLSP-only
+ * bits from `GEdgeView` — router dispatch, dangling-edge rendering,
+ * `additionalClasses` hook, and the edge-padding mouse-handle overlay.
+ *
+ * Subclasses override {@link createPathForSegments} to inject per-point path
+ * fragments. Intersections are spliced into the rendered line
+ * (`addIntersectionPoints = true`) and skipped for the mouse-handle overlay
+ * so the hit area stays contiguous.
+ */
+@injectable()
+export class GEdgeViewWithGapsOnIntersections extends PolylineEdgeViewWithGapsOnIntersections {
+    override render(edge: Readonly<GEdge>, context: RenderingContext, args?: IViewArgs): VNode {
+        // route(edge, args) picks up the postprocessed routing populated by
+        // SGraphView — that's where IntersectionFinder tags points.
+        const route = this.edgeRouterRegistry.route(edge, args);
+        if (route.length === 0) {
+            return this.renderDanglingEdge('Cannot compute route', edge, context);
+        }
+        return (
+            <g class-sprotty-edge={true} class-mouseover={edge.hoverFeedback} {...this.additionalClasses(edge, context)}>
+                {this.renderLine(edge, route, context, args)}
+                {this.renderAdditionals(edge, route, context)}
+                {context.renderChildren(edge, { route })}
+            </g>
+        );
+    }
+
+    protected additionalClasses(_edge: Readonly<GEdge>, _context: RenderingContext): Classes {
+        return {};
+    }
+
+    protected override renderLine(edge: GEdge, segments: Point[], _context: RenderingContext, args?: IViewArgs): VNode {
+        return <path d={this.createPathForSegments(segments, edge, true, args)} />;
+    }
+
+    protected override renderAdditionals(edge: GEdge, segments: Point[], _context: RenderingContext): VNode[] {
+        const edgePadding = EdgePadding.from(edge);
+        return edgePadding ? [this.renderMouseHandle(edge, segments, edgePadding)] : [];
+    }
+
+    protected renderMouseHandle(edge: GEdge, segments: Point[], padding: number): VNode {
+        return (
+            <path
+                class-mouse-handle
+                d={this.createPathForSegments(segments, edge, false)}
+                style-stroke-width={padding * 2}
+                style-stroke='transparent'
+                style-stroke-dasharray='none'
+                style-stroke-dashoffset='0'
+            />
+        );
+    }
+
+    protected createPathForSegments(segments: Point[], edge: GEdge, addIntersectionPoints: boolean, args?: IViewArgs): string {
+        if (segments.length === 0) {
+            return '';
+        }
+        let path = `M ${segments[0].x},${segments[0].y}`;
+        for (let i = 1; i < segments.length; i++) {
+            const p = segments[i];
+            if (addIntersectionPoints && isIntersectingRoutedPoint(p)) {
+                path += this.intersectionPath(edge, segments, p, args);
+            }
+            path += ` L ${p.x},${p.y}`;
+        }
+        return path;
+    }
+}

package/src/views/issue-marker-view.tsx

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2024 EclipseSource and others.
+ * Copyright (c) 2020-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
@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-/* eslint-disable max-len */
+
 /** @jsx svg */
 import { GIssueSeverity, IssueMarkerView, RenderingContext, setClass, svg } from '@eclipse-glsp/sprotty';
 import { injectable } from 'inversify';

package/src/views/rounded-corner-manhattan-edge-view.ts

@@ -0,0 +1,171 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+import { IntersectingRoutedPoint, IViewArgs, Point, isIntersectingRoutedPoint } from '@eclipse-glsp/sprotty';
+import { injectable } from 'inversify';
+import { GEdge } from '../model';
+import { GEdgeViewWithGapsOnIntersections } from './gedge-view-with-gaps-on-intersections';
+
+/**
+ * Manhattan edge view with rounded bends rendered as quadratic Béziers.
+ * Non-orthogonal inputs render as sharp corners. Radius is clamped per corner;
+ * override {@link cornerRadius} or {@link computeMaxRadius} to tune.
+ *
+ * Inherits gap / line-jump rendering from {@link GEdgeViewWithGapsOnIntersections}.
+ * The rendered line splices intersection fragments between points; the mouse-
+ * handle overlay skips them so the hit area stays contiguous.
+ *
+ * Based on Ralph Soika's `BPMNEdgeView`; see
+ * https://github.com/eclipse-glsp/glsp/discussions/1642.
+ */
+@injectable()
+export class RoundedCornerManhattanEdgeView extends GEdgeViewWithGapsOnIntersections {
+    /** Target corner radius in pixels. The effective radius is clamped per corner. */
+    protected readonly cornerRadius: number = 10;
+
+    /** Lower bound for the effective radius, even on very short adjacent segments. */
+    protected readonly minCornerRadius: number = 2;
+
+    /** Upper fraction of the shorter adjacent segment to use for the radius. */
+    protected readonly maxRadiusFactor: number = 0.45;
+
+    /** Segment length (px) below which {@link shortSegmentRadiusFactor} tightens the radius further. */
+    protected readonly shortSegmentThreshold: number = 5;
+
+    /** Fraction of the shorter adjacent segment to use as the radius below {@link shortSegmentThreshold}. */
+    protected readonly shortSegmentRadiusFactor: number = 0.3;
+
+    protected override createPathForSegments(segments: Point[], edge: GEdge, addIntersectionPoints: boolean, args?: IViewArgs): string {
+        if (segments.length === 0) {
+            return '';
+        }
+        let path = `M ${segments[0].x},${segments[0].y}`;
+        for (let i = 1; i < segments.length; i++) {
+            const p = segments[i];
+            if (addIntersectionPoints && isIntersectingRoutedPoint(p)) {
+                const effective = this.filterCornerZoneIntersections(p, segments, i);
+                if (effective.intersections.length > 0) {
+                    path += this.intersectionPath(edge, segments, effective, args);
+                }
+            }
+            if (i < segments.length - 1) {
+                const prev = segments[i - 1];
+                const next = segments[i + 1];
+                const radius = this.computeMaxRadius(p, prev, next);
+                path += this.renderRoundedCorner(p, prev, next, radius);
+            } else {
+                path += ` L ${p.x},${p.y}`;
+            }
+        }
+        return path;
+    }
+
+    /**
+     * Drops intersections inside either endpoint's rounded-corner zone (padded
+     * by the gap's skip-offset). The gap fragment can't be placed there without
+     * drawing backward into the curve on one side, and the crossing is hidden
+     * behind the curve anyway.
+     */
+    protected filterCornerZoneIntersections(
+        intersectingPoint: IntersectingRoutedPoint,
+        segments: Point[],
+        pointIndex: number
+    ): IntersectingRoutedPoint {
+        const p1 = segments[pointIndex - 1];
+        const p2 = segments[pointIndex];
+        const p1Threshold = this.getCornerRadius(segments, pointIndex - 1) + this.skipOffsetBefore;
+        const p2Threshold = this.getCornerRadius(segments, pointIndex) + this.skipOffsetAfter;
+        const filtered = intersectingPoint.intersections.filter(
+            intersection =>
+                Point.maxDistance(intersection.intersectionPoint, p1) > p1Threshold &&
+                Point.maxDistance(intersection.intersectionPoint, p2) > p2Threshold
+        );
+        return { ...intersectingPoint, intersections: filtered };
+    }
+
+    /** Curve radius at `segments[cornerIndex]`, or 0 for source / target. */
+    protected getCornerRadius(segments: Point[], cornerIndex: number): number {
+        if (cornerIndex <= 0 || cornerIndex >= segments.length - 1) {
+            return 0;
+        }
+        const corner = segments[cornerIndex];
+        const prev = segments[cornerIndex - 1];
+        const next = segments[cornerIndex + 1];
+        return this.computeMaxRadius(corner, prev, next);
+    }
+
+    /** SVG fragment for one rounded corner; falls back to `L` if not a right angle. */
+    protected renderRoundedCorner(corner: Point, prev: Point, next: Point, radius: number): string {
+        // Round only right-angle bends; diagonal / collinear inputs render sharp.
+        const horizIn = Point.isHorizontalAligned(prev, corner);
+        const vertIn = Point.isVerticalAligned(prev, corner);
+        const horizOut = Point.isHorizontalAligned(corner, next);
+        const vertOut = Point.isVerticalAligned(corner, next);
+        const isRightAngle = (horizIn && vertOut && !vertIn) || (vertIn && horizOut && !horizIn);
+        if (!isRightAngle) {
+            return ` L ${corner.x},${corner.y}`;
+        }
+        if (prev.x < corner.x && corner.y < next.y) {
+            // right → down
+            return ` L ${corner.x - radius},${corner.y} Q ${corner.x},${corner.y} ${corner.x},${corner.y + radius}`;
+        }
+        if (prev.y < corner.y && corner.x < next.x) {
+            // down → right
+            return ` L ${corner.x},${corner.y - radius} Q ${corner.x},${corner.y} ${corner.x + radius},${corner.y}`;
+        }
+        if (prev.x < corner.x && corner.y > next.y) {
+            // right → up
+            return ` L ${corner.x - radius},${corner.y} Q ${corner.x},${corner.y} ${corner.x},${corner.y - radius}`;
+        }
+        if (prev.y > corner.y && corner.x < next.x) {
+            // up → right
+            return ` L ${corner.x},${corner.y + radius} Q ${corner.x},${corner.y} ${corner.x + radius},${corner.y}`;
+        }
+        if (prev.y < corner.y && corner.x > next.x) {
+            // down → left
+            return ` L ${corner.x},${corner.y - radius} Q ${corner.x},${corner.y} ${corner.x - radius},${corner.y}`;
+        }
+        if (prev.x > corner.x && corner.y < next.y) {
+            // left → down
+            return ` L ${corner.x + radius},${corner.y} Q ${corner.x},${corner.y} ${corner.x},${corner.y + radius}`;
+        }
+        if (prev.y > corner.y && corner.x > next.x) {
+            // up → left
+            return ` L ${corner.x},${corner.y + radius} Q ${corner.x},${corner.y} ${corner.x - radius},${corner.y}`;
+        }
+        if (prev.x > corner.x && corner.y > next.y) {
+            // left → up
+            return ` L ${corner.x + radius},${corner.y} Q ${corner.x},${corner.y} ${corner.x},${corner.y - radius}`;
+        }
+        return ` L ${corner.x},${corner.y}`;
+    }
+
+    /** Clamps {@link cornerRadius} to a fraction of the shorter adjacent segment. */
+    protected computeMaxRadius(corner: Point, prev: Point, next: Point): number {
+        const segBefore = Point.maxDistance(corner, prev);
+        const segAfter = Point.maxDistance(next, corner);
+        if (segBefore === 0 || segAfter === 0) {
+            return this.minCornerRadius;
+        }
+        const shortest = Math.min(segBefore, segAfter);
+        let radius = Math.min(this.cornerRadius, shortest * this.maxRadiusFactor);
+        if (shortest < this.shortSegmentThreshold) {
+            radius = Math.min(radius, shortest * this.shortSegmentRadiusFactor);
+        }
+        radius = Math.min(radius, shortest / 2);
+        return Math.max(this.minCornerRadius, radius);
+    }
+}