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

package/src/features/tool-feedback/creation-tool-feedback.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 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, Point } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import {
-    Action,
     add,
     AnchorComputerRegistry,
     center,
@@ -28,7 +28,6 @@ import {
     isConnectable,
     MouseListener,
     MoveAction,
-    Point,
     PolylineEdgeRouter,
     SChildElement,
     SConnectableElement,
@@ -39,8 +38,7 @@ import {
     SRoutableElement,
     TYPES
 } from 'sprotty';
-
-import { isRoutable } from '../../utils/smodel-util';
+import { BoundsAwareModelElement, isRoutable } from '../../utils/smodel-util';
 import { getAbsolutePosition, toAbsoluteBounds, toAbsolutePosition } from '../../utils/viewpoint-util';
 import { FeedbackCommand } from './model';
 
@@ -49,7 +47,8 @@ export class DrawFeedbackEdgeAction implements Action {
         public readonly elementTypeId: string,
         public readonly sourceId: string,
         public readonly edgeSchema?: SEdgeSchema,
-        public readonly kind: string = DrawFeedbackEdgeCommand.KIND) { }
+        public readonly kind: string = DrawFeedbackEdgeCommand.KIND
+    ) {}
 }
 
 @injectable()
@@ -68,7 +67,7 @@ export class DrawFeedbackEdgeCommand extends FeedbackCommand {
 }
 
 export class RemoveFeedbackEdgeAction implements Action {
-    constructor(public readonly kind: string = RemoveFeedbackEdgeCommand.KIND) { }
+    constructor(public readonly kind: string = RemoveFeedbackEdgeCommand.KIND) {}
 }
 
 @injectable()
