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

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023-2025 Business Informatics Group (TU Wien) and others.
+ * Copyright (c) 2023-2026 Business Informatics Group (TU Wien) 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
@@ -14,9 +14,8 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { GModelElement, GModelRoot, GNode, LabeledAction, SelectAllAction, toArray, TYPES } from '@eclipse-glsp/sprotty';
+import { GModelElement, GModelRoot, GNode, LabeledAction, SelectAllAction, debounce, toArray, TYPES } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
-import { debounce, isEqual } from 'lodash';
 import {
     AutocompleteSuggestionProviderContext,
     type AutocompleteSuggestion,
@@ -150,7 +149,7 @@ export class SearchAutocompletePalette extends BaseAutocompletePalette {
     }
 
     protected getSuggestionsFromLabeledActions(labeledActions: LabeledAction[]): SearchAutocompleteSuggestion[] {
-        return this.cachedSuggestions.filter(c => labeledActions.find(s => isEqual(s, c.action)));
+        return this.cachedSuggestions.filter(c => labeledActions.find(s => s === c.action));
     }
 
     protected getHiddenElements(root: Readonly<GModelRoot>, suggestions: SearchAutocompleteSuggestion[]): GModelElement[] {

package/src/features/select/select-module.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2024 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

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

@@ -20,6 +20,7 @@ import {
     IActionHandler,
     ICommand,
     MarkersReason,
+    OriginViewportAction,
     PaletteItem,
     RequestContextActions,
     RequestMarkersAction,
@@ -43,7 +44,6 @@ import { IDebugManager } from '../debug/debug-manager';
 import { IGridManager } from '../grid/grid-manager';
 import { MouseDeleteTool } from '../tools/deletion/delete-tool';
 import { MarqueeMouseTool } from '../tools/marquee-selection/marquee-mouse-tool';
-import { OriginViewportAction } from '../viewport/origin-viewport';
 
 const CLICKED_CSS_CLASS = 'clicked';
 const SEARCH_ICON_ID = 'search';

package/src/features/tools/change-bounds/change-bounds-tool-move-feedback.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2024 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
@@ -13,9 +13,19 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, ElementMove, GModelElement, GModelRoot, MoveAction, Point, TypeGuard, findParentByFeature } from '@eclipse-glsp/sprotty';
+import {
+    Action,
+    DebouncedFunc,
+    ElementMove,
+    GModelElement,
+    GModelRoot,
+    MoveAction,
+    Point,
+    TypeGuard,
+    debounce,
+    findParentByFeature
+} from '@eclipse-glsp/sprotty';
 
-import { DebouncedFunc, debounce } from 'lodash';
 import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
 import { CursorCSS, cursorFeedbackAction } from '../../../base/feedback/css-feedback';
 import { FeedbackEmitter } from '../../../base/feedback/feedback-emitter';

package/src/features/viewport/origin-viewport.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2024-2025 Axon Ivy AG and others.
+ * Copyright (c) 2024-2026 Axon Ivy AG 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
@@ -14,31 +14,18 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { Action, Bounds, BoundsAwareViewportCommand, GModelRoot, TYPES, Viewport, limitViewport } from '@eclipse-glsp/sprotty';
+import {
+    Bounds,
+    BoundsAwareViewportCommand,
+    GModelRoot,
+    OriginViewportAction,
+    TYPES,
+    Viewport,
+    limitViewport
+} from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
 import { EditorContextService } from '../../base/editor-context-service';
 
-export interface OriginViewportAction extends Action {
-    kind: typeof OriginViewportAction.KIND;
-    animate: boolean;
-}
-
-export namespace OriginViewportAction {
-    export const KIND = 'originViewport';
-
-    export function is(object: any): object is OriginViewportAction {
-        return Action.hasKind(object, KIND);
-    }
-
-    export function create(options: { animate?: boolean } = {}): OriginViewportAction {
-        return {
-            kind: KIND,
-            animate: true,
-            ...options
-        };
-    }
-}
-
 @injectable()
 export class OriginViewportCommand extends BoundsAwareViewportCommand {
     static readonly KIND = OriginViewportAction.KIND;

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
@@ -132,9 +132,15 @@ export * from './features/element-template/add-template-element';
 export * from './features/element-template/element-template-module';
 export * from './features/element-template/mouse-tracking-element-position-listener';
 export * from './features/element-template/remove-template-element';
+export * from './features/export/default-png-diagram-exporter';
+export * from './features/export/default-svg-diagram-exporter';
+export * from './features/export/diagram-export-postprocessor';
+export * from './features/export/diagram-exporter';
 export * from './features/export/export-modules';
+export * from './features/export/export-result-action-handler';
 export * from './features/export/export-svg-action-handler';
 export * from './features/export/glsp-svg-exporter';
+export * from './features/export/request-export-command';
 export * from './features/grid/grid';
 export * from './features/grid/grid-manager';
 export * from './features/grid/grid-model';
@@ -165,6 +171,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 +251,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/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);
+    }
+}