@eclipse-glsp/client 0.9.0 → 0.10.0-next.385713d.170

package/src/features/layout/layout-commands.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,26 +13,19 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, ChangeBoundsOperation, ElementAndBounds } from '@eclipse-glsp/protocol';
+import { Action, ChangeBoundsOperation, ElementAndBounds, hasArrayProp, hasNumberProp, SetBoundsAction } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
-import {
-    Command,
-    CommandExecutionContext,
-    CommandReturn,
-    ElementMove,
-    IActionDispatcher,
-    MoveAction,
-    SetBoundsAction,
-    SModelElement,
-    TYPES
-} from 'sprotty';
-import { GLSP_TYPES } from '../../base/types';
+import { Command, CommandExecutionContext, CommandReturn, ElementMove, IActionDispatcher, 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 { isBoundsAwareMoveable, isResizable } from '../change-bounds/model';
 import { IMovementRestrictor } from '../change-bounds/movement-restrictor';
 import { SelectionService } from '../select/selection-service';
 
+/**
+ * Used to specify the desired resize dimension for a {@link ResizeElementsCommand}.
+ */
 // eslint-disable-next-line no-shadow
 export enum ResizeDimension {
     Width,
@@ -41,43 +34,99 @@ export enum ResizeDimension {
 }
 
 export namespace Reduce {
+    /**
+     * Returns the minimal value of the given numbers.
+     * @param values Numbers to be evaluated.
+     * @returns The reduced number.
+     */
     export function min(...values: number[]): number {
         return Math.min(...values);
     }
 
+    /**
+     * Returns the maximal value of the given numbers.
+     * @param values Numbers to be evaluated.
+     * @returns The reduced number.
+     */
     export function max(...values: number[]): number {
         return Math.max(...values);
     }
 
+    /**
+     * Computes the  average of the given numbers.
+     * @param values Numbers to be evaluated.
+     */
     export function avg(...values: number[]): number {
         return values.reduce((a, b) => a + b, 0) / values.length;
     }
 
+    /**
+     *  Returns the last value of the given numbers.
+     *  @param values Numbers to be evaluated.
+     *  @returns The reduced number.
+     */
     export function first(...values: number[]): number {
         return values[0];
     }
 
+    /**
+     *  Returns the minimal value of the given numbers.
+     *  @param values Numbers  to be evaluated.
+     *  @returns The reduced number.
+     */
     export function last(...values: number[]): number {
         return values[values.length - 1];
     }
+
+    /**
+     * Returns the reduce function that corresponds to the given {@link ReduceFunctionKind}.
+     * @param type The reduce function kind.
+     * @returns The corresponding reduce function.
+     */
 }
 
-export class ResizeElementsAction implements Action {
-    constructor(
-        /**
-         * IDs of the elements that should be resized. If no IDs are given, the selected elements will be resized.
-         */
-        public readonly elementIds: string[] = [],
-        /**
-         * Resize dimension.
-         */
-        public readonly dimension: ResizeDimension = ResizeDimension.Width,
-        /**
-         * Function to reduce the dimension to a target dimension value, see Reduce.* for potential functions.
-         */
-        public readonly reductionFunction: (...values: number[]) => number,
-        public readonly kind: string = ResizeElementsCommand.KIND
-    ) {}
+type ReduceFn = (...values: number[]) => number;
+export interface ResizeElementsAction extends Action {
+    kind: typeof ResizeElementsAction.KIND;
+
+    /**
+     * 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.
+     */
+    reductionFunction: ReduceFn;
+}
+
+export namespace ResizeElementsAction {
+    export const KIND = 'resizeElementAction';
+
+    export function is(object: any): object is ResizeElementsAction {
+        return (
+            Action.hasKind(object, KIND) &&
+            hasArrayProp(object, 'elementIds') &&
+            hasNumberProp(object, 'dimension') &&
+            'reductionFunction' in object
+        );
+    }
+
+    export function create(options: {
+        elementIds?: string[];
+        dimension?: ResizeDimension;
+        reductionFunction: ReduceFn;
+    }): ResizeElementsAction {
+        return {
+            kind: KIND,
+            dimension: ResizeDimension.Width,
+            elementIds: [],
+            ...options
+        };
+    }
 }
 
 // eslint-disable-next-line no-shadow
@@ -104,31 +153,56 @@ export namespace Select {
     }
 }
 
-export class AlignElementsAction implements Action {
-    constructor(
-        /**
-         * IDs of the elements that should be aligned. If no IDs are given, the selected elements will be aligned.
-         */
-        public readonly elementIds: string[] = [],
-        /**
-         * Alignment direction.
-         */
-        public readonly alignment: Alignment = Alignment.Left,
-        /**
-         * Function to selected elements that are considered during alignment calculation, see Select.* for potential functions.
-         */
-        public readonly selectionFunction: (elements: BoundsAwareModelElement[]) => BoundsAwareModelElement[] = Select.all,
-        public readonly kind = AlignElementsCommand.KIND
-    ) {}
+type SelectFn = (elements: BoundsAwareModelElement[]) => BoundsAwareModelElement[];
+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, see Select.* for potential functions.
+     * The default value is {@link Select.all}.
+     */
+    selectionFunction: SelectFn;
 }
 
+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') &&
+            'selectionFunction' in object
+        );
+    }
+
+    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(GLSP_TYPES.SelectionService) protected selectionService: SelectionService,
-        @inject(GLSP_TYPES.IMovementRestrictor) @optional() readonly movementRestrictor?: IMovementRestrictor
+        @inject(TYPES.SelectionService) protected selectionService: SelectionService,
+        @inject(TYPES.IMovementRestrictor) @optional() readonly movementRestrictor?: IMovementRestrictor
     ) {
         super();
     }
