@eclipse-glsp/client 0.10.0-next.ca17587.154 → 1.1.0-RC01

package/src/features/validation/marker-navigator.spec.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
@@ -14,6 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 /* eslint-disable import/no-deprecated,no-unused-expressions */
+import { SNodeSchema } from '@eclipse-glsp/protocol';
 import { expect } from 'chai';
 import { Container } from 'inversify';
 import 'mocha';
@@ -26,7 +27,6 @@ import {
     SIssueMarker,
     SModelElement,
     SModelRoot,
-    SNodeSchema,
     SParentElement,
     TYPES
 } from 'sprotty';
@@ -38,7 +38,9 @@ import { MarkerNavigator } from './marker-navigator';
 describe('MarkerNavigator', () => {
     const container = new Container();
     container.load(defaultModule, decorationModule, markerNavigatorModule);
+    // eslint-disable-next-line deprecation/deprecation
     container.rebind(TYPES.IModelFactory).to(SGraphFactory).inSingletonScope();
+    // eslint-disable-next-line deprecation/deprecation
     const graphFactory = container.get<SGraphFactory>(TYPES.IModelFactory);
     const markerNavigator = container.get<MarkerNavigator>(MarkerNavigator);
 

package/src/features/validation/marker-navigator.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,45 +13,60 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, CenterAction, Point } from '@eclipse-glsp/protocol';
+import { Action, CenterAction, hasArrayProp, hasStringProp, Point, SelectAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import {
+    ActionDispatcher,
     BoundsAware,
-    CenterCommand,
-    Command,
-    CommandExecutionContext,
-    CommandReturn,
     findParentByFeature,
+    IActionHandler,
     IContextMenuItemProvider,
     isBoundsAware,
     isSelectable,
     KeyListener,
     MenuItem,
     Selectable,
-    SelectAction,
     SIssueMarker,
     SIssueSeverity,
     SModelElement,
-    SModelRoot,
-    TYPES
+    SModelRoot
 } from 'sprotty';
 import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
 import { collectIssueMarkers, MarkerPredicates } from '../../utils/marker';
-import { isSelectableAndBoundsAware } from '../../utils/smodel-util';
-import { SelectCommand, SelectionService } from '../select/selection-service';
+import { getElements, isSelectableAndBoundsAware } from '../../utils/smodel-util';
+import { SelectionService } from '../select/selection-service';
 
-export class NavigateToMarkerAction implements Action {
-    static readonly KIND = 'navigateToMarker';
+export interface NavigateToMarkerAction extends Action {
+    kind: typeof NavigateToMarkerAction.KIND;
 
-    constructor(
-        public readonly direction: 'next' | 'previous' = 'next',
-        public readonly selectedElementIds?: string[],
-        public readonly severities: SIssueSeverity[] = MarkerNavigator.ALL_SEVERITIES,
-        public kind = NavigateToMarkerAction.KIND
-    ) {}
+    direction: MarkerNavigationDirection;
+    selectedElementIds?: string[];
+    severities: SIssueSeverity[];
 }
 
+export type MarkerNavigationDirection = 'next' | 'previous';
+
+export namespace NavigateToMarkerAction {
+    export const KIND = 'navigateToMarker';
+
+    export function is(object: any): object is NavigateToMarkerAction {
+        return Action.hasKind(object, KIND) && hasStringProp(object, 'direction') && hasArrayProp(object, 'severities');
+    }
+
+    export function create(options: {
+        direction?: MarkerNavigationDirection;
+        selectedElementIds?: string[];
+        severities?: SIssueSeverity[];
+    }): NavigateToMarkerAction {
+        return {
+            kind: KIND,
+            direction: 'next',
+            severities: MarkerNavigator.ALL_SEVERITIES,
+            ...options
+        };
+    }
+}
 export class SModelElementComparator {
     compare(_one: SModelElement, _other: SModelElement): number {
         return 0;
@@ -89,7 +104,7 @@ export class MarkerNavigator {
     protected markerComparator: SModelElementComparator;
 
     next(
-        root: SModelRoot,
+        root: Readonly<SModelRoot>,
         current?: SModelElement & BoundsAware,
         predicate: (marker: SIssueMarker) => boolean = MarkerPredicates.ALL
     ): SIssueMarker | undefined {
@@ -101,7 +116,7 @@ export class MarkerNavigator {
     }
 
     previous(
-        root: SModelRoot,
+        root: Readonly<SModelRoot>,
         current?: SModelElement & BoundsAware,
         predicate: (marker: SIssueMarker) => boolean = MarkerPredicates.ALL
     ): SIssueMarker | undefined {
@@ -112,7 +127,7 @@ export class MarkerNavigator {
         return markers[this.getPreviousIndex(current, markers) % markers.length];
     }
 
-    protected getMarkers(root: SModelRoot, predicate: (marker: SIssueMarker) => boolean): SIssueMarker[] {
+    protected getMarkers(root: Readonly<SModelRoot>, predicate: (marker: SIssueMarker) => boolean): SIssueMarker[] {
         const markers = collectIssueMarkers(root);
         return markers.filter(predicate).sort(this.markerComparator.compare);
     }
@@ -137,86 +152,56 @@ export class MarkerNavigator {
 }
 
 @injectable()
-export class NavigateToMarkerCommand extends Command {
-    static KIND = NavigateToMarkerAction.KIND;
-
+export class NavigateToMarkerActionHandler implements IActionHandler {
     @inject(SModelElementComparator)
     protected markerComparator: SModelElementComparator;
 
     @inject(MarkerNavigator)
     protected markerNavigator: MarkerNavigator;
 
-    @inject(GLSP_TYPES.SelectionService)
+    @inject(TYPES.SelectionService)
     protected selectionService: SelectionService;
 
-    protected selectCommand: SelectCommand;
-    protected centerCommand: CenterCommand;
+    @inject(TYPES.IActionDispatcher)
+    protected actionDispatcher: ActionDispatcher;
 
-    constructor(@inject(TYPES.Action) protected action: NavigateToMarkerAction) {
-        super();
-    }
+    handle(action: NavigateToMarkerAction): void {
+        const selected = this.getSelectedElements(action);
+        const target = this.getTarget(action, selected);
 
-    execute(context: CommandExecutionContext): CommandReturn {
-        const root = context.root;
-        const selected = this.getSelectedElements(root);
-        const target = this.getTarget(selected, root);
-        if (target === undefined) {
-            return root;
-        }
-
-        const selectableTarget = findParentByFeature(target, isSelectable);
+        const selectableTarget = target ? findParentByFeature(target, isSelectable) : undefined;
         if (selectableTarget) {
-            const deselect = selected.map(e => e.id).filter(id => id !== selectableTarget.id);
-            this.selectCommand = new SelectCommand(new SelectAction([selectableTarget.id], deselect), this.selectionService);
-            this.centerCommand = new CenterCommand(new CenterAction([selectableTarget.id]));
-            this.centerCommand.execute(context);
-            return this.selectCommand.execute(context);
+            const deselectedElementsIDs = selected.map(e => e.id).filter(id => id !== selectableTarget.id);
+            this.actionDispatcher.dispatch(SelectAction.create({ selectedElementsIDs: [selectableTarget.id], deselectedElementsIDs }));
+            this.actionDispatcher.dispatch(CenterAction.create([selectableTarget.id]));
         }
-        return root;
     }
 
-    protected getSelectedElements(root: SModelRoot): (SModelElement & Selectable)[] {
-        let selectedIds = [];
-        if (this.action.selectedElementIds !== undefined && this.action.selectedElementIds.length > 0) {
-            selectedIds = this.action.selectedElementIds;
-        } else {
-            selectedIds = Array.from(this.selectionService.getSelectedElementIDs());
+    protected getSelectedElements(action: NavigateToMarkerAction): (SModelElement & Selectable)[] {
+        if (action.selectedElementIds && action.selectedElementIds.length > 0) {
+            return getElements(this.selectionService.getModelRoot().index, action.selectedElementIds, isSelectable);
         }
-        return selectedIds.map(id => root.index.getById(id)).filter(isSelectable);
+        return this.selectionService.getSelectedElements();
     }
 
-    protected getTarget(selected: SModelElement[], root: SModelRoot): SIssueMarker | undefined {
-        const selectedBoundsAware = selected.filter(isBoundsAware).sort(this.markerComparator.compare);
-        const currentTopmost = selectedBoundsAware.length > 0 ? selectedBoundsAware[0] : undefined;
-        if (this.action.direction === 'previous') {
-            return this.markerNavigator.previous(root, currentTopmost, marker => this.matchesSeverities(marker));
+    protected getTarget(action: NavigateToMarkerAction, selected: SModelElement[]): SIssueMarker | undefined {
+        const root = this.selectionService.getModelRoot();
+        const target = selected.sort(this.markerComparator.compare).find(isBoundsAware);
+        if (action.direction === 'previous') {
+            return this.markerNavigator.previous(root, target, marker => this.matchesSeverities(action, marker));
         } else {
-            return this.markerNavigator.next(root, currentTopmost, marker => this.matchesSeverities(marker));
-        }
-    }
-
-    protected matchesSeverities(marker: SIssueMarker): boolean {
-        return marker.issues.find(issue => this.action.severities.includes(issue.severity)) !== undefined;
-    }
-
-    undo(context: CommandExecutionContext): CommandReturn {
-        if (this.selectCommand) {
-            context.root = this.selectCommand.undo(context);
+            return this.markerNavigator.next(root, target, marker => this.matchesSeverities(action, marker));
         }
-        return this.centerCommand ? this.centerCommand.undo(context) : context.root;
     }
 
-    redo(context: CommandExecutionContext): CommandReturn {
-        if (this.selectCommand) {
-            context.root = this.selectCommand.redo(context);
-        }
-        return this.centerCommand ? this.centerCommand.redo(context) : context.root;
+    protected matchesSeverities(action: NavigateToMarkerAction, marker: SIssueMarker): boolean {
+        return marker.issues.find(issue => action.severities.includes(issue.severity)) !== undefined;
     }
 }
 
 @injectable()
 export class MarkerNavigatorContextMenuItemProvider implements IContextMenuItemProvider {
-    @inject(GLSP_TYPES.SelectionService) protected selectionService: SelectionService;
+    @inject(TYPES.SelectionService) protected selectionService: SelectionService;
 
     getItems(root: Readonly<SModelRoot>, lastMousePosition?: Point): Promise<MenuItem[]> {
         const selectedElementIds = Array.from(this.selectionService.getSelectedElementIDs());
@@ -232,14 +217,14 @@ export class MarkerNavigatorContextMenuItemProvider implements IContextMenuItemP
                         id: 'next-marker',
                         label: 'Next marker',
                         group: 'marker',
-                        actions: [new NavigateToMarkerAction('next', selectedElementIds)],
+                        actions: [NavigateToMarkerAction.create({ direction: 'next', selectedElementIds })],
                         isEnabled: () => hasMarkers
                     },
                     {
                         id: 'previous-marker',
                         label: 'Previous marker',
                         group: 'marker',
-                        actions: [new NavigateToMarkerAction('previous', selectedElementIds)],
+                        actions: [NavigateToMarkerAction.create({ direction: 'previous', selectedElementIds })],
                         isEnabled: () => hasMarkers
                     }
                 ]
@@ -250,11 +235,11 @@ export class MarkerNavigatorContextMenuItemProvider implements IContextMenuItemP
 
 @injectable()
 export class MarkerNavigatorKeyListener extends KeyListener {
-    keyDown(_element: SModelElement, event: KeyboardEvent): Action[] {
+    override keyDown(_element: SModelElement, event: KeyboardEvent): Action[] {
         if (matchesKeystroke(event, 'Period', 'ctrl')) {
-            return [new NavigateToMarkerAction('next')];
+            return [NavigateToMarkerAction.create({ direction: 'next' })];
         } else if (matchesKeystroke(event, 'Comma', 'ctrl')) {
-            return [new NavigateToMarkerAction('previous')];
+            return [NavigateToMarkerAction.create({ direction: 'previous' })];
         }
         return [];
     }

package/src/features/validation/validate.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,27 +13,15 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, DeleteMarkersAction, Marker, SetMarkersAction } from '@eclipse-glsp/protocol';
+import { Action, DeleteMarkersAction, hasArrayProp, Marker, SetMarkersAction } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
-import {
-    Command,
-    CommandExecutionContext,
-    CommandReturn,
-    IActionDispatcher,
-    SIssue,
-    SIssueMarker,
-    SModelElement,
-    SModelRoot,
-    SParentElement,
-    TYPES
-} from 'sprotty';
+import { CommandExecutionContext, CommandReturn, IActionDispatcher, IActionHandler, ICommand, SIssueMarker, SParentElement } from 'sprotty';
 import { EditorContextService } from '../../base/editor-context-service';
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
 import { removeCssClasses } from '../../utils/smodel-util';
-import { getSeverity } from '../hover/hover';
 import { IFeedbackActionDispatcher, IFeedbackEmitter } from '../tool-feedback/feedback-action-dispatcher';
 import { FeedbackCommand } from '../tool-feedback/model';
-import { createSIssue, getOrCreateSIssueMarker, getSIssueMarker } from './issue-marker';
+import { createSIssue, getOrCreateSIssueMarker, getSeverity, getSIssueMarker, GIssueMarker } from './issue-marker';
 
 /**
  * Feedback emitter sending actions for visualizing model validation feedback and
@@ -41,11 +29,11 @@ import { createSIssue, getOrCreateSIssueMarker, getSIssueMarker } from './issue-
  */
 @injectable()
 export class ValidationFeedbackEmitter implements IFeedbackEmitter {
-    @inject(GLSP_TYPES.IFeedbackActionDispatcher) protected feedbackActionDispatcher: IFeedbackActionDispatcher;
+    @inject(TYPES.IFeedbackActionDispatcher) protected feedbackActionDispatcher: IFeedbackActionDispatcher;
 
     @inject(TYPES.IActionDispatcherProvider) protected actionDispatcher: () => Promise<IActionDispatcher>;
 
-    private registeredAction: MarkersAction;
+    private registeredAction: ApplyMarkersAction;
 
     // eslint-disable-next-line @typescript-eslint/no-empty-function
     private constructor() {}
@@ -54,13 +42,13 @@ export class ValidationFeedbackEmitter implements IFeedbackEmitter {
      * Register the action that should be emitted for visualizing validation feedback.
      * @param action the action that should be emitted when the model is updated and that will visualize the model validation feedback.
      */
-    registerValidationFeedbackAction(action: MarkersAction): void {
+    registerValidationFeedbackAction(action: ApplyMarkersAction): void {
         // De-register old action responsible for applying markers and re-applying them when the model is updated
         this.feedbackActionDispatcher.deregisterFeedback(this, []);
 
         // Clear existing markers
         if (this.registeredAction !== undefined) {
-            const deleteMarkersAction = new DeleteMarkersAction(this.registeredAction.markers);
+            const deleteMarkersAction = DeleteMarkersAction.create(this.registeredAction.markers);
             this.actionDispatcher().then(dispatcher => dispatcher.dispatch(deleteMarkersAction));
         }
 
@@ -88,101 +76,92 @@ export abstract class ExternalMarkerManager {
 
     removeMarkers(markers: Marker[]): void {
         if (this.actionDispatcher) {
-            this.actionDispatcher.dispatch(new DeleteMarkersAction(markers));
+            this.actionDispatcher.dispatch(DeleteMarkersAction.create(markers));
         }
     }
 
     abstract setMarkers(markers: Marker[], sourceUri?: string): void;
 }
 
-/**
- * Command for handling `SetMarkersAction`
- */
 @injectable()
-export class SetMarkersCommand extends Command {
-    @inject(ValidationFeedbackEmitter) protected validationFeedbackEmitter: ValidationFeedbackEmitter;
-    @inject(ExternalMarkerManager) @optional() protected externalMarkerManager?: ExternalMarkerManager;
-    @inject(EditorContextService) protected editorContextService: EditorContextService;
+export class SetMarkersActionHandler implements IActionHandler {
+    @inject(ValidationFeedbackEmitter)
+    protected validationFeedbackEmitter: ValidationFeedbackEmitter;
 
-    static readonly KIND = SetMarkersAction.KIND;
+    @inject(ExternalMarkerManager)
+    @optional()
+    protected externalMarkerManager?: ExternalMarkerManager;
 
-    constructor(@inject(TYPES.Action) public action: SetMarkersAction) {
-        super();
+    @inject(EditorContextService)
+    protected editorContextService: EditorContextService;
+
+    handle(action: SetMarkersAction): void | Action | ICommand {
+        const markers: Marker[] = action.markers;
+        this.setMarkers(markers);
     }
 
-    async execute(context: CommandExecutionContext): Promise<SModelRoot> {
-        const markers: Marker[] = this.action.markers;
+    async setMarkers(markers: Marker[]): Promise<void> {
         const uri = await this.editorContextService.getSourceUri();
-        if (this.externalMarkerManager) {
-            this.externalMarkerManager.setMarkers(markers, uri);
-        }
-        const applyMarkersAction: ApplyMarkersAction = new ApplyMarkersAction(markers);
+        this.externalMarkerManager?.setMarkers(markers, uri);
+        const applyMarkersAction = ApplyMarkersAction.create(markers);
         this.validationFeedbackEmitter.registerValidationFeedbackAction(applyMarkersAction);
-        return context.root;
-    }
-
-    undo(context: CommandExecutionContext): CommandReturn {
-        return context.root;
-    }
-
-    redo(context: CommandExecutionContext): CommandReturn {
-        return this.execute(context);
     }
 }
 
 /**
- * Interface for actions processing markers
+ * Action for applying makers to the graphical model.
  */
-export interface MarkersAction extends Action {
-    readonly markers: Marker[];
+export interface ApplyMarkersAction extends Action {
+    kind: typeof ApplyMarkersAction.KIND;
+    markers: Marker[];
 }
 
-/**
- * Action for applying makers to a model
- */
-@injectable()
-export class ApplyMarkersAction implements MarkersAction {
-    constructor(public readonly markers: Marker[], public readonly kind = ApplyMarkersCommand.KIND) {}
+export namespace ApplyMarkersAction {
+    export const KIND = 'applyMarkers';
+
+    export function is(object: any): object is ApplyMarkersAction {
+        return Action.hasKind(object, KIND) && hasArrayProp(object, 'markers');
+    }
+
+    export function create(markers: Marker[]): ApplyMarkersAction {
+        return {
+            kind: KIND,
+            markers
+        };
+    }
 }
 
 /**
- * Command for handling `ApplyMarkersAction`
+ * Handles {@link ApplyMarkersAction}s by creating the corresponding {@link SIssueMarker}s and
+ * adding them to the graphical model.
  */
 @injectable()
 export class ApplyMarkersCommand extends FeedbackCommand {
-    static KIND = 'applyMarkers';
-    readonly priority = 0;
+    static KIND = ApplyMarkersAction.KIND;
 
     constructor(@inject(TYPES.Action) protected action: ApplyMarkersAction) {
         super();
     }
 
     execute(context: CommandExecutionContext): CommandReturn {
-        const markers: Marker[] = this.action.markers;
-        for (const marker of markers) {
-            const modelElement: SModelElement | undefined = context.root.index.getById(marker.elementId);
+        this.action.markers.forEach(marker => {
+            const modelElement = context.root.index.getById(marker.elementId);
             if (modelElement instanceof SParentElement) {
-                const issueMarker: SIssueMarker = getOrCreateSIssueMarker(modelElement);
-                const issue: SIssue = createSIssue(marker);
+                const issueMarker = getOrCreateSIssueMarker(modelElement);
+                const issue = createSIssue(marker);
                 issueMarker.issues.push(issue);
+                if (issueMarker instanceof GIssueMarker) {
+                    issueMarker.computeProjectionCssClasses();
+                }
                 addMaxSeverityCSSClassToIssueParent(modelElement, issueMarker);
             }
-        }
+        });
         return context.root;
     }
-
-    undo(context: CommandExecutionContext): CommandReturn {
-        return context.root;
-    }
-
-    redo(context: CommandExecutionContext): CommandReturn {
-        return this.execute(context);
-    }
 }
 
 function addMaxSeverityCSSClassToIssueParent(modelElement: SParentElement, issueMarker: SIssueMarker): void {
     const maxSeverityCSSClass = getSeverity(issueMarker);
-
     if (!modelElement.cssClasses) {
         modelElement.cssClasses = [maxSeverityCSSClass];
     } else {
@@ -192,14 +171,15 @@ function addMaxSeverityCSSClassToIssueParent(modelElement: SParentElement, issue
 }
 
 function removeCSSClassFromIssueParent(modelElement: SParentElement, issueMarker: SIssueMarker): void {
-    removeCssClasses(modelElement, [getSeverity(issueMarker)]);
+    const severity = getSeverity(issueMarker);
+    removeCssClasses(modelElement, [severity]);
 }
 
 /**
  * Command for handling `DeleteMarkersAction`
  */
 @injectable()
-export class DeleteMarkersCommand extends Command {
+export class DeleteMarkersCommand extends FeedbackCommand {
     static KIND = DeleteMarkersAction.KIND;
 
     constructor(@inject(TYPES.Action) protected action: DeleteMarkersAction) {
@@ -207,15 +187,14 @@ export class DeleteMarkersCommand extends Command {
     }
 
     execute(context: CommandExecutionContext): CommandReturn {
-        const markers: Marker[] = this.action.markers;
-        for (const marker of markers) {
-            const modelElement: SModelElement | undefined = context.root.index.getById(marker.elementId);
+        this.action.markers.forEach(marker => {
+            const modelElement = context.root.index.getById(marker.elementId);
             if (modelElement instanceof SParentElement) {
-                const issueMarker: SIssueMarker | undefined = getSIssueMarker(modelElement);
-                if (issueMarker !== undefined) {
+                const issueMarker = getSIssueMarker(modelElement);
+                if (issueMarker) {
                     removeCSSClassFromIssueParent(modelElement, issueMarker);
                     for (let index = 0; index < issueMarker.issues.length; ++index) {
-                        const issue: SIssue = issueMarker.issues[index];
+                        const issue = issueMarker.issues[index];
                         if (issue.message === marker.description) {
                             issueMarker.issues.splice(index--, 1);
                         }
@@ -227,15 +206,8 @@ export class DeleteMarkersCommand extends Command {
                     }
                 }
             }
-        }
-        return context.root;
-    }
+        });
 
-    undo(context: CommandExecutionContext): CommandReturn {
         return context.root;
     }
-
-    redo(context: CommandExecutionContext): CommandReturn {
-        return this.execute(context);
-    }
 }

package/src/features/viewport/di.config.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
@@ -27,7 +27,6 @@ import {
     TYPES,
     ZoomMouseListener
 } from 'sprotty';
-
 import { GLSPScrollMouseListener } from './glsp-scroll-mouse-listener';
 
 const glspViewportModule = new ContainerModule((bind, _unbind, isBound) => {

package/src/features/viewport/glsp-scroll-mouse-listener.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
@@ -23,16 +23,16 @@ export class GLSPScrollMouseListener extends ScrollMouseListener implements IAct
     preventScrolling = false;
 
     handle(action: Action): void | Action | ICommand {
-        if (action instanceof EnableToolsAction) {
-            if (action.toolIds.includes(MarqueeMouseTool.ID)) {
+        if (action.kind === EnableToolsAction.KIND) {
+            if ((action as EnableToolsAction).toolIds.includes(MarqueeMouseTool.ID)) {
                 this.preventScrolling = true;
             }
-        } else if (action instanceof EnableDefaultToolsAction) {
+        } else if (action.kind === EnableDefaultToolsAction.KIND) {
             this.preventScrolling = false;
         }
     }
 
-    mouseDown(target: SModelElement, event: MouseEvent): (Action | Promise<Action>)[] {
+    override mouseDown(target: SModelElement, event: MouseEvent): (Action | Promise<Action>)[] {
         if (this.preventScrolling) {
             return [];
         }