@@ -83,10 +82,12 @@ export class RemoveFeedbackEdgeCommand extends FeedbackCommand {
 
 export class FeedbackEdgeEnd extends SDanglingAnchor {
     static readonly TYPE = 'feedback-edge-end';
-    constructor(readonly sourceId: string,
+    constructor(
+        readonly sourceId: string,
         readonly elementTypeId: string,
         public feedbackEdge: SRoutableElement | undefined = undefined,
-        public readonly type: string = FeedbackEdgeEnd.TYPE) {
+        override readonly type: string = FeedbackEdgeEnd.TYPE
+    ) {
         super();
     }
 }
@@ -96,7 +97,7 @@ export class FeedbackEdgeEndMovingMouseListener extends MouseListener {
         super();
     }
 
-    mouseMove(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseMove(target: SModelElement, event: MouseEvent): Action[] {
         const root = target.root;
         const edgeEnd = root.index.getById(feedbackEdgeEndId(root));
         if (!(edgeEnd instanceof FeedbackEdgeEnd) || !edgeEnd.feedbackEdge) {
@@ -106,10 +107,11 @@ export class FeedbackEdgeEndMovingMouseListener extends MouseListener {
         const edge = edgeEnd.feedbackEdge;
         const position = getAbsolutePosition(edgeEnd, event);
         const endAtMousePosition = findChildrenAtPosition(target.root, position)
+            .reverse()
             .find(element => isConnectable(element) && element.canConnect(edge, 'target'));
 
         if (endAtMousePosition instanceof SConnectableElement && edge.source && isBoundsAware(edge.source)) {
-            const anchor = this.computeAbsoluteAnchor(endAtMousePosition, center(edge.source.bounds));
+            const anchor = this.computeAbsoluteAnchor(endAtMousePosition, center(toAbsoluteBounds(edge.source)));
             if (euclideanDistance(anchor, edgeEnd.position) > 1) {
                 return [new MoveAction([{ elementId: edgeEnd.id, toPosition: anchor }], false)];
             }
@@ -120,9 +122,10 @@ export class FeedbackEdgeEndMovingMouseListener extends MouseListener {
         return [];
     }
 
-    protected computeAbsoluteAnchor(element: SConnectableElement, referencePoint: Point, offset?: number): Point {
+    protected computeAbsoluteAnchor(element: SConnectableElement, absoluteReferencePoint: Point, offset?: number): Point {
+        const referencePointInParent = absoluteToParent(element, absoluteReferencePoint);
         const anchorComputer = this.anchorRegistry.get(PolylineEdgeRouter.KIND, element.anchorKind);
-        let anchor = anchorComputer.getAnchor(element, referencePoint, offset);
+        let anchor = anchorComputer.getAnchor(element, referencePointInParent, offset);
         // The anchor is computed in the local coordinate system of the element.
         // If the element is a nested child element we have to add the absolute position of its parent to the anchor.
         if (element.parent !== element.root) {
@@ -136,6 +139,33 @@ export class FeedbackEdgeEndMovingMouseListener extends MouseListener {
     }
 }
 
+/**
+ * Convert a point, specified in absolute coordinates, to a point relative
+ * to the parent of the specified child element.
+ * @param element the child element
+ * @param absolutePoint a point in absolute coordinates
+ * @returns the equivalent point, relative to the element's parent coordinates
+ */
+function absoluteToParent(element: BoundsAwareModelElement & SChildElement, absolutePoint: Point): Point {
+    if (isBoundsAware(element.parent)) {
+        return absoluteToLocal(element.parent, absolutePoint);
+    }
+    // If the parent is not bounds-aware, assume it's at 0; 0 and proceed
+    return absoluteToLocal(element, absolutePoint);
+}
+
+/**
+ * Convert a point, specified in absolute coordinates, to a point relative
+ * to the specified element.
+ * @param element the element
+ * @param absolutePoint a point in absolute coordinates
+ * @returns the equivalent point, relative to the element's coordinates
+ */
+function absoluteToLocal(element: BoundsAwareModelElement, absolutePoint: Point): Point {
+    const absoluteElementBounds = toAbsoluteBounds(element);
+    return { x: absolutePoint.x - absoluteElementBounds.x, y: absolutePoint.y - absoluteElementBounds.y };
+}
+
 export function feedbackEdgeId(root: SModelRoot): string {
     return root.id + '_feedback_edge';
 }
@@ -149,7 +179,12 @@ export const defaultFeedbackEdgeSchema: SEdgeSchema = {
     opacity: 0.3
 } as SEdgeSchema;
 
-export function drawFeedbackEdge(context: CommandExecutionContext, sourceId: string, elementTypeId: string, feedbackEdgeSchema: SEdgeSchema): void {
+export function drawFeedbackEdge(
+    context: CommandExecutionContext,
+    sourceId: string,
+    elementTypeId: string,
+    feedbackEdgeSchema: SEdgeSchema
+): void {
     const root = context.root;
     const sourceChild = root.index.getById(sourceId);
     if (!sourceChild) {

package/src/features/tool-feedback/css-feedback.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 { Action, isStringArray } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { Action, CommandExecutionContext, SModelElement, SModelRoot, TYPES } from 'sprotty';
-
-import { isStringArray } from '../../utils/array-utils';
+import { CommandExecutionContext, SModelElement, SModelRoot, TYPES } from 'sprotty';
 import { addCssClasses, removeCssClasses } from '../../utils/smodel-util';
 import { FeedbackCommand } from './model';
 
@@ -27,7 +26,8 @@ export class ModifyCSSFeedbackAction implements Action {
         public readonly input?: string[] | SModelElement[],
         public readonly addClasses?: string[],
         public readonly removeClasses?: string[],
-        public kind = ModifyCssFeedbackCommand.KIND) {
+        public kind = ModifyCssFeedbackCommand.KIND
+    ) {
         if (input) {
             this.elementIds = isStringArray(input) ? input : input.map(element => element.id);
         }
@@ -68,6 +68,7 @@ function exists(elt?: SModelElement): elt is SModelElement {
     return elt !== undefined;
 }
 
+// eslint-disable-next-line no-shadow
 export enum CursorCSS {
     DEFAULT = 'default-mode',
     OVERLAP_FORBIDDEN = 'overlap-forbidden-mode',
@@ -77,7 +78,9 @@ export enum CursorCSS {
     EDGE_RECONNECT = 'edge-reconnect-select-target-mode',
     OPERATION_NOT_ALLOWED = 'edge-modification-not-allowed-mode',
     ELEMENT_DELETION = 'element-deletion-mode',
-    RESIZE = 'resize-mode',
+    RESIZE_NESW = 'resize-nesw-mode',
+    RESIZE_NWSE = 'resize-nwse-mode',
+    MOVE = 'move-mode',
     MARQUEE = 'marquee-mode'
 }
 

package/src/features/tool-feedback/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
@@ -18,10 +18,7 @@ import { configureCommand, configureView, LocationPostprocessor, MoveCommand, TY
 
 import { GLSP_TYPES } from '../../base/types';
 import { SResizeHandle } from '../change-bounds/model';
-import {
-    HideChangeBoundsToolResizeFeedbackCommand,
-    ShowChangeBoundsToolResizeFeedbackCommand
-} from './change-bounds-tool-feedback';
+import { HideChangeBoundsToolResizeFeedbackCommand, ShowChangeBoundsToolResizeFeedbackCommand } from './change-bounds-tool-feedback';
 import { DrawFeedbackEdgeCommand, FeedbackEdgeEnd, RemoveFeedbackEdgeCommand } from './creation-tool-feedback';
 import { ModifyCssFeedbackCommand } from './css-feedback';
 import {

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 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,10 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Action, Point } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { VNode } from 'snabbdom/vnode';
+import { VNode } from 'snabbdom';
 import {
-    Action,
     add,
     AnchorComputerRegistry,
     center,
@@ -29,11 +29,10 @@ import {
     findParentByFeature,
     isBoundsAware,
     isConnectable,
+    ISnapper,
     isSelected,
-    isViewport,
     MouseListener,
     MoveAction,
-    Point,
     PolylineEdgeRouter,
     SConnectableElement,
     SModelElement,
@@ -43,16 +42,11 @@ import {
     SwitchEditModeCommand,
     TYPES
 } from 'sprotty';
-
-import { isNotUndefined, isRoutable, isRoutingHandle } from '../../utils/smodel-util';
+import { forEachElement, isNotUndefined, isRoutable, isRoutingHandle } from '../../utils/smodel-util';
 import { getAbsolutePosition, toAbsoluteBounds } from '../../utils/viewpoint-util';
+import { PointPositionUpdater } from '../change-bounds/snap';
 import { addReconnectHandles, removeReconnectHandles } from '../reconnect/model';
-import {
-    FeedbackEdgeEnd,
-    feedbackEdgeEndId,
-    FeedbackEdgeEndMovingMouseListener,
-    feedbackEdgeId
-} from './creation-tool-feedback';
+import { FeedbackEdgeEnd, feedbackEdgeEndId, FeedbackEdgeEndMovingMouseListener, feedbackEdgeId } from './creation-tool-feedback';
 import { FeedbackCommand } from './model';
 
 /**
@@ -60,11 +54,11 @@ import { FeedbackCommand } from './model';
  */
 
 export class ShowEdgeReconnectHandlesFeedbackAction implements Action {
-    constructor(readonly elementId?: string, public readonly kind: string = ShowEdgeReconnectHandlesFeedbackCommand.KIND) { }
+    constructor(readonly elementId?: string, public readonly kind: string = ShowEdgeReconnectHandlesFeedbackCommand.KIND) {}
 }
 
 export class HideEdgeReconnectHandlesFeedbackAction implements Action {
-    constructor(public readonly kind: string = HideEdgeReconnectHandlesFeedbackCommand.KIND) { }
+    constructor(public readonly kind: string = HideEdgeReconnectHandlesFeedbackCommand.KIND) {}
 }
 
 @injectable()
@@ -77,7 +71,7 @@ export class ShowEdgeReconnectHandlesFeedbackCommand extends FeedbackCommand {
 
     execute(context: CommandExecutionContext): CommandReturn {
         const index = context.root.index;
-        index.all().filter(isRoutable).forEach(removeReconnectHandles);
+        forEachElement(index, isRoutable, removeReconnectHandles);
 
         if (isNotUndefined(this.action.elementId)) {
             const routableElement = index.getById(this.action.elementId);
@@ -99,7 +93,7 @@ export class HideEdgeReconnectHandlesFeedbackCommand extends FeedbackCommand {
 
     execute(context: CommandExecutionContext): CommandReturn {
         const index = context.root.index;
-        index.all().filter(isRoutable).forEach(removeReconnectHandles);
+        forEachElement(index, isRoutable, removeReconnectHandles);
         return context.root;
     }
 }
@@ -108,16 +102,18 @@ export class HideEdgeReconnectHandlesFeedbackCommand extends FeedbackCommand {
  */
 
 export class SwitchRoutingModeAction extends SwitchEditModeAction {
-    constructor(public readonly elementsToActivate: string[] = [],
-        public readonly elementsToDeactivate: string[] = [],
-        public readonly kind: string = SwitchRoutingModeCommand.KIND) {
+    constructor(
+        override readonly elementsToActivate: string[] = [],
+        override readonly elementsToDeactivate: string[] = [],
+        override readonly kind: string = SwitchRoutingModeCommand.KIND
+    ) {
         super(elementsToActivate, elementsToDeactivate);
     }
 }
 
 @injectable()
 export class SwitchRoutingModeCommand extends SwitchEditModeCommand {
-    static KIND = 'switchRoutingMode';
+    static override KIND = 'switchRoutingMode';
     constructor(@inject(TYPES.Action) action: SwitchRoutingModeAction) {
         super(action);
     }
@@ -128,7 +124,11 @@ export class SwitchRoutingModeCommand extends SwitchEditModeCommand {
  */
 
 export class DrawFeedbackEdgeSourceAction implements Action {
-    constructor(readonly elementTypeId: string, readonly targetId: string, public readonly kind: string = DrawFeedbackEdgeSourceCommand.KIND) { }
+    constructor(
+        readonly elementTypeId: string,
+        readonly targetId: string,
+        public readonly kind: string = DrawFeedbackEdgeSourceCommand.KIND
+    ) {}
 }
 
 @injectable()
@@ -150,7 +150,7 @@ export class DrawFeedbackEdgeSourceCommand extends FeedbackCommand {
  */
 
 export class FeedbackEdgeTargetMovingMouseListener extends FeedbackEdgeEndMovingMouseListener {
-    constructor(protected anchorRegistry: AnchorComputerRegistry) {
+    constructor(protected override anchorRegistry: AnchorComputerRegistry) {
         super(anchorRegistry);
     }
 }
@@ -160,7 +160,7 @@ export class FeedbackEdgeSourceMovingMouseListener extends MouseListener {
         super();
     }
 
-    mouseMove(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseMove(target: SModelElement, event: MouseEvent): Action[] {
         const root = target.root;
         const edgeEnd = root.index.getById(feedbackEdgeEndId(root));
         if (!(edgeEnd instanceof FeedbackEdgeEnd) || !edgeEnd.feedbackEdge) {
@@ -169,8 +169,9 @@ export class FeedbackEdgeSourceMovingMouseListener extends MouseListener {
 
         const edge = edgeEnd.feedbackEdge;
         const position = getAbsolutePosition(edgeEnd, event);
-        const endAtMousePosition = findChildrenAtPosition(target.root, position)
-            .find(e => isConnectable(e) && e.canConnect(edge, 'source'));
+        const endAtMousePosition = findChildrenAtPosition(target.root, position).find(
+            e => isConnectable(e) && e.canConnect(edge, 'source')
+        );
 
         if (endAtMousePosition instanceof SConnectableElement && edge.target && isBoundsAware(edge.target)) {
             const anchor = this.computeAbsoluteAnchor(endAtMousePosition, center(edge.target.bounds));
@@ -201,64 +202,74 @@ export class FeedbackEdgeSourceMovingMouseListener extends MouseListener {
 }
 
 export class FeedbackEdgeRouteMovingMouseListener extends MouseListener {
-    protected hasDragged = false;
-    protected lastDragPosition: Point | undefined;
+    protected pointPositionUpdater: PointPositionUpdater;
 
-    constructor(protected edgeRouterRegistry?: EdgeRouterRegistry) {
+    constructor(protected edgeRouterRegistry?: EdgeRouterRegistry, protected snapper?: ISnapper) {
         super();
+        this.pointPositionUpdater = new PointPositionUpdater(snapper);
     }
 
-    mouseDown(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseDown(target: SModelElement, event: MouseEvent): Action[] {
         const result: Action[] = [];
         if (event.button === 0) {
             const routingHandle = findParentByFeature(target, isRoutingHandle);
             if (routingHandle !== undefined) {
                 result.push(new SwitchRoutingModeAction([target.id], []));
-                this.lastDragPosition = { x: event.pageX, y: event.pageY };
+                this.pointPositionUpdater.updateLastDragPosition({ x: event.pageX, y: event.pageY });
             } else {
-                this.lastDragPosition = undefined;
+                this.pointPositionUpdater.resetPosition();
             }
-            this.hasDragged = false;
         }
         return result;
     }
 
-    mouseMove(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseMove(target: SModelElement, event: MouseEvent): Action[] {
         const result: Action[] = [];
         if (event.buttons === 0) {
-            this.mouseUp(target, event);
-        } else if (this.lastDragPosition) {
-            const viewport = findParentByFeature(target, isViewport);
-            this.hasDragged = true;
-            const zoom = viewport ? viewport.zoom : 1;
-            const dx = (event.pageX - this.lastDragPosition.x) / zoom;
-            const dy = (event.pageY - this.lastDragPosition.y) / zoom;
-            const handleMoves: ElementMove[] = [];
-            target.root.index.all()
-                .filter(element => isSelected(element))
-                .forEach(element => {
-                    if (isRoutingHandle(element)) {
-                        const point = this.getHandlePosition(element);
-                        if (point !== undefined) {
-                            handleMoves.push({
-                                elementId: element.id,
-                                fromPosition: point,
-                                toPosition: {
-                                    x: point.x + dx,
-                                    y: point.y + dy
-                                }
-                            });
-                        }
-                    }
-                });
-            this.lastDragPosition = { x: event.pageX, y: event.pageY };
-            if (handleMoves.length > 0) {
-                result.push(new MoveAction(handleMoves, false));
-            }
+            return this.mouseUp(target, event);
+        }
+        const positionUpdate = this.pointPositionUpdater.updatePosition(target, { x: event.pageX, y: event.pageY }, !event.altKey);
+        if (positionUpdate) {
+            const moveActions = this.handleMoveOnClient(target, positionUpdate);
+            result.push(...moveActions);
         }
         return result;
     }
 
+    protected handleMoveOnClient(target: SModelElement, positionUpdate: Point): Action[] {
+        const handleMoves: ElementMove[] = [];
+        target.root.index
+            .all()
+            .filter(element => isSelected(element))
+            .forEach(element => {
+                if (isRoutingHandle(element)) {
+                    const elementMove = this.toElementMove(element, positionUpdate);
+                    if (elementMove) {
+                        handleMoves.push(elementMove);
+                    }
+                }
+            });
+        if (handleMoves.length > 0) {
+            return [new MoveAction(handleMoves, false)];
+        }
+        return [];
+    }
+
+    protected toElementMove(element: SRoutingHandle, positionDelta: Point): ElementMove | undefined {
+        const point = this.getHandlePosition(element);
+        if (point !== undefined) {
+            return {
+                elementId: element.id,
+                fromPosition: point,
+                toPosition: {
+                    x: point.x + positionDelta.x,
+                    y: point.y + positionDelta.y
+                }
+            };
+        }
+        return undefined;
+    }
+
     protected getHandlePosition(handle: SRoutingHandle): Point | undefined {
         if (this.edgeRouterRegistry) {
             const parent = handle.parent;
@@ -272,20 +283,19 @@ export class FeedbackEdgeRouteMovingMouseListener extends MouseListener {
         return undefined;
     }
 
-    mouseEnter(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseEnter(target: SModelElement, event: MouseEvent): Action[] {
         if (target instanceof SModelRoot && event.buttons === 0) {
             this.mouseUp(target, event);
         }
         return [];
     }
 
-    mouseUp(_target: SModelElement, event: MouseEvent): Action[] {
-        this.hasDragged = false;
-        this.lastDragPosition = undefined;
+    override mouseUp(_target: SModelElement, event: MouseEvent): Action[] {
+        this.pointPositionUpdater.resetPosition();
         return [];
     }
 
-    decorate(vnode: VNode, _element: SModelElement): VNode {
+    override decorate(vnode: VNode, _element: SModelElement): VNode {
         return vnode;
     }
 }

package/src/features/tool-feedback/feedback-action-dispatcher.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,11 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Action } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { Action, IActionDispatcher, ILogger, TYPES } from 'sprotty';
+import { IActionDispatcher, ILogger, TYPES } from 'sprotty';
 
-export interface IFeedbackEmitter { }
+export interface IFeedbackEmitter {}
 
 /**
  * Dispatcher for actions that are meant to show visual feedback on
@@ -29,7 +30,7 @@ export interface IFeedbackEmitter { }
  * extending the `SModelRoot`. Therefore, tools can register themselves
  * as feedback emitters with actions they want to place for showing
  * feedback. This dispatcher will then re-establish all feedback actions
- * of the registered tools, whenever the `SModelRoot` has been set or updated.
+ * of the registered emitters, whenever the `SModelRoot` has been set or updated.
  */
 export interface IFeedbackActionDispatcher {
     /**
@@ -52,14 +53,14 @@ export interface IFeedbackActionDispatcher {
     deregisterFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void;
 
     /**
-    * Retrieve all `actions` sent out by currently registered `feedbackEmitter`.
-    */
+     * Retrieve all `actions` sent out by currently registered `feedbackEmitter`.
+     */
     getRegisteredFeedback(): Action[];
 }
 
 @injectable()
 export class FeedbackActionDispatcher implements IFeedbackActionDispatcher {
-    protected feedbackEmitters: Map<IFeedbackEmitter, Action[]> = new Map;
+    protected feedbackEmitters: Map<IFeedbackEmitter, Action[]> = new Map();
 
     @inject(TYPES.IActionDispatcherProvider) protected actionDispatcher: () => Promise<IActionDispatcher>;
     @inject(TYPES.ILogger) protected logger: ILogger;
@@ -93,9 +94,7 @@ export class FeedbackActionDispatcher implements IFeedbackActionDispatcher {
             if (value.find(a => a === action)) {
                 result.push(key);
             }
-        }
-        );
+        });
         return result;
     }
-
 }

package/src/features/tool-feedback/marquee-tool-feedback.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021 EclipseSource and others.
+ * Copyright (c) 2021-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,27 +13,26 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Action, Point } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import {
-    Action,
     AnchorComputerRegistry,
     CommandExecutionContext,
     CommandReturn,
     MouseListener,
-    Point,
     SChildElement,
     SModelElement,
     SModelRoot,
     TYPES
 } from 'sprotty';
-
 import { FeedbackCommand } from './model';
 
 export class DrawMarqueeAction implements Action {
     constructor(
         public readonly startPoint: Point,
         public readonly endPoint: Point,
-        public readonly kind: string = DrawMarqueeCommand.KIND) { }
+        public readonly kind: string = DrawMarqueeCommand.KIND
+    ) {}
 }
 
 @injectable()
@@ -51,7 +50,7 @@ export class DrawMarqueeCommand extends FeedbackCommand {
 }
 
 export class RemoveMarqueeAction implements Action {
-    constructor(public readonly kind: string = RemoveMarqueeCommand.KIND) { }
+    constructor(public readonly kind: string = RemoveMarqueeCommand.KIND) {}
 }
 
 @injectable()
@@ -69,7 +68,7 @@ export class MarqueeEndMovingMouseListener extends MouseListener {
         super();
     }
 
-    mouseMove(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseMove(target: SModelElement, event: MouseEvent): Action[] {
         return [];
     }
 }

package/src/features/tool-feedback/model.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
@@ -19,8 +19,6 @@ export abstract class FeedbackCommand extends Command {
     // used by the `FeedbackAwareUpdateModelCommand`
     readonly priority: number = 0;
 
-    abstract execute(context: CommandExecutionContext): CommandReturn;
-
     undo(context: CommandExecutionContext): CommandReturn {
         return context.root;
     }
@@ -29,4 +27,3 @@ export abstract class FeedbackCommand extends Command {
         return context.root;
     }
 }
-