@@ -163,13 +237,13 @@ abstract class LayoutElementsCommand extends Command {
 
 @injectable()
 export class ResizeElementsCommand extends LayoutElementsCommand {
-    static readonly KIND = 'layout:resize';
+    static readonly KIND = ResizeElementsAction.KIND;
 
     constructor(
-        @inject(TYPES.Action) protected action: ResizeElementsAction,
-        @inject(TYPES.IActionDispatcher) protected actionDispatcher: IActionDispatcher,
-        @inject(GLSP_TYPES.SelectionService) protected selectionService: SelectionService,
-        @inject(GLSP_TYPES.IMovementRestrictor) @optional() readonly movementRestrictor?: IMovementRestrictor
+        @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);
     }
@@ -242,7 +316,7 @@ export class ResizeElementsCommand extends LayoutElementsCommand {
                 elementAndBounds.push(elementChange);
             }
         });
-        this.dispatchActions([new SetBoundsAction(elementAndBounds), new ChangeBoundsOperation(elementAndBounds)]);
+        this.dispatchActions([SetBoundsAction.create(elementAndBounds), ChangeBoundsOperation.create(elementAndBounds)]);
     }
 
     createElementAndBounds(
@@ -277,13 +351,13 @@ export class ResizeElementsCommand extends LayoutElementsCommand {
 
 @injectable()
 export class AlignElementsCommand extends LayoutElementsCommand {
-    static readonly KIND = 'layout:align';
+    static readonly KIND = AlignElementsAction.KIND;
 
     constructor(
-        @inject(TYPES.Action) protected action: AlignElementsAction,
-        @inject(TYPES.IActionDispatcher) protected actionDispatcher: IActionDispatcher,
-        @inject(GLSP_TYPES.SelectionService) protected selectionService: SelectionService,
-        @inject(GLSP_TYPES.IMovementRestrictor) @optional() readonly movementRestrictor?: IMovementRestrictor
+        @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);
     }
@@ -376,7 +450,7 @@ export class AlignElementsCommand extends LayoutElementsCommand {
                 elementAndBounds.push(elementAndBound);
             }
         });
