@eclipse-glsp/client 0.10.0-next.e5fcffe.169 → 1.0.0

package/src/features/layout/{layout-commands.ts → layout-elements-action.ts}

@@ -13,12 +13,21 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, ChangeBoundsOperation, ElementAndBounds, hasArrayProp, hasNumberProp, SetBoundsAction } from '@eclipse-glsp/protocol';
+import {
+    Action,
+    ChangeBoundsOperation,
+    ElementAndBounds,
+    hasArrayProp,
+    hasNumberProp,
+    hasStringProp,
+    SetBoundsAction,
+    Writable
+} from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
-import { Command, CommandExecutionContext, CommandReturn, ElementMove, IActionDispatcher, MoveAction, SModelElement } from 'sprotty';
+import { ElementMove, IActionDispatcher, IActionHandler, ICommand, MoveAction, SModelElement } from 'sprotty';
 import { TYPES } from '../../base/types';
-import { toValidElementAndBounds, toValidElementMove, WriteableElementAndBounds, WriteableElementMove } from '../../utils/layout-utils';
-import { BoundsAwareModelElement } from '../../utils/smodel-util';
+import { toValidElementAndBounds, toValidElementMove } from '../../utils/layout-utils';
+import { BoundsAwareModelElement, getElements } from '../../utils/smodel-util';
 import { isBoundsAwareMoveable, isResizable } from '../change-bounds/model';
 import { IMovementRestrictor } from '../change-bounds/movement-restrictor';
 import { SelectionService } from '../select/selection-service';
@@ -33,7 +42,14 @@ export enum ResizeDimension {
     Width_And_Height
 }
 
