@eclipse-glsp/client 0.9.0-rc-01 → 0.10.0-next.146a812.165

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2022 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,10 +13,18 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable, optional } from 'inversify';
 import {
     Action,
     Bounds,
+    ChangeBoundsOperation,
+    ChangeRoutingPointsOperation,
+    CompoundOperation,
+    ElementAndRoutingPoints,
+    Operation,
+    Point
+} from '@eclipse-glsp/protocol';
+import { inject, injectable, optional } from 'inversify';
+import {
     BoundsAware,
     Dimension,
     EdgeRouterRegistry,
@@ -24,9 +32,8 @@ import {
     findParentByFeature,
     ISnapper,
     isSelected,
-    isViewport,
     MouseListener,
-    Point,
+    SChildElement,
     SConnectableElement,
     SetBoundsAction,
     SModelElement,
@@ -34,17 +41,9 @@ import {
     SParentElement,
     TYPES
 } from 'sprotty';
-
 import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-import {
-    ChangeBoundsOperation,
-    ChangeRoutingPointsOperation,
-    CompoundOperation,
-    ElementAndRoutingPoints,
-    Operation
-} from '../../base/operations/operation';
 import { GLSP_TYPES } from '../../base/types';
-import { isValidMove, isValidSize, WriteablePoint } from '../../utils/layout-utils';
+import { isValidMove, isValidSize } from '../../utils/layout-utils';
 import {
     forEachElement,
     isNonRoutableSelectedMovableBoundsAware,
@@ -57,6 +56,7 @@ import {
     IMovementRestrictor,
     removeMovementRestrictionFeedback
 } from '../change-bounds/movement-restrictor';
+import { PointPositionUpdater } from '../change-bounds/snap';
 import { SelectionListener, SelectionService } from '../select/selection-service';
 import {
     FeedbackMoveMouseListener,
@@ -76,8 +76,8 @@ import { BaseGLSPTool } from './base-glsp-tool';
  * | Move      | MoveAction       | ChangeBoundsOperationAction
  * | Resize    | SetBoundsAction  | ChangeBoundsOperationAction
  *
- * To provide a visual client updates during move we install the `FeedbackMoveMouseListener` and to provide visual client updates during resize
- * and send the server updates we install the `ChangeBoundsListener`.
+ * To provide a visual client updates during move we install the `FeedbackMoveMouseListener` and to provide visual client updates during
+ * resize and send the server updates we install the `ChangeBoundsListener`.
  */
 @injectable()
 export class ChangeBoundsTool extends BaseGLSPTool {
@@ -118,7 +118,7 @@ export class ChangeBoundsTool extends BaseGLSPTool {
         this.selectionService.deregister(this.changeBoundsListener);
         this.mouseTool.deregister(this.feedbackMoveMouseListener);
         this.deregisterFeedback([], this.feedbackMoveMouseListener);
-        this.deregisterFeedback([new HideChangeBoundsToolResizeFeedbackAction], this.changeBoundsListener);
+        this.deregisterFeedback([new HideChangeBoundsToolResizeFeedbackAction()], this.changeBoundsListener);
     }
 }
 
@@ -127,8 +127,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
 
     // members for calculating the correct position change
     protected initialBounds: Bounds | undefined;
-    protected lastDragPosition?: Point;
-    protected positionDelta: WriteablePoint = { x: 0, y: 0 };
+    protected pointPositionUpdater: PointPositionUpdater;
 
     // members for resize mode
     protected activeResizeElement?: SModelElement;
@@ -136,9 +135,10 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
 
     constructor(protected tool: ChangeBoundsTool) {
         super();
+        this.pointPositionUpdater = new PointPositionUpdater(tool.snapper);
     }
 
-    mouseDown(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseDown(target: SModelElement, event: MouseEvent): Action[] {
         super.mouseDown(target, event);
         if (event.button !== 0) {
             return [];
@@ -157,13 +157,16 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
         return [];
     }
 
-    mouseMove(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseMove(target: SModelElement, event: MouseEvent): Action[] {
         super.mouseMove(target, event);
         if (this.isMouseDrag && this.activeResizeHandle) {
             // rely on the FeedbackMoveMouseListener to update the element bounds of selected elements
             // consider resize handles ourselves
-            const actions: Action[] = [cursorFeedbackAction(CursorCSS.RESIZE), applyCssClasses(this.activeResizeHandle, ChangeBoundsListener.CSS_CLASS_ACTIVE)];
-            const positionUpdate = this.updatePosition(target, event);
+            const actions: Action[] = [
+                cursorFeedbackAction(this.activeResizeHandle.isNwSeResize() ? CursorCSS.RESIZE_NWSE : CursorCSS.RESIZE_NESW),
+                applyCssClasses(this.activeResizeHandle, ChangeBoundsListener.CSS_CLASS_ACTIVE)
+            ];
+            const positionUpdate = this.pointPositionUpdater.updatePosition(target, { x: event.pageX, y: event.pageY }, !event.altKey);
             if (positionUpdate) {
                 const resizeActions = this.handleResizeOnClient(positionUpdate);
                 actions.push(...resizeActions);
@@ -173,8 +176,8 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
         return [];
     }
 
-    draggingMouseUp(target: SModelElement, event: MouseEvent): Action[] {
-        if (this.lastDragPosition === undefined) {
+    override draggingMouseUp(target: SModelElement, event: MouseEvent): Action[] {
+        if (this.pointPositionUpdater.isLastDragPositionUndefined()) {
             this.resetPosition();
             return [];
         }
@@ -205,19 +208,37 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
     protected handleMoveElementsOnServer(target: SModelElement): Action[] {
         const result: Operation[] = [];
         const newBounds: ElementAndBounds[] = [];
-        forEachElement(target, isNonRoutableSelectedMovableBoundsAware, element => {
-            this.createElementAndBounds(element).forEach(bounds => newBounds.push(bounds));
+        const selectedElements: (SModelElement & BoundsAware)[] = [];
+        forEachElement(target.index, isNonRoutableSelectedMovableBoundsAware, element => {
+            selectedElements.push(element);
         });
+
+        const selectionSet: Set<SModelElement & BoundsAware> = new Set(selectedElements);
+        selectedElements
+            .filter(element => !this.isChildOfSelected(selectionSet, element))
+            .map(element => this.createElementAndBounds(element))
+            .forEach(bounds => newBounds.push(...bounds));
+
         if (newBounds.length > 0) {
             result.push(new ChangeBoundsOperation(newBounds));
         }
         return result;
     }
 
+    protected isChildOfSelected(selectedElements: Set<SModelElement>, element: SModelElement): boolean {
+        while (element instanceof SChildElement) {
+            element = element.parent;
+            if (selectedElements.has(element)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     protected handleMoveRoutingPointsOnServer(target: SModelElement): Action[] {
         const result: Operation[] = [];
         const newRoutingPoints: ElementAndRoutingPoints[] = [];
-        forEachElement(target, isNonRoutableSelectedMovableBoundsAware, element => {
+        forEachElement(target.index, isNonRoutableSelectedMovableBoundsAware, element => {
             //  If client routing is enabled -> delegate routingpoints of connected edges to server
             if (this.tool.edgeRouterRegistry && element instanceof SConnectableElement) {
                 element.incomingEdges.map(toElementAndRoutingPoints).forEach(ear => newRoutingPoints.push(ear));
@@ -278,47 +299,21 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
     }
 
     protected initPosition(event: MouseEvent): void {
-        this.lastDragPosition = { x: event.pageX, y: event.pageY };
+        this.pointPositionUpdater.updateLastDragPosition({ x: event.pageX, y: event.pageY });
         if (this.activeResizeHandle) {
             const resizeElement = findParentByFeature(this.activeResizeHandle, isResizable);
-            this.initialBounds = { x: resizeElement!.bounds.x, y: resizeElement!.bounds.y, width: resizeElement!.bounds.width, height: resizeElement!.bounds.height };
+            this.initialBounds = {
+                x: resizeElement!.bounds.x,
+                y: resizeElement!.bounds.y,
+                width: resizeElement!.bounds.width,
+                height: resizeElement!.bounds.height
+            };
         }
     }
 
-    protected updatePosition(target: SModelElement, event: MouseEvent): Point | undefined {
-        if (this.lastDragPosition) {
-            const newDragPosition = { x: event.pageX, y: event.pageY };
-
-            const viewport = findParentByFeature(target, isViewport);
-            const zoom = viewport ? viewport.zoom : 1;
-            const dx = (event.pageX - this.lastDragPosition.x) / zoom;
-            const dy = (event.pageY - this.lastDragPosition.y) / zoom;
-            const deltaToLastPosition = { x: dx, y: dy };
-            this.lastDragPosition = newDragPosition;
-
-            // update position delta with latest delta
-            this.positionDelta.x += deltaToLastPosition.x;
-            this.positionDelta.y += deltaToLastPosition.y;
-
-            // snap our delta and only send update if the position actually changes
-            // otherwise accumulate delta until we do snap to an update
-            const positionUpdate = this.snap(this.positionDelta, target, !event.shiftKey);
-            if (positionUpdate.x === 0 && positionUpdate.y === 0) {
-                return undefined;
-            }
-
-            // we update our position so we need to reset our delta
-            this.positionDelta.x = 0;
-            this.positionDelta.y = 0;
-            return positionUpdate;
-        }
-        return undefined;
-    }
-
     protected reset(): void {
         if (this.activeResizeElement && isResizable(this.activeResizeElement)) {
             this.tool.dispatchFeedback([new HideChangeBoundsToolResizeFeedbackAction()], this);
-
         }
         this.tool.dispatchActions([cursorFeedbackAction(CursorCSS.DEFAULT)]);
         this.resetPosition();
@@ -326,8 +321,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
 
     protected resetPosition(): void {
         this.activeResizeHandle = undefined;
-        this.lastDragPosition = undefined;
-        this.positionDelta = { x: 0, y: 0 };
+        this.pointPositionUpdater.resetPosition();
     }
 
     protected handleResizeOnClient(positionUpdate: Point): Action[] {
@@ -352,35 +346,43 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
     }
 
     protected handleTopLeftResize(resizeElement: SParentElement & Resizable, positionUpdate: Point): Action[] {
-        return this.createSetBoundsAction(resizeElement,
+        return this.createSetBoundsAction(
+            resizeElement,
             resizeElement.bounds.x + positionUpdate.x,
             resizeElement.bounds.y + positionUpdate.y,
             resizeElement.bounds.width - positionUpdate.x,
-            resizeElement.bounds.height - positionUpdate.y);
+            resizeElement.bounds.height - positionUpdate.y
+        );
     }
 
     protected handleTopRightResize(resizeElement: SParentElement & Resizable, positionUpdate: Point): Action[] {
-        return this.createSetBoundsAction(resizeElement,
+        return this.createSetBoundsAction(
+            resizeElement,
             resizeElement.bounds.x,
             resizeElement.bounds.y + positionUpdate.y,
             resizeElement.bounds.width + positionUpdate.x,
-            resizeElement.bounds.height - positionUpdate.y);
+            resizeElement.bounds.height - positionUpdate.y
+        );
     }
 
     protected handleBottomLeftResize(resizeElement: SParentElement & Resizable, positionUpdate: Point): Action[] {
-        return this.createSetBoundsAction(resizeElement,
+        return this.createSetBoundsAction(
+            resizeElement,
             resizeElement.bounds.x + positionUpdate.x,
             resizeElement.bounds.y,
             resizeElement.bounds.width - positionUpdate.x,
-            resizeElement.bounds.height + positionUpdate.y);
+            resizeElement.bounds.height + positionUpdate.y
+        );
     }
 
     protected handleBottomRightResize(resizeElement: SParentElement & Resizable, positionUpdate: Point): Action[] {
-        return this.createSetBoundsAction(resizeElement,
+        return this.createSetBoundsAction(
+            resizeElement,
             resizeElement.bounds.x,
             resizeElement.bounds.y,
             resizeElement.bounds.width + positionUpdate.x,
-            resizeElement.bounds.height + positionUpdate.y);
+            resizeElement.bounds.height + positionUpdate.y
+        );
     }
 
     protected createChangeBoundsAction(element: SModelElement & BoundsAware): Action[] {
@@ -414,7 +416,6 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
                 result.push(removeMovementRestrictionFeedback(element, this.tool.movementRestrictor));
             }
             result.push(new SetBoundsAction([{ elementId: element.id, newPosition, newSize }]));
-
         } else if (this.isValidSize(element, newSize)) {
             if (this.tool.movementRestrictor) {
                 result.push(createMovementRestrictionFeedback(element, this.tool.movementRestrictor));
@@ -426,9 +427,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
     }
 
     protected snap(position: Point, element: SModelElement, isSnap: boolean): Point {
-        return isSnap && this.tool.snapper
-            ? this.tool.snapper.snap(position, element)
-            : { x: position.x, y: position.y };
+        return isSnap && this.tool.snapper ? this.tool.snapper.snap(position, element) : { x: position.x, y: position.y };
     }
 
     protected isValidBoundChange(element: SModelElement & BoundsAware, newPosition: Point, newSize: Dimension): boolean {

package/src/features/tools/delete-tool.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2022 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,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Action, DeleteElementOperation } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import {
-    Action,
     EnableDefaultToolsAction,
     findParentByFeature,
     isCtrlOrCmd,
@@ -27,8 +27,6 @@ import {
     SModelElement
 } from 'sprotty';
 import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
-
-import { DeleteElementOperation } from '../../base/operations/operation';
 import { GLSPTool } from '../../base/tool-manager/glsp-tool-manager';
 import { GLSP_TYPES } from '../../base/types';
 import { IMouseTool } from '../mouse-tool/mouse-tool';
@@ -62,10 +60,15 @@ export class DelKeyDeleteTool implements GLSPTool {
 
 @injectable()
 export class DeleteKeyListener extends KeyListener {
-    keyDown(element: SModelElement, event: KeyboardEvent): Action[] {
+    override keyDown(element: SModelElement, event: KeyboardEvent): Action[] {
         if (matchesKeystroke(event, 'Delete')) {
-            const deleteElementIds = Array.from(element.root.index.all().filter(e => isDeletable(e) && isSelectable(e) && e.selected)
-                .filter(e => e.id !== e.root.id).map(e => e.id));
+            const deleteElementIds = Array.from(
+                element.root.index
+                    .all()
+                    .filter(e => isDeletable(e) && isSelectable(e) && e.selected)
+                    .filter(e => e.id !== e.root.id)
+                    .map(e => e.id)
+            );
             if (deleteElementIds.length > 0) {
                 return [new DeleteElementOperation(deleteElementIds)];
             }
@@ -105,7 +108,7 @@ export class MouseDeleteTool implements GLSPTool {
 
 @injectable()
 export class DeleteToolMouseListener extends MouseListener {
-    mouseUp(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseUp(target: SModelElement, event: MouseEvent): Action[] {
         const deletableParent = findParentByFeature(target, isDeletable);
         if (deletableParent === undefined) {
             return [];

package/src/features/tools/di.config.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2021 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,10 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { TriggerEdgeCreationAction, TriggerNodeCreationAction } from '@eclipse-glsp/protocol';
 import { ContainerModule, interfaces } from 'inversify';
 import { configureActionHandler, configureModelElement } from 'sprotty';
-
-import { TriggerEdgeCreationAction, TriggerNodeCreationAction } from '../../base/operations/operation';
 import { GLSP_TYPES } from '../../base/types';
 import { MARQUEE } from '../tool-feedback/marquee-tool-feedback';
 import { ChangeBoundsTool } from './change-bounds-tool';

package/src/features/tools/edge-creation-tool.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2022 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,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Action, CreateEdgeOperation, isTriggerElementTypeCreationAction, TriggerEdgeCreationAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import {
-    Action,
     AnchorComputerRegistry,
     EnableDefaultToolsAction,
     EnableToolsAction,
@@ -26,13 +26,7 @@ import {
     SEdge,
     SModelElement
 } from 'sprotty';
-
 import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-import {
-    CreateEdgeOperation,
-    isTriggerElementTypeCreationAction,
-    TriggerEdgeCreationAction
-} from '../../base/operations/operation';
 import {
     DrawFeedbackEdgeAction,
     FeedbackEdgeEndMovingMouseListener,
@@ -105,7 +99,7 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
         this.tool.dispatchFeedback([new RemoveFeedbackEdgeAction()]);
     }
 
-    nonDraggingMouseUp(_element: SModelElement, event: MouseEvent): Action[] {
+    override nonDraggingMouseUp(_element: SModelElement, event: MouseEvent): Action[] {
         const result: Action[] = [];
         if (event.button === 0) {
             if (!this.isSourceSelected()) {
@@ -140,7 +134,7 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
         return this.target !== undefined;
     }
 
-    mouseOver(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseOver(target: SModelElement, event: MouseEvent): Action[] {
         const newCurrentTarget = findParentByFeature(target, isConnectable);
         if (newCurrentTarget !== this.currentTarget) {
             this.currentTarget = newCurrentTarget;
@@ -151,8 +145,9 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
                     this.allowedTarget = this.isAllowedTarget(newCurrentTarget);
                 }
                 if (this.allowedTarget) {
-                    const action = !this.isSourceSelected() ? cursorFeedbackAction(CursorCSS.EDGE_CREATION_SOURCE) :
-                        cursorFeedbackAction(CursorCSS.EDGE_CREATION_TARGET);
+                    const action = !this.isSourceSelected()
+                        ? cursorFeedbackAction(CursorCSS.EDGE_CREATION_SOURCE)
+                        : cursorFeedbackAction(CursorCSS.EDGE_CREATION_TARGET);
                     return [action];
                 }
             }

package/src/features/tools/edge-edit-tool.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2022 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,33 +13,27 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Action, ChangeRoutingPointsOperation, ReconnectEdgeOperation } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
 import {
-    Action,
     AnchorComputerRegistry,
     canEditRouting,
     Connectable,
     EdgeRouterRegistry,
     findParentByFeature,
     isConnectable,
+    ISnapper,
     isSelected,
     SModelElement,
     SModelRoot,
     SRoutableElement,
-    SRoutingHandle
+    SRoutingHandle,
+    TYPES
 } from 'sprotty';
-
 import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-import { ChangeRoutingPointsOperation, ReconnectEdgeOperation } from '../../base/operations/operation';
 import { GLSP_TYPES } from '../../base/types';
 import { isRoutable, isRoutingHandle } from '../../utils/smodel-util';
-import {
-    isReconnectable,
-    isReconnectHandle,
-    isSourceRoutingHandle,
-    isTargetRoutingHandle,
-    SReconnectHandle
-} from '../reconnect/model';
+import { isReconnectable, isReconnectHandle, isSourceRoutingHandle, isTargetRoutingHandle, SReconnectHandle } from '../reconnect/model';
 import { SelectionListener, SelectionService } from '../select/selection-service';
 import { DrawFeedbackEdgeAction, feedbackEdgeId, RemoveFeedbackEdgeAction } from '../tool-feedback/creation-tool-feedback';
 import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
@@ -61,6 +55,7 @@ export class EdgeEditTool extends BaseGLSPTool {
     @inject(GLSP_TYPES.SelectionService) protected selectionService: SelectionService;
     @inject(AnchorComputerRegistry) protected anchorRegistry: AnchorComputerRegistry;
     @inject(EdgeRouterRegistry) @optional() protected edgeRouterRegistry?: EdgeRouterRegistry;
+    @inject(TYPES.ISnapper) @optional() readonly snapper?: ISnapper;
 
     protected feedbackEdgeSourceMovingListener: FeedbackEdgeSourceMovingMouseListener;
     protected feedbackEdgeTargetMovingListener: FeedbackEdgeTargetMovingMouseListener;
@@ -79,7 +74,7 @@ export class EdgeEditTool extends BaseGLSPTool {
         // install feedback move mouse listener for client-side move updates
         this.feedbackEdgeSourceMovingListener = new FeedbackEdgeSourceMovingMouseListener(this.anchorRegistry);
         this.feedbackEdgeTargetMovingListener = new FeedbackEdgeTargetMovingMouseListener(this.anchorRegistry);
-        this.feedbackMovingListener = new FeedbackEdgeRouteMovingMouseListener(this.edgeRouterRegistry);
+        this.feedbackMovingListener = new FeedbackEdgeRouteMovingMouseListener(this.edgeRouterRegistry, this.snapper);
     }
 
     registerFeedbackListeners(): void {
@@ -193,7 +188,7 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
         return this.routingHandle !== undefined;
     }
 
-    mouseDown(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseDown(target: SModelElement, event: MouseEvent): Action[] {
         const result: Action[] = super.mouseDown(target, event);
         if (event.button === 0) {
             const reconnectHandle = findParentByFeature(target, isReconnectHandle);
@@ -216,7 +211,7 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
         return result;
     }
 
-    mouseMove(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseMove(target: SModelElement, event: MouseEvent): Action[] {
         const result = super.mouseMove(target, event);
         if (this.isMouseDrag) {
             // reset any selected connectables when we are dragging, maybe the user is just panning
@@ -225,7 +220,7 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
         return result;
     }
 
-    mouseUp(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseUp(target: SModelElement, event: MouseEvent): Action[] {
         const result = super.mouseUp(target, event);
         if (!this.isReadyToReconnect() && !this.isReadyToReroute()) {
             return result;
@@ -239,7 +234,8 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
             }
             this.reset();
         } else if (this.edge && this.routingHandle) {
-            // we need to re-retrieve the edge as it might have changed due to a server udpate since we do not reset the state between reroute actions
+            // we need to re-retrieve the edge as it might have changed due to a server update since we do not reset the state between
+            // reroute actions
             const latestEdge = target.index.getById(this.edge.id);
             if (latestEdge && isRoutable(latestEdge)) {
                 result.push(new ChangeRoutingPointsOperation([{ elementId: latestEdge.id, newRoutingPoints: latestEdge.routingPoints }]));
@@ -249,15 +245,16 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
         return result;
     }
 
-    mouseOver(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseOver(target: SModelElement, event: MouseEvent): Action[] {
         if (this.edge && this.isReconnecting()) {
             const currentTarget = findParentByFeature(target, isConnectable);
             if (!this.newConnectable || currentTarget !== this.newConnectable) {
                 this.setNewConnectable(currentTarget);
                 if (currentTarget) {
-                    if ((this.reconnectMode === 'NEW_SOURCE' && currentTarget.canConnect(this.edge, 'source')) ||
-                        (this.reconnectMode === 'NEW_TARGET' && currentTarget.canConnect(this.edge, 'target'))) {
-
+                    if (
+                        (this.reconnectMode === 'NEW_SOURCE' && currentTarget.canConnect(this.edge, 'source')) ||
+                        (this.reconnectMode === 'NEW_TARGET' && currentTarget.canConnect(this.edge, 'target'))
+                    ) {
                         this.tool.dispatchFeedback([cursorFeedbackAction(CursorCSS.EDGE_RECONNECT)]);
                         return [];
                     }
@@ -314,11 +311,7 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
         if (this.edge) {
             result.push(new SwitchRoutingModeAction([], [this.edge.id]));
         }
-        result.push(...[
-            new HideEdgeReconnectHandlesFeedbackAction(),
-            cursorFeedbackAction(),
-            new RemoveFeedbackEdgeAction()
-        ]);
+        result.push(...[new HideEdgeReconnectHandlesFeedbackAction(), cursorFeedbackAction(), new RemoveFeedbackEdgeAction()]);
         this.tool.deregisterFeedback(result);
         this.tool.deregisterFeedbackListeners();
     }