-        this.dispatchActions([new MoveAction(moves), new ChangeBoundsOperation(elementAndBounds)]);
+        this.dispatchActions([MoveAction.create(moves), ChangeBoundsOperation.create(elementAndBounds)]);
     }
 
     createElementMove(

package/src/features/layout/vbox-layout.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,17 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Bounds, Dimension, Point } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
 import {
-    Bounds,
     BoundsData,
-    Dimension,
-    EMPTY_BOUNDS,
     isBoundsAware,
     isLayoutableChild,
-    isValidDimension,
     LayoutContainer,
-    Point,
     SChildElement,
     SModelElement,
     SParentElement,
@@ -44,9 +40,9 @@ export interface VBoxLayoutOptionsExt extends VBoxLayoutOptions {
  */
 @injectable()
 export class VBoxLayouterExt extends VBoxLayouter {
-    static KIND = VBoxLayouter.KIND;
+    static override KIND = VBoxLayouter.KIND;
 
-    layout(container: SParentElement & LayoutContainer, layouter: StatefulLayouter): void {
+    override layout(container: SParentElement & LayoutContainer, layouter: StatefulLayouter): void {
         const boundsData = layouter.getBoundsData(container);
         const options = this.getLayoutOptions(container);
         const childrenSize = this.getChildrenSize(container, options, layouter);
@@ -80,7 +76,7 @@ export class VBoxLayouterExt extends VBoxLayouter {
         }
     }
 
-    protected getChildrenSize(
+    protected override getChildrenSize(
         container: SParentElement & LayoutContainer,
         containerOptions: VBoxLayoutOptionsExt,
         layouter: StatefulLayouter
@@ -91,7 +87,7 @@ export class VBoxLayouterExt extends VBoxLayouter {
         container.children.forEach(child => {
             if (isLayoutableChild(child)) {
                 const bounds = layouter.getBoundsData(child).bounds;
-                if (bounds !== undefined && isValidDimension(bounds)) {
+                if (bounds !== undefined && Dimension.isValid(bounds)) {
                     maxHeight += bounds.height;
                     if (isFirst) {
                         isFirst = false;
@@ -109,7 +105,7 @@ export class VBoxLayouterExt extends VBoxLayouter {
         return result;
     }
 
-    protected layoutChildren(
+    protected override layoutChildren(
         container: SParentElement & LayoutContainer,
         layouter: StatefulLayouter,
         containerOptions: VBoxLayoutOptionsExt,
@@ -128,7 +124,7 @@ export class VBoxLayouterExt extends VBoxLayouter {
                 const boundsData = layouter.getBoundsData(child);
                 const bounds = boundsData.bounds;
                 const childOptions = this.getChildLayoutOptions(child, containerOptions);
-                if (bounds !== undefined && isValidDimension(bounds)) {
+                if (bounds !== undefined && Dimension.isValid(bounds)) {
                     currentOffset = this.layoutChild(
                         child,
                         boundsData,
@@ -147,7 +143,7 @@ export class VBoxLayouterExt extends VBoxLayouter {
         return currentOffset;
     }
 
-    protected layoutChild(
+    protected override layoutChild(
         child: SChildElement,
         boundsData: BoundsData,
         bounds: Bounds,
@@ -183,7 +179,11 @@ export class VBoxLayouterExt extends VBoxLayouter {
         return offset;
     }
 
-    protected getFixedContainerBounds(container: SModelElement, layoutOptions: VBoxLayoutOptionsExt, layouter: StatefulLayouter): Bounds {
+    protected override getFixedContainerBounds(
+        container: SModelElement,
+        layoutOptions: VBoxLayoutOptionsExt,
+        layouter: StatefulLayouter
+    ): Bounds {
         const currentContainer = container;
         // eslint-disable-next-line no-constant-condition
         if (isBoundsAware(currentContainer)) {
@@ -193,14 +193,14 @@ export class VBoxLayouterExt extends VBoxLayouter {
             const height = elementOptions?.prefHeight ?? 0;
             return { ...bounds, width, height };
         }
-        return EMPTY_BOUNDS;
+        return Bounds.EMPTY;
     }
 
-    protected getChildLayoutOptions(child: SChildElement, containerOptions: VBoxLayoutOptionsExt): VBoxLayoutOptionsExt {
+    protected override getChildLayoutOptions(child: SChildElement, containerOptions: VBoxLayoutOptionsExt): VBoxLayoutOptionsExt {
         return super.getChildLayoutOptions(child, containerOptions) as VBoxLayoutOptionsExt;
     }
 
-    protected getLayoutOptions(element: SModelElement): VBoxLayoutOptionsExt {
+    protected override getLayoutOptions(element: SModelElement): VBoxLayoutOptionsExt {
         return super.getLayoutOptions(element) as VBoxLayoutOptionsExt;
     }
 
@@ -208,7 +208,7 @@ export class VBoxLayouterExt extends VBoxLayouter {
         return (element as any).layoutOptions;
     }
 
-    protected getFinalContainerBounds(
+    protected override getFinalContainerBounds(
         container: SParentElement & LayoutContainer,
         lastOffset: Point,
         options: VBoxLayoutOptionsExt,
@@ -229,7 +229,7 @@ export class VBoxLayouterExt extends VBoxLayouter {
         return result;
     }
 
-    protected getDefaultLayoutOptions(): VBoxLayoutOptionsExt {
+    protected override getDefaultLayoutOptions(): VBoxLayoutOptionsExt {
         return {
             resizeContainer: true,
             paddingTop: 5,
@@ -250,7 +250,7 @@ export class VBoxLayouterExt extends VBoxLayouter {
         };
     }
 
-    protected spread(a: VBoxLayoutOptionsExt, b: VBoxLayoutOptionsExt): VBoxLayoutOptionsExt {
+    protected override spread(a: VBoxLayoutOptionsExt, b: VBoxLayoutOptionsExt): VBoxLayoutOptionsExt {
         return { ...a, ...b };
     }
 }

package/src/features/model-source-watcher/model-source-changed-action-handler.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2021 EclipseSource and others.
+ * Copyright (c) 2020-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,15 +13,10 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import {
-    Action,
-    GLSPServerStatusAction,
-    isModelSourceChangedAction,
-    ModelSourceChangedAction,
-    ServerMessageAction
-} from '@eclipse-glsp/protocol';
+import { Action, ModelSourceChangedAction, ServerMessageAction, ServerStatusAction } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
-import { IActionDispatcher, IActionHandler, TYPES, ViewerOptions } from 'sprotty';
+import { IActionDispatcher, IActionHandler, ViewerOptions } from 'sprotty';
+import { TYPES } from '../../base/types';
 
 /**
  * An external handler of the model source change event.
@@ -51,7 +46,7 @@ export class ModelSourceChangedActionHandler implements IActionHandler {
     protected externalModelSourceChangedHandler?: ExternalModelSourceChangedHandler;
 
     handle(action: Action): void {
-        if (isModelSourceChangedAction(action)) {
+        if (ModelSourceChangedAction.is(action)) {
             if (this.externalModelSourceChangedHandler) {
                 this.externalModelSourceChangedHandler
                     .notifyModelSourceChange(action.modelSourceName, this.options)
@@ -67,8 +62,8 @@ export class ModelSourceChangedActionHandler implements IActionHandler {
         const timeout = 0;
         const severity = 'WARNING';
         this.dispatcher.dispatchAll([
-            { kind: GLSPServerStatusAction.KIND, severity, timeout, message } as GLSPServerStatusAction,
-            { kind: ServerMessageAction.KIND, severity, timeout, message } as ServerMessageAction
+            ServerStatusAction.create(message, { severity, timeout }),
+            ServerMessageAction.create(message, { severity, timeout })
         ]);
     }
 }

package/src/features/mouse-tool/di.config.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
@@ -15,13 +15,12 @@
  ********************************************************************************/
 import { ContainerModule } from 'inversify';
 import { MouseTool } from 'sprotty';
-
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
 import { RankingMouseTool } from './mouse-tool';
 
 const glspMouseToolModule = new ContainerModule((bind, _unbind, _isBound, rebind) => {
     bind(RankingMouseTool).toSelf().inSingletonScope();
-    bind(GLSP_TYPES.MouseTool).toService(RankingMouseTool);
+    bind(TYPES.MouseTool).toService(RankingMouseTool);
     rebind(MouseTool).toService(RankingMouseTool);
 });
 

package/src/features/mouse-tool/mouse-tool.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,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, isAction } from '@eclipse-glsp/protocol';
 import { injectable, multiInject, optional } from 'inversify';
-import { On, VNode, VNodeData } from 'snabbdom';
-import { MouseListener, MouseTool, SModelElement, SModelRoot, TYPES } from 'sprotty';
+import { MouseListener, MouseTool, SModelElement, SModelRoot } from 'sprotty';
+import { TYPES } from '../../base/types';
 import { getRank } from '../rank/model';
 
 export interface IMouseTool {
@@ -24,48 +23,36 @@ export interface IMouseTool {
     deregister(mouseListener: MouseListener): void;
 }
 
+/**
+ * Custom helper type to declare the explicit mouse listener methods
+ * of {@link MouseListener} i.e. omitting the `decorate` method.
+ */
+type MouseListenerMethods = keyof Omit<MouseListener, 'decorate'>;
+
 @injectable()
 export class RankingMouseTool extends MouseTool implements IMouseTool {
     protected rankedMouseListeners: Map<number, MouseListener[]>;
 
-    constructor(@multiInject(TYPES.MouseListener) @optional() protected mouseListeners: MouseListener[] = []) {
+    constructor(@multiInject(TYPES.MouseListener) @optional() protected override mouseListeners: MouseListener[] = []) {
         super(mouseListeners);
         this.rankedMouseListeners = groupBy(mouseListeners, listener => getRank(listener));
     }
 
-    register(mouseListener: MouseListener): void {
+    override register(mouseListener: MouseListener): void {
         super.register(mouseListener);
         this.rankedMouseListeners = groupBy(this.mouseListeners, listener => getRank(listener));
     }
 
-    deregister(mouseListener: MouseListener): void {
+    override deregister(mouseListener: MouseListener): void {
         super.deregister(mouseListener);
         this.rankedMouseListeners = groupBy(this.mouseListeners, listener => getRank(listener));
     }
 
-    decorate(vnode: VNode, element: SModelElement): VNode {
-        // we need to overwrite the existing event handlers registered by the original mouse tool
-        if (element instanceof SModelRoot) {
-            overwriteOn(vnode, 'mouseover', this.mouseOver.bind(this, element), element);
-            overwriteOn(vnode, 'mouseout', this.mouseOut.bind(this, element), element);
-            overwriteOn(vnode, 'mouseenter', this.mouseEnter.bind(this, element), element);
-            overwriteOn(vnode, 'mouseleave', this.mouseLeave.bind(this, element), element);
-            overwriteOn(vnode, 'mousedown', this.mouseDown.bind(this, element), element);
-            overwriteOn(vnode, 'mouseup', this.mouseUp.bind(this, element), element);
-            overwriteOn(vnode, 'mousemove', this.mouseMove.bind(this, element), element);
-            overwriteOn(vnode, 'wheel', this.wheel.bind(this, element), element);
-            overwriteOn(vnode, 'contextmenu', this.contextMenu.bind(this, element), element);
-            overwriteOn(vnode, 'dblclick', this.doubleClick.bind(this, element), element);
-        }
-        vnode = this.mouseListeners.reduce((n: VNode, listener: MouseListener) => listener.decorate(n, element), vnode);
-        return vnode;
-    }
-
     contextMenu(model: SModelRoot, event: MouseEvent): void {
         event.preventDefault();
     }
 
-    protected handleEvent<K extends keyof MouseListener>(methodName: K, model: SModelRoot, event: MouseEvent): void {
+    protected override handleEvent<K extends MouseListenerMethods>(methodName: K, model: SModelRoot, event: MouseEvent): void {
         this.focusOnMouseEvent(methodName, model);
         const element = this.getTargetElement(model, event);
         if (!element) {
@@ -74,7 +61,7 @@ export class RankingMouseTool extends MouseTool implements IMouseTool {
         this.notifyListenersByRank(element, methodName, model, event);
     }
 
-    async notifyListenersByRank<K extends keyof MouseListener>(
+    async notifyListenersByRank<K extends MouseListenerMethods>(
         element: SModelElement,
         methodName: K,
         model: SModelRoot,
@@ -85,25 +72,18 @@ export class RankingMouseTool extends MouseTool implements IMouseTool {
         }
     }
 
-    async dispatchActions<K extends keyof MouseListener>(
+    async dispatchActions<K extends MouseListenerMethods>(
         mouseListeners: MouseListener[],
         methodName: K,
         element: SModelElement,
         event: MouseEvent
     ): Promise<void> {
-        const actions = mouseListeners
-            .map(listener => listener[methodName].apply(listener, [element, event]))
-            .reduce((a, b) => a.concat(b));
+        const actions = mouseListeners.map(listener => listener[methodName](element, event as WheelEvent)).reduce((a, b) => a.concat(b));
         if (actions.length > 0) {
             event.preventDefault();
             for (const actionOrPromise of actions) {
-                if (isAction(actionOrPromise)) {
-                    await this.actionDispatcher.dispatch(actionOrPromise);
-                } else {
-                    actionOrPromise.then((action: Action) => {
-                        this.actionDispatcher.dispatch(action);
-                    });
-                }
+                const action = await actionOrPromise;
+                await this.actionDispatcher.dispatch(action);
             }
         }
     }
@@ -124,24 +104,3 @@ function groupBy<K, T>(array: Array<T>, keyFunction: (x: T) => K): Map<K, T[]> {
     }, new Map<K, T[]>());
     return new Map<K, T[]>([...unsortedMap.entries()].sort());
 }
-
-function overwriteOn(vnode: VNode, event: string, listener: (model: SModelElement, _event: Event) => void, element: SModelElement): void {
-    const val = getOn(vnode);
-    // ignore any previous val[event] registrations
-    (val as any)[event] = [listener, element];
-}
-
-function getOn(vnode: VNode): On {
-    const data = getData(vnode);
-    if (!data.on) {
-        data.on = {};
-    }
-    return data.on;
-}
-
-function getData(vnode: VNode): VNodeData {
-    if (!vnode.data) {
-        vnode.data = {};
-    }
-    return vnode.data;
-}