-export namespace Reduce {
+/**
+ * A function that computes a single number from a set of given numbers
+ * i.e. it reduces the given numbers to one single number.
+ * Mainly used by the {@link ResizeElementsCommand} to reduce the given dimensions to a target dimension value.
+ */
+export type ReduceFunction = (...values: number[]) => number;
+
+export namespace ReduceFunction {
     /**
      * Returns the minimal value of the given numbers.
      * @param values Numbers to be evaluated.
@@ -79,13 +95,18 @@ export namespace Reduce {
     }
 
     /**
-     * Returns the reduce function that corresponds to the given {@link ReduceFunctionKind}.
+     * Returns the reduce function that corresponds to the given {@link ReduceFunctionType}.
      * @param type The reduce function kind.
      * @returns The corresponding reduce function.
      */
+    export function get(type: ReduceFunctionType): ReduceFunction {
+        return ReduceFunction[type];
+    }
 }
 
-type ReduceFn = (...values: number[]) => number;
+/** Union type of all {@link ReduceFunction} keys. */
+export type ReduceFunctionType = Exclude<keyof typeof ReduceFunction, 'get'>;
+
 export interface ResizeElementsAction extends Action {
     kind: typeof ResizeElementsAction.KIND;
 
@@ -93,14 +114,16 @@ export interface ResizeElementsAction extends Action {
      * IDs of the elements that should be resized. If no IDs are given, the selected elements will be resized.
      */
     elementIds: string[];
+
     /**
      * Resize dimension. The default is {@link ResizeDimension.Width}.
      */
     dimension: ResizeDimension;
+
     /**
-     * Function to reduce the dimension to a target dimension value, see Reduce.* for potential functions.
+     * Type of the {@link ReduceFunction} that should be used to reduce the dimension to a target dimension value
      */
-    reductionFunction: ReduceFn;
+    reduceFunction: ReduceFunctionType;
 }
 
 export namespace ResizeElementsAction {
@@ -111,14 +134,14 @@ export namespace ResizeElementsAction {
             Action.hasKind(object, KIND) &&
             hasArrayProp(object, 'elementIds') &&
             hasNumberProp(object, 'dimension') &&
-            'reductionFunction' in object
+            hasStringProp(object, 'reduceFunction')
         );
     }
 
     export function create(options: {
         elementIds?: string[];
         dimension?: ResizeDimension;
-        reductionFunction: ReduceFn;
+        reduceFunction: ReduceFunctionType;
     }): ResizeElementsAction {
         return {
             kind: KIND,
@@ -129,99 +152,24 @@ export namespace ResizeElementsAction {
     }
 }
 
-// eslint-disable-next-line no-shadow
-export enum Alignment {
-    Left,
-    Center,
-    Right,
-    Top,
-    Middle,
-    Bottom
-}
-
-export namespace Select {
-    export function all(elements: BoundsAwareModelElement[]): BoundsAwareModelElement[] {
-        return elements;
-    }
-
-    export function first(elements: BoundsAwareModelElement[]): BoundsAwareModelElement[] {
-        return [elements[0]];
-    }
-
-    export function last(elements: BoundsAwareModelElement[]): BoundsAwareModelElement[] {
-        return [elements[elements.length - 1]];
-    }
-}
-
-type SelectFn = (elements: BoundsAwareModelElement[]) => BoundsAwareModelElement[];
-export interface AlignElementsAction extends Action {
-    kind: typeof AlignElementsAction.KIND;
+@injectable()
+export abstract class LayoutElementsActionHandler implements IActionHandler {
+    @inject(TYPES.IActionDispatcher)
+    protected actionDispatcher: IActionDispatcher;
 
-    /**
-     * IDs of the elements that should be aligned. If no IDs are given, the selected elements will be aligned.
-     */
-    elementIds: string[];
-    /**
-     * Alignment direction. The default is {@link Alignment.Left}
-     */
-    alignment: Alignment;
-    /**
-     * Function to selected elements that are considered during alignment calculation, see Select.* for potential functions.
-     * The default value is {@link Select.all}.
-     */
-    selectionFunction: SelectFn;
-}
+    @inject(TYPES.SelectionService)
+    protected selectionService: SelectionService;
 
-export namespace AlignElementsAction {
-    export const KIND = 'alignElements';
+    @inject(TYPES.IMovementRestrictor)
+    @optional()
+    protected movementRestrictor?: IMovementRestrictor;
 
-    export function is(object: any): object is AlignElementsAction {
-        return (
-            Action.hasKind(object, KIND) &&
-            hasArrayProp(object, 'elementIds') &&
-            hasNumberProp(object, 'alignment') &&
-            'selectionFunction' in object
-        );
-    }
+    abstract handle(action: Action): void | Action | ICommand;
 
-    export function create(
-        options: { elementIds?: string[]; alignment?: Alignment; selectionFunction?: SelectFn } = {}
-    ): AlignElementsAction {
-        return {
-            kind: KIND,
-            elementIds: [],
-            alignment: Alignment.Left,
-            selectionFunction: Select.all,
-            ...options
-        };
-    }
-}
-@injectable()
-abstract class LayoutElementsCommand extends Command {
-    constructor(
-        @inject(TYPES.Action) protected action: ResizeElementsAction | AlignElementsAction,
-        @inject(TYPES.IActionDispatcher) protected actionDispatcher: IActionDispatcher,
-        @inject(TYPES.SelectionService) protected selectionService: SelectionService,
-        @inject(TYPES.IMovementRestrictor) @optional() readonly movementRestrictor?: IMovementRestrictor
-    ) {
-        super();
-    }
-
-    getActionElements(context: CommandExecutionContext): BoundsAwareModelElement[] {
-        const model = context.root;
-        const elementIDs = this.action.elementIds;
-        if (elementIDs.length === 0) {
-            // collect the selected elements from the selection service (selection order is kept by service)
-            this.selectionService.getSelectedElementIDs().forEach(elementID => elementIDs.push(elementID));
-        }
-        const boundsAwareElements: BoundsAwareModelElement[] = [];
-        elementIDs.forEach(id => {
-            const element = model.index.getById(id);
-            if (element && this.isActionElement(element)) {
-                boundsAwareElements.push(element);
-            }
-        });
-        return boundsAwareElements;
+    getSelectedElements(selection: { elementIds: string[] }): BoundsAwareModelElement[] {
+        const index = this.selectionService.getModelRoot().index;
+        const selectedElements = selection.elementIds.length > 0 ? selection.elementIds : this.selectionService.getSelectedElementIDs();
+        return getElements(index, selectedElements, this.isActionElement);
     }
 
     protected abstract isActionElement(element: SModelElement): element is BoundsAwareModelElement;
@@ -236,79 +184,60 @@ abstract class LayoutElementsCommand extends Command {
 }
 
 @injectable()
-export class ResizeElementsCommand extends LayoutElementsCommand {
-    static readonly KIND = ResizeElementsAction.KIND;
-
-    constructor(
-        @inject(TYPES.Action) protected override action: ResizeElementsAction,
-        @inject(TYPES.IActionDispatcher) protected override actionDispatcher: IActionDispatcher,
-        @inject(TYPES.SelectionService) protected override selectionService: SelectionService,
-        @inject(TYPES.IMovementRestrictor) @optional() override readonly movementRestrictor?: IMovementRestrictor
-    ) {
-        super(action, actionDispatcher, selectionService, movementRestrictor);
-    }
-
-    protected isActionElement(element: SModelElement): element is BoundsAwareModelElement {
-        return isResizable(element);
-    }
-
-    execute(context: CommandExecutionContext): CommandReturn {
-        const elements = this.getActionElements(context);
+export class ResizeElementsActionHandler extends LayoutElementsActionHandler {
+    handle(action: ResizeElementsAction): void {
+        const elements = this.getSelectedElements(action);
         if (elements.length > 1) {
-            switch (this.action.dimension) {
+            const reduceFn = ReduceFunction.get(action.reduceFunction);
+            switch (action.dimension) {
                 case ResizeDimension.Width:
-                    this.resizeWidth(elements);
-                    break;
+                    return this.resizeWidth(elements, reduceFn);
                 case ResizeDimension.Height:
-                    this.resizeHeight(elements);
-                    break;
+                    return this.resizeHeight(elements, reduceFn);
                 case ResizeDimension.Width_And_Height:
-                    this.resizeWidthAndHeight(elements);
-                    break;
+                    return this.resizeWidthAndHeight(elements, reduceFn);
             }
         }
-        return context.root;
     }
 
-    resizeWidth(elements: BoundsAwareModelElement[]): void {
-        const targetWidth = this.action.reductionFunction(...elements.map(element => element.bounds.width));
+    resizeWidth(elements: BoundsAwareModelElement[], reduceFn: ReduceFunction): void {
+        const targetWidth = reduceFn(...elements.map(element => element.bounds.width));
         this.dispatchResizeActions(elements, (element, bounds) => {
-            // resize around center
+            // resize around center (horizontal)
             const halfDiffWidth = 0.5 * (targetWidth - element.bounds.width);
-            bounds.newPosition.x = element.bounds.x - halfDiffWidth;
+            bounds.newPosition!.x = element.bounds.x - halfDiffWidth;
             bounds.newSize.width = targetWidth;
         });
     }
 
-    resizeHeight(elements: BoundsAwareModelElement[]): void {
-        const targetHeight = this.action.reductionFunction(...elements.map(element => element.bounds.height));
+    resizeHeight(elements: BoundsAwareModelElement[], reduceFn: ReduceFunction): void {
+        const targetHeight = reduceFn(...elements.map(element => element.bounds.height));
         this.dispatchResizeActions(elements, (element, bounds) => {
-            // resize around middle
+            // resize around middle (vertical)
             const halfDiffHeight = 0.5 * (targetHeight - element.bounds.height);
-            bounds.newPosition.y = element.bounds.y - halfDiffHeight;
+            bounds.newPosition!.y = element.bounds.y - halfDiffHeight;
             bounds.newSize.height = targetHeight;
         });
     }
 
-    resizeWidthAndHeight(elements: BoundsAwareModelElement[]): void {
-        const targetWidth = this.action.reductionFunction(...elements.map(element => element.bounds.width));
-        const targetHeight = this.action.reductionFunction(...elements.map(element => element.bounds.height));
+    resizeWidthAndHeight(elements: BoundsAwareModelElement[], reduceFn: ReduceFunction): void {
+        const targetWidth = reduceFn(...elements.map(element => element.bounds.width));
+        const targetHeight = reduceFn(...elements.map(element => element.bounds.height));
         this.dispatchResizeActions(elements, (element, bounds) => {
-            // resize around center and middle
+            // resize around center and middle (horizontal & vertical)
             const halfDiffWidth = 0.5 * (targetWidth - element.bounds.width);
             const halfDiffHeight = 0.5 * (targetHeight - element.bounds.height);
-            bounds.newPosition.x = element.bounds.x - halfDiffWidth;
-            bounds.newPosition.y = element.bounds.y - halfDiffHeight;
-            bounds.newSize.width = targetWidth;
-            bounds.newSize.height = targetHeight;
+            bounds.newPosition = { x: element.bounds.x - halfDiffWidth, y: element.bounds.y - halfDiffHeight };
+            bounds.newSize = { width: targetWidth, height: targetHeight };
         });
     }
 
     dispatchResizeActions(
         elements: BoundsAwareModelElement[],
-        change: (element: BoundsAwareModelElement, bounds: WriteableElementAndBounds) => void
+        change: (element: BoundsAwareModelElement, bounds: Writable<ElementAndBounds>) => void
     ): void {
         const elementAndBounds: ElementAndBounds[] = []; // client- and server-side resize
+
         elements.forEach(element => {
             const elementChange = this.createElementAndBounds(element, change);
             if (elementChange) {
@@ -321,9 +250,9 @@ export class ResizeElementsCommand extends LayoutElementsCommand {
 
     createElementAndBounds(
         element: BoundsAwareModelElement,
-        change: (_element: BoundsAwareModelElement, _bounds: WriteableElementAndBounds) => void
-    ): WriteableElementAndBounds | undefined {
-        const bounds: WriteableElementAndBounds = {
+        change: (_element: BoundsAwareModelElement, _bounds: Writable<ElementAndBounds>) => void
+    ): Writable<ElementAndBounds> | undefined {
+        const bounds: ElementAndBounds = {
             elementId: element.id,
             newPosition: {
                 x: element.bounds.x,
@@ -337,107 +266,173 @@ export class ResizeElementsCommand extends LayoutElementsCommand {
         change(element, bounds);
         return toValidElementAndBounds(element, bounds, this.movementRestrictor);
     }
+    protected isActionElement(element: SModelElement): element is BoundsAwareModelElement {
+        return isResizable(element);
+    }
+}
+
+// eslint-disable-next-line no-shadow
+export enum Alignment {
+    Left,
+    Center,
+    Right,
+    Top,
+    Middle,
+    Bottom
+}
 
-    undo(context: CommandExecutionContext): CommandReturn {
-        // we dispatch another action which can be undone, so no explicit implementation necessary
-        return context.root;
+/**
+ * A function that retrieves a specific (sub)-selection of elements from a given set of elements.
+ * Mainly used by the {@link AlignElementsActionHandler}.
+ */
+export type SelectFunction = (elements: BoundsAwareModelElement[]) => BoundsAwareModelElement[];
+export namespace SelectFunction {
+    /**
+     * Select all elements from the given set of elements.
+     * @param elements The set of elements.
+     * @returns All elements.
+     */
+    export function all(elements: BoundsAwareModelElement[]): BoundsAwareModelElement[] {
+        return elements;
     }
 
-    redo(context: CommandExecutionContext): CommandReturn {
-        // we dispatch another action which can be redone, so no explicit implementation necessary
-        return context.root;
+    /**
+     * Select the first element from a given set of elements.
+     * @param elements The elements.
+     * @returns An array containing the first element of the given elements.
+     */
+    export function first(elements: BoundsAwareModelElement[]): BoundsAwareModelElement[] {
+        return [elements[0]];
+    }
+
+    /**
+     * Select the last element from a given set of elements.
+     * @param elements The elements.
+     * @returns An array containing the last element of the given elements.
+     */
+    export function last(elements: BoundsAwareModelElement[]): BoundsAwareModelElement[] {
+        return [elements[elements.length - 1]];
+    }
+
+    /**
+     * Returns the select function that corresponds to the given {@link SelectFunctionType}.
+     * @param type The select function type.
+     * @returns The corresponding select function.
+     */
+    export function get(kind: SelectFunctionType): SelectFunction {
+        return SelectFunction[kind];
     }
 }
 
-@injectable()
-export class AlignElementsCommand extends LayoutElementsCommand {
-    static readonly KIND = AlignElementsAction.KIND;
+/** Union type of all {@link SelectFunction} keys. */
+export type SelectFunctionType = Exclude<keyof typeof SelectFunction, 'get'>;
 
-    constructor(
-        @inject(TYPES.Action) protected override action: AlignElementsAction,
-        @inject(TYPES.IActionDispatcher) protected override actionDispatcher: IActionDispatcher,
-        @inject(TYPES.SelectionService) protected override selectionService: SelectionService,
-        @inject(TYPES.IMovementRestrictor) @optional() override readonly movementRestrictor?: IMovementRestrictor
-    ) {
-        super(action, actionDispatcher, selectionService, movementRestrictor);
+export interface AlignElementsAction extends Action {
+    kind: typeof AlignElementsAction.KIND;
+
+    /**
+     * IDs of the elements that should be aligned. If no IDs are given, the selected elements will be aligned.
+     */
+    elementIds: string[];
+    /**
+     * Alignment direction. The default is {@link Alignment.Left}
+     */
+    alignment: Alignment;
+    /**
+     * Function to selected elements that are considered during alignment calculation.
+     * The default value is {@link Select.all}.
+     */
+    selectFunction: SelectFunctionType;
+}
+
+export namespace AlignElementsAction {
+    export const KIND = 'alignElements';
+
+    export function is(object: any): object is AlignElementsAction {
+        return (
+            Action.hasKind(object, KIND) &&
+            hasArrayProp(object, 'elementIds') &&
+            hasNumberProp(object, 'alignment') &&
+            hasStringProp(object, 'selectFunction')
+        );
     }
 
-    protected isActionElement(element: SModelElement): element is BoundsAwareModelElement {
-        return isBoundsAwareMoveable(element);
+    export function create(
+        options: { elementIds?: string[]; alignment?: Alignment; selectionFunction?: SelectFunctionType } = {}
+    ): AlignElementsAction {
+        return {
+            kind: KIND,
+            elementIds: [],
+            alignment: Alignment.Left,
+            selectFunction: 'all',
+            ...options
+        };
     }
+}
 
-    execute(context: CommandExecutionContext): CommandReturn {
-        const elements = this.getActionElements(context);
+@injectable()
+export class AlignElementsActionHandler extends LayoutElementsActionHandler {
+    handle(action: AlignElementsAction): void {
+        const elements = this.getSelectedElements(action);
+        const selectFn = SelectFunction.get(action.selectFunction);
+        const calculatedElements = selectFn(elements);
         if (elements.length > 1) {
-            switch (this.action.alignment) {
+            switch (action.alignment) {
                 case Alignment.Left:
-                    this.alignLeft(elements);
-                    break;
+                    return this.alignLeft(calculatedElements);
                 case Alignment.Center:
-                    this.alignCenter(elements);
-                    break;
+                    return this.alignCenter(calculatedElements);
                 case Alignment.Right:
-                    this.alignRight(elements);
-                    break;
+                    return this.alignRight(calculatedElements);
                 case Alignment.Top:
-                    this.alignTop(elements);
-                    break;
+                    return this.alignTop(calculatedElements);
                 case Alignment.Middle:
-                    this.alignMiddle(elements);
-                    break;
+                    return this.alignMiddle(calculatedElements);
                 case Alignment.Bottom:
-                    this.alignBottom(elements);
-                    break;
+                    return this.alignBottom(calculatedElements);
             }
         }
-        return context.root;
     }
 
     alignLeft(elements: BoundsAwareModelElement[]): void {
-        const calculationElements = this.action.selectionFunction(elements);
-        const minX = calculationElements.map(element => element.bounds.x).reduce((a, b) => Math.min(a, b));
+        const minX = elements.map(element => element.bounds.x).reduce((a, b) => Math.min(a, b));
         this.dispatchAlignActions(elements, (_, move) => (move.toPosition.x = minX));
     }
 
     alignCenter(elements: BoundsAwareModelElement[]): void {
-        const calculationElements = this.action.selectionFunction(elements);
-        const minX = calculationElements.map(element => element.bounds.x).reduce((a, b) => Math.min(a, b));
-        const maxX = calculationElements.map(element => element.bounds.x + element.bounds.width).reduce((a, b) => Math.max(a, b));
+        const minX = elements.map(element => element.bounds.x).reduce((a, b) => Math.min(a, b));
+        const maxX = elements.map(element => element.bounds.x + element.bounds.width).reduce((a, b) => Math.max(a, b));
         const diffX = maxX - minX;
         const centerX = minX + 0.5 * diffX;
         this.dispatchAlignActions(elements, (element, move) => (move.toPosition.x = centerX - 0.5 * element.bounds.width));
     }
 
     alignRight(elements: BoundsAwareModelElement[]): void {
-        const calculationElements = this.action.selectionFunction(elements);
-        const maxX = calculationElements.map(element => element.bounds.x + element.bounds.width).reduce((a, b) => Math.max(a, b));
+        const maxX = elements.map(element => element.bounds.x + element.bounds.width).reduce((a, b) => Math.max(a, b));
         this.dispatchAlignActions(elements, (element, move) => (move.toPosition.x = maxX - element.bounds.width));
     }
 
     alignTop(elements: BoundsAwareModelElement[]): void {
-        const calculationElements = this.action.selectionFunction(elements);
-        const minY = calculationElements.map(element => element.bounds.y).reduce((a, b) => Math.min(a, b));
+        const minY = elements.map(element => element.bounds.y).reduce((a, b) => Math.min(a, b));
         this.dispatchAlignActions(elements, (_, move) => (move.toPosition.y = minY));
     }
 
     alignMiddle(elements: BoundsAwareModelElement[]): void {
-        const calculationElements = this.action.selectionFunction(elements);
-        const minY = calculationElements.map(element => element.bounds.y).reduce((a, b) => Math.min(a, b));
-        const maxY = calculationElements.map(element => element.bounds.y + element.bounds.height).reduce((a, b) => Math.max(a, b));
+        const minY = elements.map(element => element.bounds.y).reduce((a, b) => Math.min(a, b));
+        const maxY = elements.map(element => element.bounds.y + element.bounds.height).reduce((a, b) => Math.max(a, b));
         const diffY = maxY - minY;
         const middleY = minY + 0.5 * diffY;
         this.dispatchAlignActions(elements, (element, move) => (move.toPosition.y = middleY - 0.5 * element.bounds.height));
     }
 
     alignBottom(elements: BoundsAwareModelElement[]): void {
-        const calculationElements = this.action.selectionFunction(elements);
-        const maxY = calculationElements.map(element => element.bounds.y + element.bounds.height).reduce((a, b) => Math.max(a, b));
+        const maxY = elements.map(element => element.bounds.y + element.bounds.height).reduce((a, b) => Math.max(a, b));
         this.dispatchAlignActions(elements, (element, move) => (move.toPosition.y = maxY - element.bounds.height));
     }
 
     dispatchAlignActions(
         elements: BoundsAwareModelElement[],
-        change: (element: BoundsAwareModelElement, move: WriteableElementMove) => void
+        change: (element: BoundsAwareModelElement, move: Writable<ElementMove>) => void
     ): void {
         const moves: ElementMove[] = []; // client-side move
         const elementAndBounds: ElementAndBounds[] = []; // server-side move
@@ -455,9 +450,9 @@ export class AlignElementsCommand extends LayoutElementsCommand {
 
     createElementMove(
         element: BoundsAwareModelElement,
-        change: (_element: BoundsAwareModelElement, _move: WriteableElementMove) => void
-    ): WriteableElementMove | undefined {
-        const move: WriteableElementMove = {
+        change: (_element: BoundsAwareModelElement, _move: Writable<ElementMove>) => void
+    ): Writable<ElementMove> | undefined {
+        const move: ElementMove = {
             elementId: element.id,
             fromPosition: {
                 x: element.bounds.x,
@@ -485,14 +480,7 @@ export class AlignElementsCommand extends LayoutElementsCommand {
             }
         };
     }
-
-    undo(context: CommandExecutionContext): CommandReturn {
-        // we dispatch another action which can be undone, so no explicit implementation necessary
-        return context.root;
-    }
-
-    redo(context: CommandExecutionContext): CommandReturn {
-        // we dispatch another action which can be redone, so no explicit implementation necessary
-        return context.root;
+    protected isActionElement(element: SModelElement): element is BoundsAwareModelElement {
+        return isBoundsAwareMoveable(element);
     }
 }

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

@@ -13,6 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Action } from '@eclipse-glsp/protocol';
 import { injectable, multiInject, optional } from 'inversify';
 import { MouseListener, MouseTool, SModelElement, SModelRoot } from 'sprotty';
 import { TYPES } from '../../base/types';
@@ -48,10 +49,6 @@ export class RankingMouseTool extends MouseTool implements IMouseTool {
         this.rankedMouseListeners = groupBy(this.mouseListeners, listener => getRank(listener));
     }
 
-    contextMenu(model: SModelRoot, event: MouseEvent): void {
-        event.preventDefault();
-    }
-
     protected override handleEvent<K extends MouseListenerMethods>(methodName: K, model: SModelRoot, event: MouseEvent): void {
         this.focusOnMouseEvent(methodName, model);
         const element = this.getTargetElement(model, event);
@@ -82,8 +79,13 @@ export class RankingMouseTool extends MouseTool implements IMouseTool {
         if (actions.length > 0) {
             event.preventDefault();
             for (const actionOrPromise of actions) {
-                const action = await actionOrPromise;
-                await this.actionDispatcher.dispatch(action);
+                if (Action.is(actionOrPromise)) {
+                    await this.actionDispatcher.dispatch(actionOrPromise);
+                } else {
+                    actionOrPromise.then((action: Action) => {
+                        this.actionDispatcher.dispatch(action);
+                    });
+                }
             }
         }
     }