@eclipse-glsp/client 2.2.0-next.329 → 2.2.0-next.331

package/src/features/accessibility/resize-key-tool/resize-key-handler.ts

@@ -18,7 +18,6 @@ import {
     Action,
     ChangeBoundsOperation,
     Dimension,
-    DisposableCollection,
     ElementAndBounds,
     GModelElement,
     GParentElement,
@@ -30,13 +29,13 @@ import {
     SetBoundsAction,
     TYPES
 } from '@eclipse-glsp/sprotty';
-import { inject, injectable, optional } from 'inversify';
+import { inject, injectable, optional, postConstruct } from 'inversify';
 import { DebouncedFunc, debounce } from 'lodash';
+import { FeedbackEmitter } from '../../../base';
 import { EditorContextService } from '../../../base/editor-context-service';
 import { IFeedbackActionDispatcher } from '../../../base/feedback/feedback-action-dispatcher';
-import { SelectableBoundsAware, getElements, isSelectableAndBoundsAware, toElementAndBounds } from '../../../utils/gmodel-util';
+import { Resizable, SelectableBoundsAware, getElements, isSelectableAndBoundsAware, toElementAndBounds } from '../../../utils/gmodel-util';
 import { isValidMove, isValidSize, minHeight, minWidth } from '../../../utils/layout-utils';
-import { Resizable } from '../../change-bounds/model';
 import { GridSnapper } from '../../change-bounds/snap';
 
 export enum ResizeType {
@@ -79,7 +78,7 @@ export class ResizeElementHandler implements IActionHandler {
     protected feedbackDispatcher: IFeedbackActionDispatcher;
 
     protected debouncedChangeBounds?: DebouncedFunc<() => void>;
-    protected disposableFeedback = new DisposableCollection();
+    protected resizeFeedback: FeedbackEmitter;
 
     // Default x resize used if GridSnapper is not provided
     static readonly defaultResizeX = 20;
@@ -96,6 +95,11 @@ export class ResizeElementHandler implements IActionHandler {
         }
     }
 
+    @postConstruct()
+    protected init(): void {
+        this.resizeFeedback = this.feedbackDispatcher.createEmitter();
+    }
+
     handle(action: Action): void | Action | ICommand {
         if (ResizeElementAction.is(action)) {
             this.handleResizeElement(action);
@@ -106,11 +110,11 @@ export class ResizeElementHandler implements IActionHandler {
         const elements = getElements(this.editorContextService.modelRoot.index, action.elementIds, isSelectableAndBoundsAware);
         const elementAndBounds = this.computeElementAndBounds(elements, action);
 
-        this.disposableFeedback.push(this.feedbackDispatcher.registerFeedback(this, [SetBoundsAction.create(elementAndBounds)]));
+        this.resizeFeedback.add(SetBoundsAction.create(elementAndBounds)).submit();
 
         this.debouncedChangeBounds?.cancel();
         this.debouncedChangeBounds = debounce(() => {
-            this.disposableFeedback.dispose();
+            this.resizeFeedback.dispose();
             this.dispatcher.dispatchAll([ChangeBoundsOperation.create(elementAndBounds)]);
             this.debouncedChangeBounds = undefined;
         }, 300);

package/src/features/change-bounds/model.ts

@@ -14,24 +14,20 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import {
-    BoundsAware,
     GChildElement,
     GModelElement,
     GParentElement,
     Hoverable,
-    Locateable,
-    Selectable,
     hoverFeedbackFeature,
     isBoundsAware,
     isMoveable,
     isSelectable
 } from '@eclipse-glsp/sprotty';
+import { BoundsAwareModelElement, MoveableElement, ResizableModelElement } from '../../utils';
 
 export const resizeFeature = Symbol('resizeFeature');
 
-export interface Resizable extends BoundsAware, Selectable {}
-
-export function isResizable(element: GModelElement): element is GParentElement & Resizable {
+export function isResizable(element: GModelElement): element is ResizableModelElement {
     return isBoundsAware(element) && isSelectable(element) && element instanceof GParentElement && element.hasFeature(resizeFeature);
 }
 
@@ -43,15 +39,17 @@ export enum ResizeHandleLocation {
     BottomRight = 'bottom-right'
 }
 
-export function isBoundsAwareMoveable(element: GModelElement): element is GModelElement & Locateable & BoundsAware {
+export function isBoundsAwareMoveable(element: GModelElement): element is BoundsAwareModelElement & MoveableElement {
     return isMoveable(element) && isBoundsAware(element);
 }
 
 export class SResizeHandle extends GChildElement implements Hoverable {
     static readonly TYPE = 'resize-handle';
 
+    override readonly parent: ResizableModelElement;
+
     constructor(
-        readonly location?: ResizeHandleLocation,
+        readonly location: ResizeHandleLocation,
         override readonly type: string = SResizeHandle.TYPE,
         readonly hoverFeedback: boolean = false
     ) {
@@ -87,11 +85,25 @@ export class SResizeHandle extends GChildElement implements Hoverable {
     }
 }
 
-export function addResizeHandles(element: GParentElement): void {
-    element.add(new SResizeHandle(ResizeHandleLocation.TopLeft));
-    element.add(new SResizeHandle(ResizeHandleLocation.TopRight));
-    element.add(new SResizeHandle(ResizeHandleLocation.BottomLeft));
-    element.add(new SResizeHandle(ResizeHandleLocation.BottomRight));
+export function addResizeHandles(
+    element: ResizableModelElement,
+    locations: ResizeHandleLocation[] = [
+        ResizeHandleLocation.TopLeft,
+        ResizeHandleLocation.TopRight,
+        ResizeHandleLocation.BottomLeft,
+        ResizeHandleLocation.BottomRight
+    ]
+): void {
+    for (const location of Object.values(ResizeHandleLocation)) {
+        const existing = element.children.find(child => child instanceof SResizeHandle && child.location === location);
+        if (locations.includes(location) && !existing) {
+            // add missing handle
+            element.add(new SResizeHandle(location));
+        } else if (!locations.includes(location) && existing) {
+            // remove existing handle
+            element.remove(existing);
+        }
+    }
 }
 
 export function removeResizeHandles(element: GParentElement): void {

package/src/features/change-bounds/movement-restrictor.ts

@@ -13,9 +13,10 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Bounds, BoundsAware, GModelElement, GNode, GParentElement, Point } from '@eclipse-glsp/sprotty';
+import { Bounds, GModelElement, GNode, GParentElement, Point } from '@eclipse-glsp/sprotty';
 import { injectable } from 'inversify';
 import { ModifyCSSFeedbackAction } from '../../base/feedback/css-feedback';
+import { BoundsAwareModelElement } from '../../utils';
 import { toAbsoluteBounds } from '../../utils/viewpoint-util';
 import { SResizeHandle, isBoundsAwareMoveable } from './model';
 
@@ -51,7 +52,7 @@ export class NoOverlapMovementRestrictor implements IMovementRestrictor {
             return false;
         }
         // Create ghost element at the newLocation
-        const ghostElement = Object.create(element) as GModelElement & BoundsAware;
+        const ghostElement = Object.create(element) as BoundsAwareModelElement;
         ghostElement.bounds = {
             x: newLocation.x,
             y: newLocation.y,
@@ -64,11 +65,11 @@ export class NoOverlapMovementRestrictor implements IMovementRestrictor {
             element.root.index
                 .all()
                 .filter(e => e.id !== ghostElement.id && e !== ghostElement.root && e instanceof GNode)
-                .map(e => e as GModelElement & BoundsAware)
+                .map(e => e as BoundsAwareModelElement)
         ).some(e => this.areOverlapping(e, ghostElement));
     }
 
-    protected areOverlapping(element1: GModelElement & BoundsAware, element2: GModelElement & BoundsAware): boolean {
+    protected areOverlapping(element1: BoundsAwareModelElement, element2: BoundsAwareModelElement): boolean {
         return Bounds.overlap(toAbsoluteBounds(element1), toAbsoluteBounds(element2));
     }
 }

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

@@ -14,8 +14,9 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { CSS_HIDDEN_EXTENSION_CLASS, CSS_UI_EXTENSION_CLASS, CommandPalette } from '@eclipse-glsp/sprotty';
+import { CommandPalette } from '@eclipse-glsp/sprotty';
 import { injectable } from 'inversify';
+import { CSS_HIDDEN_EXTENSION_CLASS, CSS_UI_EXTENSION_CLASS } from '../../base/ui-extension/ui-extension';
 
 @injectable()
 export class GlspCommandPalette extends CommandPalette {

package/src/features/element-template/mouse-tracking-element-position-listener.ts

@@ -18,8 +18,8 @@ import {
     Action,
     Dimension,
     Disposable,
+    ElementMove,
     GModelElement,
-    Locateable,
     MoveAction,
     Point,
     isBoundsAware,
@@ -28,8 +28,10 @@ import {
 import { injectable } from 'inversify';
 import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
 import { CSS_HIDDEN, ModifyCSSFeedbackAction } from '../../base/feedback/css-feedback';
+import { FeedbackEmitter } from '../../base/feedback/feeback-emitter';
 import { IFeedbackEmitter } from '../../base/feedback/feedback-action-dispatcher';
 import { Tool } from '../../base/tool-manager/tool';
+import { MoveableElement } from '../../utils';
 import { getAbsolutePosition } from '../../utils/viewpoint-util';
 import {
     IMovementRestrictor,
@@ -39,20 +41,28 @@ import {
 import { PointPositionUpdater } from '../change-bounds/point-position-updater';
 import { PositionSnapper } from '../change-bounds/position-snapper';
 import { useSnap } from '../change-bounds/snap';
+import { MoveFinishedEventAction } from '../tools';
 
 export interface PositioningTool extends Tool {
     readonly positionSnapper: PositionSnapper;
     readonly movementRestrictor?: IMovementRestrictor;
 
+    createFeedbackEmitter(): FeedbackEmitter;
+    /**
+     * @deprecated It is recommended to create a {@link createFeedbackEmitter dedicated emitter} per feedback instead of using the tool.
+     */
     registerFeedback(feedbackActions: Action[], feedbackEmitter?: IFeedbackEmitter, cleanupActions?: Action[]): Disposable;
+    /**
+     * @deprecated It is recommended to create a {@link createFeedbackEmitter dedicated emitter} per feedback and dispose it like that.
+     */
     deregisterFeedback(feedbackEmitter?: IFeedbackEmitter, cleanupActions?: Action[]): void;
 }
 
 @injectable()
 export class MouseTrackingElementPositionListener extends DragAwareMouseListener {
-    currentPosition?: Point;
-
     protected positionUpdater: PointPositionUpdater;
+    protected moveGhostFeedback: FeedbackEmitter;
+    protected currentPosition?: Point;
 
     constructor(
         protected elementId: string,
@@ -61,6 +71,7 @@ export class MouseTrackingElementPositionListener extends DragAwareMouseListener
     ) {
         super();
         this.positionUpdater = new PointPositionUpdater(this.tool.positionSnapper);
+        this.moveGhostFeedback = this.tool.createFeedbackEmitter();
     }
 
     override mouseMove(target: GModelElement, event: MouseEvent): Action[] {
@@ -69,59 +80,48 @@ export class MouseTrackingElementPositionListener extends DragAwareMouseListener
         if (!element || !isMoveable(element)) {
             return [];
         }
-        let targetPosition = this.getTargetPosition(target, event, element);
         if (this.positionUpdater.isLastDragPositionUndefined()) {
-            this.positionUpdater.updateLastDragPosition(targetPosition);
+            this.positionUpdater.updateLastDragPosition(element.position);
         }
-        const delta = this.positionUpdater.updatePosition(element, targetPosition, useSnap(event));
+        const mousePosition = getAbsolutePosition(target, event);
+        const delta = this.positionUpdater.updatePosition(element, mousePosition, useSnap(event));
         if (!delta) {
             return [];
         }
-        targetPosition = this.validateMove(this.currentPosition ?? targetPosition, targetPosition, element, false);
-        const moveGhostElement = MoveAction.create(
-            [
-                {
-                    elementId: element.id,
-                    fromPosition: this.currentPosition,
-                    toPosition: targetPosition
-                }
-            ],
-            { animate: false, finished: false }
-        );
-        this.currentPosition = targetPosition;
-        this.tool.registerFeedback([moveGhostElement], this);
-        return element.cssClasses?.includes(CSS_HIDDEN)
-            ? [ModifyCSSFeedbackAction.create({ elements: [element.id], remove: [CSS_HIDDEN] })]
-            : [];
-    }
-
-    protected getTargetPosition(target: GModelElement, event: MouseEvent, element: GModelElement & Locateable): Point {
-        let targetPosition = getAbsolutePosition(target, event);
-        if (this.cursorPosition === 'middle' && isBoundsAware(element)) {
-            targetPosition = Point.subtract(targetPosition, Dimension.center(element.bounds));
-        }
-        return targetPosition;
+        const toPosition = this.getElementTargetPosition(mousePosition, element, event);
+        const elementMove = { elementId: element.id, toPosition: toPosition };
+        this.addMoveFeeback(element, elementMove);
+        this.currentPosition = toPosition;
+        // since we are moving a ghost element that is feedback-only and will be removed anyway,
+        // we just send a MoveFinishedEventAction instead of reseting the position with a MoveAction and the finished flag set to true.
+        this.moveGhostFeedback.add(MoveAction.create([elementMove], { animate: false }), MoveFinishedEventAction.create()).submit();
+        return [];
     }
 
-    protected snap(position: Point, element: GModelElement, isSnap = true): Point {
-        return this.tool.positionSnapper.snapPosition(position, element, isSnap);
+    protected getElementTargetPosition(mousePosition: Point, element: MoveableElement, event: MouseEvent): Point {
+        const unsnappedPosition =
+            this.cursorPosition === 'middle' && isBoundsAware(element)
+                ? Point.subtract(mousePosition, Dimension.center(element.bounds))
+                : mousePosition;
+        return this.tool.positionSnapper.snapPosition(unsnappedPosition, element, useSnap(event));
     }
 
-    protected validateMove(startPosition: Point, toPosition: Point, element: GModelElement, isFinished: boolean): Point {
-        let newPosition = toPosition;
+    protected addMoveFeeback(element: MoveableElement, elementMove: ElementMove): void {
         if (this.tool.movementRestrictor) {
-            const valid = this.tool.movementRestrictor.validate(element, toPosition);
-            let action;
-            if (!valid) {
-                action = createMovementRestrictionFeedback(element, this.tool.movementRestrictor);
-                if (isFinished) {
-                    newPosition = startPosition;
-                }
+            if (!this.tool.movementRestrictor.validate(element, elementMove.toPosition)) {
+                this.moveGhostFeedback.add(
+                    createMovementRestrictionFeedback(element, this.tool.movementRestrictor),
+                    removeMovementRestrictionFeedback(element, this.tool.movementRestrictor)
+                );
             } else {
-                action = removeMovementRestrictionFeedback(element, this.tool.movementRestrictor);
+                this.moveGhostFeedback.add(removeMovementRestrictionFeedback(element, this.tool.movementRestrictor));
             }
-            this.tool.registerFeedback([action], this, [removeMovementRestrictionFeedback(element, this.tool.movementRestrictor)]);
         }
-        return newPosition;
+        this.moveGhostFeedback.add(ModifyCSSFeedbackAction.create({ elements: [element.id], remove: [CSS_HIDDEN] }));
+    }
+
+    override dispose(): void {
+        this.moveGhostFeedback.dispose();
+        super.dispose();
     }
 }

package/src/features/helper-lines/helper-line-manager-default.ts

@@ -13,18 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import {
-    Action,
-    DisposableCollection,
-    GModelElement,
-    GModelRoot,
-    IActionHandler,
-    MoveAction,
-    Point,
-    SetBoundsAction,
-    TYPES
-} from '@eclipse-glsp/sprotty';
+import { Action, GModelElement, GModelRoot, IActionHandler, MoveAction, Point, SetBoundsAction, TYPES } from '@eclipse-glsp/sprotty';
 import { inject, injectable, optional, postConstruct } from 'inversify';
+import { FeedbackEmitter } from '../../base';
 import { IFeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
 import { ISelectionListener, SelectionService } from '../../base/selection-service';
 import { SetBoundsFeedbackAction } from '../bounds/set-bounds-feedback-command';
@@ -95,10 +86,11 @@ export class HelperLineManager implements IActionHandler, ISelectionListener, IH
     @optional() @inject(TYPES.IHelperLineOptions) protected userOptions?: IHelperLineOptions;
 
     protected options: Required<IHelperLineOptions>;
-    protected feedback: DisposableCollection = new DisposableCollection();
+    protected feedback: FeedbackEmitter;
 
     @postConstruct()
     protected init(): void {
+        this.feedback = this.feedbackDispatcher.createEmitter();
         this.options = { ...DEFAULT_HELPER_LINE_OPTIONS, ...this.userOptions };
         this.selectionService.onSelectionChanged(change =>
             this.selectionChanged(change.root, change.selectedElements, change.deselectedElements)
@@ -118,9 +110,7 @@ export class HelperLineManager implements IActionHandler, ISelectionListener, IH
     }
 
     protected handleMoveInitializedAction(_action: MoveInitializedEventAction): void {
-        this.feedback.dispose();
-        const feedback = this.createHelperLineFeedback(this.selectionService.getSelectedElementIDs());
-        this.feedback.push(this.feedbackDispatcher.registerFeedback(this, [feedback], [RemoveHelperLinesFeedbackAction.create()]));
+        this.submitHelperLineFeedback();
     }
 
     protected handleMoveFinishedAction(_action: MoveFinishedEventAction): void {
@@ -129,22 +119,23 @@ export class HelperLineManager implements IActionHandler, ISelectionListener, IH
 
     protected handleMoveAction(action: MoveAction): void {
         if (!action.finished) {
-            const elementIds = action.moves.map(move => move.elementId);
-            const feedback = this.createHelperLineFeedback(elementIds);
-            this.feedback.push(this.feedbackDispatcher.registerFeedback(this, [feedback], [RemoveHelperLinesFeedbackAction.create()]));
+            this.submitHelperLineFeedback(action.moves.map(move => move.elementId));
         } else {
             this.feedback.dispose();
         }
     }
 
+    protected submitHelperLineFeedback(elementIds: string[] = this.selectionService.getSelectedElementIDs()): void {
+        const feedback = this.createHelperLineFeedback(elementIds);
+        this.feedback.add(feedback, [RemoveHelperLinesFeedbackAction.create()]).submit();
+    }
+
     protected createHelperLineFeedback(elementIds: string[]): DrawHelperLinesFeedbackAction {
         return DrawHelperLinesFeedbackAction.create({ elementIds, ...this.options });
     }
 
     protected handleSetBoundsAction(action: SetBoundsAction | SetBoundsFeedbackAction): void {
-        const elementIds = action.bounds.map(bound => bound.elementId);
-        const feedback = this.createHelperLineFeedback(elementIds);
-        this.feedback.push(this.feedbackDispatcher.registerFeedback(this, [feedback], [RemoveHelperLinesFeedbackAction.create()]));
+        this.submitHelperLineFeedback(action.bounds.map(bound => bound.elementId));
     }
 
     selectionChanged(root: Readonly<GModelRoot>, selectedElements: string[], deselectedElements?: string[] | undefined): void {

package/src/features/hints/type-hint-provider.spec.ts

@@ -35,6 +35,7 @@ import {
 import { expect } from 'chai';
 import { Container } from 'inversify';
 import * as sinon from 'sinon';
+import { FeedbackEmitter } from '../../base';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { FeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
 import { GEdge } from '../../model';
@@ -45,7 +46,9 @@ import { ApplyTypeHintsAction, ApplyTypeHintsCommand, ITypeHintProvider, TypeHin
 describe('TypeHintProvider', () => {
     const container = new Container();
     container.bind(GLSPActionDispatcher).toConstantValue(sinon.createStubInstance(GLSPActionDispatcher));
-    container.bind(TYPES.IFeedbackActionDispatcher).toConstantValue(sinon.createStubInstance(FeedbackActionDispatcher));
+    const stub = sinon.createStubInstance(FeedbackActionDispatcher);
+    stub.createEmitter.returns(new FeedbackEmitter(stub));
+    container.bind(TYPES.IFeedbackActionDispatcher).toConstantValue(stub);
     const typeHintProvider = container.resolve(TypeHintProvider);
 
     describe('getShapeTypeHint', () => {

package/src/features/hints/type-hint-provider.ts

@@ -35,8 +35,9 @@ import {
     isConnectable,
     moveFeature
 } from '@eclipse-glsp/sprotty';
-import { inject, injectable } from 'inversify';
+import { inject, injectable, postConstruct } from 'inversify';
 
+import { FeedbackEmitter } from '../../base';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { IFeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
 import { FeedbackCommand } from '../../base/feedback/feedback-command';
@@ -204,15 +205,21 @@ export class TypeHintProvider implements IActionHandler, ITypeHintProvider, IDia
     @inject(GLSPActionDispatcher)
     protected actionDispatcher: GLSPActionDispatcher;
 
+    protected typeHintsFeedback: FeedbackEmitter;
     protected shapeHints: Map<string, ShapeTypeHint> = new Map();
     protected edgeHints: Map<string, EdgeTypeHint> = new Map();
 
+    @postConstruct()
+    protected init(): void {
+        this.typeHintsFeedback = this.feedbackActionDispatcher.createEmitter();
+    }
+
     handle(action: SetTypeHintsAction): void {
         this.shapeHints.clear();
         this.edgeHints.clear();
         action.shapeHints.forEach(hint => this.shapeHints.set(hint.elementTypeId, hint));
         action.edgeHints.forEach(hint => this.edgeHints.set(hint.elementTypeId, hint));
-        this.feedbackActionDispatcher.registerFeedback(this, [ApplyTypeHintsAction.create()]);
+        this.typeHintsFeedback.add(ApplyTypeHintsAction.create()).submit();
     }
 
     getShapeTypeHint(input: GModelElement | GModelElementSchema | string): ShapeTypeHint | undefined {

package/src/features/label-edit-ui/label-edit-ui.ts

@@ -13,8 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { CSS_HIDDEN_EXTENSION_CLASS, CSS_UI_EXTENSION_CLASS, EditLabelUI } from '@eclipse-glsp/sprotty';
+import { EditLabelUI } from '@eclipse-glsp/sprotty';
 import { injectable } from 'inversify';
+import { CSS_HIDDEN_EXTENSION_CLASS, CSS_UI_EXTENSION_CLASS } from '../../base/ui-extension/ui-extension';
 
 @injectable()
 export class GlspEditLabelUI extends EditLabelUI {

package/src/features/routing/{glsp-manhattan-edge-router.ts → edge-router.ts}

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2023 EclipseSource and others.
+ * Copyright (c) 2024 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
@@ -14,9 +14,64 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { ManhattanEdgeRouter, ResolvedHandleMove, GRoutableElement, almostEquals } from '@eclipse-glsp/sprotty';
+import {
+    AbstractEdgeRouter,
+    BezierEdgeRouter,
+    GConnectableElement,
+    GParentElement,
+    GRoutableElement,
+    ManhattanEdgeRouter,
+    Point,
+    PolylineEdgeRouter,
+    ResolvedHandleMove,
+    almostEquals
+} from '@eclipse-glsp/sprotty';
+import { injectable } from 'inversify';
 
+@injectable()
+export abstract class GLSPAbstractEdgeRouter extends AbstractEdgeRouter {
+    override getTranslatedAnchor(
+        connectable: GConnectableElement,
+        refPoint: Point,
+        refContainer: GParentElement,
+        edge: GRoutableElement,
+        anchorCorrection?: number | undefined
+    ): Point {
+        // users may define all kinds of anchors and anchor computers, we want to make sure we return a valid one in any case
+        const anchor = super.getTranslatedAnchor(connectable, refPoint, refContainer, edge, anchorCorrection);
+        return Point.isValid(anchor) ? anchor : refPoint;
+    }
+}
+
+@injectable()
+export class GLSPPolylineEdgeRouter extends PolylineEdgeRouter {
+    override getTranslatedAnchor(
+        connectable: GConnectableElement,
+        refPoint: Point,
+        refContainer: GParentElement,
+        edge: GRoutableElement,
+        anchorCorrection?: number | undefined
+    ): Point {
+        // users may define all kinds of anchors and anchor computers, we want to make sure we return a valid one in any case
+        const anchor = super.getTranslatedAnchor(connectable, refPoint, refContainer, edge, anchorCorrection);
+        return Point.isValid(anchor) ? anchor : refPoint;
+    }
+}
+
+@injectable()
 export class GLSPManhattanEdgeRouter extends ManhattanEdgeRouter {
+    override getTranslatedAnchor(
+        connectable: GConnectableElement,
+        refPoint: Point,
+        refContainer: GParentElement,
+        edge: GRoutableElement,
+        anchorCorrection?: number | undefined
+    ): Point {
+        // users may define all kinds of anchors and anchor computers, we want to make sure we return a valid one in any case
+        const anchor = super.getTranslatedAnchor(connectable, refPoint, refContainer, edge, anchorCorrection);
+        return Point.isValid(anchor) ? anchor : refPoint;
+    }
+
     protected override applyInnerHandleMoves(edge: GRoutableElement, moves: ResolvedHandleMove[]): void {
         const route = this.route(edge);
         const routingPoints = edge.routingPoints;
@@ -57,3 +112,18 @@ export class GLSPManhattanEdgeRouter extends ManhattanEdgeRouter {
         });
     }
 }
+
+@injectable()
+export class GLSPBezierEdgeRouter extends BezierEdgeRouter {
+    override getTranslatedAnchor(
+        connectable: GConnectableElement,
+        refPoint: Point,
+        refContainer: GParentElement,
+        edge: GRoutableElement,
+        anchorCorrection?: number | undefined
+    ): Point {
+        // users may define all kinds of anchors and anchor computers, we want to make sure we return a valid one in any case
+        const anchor = super.getTranslatedAnchor(connectable, refPoint, refContainer, edge, anchorCorrection);
+        return Point.isValid(anchor) ? anchor : refPoint;
+    }
+}

package/src/features/routing/index.ts

@@ -13,5 +13,5 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-export * from './glsp-manhattan-edge-router';
+export * from './edge-router';
 export * from './routing-module';

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

@@ -17,7 +17,6 @@ import {
     AddRemoveBezierSegmentCommand,
     AnchorComputerRegistry,
     BezierDiamondAnchor,
-    BezierEdgeRouter,
     BezierEllipseAnchor,
     BezierRectangleAnchor,
     DiamondAnchor,
@@ -27,13 +26,12 @@ import {
     ManhattanDiamondAnchor,
     ManhattanEllipticAnchor,
     ManhattanRectangularAnchor,
-    PolylineEdgeRouter,
     RectangleAnchor,
     TYPES,
     bindAsService,
     configureCommand
 } from '@eclipse-glsp/sprotty';
-import { GLSPManhattanEdgeRouter } from './glsp-manhattan-edge-router';
+import { GLSPBezierEdgeRouter, GLSPManhattanEdgeRouter, GLSPPolylineEdgeRouter } from './edge-router';
 
 export const routingModule = new FeatureModule((bind, unbind, isBound, rebind) => {
     const context = { bind, unbind, isBound, rebind };
@@ -45,12 +43,12 @@ export const routingModule = new FeatureModule((bind, unbind, isBound, rebind) =
     bindAsService(context, TYPES.IAnchorComputer, ManhattanRectangularAnchor);
     bindAsService(context, TYPES.IAnchorComputer, ManhattanDiamondAnchor);
 
-    bindAsService(context, TYPES.IEdgeRouter, PolylineEdgeRouter);
+    bindAsService(context, TYPES.IEdgeRouter, GLSPPolylineEdgeRouter);
     bindAsService(context, TYPES.IAnchorComputer, EllipseAnchor);
     bindAsService(context, TYPES.IAnchorComputer, RectangleAnchor);
     bindAsService(context, TYPES.IAnchorComputer, DiamondAnchor);
 
-    bindAsService(context, TYPES.IEdgeRouter, BezierEdgeRouter);
+    bindAsService(context, TYPES.IEdgeRouter, GLSPBezierEdgeRouter);
     bindAsService(context, TYPES.IAnchorComputer, BezierEllipseAnchor);
     bindAsService(context, TYPES.IAnchorComputer, BezierRectangleAnchor);
     bindAsService(context, TYPES.IAnchorComputer, BezierDiamondAnchor);

package/src/features/select/select-mouse-listener.ts

@@ -13,8 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, BringToFrontAction, GModelElement, SelectAction, SelectMouseListener, Selectable } from '@eclipse-glsp/sprotty';
+import { Action, BringToFrontAction, GModelElement, SelectAction, SelectMouseListener } from '@eclipse-glsp/sprotty';
 import { Ranked } from '../../base/ranked';
+import { SelectableElement } from '../../utils';
 
 /**
  * Ranked select mouse listener that is executed before default mouse listeners when using the RankedMouseTool.
@@ -24,7 +25,7 @@ export class RankedSelectMouseListener extends SelectMouseListener implements Ra
     rank: number = Ranked.DEFAULT_RANK - 100; /* we want to be executed before all default mouse listeners */
 
     protected override handleSelectTarget(
-        selectableTarget: GModelElement & Selectable,
+        selectableTarget: SelectableElement,
         deselectedElements: GModelElement[],
         event: MouseEvent
     ): (Action | Promise<Action>)[] {
@@ -40,7 +41,7 @@ export class RankedSelectMouseListener extends SelectMouseListener implements Ra
         return result;
     }
 
-    protected override handleDeselectTarget(selectableTarget: GModelElement & Selectable, event: MouseEvent): (Action | Promise<Action>)[] {
+    protected override handleDeselectTarget(selectableTarget: SelectableElement, event: MouseEvent): (Action | Promise<Action>)[] {
         const result: Action[] = [];
         result.push(SelectAction.create({ selectedElementsIDs: [], deselectedElementsIDs: [selectableTarget.id] }));
         return result;