@eclipse-glsp/client 1.1.0-next.fe0b297.182 → 2.0.0

package/src/features/validation/marker-navigator.spec.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2022 EclipseSource and others.
+ * Copyright (c) 2020-2023 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,78 +13,48 @@
  *
  * 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 { BoundsAware, GChildElement, GIssue, GModelElement, GModelRoot, GNode, GParentElement } from '@eclipse-glsp/sprotty';
 import { expect } from 'chai';
 import { Container } from 'inversify';
 import 'mocha';
 import 'reflect-metadata';
-import {
-    BoundsAware,
-    decorationModule,
-    SChildElement,
-    SIssue,
-    SIssueMarker,
-    SModelElement,
-    SModelRoot,
-    SParentElement,
-    TYPES
-} from 'sprotty';
-import defaultModule from 'sprotty/lib/base/di.config';
-import { SGraphFactory } from 'sprotty/lib/graph/sgraph-factory';
-import { markerNavigatorModule } from './di.config';
+import { defaultModule } from '../../base/default.module';
+import { GGraph } from '../../model';
+import { decorationModule } from '../decoration/decoration-module';
+import { GIssueMarker } from './issue-marker';
 import { MarkerNavigator } from './marker-navigator';
+import { markerNavigatorModule } from './validation-modules';
 
 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);
+    function createRoot(...nodeIds: string[]): GModelRoot {
+        const root = new GGraph();
+        root.features = new Set<symbol>(GGraph.DEFAULT_FEATURES);
+        root.id = 'root';
+        root.type = 'graph';
+        nodeIds.forEach(id => {
+            const node = new GNode();
+            node.id = id;
+            node.type = 'node';
+            node.features = new Set<symbol>(GNode.DEFAULT_FEATURES);
+            root.add(node);
+        });
+        return root;
+    }
+
+    const rootWithoutAnyMarkers = createRoot('1');
+
+    const rootWithMarkers = createRoot('bottom-right', 'top-right', 'top-left', 'bottom-left');
 
-    const rootWithoutAnyMarkers = graphFactory.createRoot({
-        id: 'root',
-        type: 'graph',
-        children: [
-            {
-                id: '1',
-                type: 'node'
-            } as SNodeSchema
-        ]
-    }) as SModelRoot;
-
-    const rootWithMarkers = graphFactory.createRoot({
-        id: 'root',
-        type: 'graph',
-        children: [
-            {
-                id: 'bottom-right',
-                type: 'node'
-            } as SNodeSchema,
-            {
-                id: 'top-right',
-                type: 'node'
-            } as SNodeSchema,
-            {
-                id: 'top-left',
-                type: 'node'
-            } as SNodeSchema,
-            {
-                id: 'bottom-left',
-                type: 'node'
-            } as SNodeSchema
-        ]
-    }) as SModelRoot;
-
-    const elementTopLeft = rootWithMarkers.children[2] as BoundsAware & SChildElement;
+    const elementTopLeft = rootWithMarkers.children[2] as BoundsAware & GChildElement;
     elementTopLeft.bounds = { width: 10, height: 10, x: 100, y: 100 };
-    const elementTopRight = rootWithMarkers.children[1] as BoundsAware & SChildElement;
+    const elementTopRight = rootWithMarkers.children[1] as BoundsAware & GChildElement;
     elementTopRight.bounds = { width: 10, height: 10, x: 200, y: 100 };
-    const elementBottomLeft = rootWithMarkers.children[3] as BoundsAware & SChildElement;
+    const elementBottomLeft = rootWithMarkers.children[3] as BoundsAware & GChildElement;
     elementBottomLeft.bounds = { width: 10, height: 10, x: 100, y: 200 };
-    const elementBottomRight = rootWithMarkers.children[0] as BoundsAware & SChildElement;
+    const elementBottomRight = rootWithMarkers.children[0] as BoundsAware & GChildElement;
     elementBottomRight.bounds = { width: 10, height: 10, x: 200, y: 200 };
 
     beforeEach('clear issue marker', () => {
@@ -178,34 +148,34 @@ describe('MarkerNavigator', () => {
     });
 });
 
-function clearMarker(elem: SParentElement): void {
+function clearMarker(elem: GParentElement): void {
     elem.children.filter(isMarker).forEach(marker => elem.remove(marker));
 }
 
-function setIssues(elem: SParentElement, issues: SIssue[]): SIssueMarker {
+function setIssues(elem: GParentElement, issues: GIssue[]): GIssueMarker {
     const marker = getOrCreateMarker(elem);
     marker.issues = issues;
     return marker;
 }
 
-function getOrCreateMarker(elem: SParentElement): SIssueMarker {
+function getOrCreateMarker(elem: GParentElement): GIssueMarker {
     const marker = findMarker(elem);
-    if (marker instanceof SIssueMarker) {
+    if (marker instanceof GIssueMarker) {
         return marker;
     }
-    return createMarker(elem as SParentElement);
+    return createMarker(elem as GParentElement);
 }
 
-function findMarker(elem: SParentElement): SIssueMarker | undefined {
+function findMarker(elem: GParentElement): GIssueMarker | undefined {
     return elem.children.find(isMarker);
 }
 
-function isMarker(element: SModelElement): element is SIssueMarker {
-    return element instanceof SIssueMarker;
+function isMarker(element: GModelElement): element is GIssueMarker {
+    return element instanceof GIssueMarker;
 }
 
-function createMarker(elem: SParentElement): SIssueMarker {
-    const newMarker = new SIssueMarker();
+function createMarker(elem: GParentElement): GIssueMarker {
+    const newMarker = new GIssueMarker();
     newMarker.type = 'marker';
     newMarker.id = `${elem.id}_marker`;
     elem.add(newMarker);

package/src/features/validation/marker-navigator.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2022 EclipseSource and others.
+ * Copyright (c) 2020-2023 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,36 +13,41 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, CenterAction, hasArrayProp, hasStringProp, Point, SelectAction } from '@eclipse-glsp/protocol';
-import { inject, injectable } from 'inversify';
 import {
-    ActionDispatcher,
+    Action,
     BoundsAware,
-    findParentByFeature,
+    CenterAction,
+    GIssueSeverity,
+    GModelElement,
+    GModelRoot,
     IActionHandler,
     IContextMenuItemProvider,
-    isBoundsAware,
-    isSelectable,
     KeyListener,
     MenuItem,
+    Point,
+    SelectAction,
     Selectable,
-    SIssueMarker,
-    SIssueSeverity,
-    SModelElement,
-    SModelRoot
-} from 'sprotty';
-import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
-import { TYPES } from '../../base/types';
-import { collectIssueMarkers, MarkerPredicates } from '../../utils/marker';
-import { getElements, isSelectableAndBoundsAware } from '../../utils/smodel-util';
-import { SelectionService } from '../select/selection-service';
+    TYPES,
+    findParentByFeature,
+    hasArrayProp,
+    hasStringProp,
+    isBoundsAware,
+    isSelectable,
+    matchesKeystroke
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
+import { GLSPActionDispatcher } from '../../base/action-dispatcher';
+import { SelectionService } from '../../base/selection-service';
+import { getElements, isSelectableAndBoundsAware } from '../../utils/gmodel-util';
+import { MarkerPredicates, collectIssueMarkers } from '../../utils/marker';
+import { GIssueMarker } from './issue-marker';
 
 export interface NavigateToMarkerAction extends Action {
     kind: typeof NavigateToMarkerAction.KIND;
 
     direction: MarkerNavigationDirection;
     selectedElementIds?: string[];
-    severities: SIssueSeverity[];
+    severities: GIssueSeverity[];
 }
 
 export type MarkerNavigationDirection = 'next' | 'previous';
@@ -57,7 +62,7 @@ export namespace NavigateToMarkerAction {
     export function create(options: {
         direction?: MarkerNavigationDirection;
         selectedElementIds?: string[];
-        severities?: SIssueSeverity[];
+        severities?: GIssueSeverity[];
     }): NavigateToMarkerAction {
         return {
             kind: KIND,
@@ -67,8 +72,8 @@ export namespace NavigateToMarkerAction {
         };
     }
 }
-export class SModelElementComparator {
-    compare(_one: SModelElement, _other: SModelElement): number {
+export class GModelElementComparator {
+    compare(_one: GModelElement, _other: GModelElement): number {
         return 0;
     }
 }
@@ -76,7 +81,7 @@ export class SModelElementComparator {
 /** Specifies the order of two selectable and bounds-aware elements left-to-right and top-to-bottom. */
 @injectable()
 export class LeftToRightTopToBottomComparator {
-    compare(one: SModelElement, other: SModelElement): number {
+    compare(one: GModelElement, other: GModelElement): number {
         const boundsOne = findParentByFeature(one, isSelectableAndBoundsAware);
         const boundsOther = findParentByFeature(other, isSelectableAndBoundsAware);
         if (boundsOne && boundsOther) {
@@ -98,16 +103,16 @@ export class LeftToRightTopToBottomComparator {
  */
 @injectable()
 export class MarkerNavigator {
-    static readonly ALL_SEVERITIES: SIssueSeverity[] = ['error', 'warning', 'info'];
+    static readonly ALL_SEVERITIES: GIssueSeverity[] = ['error', 'warning', 'info'];
 
-    @inject(SModelElementComparator)
-    protected markerComparator: SModelElementComparator;
+    @inject(GModelElementComparator)
+    protected markerComparator: GModelElementComparator;
 
     next(
-        root: Readonly<SModelRoot>,
-        current?: SModelElement & BoundsAware,
-        predicate: (marker: SIssueMarker) => boolean = MarkerPredicates.ALL
-    ): SIssueMarker | undefined {
+        root: Readonly<GModelRoot>,
+        current?: GModelElement & BoundsAware,
+        predicate: (marker: GIssueMarker) => boolean = MarkerPredicates.ALL
+    ): GIssueMarker | undefined {
         const markers = this.getMarkers(root, predicate);
         if (current === undefined) {
             return markers.length > 0 ? markers[0] : undefined;
@@ -116,10 +121,10 @@ export class MarkerNavigator {
     }
 
     previous(
-        root: Readonly<SModelRoot>,
-        current?: SModelElement & BoundsAware,
-        predicate: (marker: SIssueMarker) => boolean = MarkerPredicates.ALL
-    ): SIssueMarker | undefined {
+        root: Readonly<GModelRoot>,
+        current?: GModelElement & BoundsAware,
+        predicate: (marker: GIssueMarker) => boolean = MarkerPredicates.ALL
+    ): GIssueMarker | undefined {
         const markers = this.getMarkers(root, predicate);
         if (current === undefined) {
             return markers.length > 0 ? markers[0] : undefined;
@@ -127,12 +132,12 @@ export class MarkerNavigator {
         return markers[this.getPreviousIndex(current, markers) % markers.length];
     }
 
-    protected getMarkers(root: Readonly<SModelRoot>, predicate: (marker: SIssueMarker) => boolean): SIssueMarker[] {
+    protected getMarkers(root: Readonly<GModelRoot>, predicate: (marker: GIssueMarker) => boolean): GIssueMarker[] {
         const markers = collectIssueMarkers(root);
         return markers.filter(predicate).sort(this.markerComparator.compare);
     }
 
-    protected getNextIndex(current: SModelElement & BoundsAware, markers: SIssueMarker[]): number {
+    protected getNextIndex(current: GModelElement & BoundsAware, markers: GIssueMarker[]): number {
         for (let index = 0; index < markers.length; index++) {
             if (this.markerComparator.compare(markers[index], current) > 0) {
                 return index;
@@ -141,7 +146,7 @@ export class MarkerNavigator {
         return 0;
     }
 
-    protected getPreviousIndex(current: SModelElement & BoundsAware, markers: SIssueMarker[]): number {
+    protected getPreviousIndex(current: GModelElement & BoundsAware, markers: GIssueMarker[]): number {
         for (let index = markers.length - 1; index >= 0; index--) {
             if (this.markerComparator.compare(markers[index], current) < 0) {
                 return index;
@@ -153,17 +158,17 @@ export class MarkerNavigator {
 
 @injectable()
 export class NavigateToMarkerActionHandler implements IActionHandler {
-    @inject(SModelElementComparator)
-    protected markerComparator: SModelElementComparator;
+    @inject(GModelElementComparator)
+    protected markerComparator: GModelElementComparator;
 
     @inject(MarkerNavigator)
     protected markerNavigator: MarkerNavigator;
 
-    @inject(TYPES.SelectionService)
+    @inject(SelectionService)
     protected selectionService: SelectionService;
 
     @inject(TYPES.IActionDispatcher)
-    protected actionDispatcher: ActionDispatcher;
+    protected actionDispatcher: GLSPActionDispatcher;
 
     handle(action: NavigateToMarkerAction): void {
         const selected = this.getSelectedElements(action);
@@ -177,14 +182,14 @@ export class NavigateToMarkerActionHandler implements IActionHandler {
         }
     }
 
-    protected getSelectedElements(action: NavigateToMarkerAction): (SModelElement & Selectable)[] {
+    protected getSelectedElements(action: NavigateToMarkerAction): (GModelElement & Selectable)[] {
         if (action.selectedElementIds && action.selectedElementIds.length > 0) {
             return getElements(this.selectionService.getModelRoot().index, action.selectedElementIds, isSelectable);
         }
         return this.selectionService.getSelectedElements();
     }
 
-    protected getTarget(action: NavigateToMarkerAction, selected: SModelElement[]): SIssueMarker | undefined {
+    protected getTarget(action: NavigateToMarkerAction, selected: GModelElement[]): GIssueMarker | undefined {
         const root = this.selectionService.getModelRoot();
         const target = selected.sort(this.markerComparator.compare).find(isBoundsAware);
         if (action.direction === 'previous') {
@@ -194,16 +199,16 @@ export class NavigateToMarkerActionHandler implements IActionHandler {
         }
     }
 
-    protected matchesSeverities(action: NavigateToMarkerAction, marker: SIssueMarker): boolean {
+    protected matchesSeverities(action: NavigateToMarkerAction, marker: GIssueMarker): boolean {
         return marker.issues.find(issue => action.severities.includes(issue.severity)) !== undefined;
     }
 }
 
 @injectable()
 export class MarkerNavigatorContextMenuItemProvider implements IContextMenuItemProvider {
-    @inject(TYPES.SelectionService) protected selectionService: SelectionService;
+    @inject(SelectionService) protected selectionService: SelectionService;
 
-    getItems(root: Readonly<SModelRoot>, lastMousePosition?: Point): Promise<MenuItem[]> {
+    getItems(root: Readonly<GModelRoot>, lastMousePosition?: Point): Promise<MenuItem[]> {
         const selectedElementIds = Array.from(this.selectionService.getSelectedElementIDs());
         const hasMarkers = collectIssueMarkers(root).length > 0;
         return Promise.resolve([
@@ -235,7 +240,7 @@ export class MarkerNavigatorContextMenuItemProvider implements IContextMenuItemP
 
 @injectable()
 export class MarkerNavigatorKeyListener extends KeyListener {
-    override keyDown(_element: SModelElement, event: KeyboardEvent): Action[] {
+    override keyDown(_element: GModelElement, event: KeyboardEvent): Action[] {
         if (matchesKeystroke(event, 'Period', 'ctrl')) {
             return [NavigateToMarkerAction.create({ direction: 'next' })];
         } else if (matchesKeystroke(event, 'Comma', 'ctrl')) {

package/src/features/validation/validate.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2022 EclipseSource and others.
+ * Copyright (c) 2019-2023 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,26 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, DeleteMarkersAction, hasArrayProp, Marker, SetMarkersAction } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
-import { CommandExecutionContext, CommandReturn, IActionDispatcher, IActionHandler, ICommand, SIssueMarker, SParentElement } from 'sprotty';
+import {
+    Action,
+    CommandExecutionContext,
+    CommandReturn,
+    DeleteMarkersAction,
+    IActionDispatcher,
+    IActionHandler,
+    ICommand,
+    Marker,
+    GParentElement,
+    SetMarkersAction,
+    TYPES,
+    hasArrayProp
+} from '@eclipse-glsp/sprotty';
 import { EditorContextService } from '../../base/editor-context-service';
-import { TYPES } from '../../base/types';
-import { removeCssClasses } from '../../utils/smodel-util';
-import { IFeedbackActionDispatcher, IFeedbackEmitter } from '../tool-feedback/feedback-action-dispatcher';
-import { FeedbackCommand } from '../tool-feedback/model';
-import { createSIssue, getOrCreateSIssueMarker, getSeverity, getSIssueMarker, GIssueMarker } from './issue-marker';
+import { IFeedbackActionDispatcher, IFeedbackEmitter } from '../../base/feedback/feedback-action-dispatcher';
+import { FeedbackCommand } from '../../base/feedback/feedback-command';
+import { removeCssClasses } from '../../utils/gmodel-util';
+import { GIssueMarker, createGIssue, getOrCreateGIssueMarker, getGIssueMarker, getSeverity } from './issue-marker';
 
 /**
  * Feedback emitter sending actions for visualizing model validation feedback and
@@ -33,28 +44,25 @@ export class ValidationFeedbackEmitter implements IFeedbackEmitter {
 
     @inject(TYPES.IActionDispatcherProvider) protected actionDispatcher: () => Promise<IActionDispatcher>;
 
-    private registeredAction: ApplyMarkersAction;
-
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    private constructor() {}
+    protected registeredFeedbackByReason: Map<string, ApplyMarkersAction> = new Map();
 
     /**
      * 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.
+     * @param reason the reason for this validation feedback.
      */
-    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 = DeleteMarkersAction.create(this.registeredAction.markers);
+    registerValidationFeedbackAction(action: ApplyMarkersAction, reason = ''): void {
+        // De-register feedback and clear existing markers with the same reason
+        const previousFeedbackWithSameReason = this.registeredFeedbackByReason.get(reason);
+        if (previousFeedbackWithSameReason) {
+            this.feedbackActionDispatcher.deregisterFeedback(this, [previousFeedbackWithSameReason]);
+            const deleteMarkersAction = DeleteMarkersAction.create(previousFeedbackWithSameReason.markers);
             this.actionDispatcher().then(dispatcher => dispatcher.dispatch(deleteMarkersAction));
         }
 
         // Register new action responsible for applying markers and re-applying them when the model is updated
-        this.feedbackActionDispatcher.registerFeedback(this, [action]);
-        this.registeredAction = action;
+        this.registeredFeedbackByReason.set(reason, action);
+        this.feedbackActionDispatcher.registerFeedback(this, [...this.registeredFeedbackByReason.values()]);
     }
 }
 
@@ -80,7 +88,7 @@ export abstract class ExternalMarkerManager {
         }
     }
 
-    abstract setMarkers(markers: Marker[], sourceUri?: string): void;
+    abstract setMarkers(markers: Marker[], reason?: string, sourceUri?: string): void;
 }
 
 @injectable()
@@ -97,14 +105,14 @@ export class SetMarkersActionHandler implements IActionHandler {
 
     handle(action: SetMarkersAction): void | Action | ICommand {
         const markers: Marker[] = action.markers;
-        this.setMarkers(markers);
+        this.setMarkers(markers, action.reason);
     }
 
-    async setMarkers(markers: Marker[]): Promise<void> {
-        const uri = await this.editorContextService.getSourceUri();
-        this.externalMarkerManager?.setMarkers(markers, uri);
+    async setMarkers(markers: Marker[], reason: string | undefined): Promise<void> {
+        const uri = this.editorContextService.sourceUri;
+        this.externalMarkerManager?.setMarkers(markers, reason, uri);
         const applyMarkersAction = ApplyMarkersAction.create(markers);
-        this.validationFeedbackEmitter.registerValidationFeedbackAction(applyMarkersAction);
+        this.validationFeedbackEmitter.registerValidationFeedbackAction(applyMarkersAction, reason);
     }
 }
 
@@ -132,7 +140,7 @@ export namespace ApplyMarkersAction {
 }
 
 /**
- * Handles {@link ApplyMarkersAction}s by creating the corresponding {@link SIssueMarker}s and
+ * Handles {@link ApplyMarkersAction}s by creating the corresponding {@link GIssueMarker}s and
  * adding them to the graphical model.
  */
 @injectable()
@@ -146,9 +154,9 @@ export class ApplyMarkersCommand extends FeedbackCommand {
     execute(context: CommandExecutionContext): CommandReturn {
         this.action.markers.forEach(marker => {
             const modelElement = context.root.index.getById(marker.elementId);
-            if (modelElement instanceof SParentElement) {
-                const issueMarker = getOrCreateSIssueMarker(modelElement);
-                const issue = createSIssue(marker);
+            if (modelElement instanceof GParentElement) {
+                const issueMarker = getOrCreateGIssueMarker(modelElement);
+                const issue = createGIssue(marker);
                 issueMarker.issues.push(issue);
                 if (issueMarker instanceof GIssueMarker) {
                     issueMarker.computeProjectionCssClasses();
@@ -160,7 +168,7 @@ export class ApplyMarkersCommand extends FeedbackCommand {
     }
 }
 
-function addMaxSeverityCSSClassToIssueParent(modelElement: SParentElement, issueMarker: SIssueMarker): void {
+function addMaxSeverityCSSClassToIssueParent(modelElement: GParentElement, issueMarker: GIssueMarker): void {
     const maxSeverityCSSClass = getSeverity(issueMarker);
     if (!modelElement.cssClasses) {
         modelElement.cssClasses = [maxSeverityCSSClass];
@@ -170,7 +178,7 @@ function addMaxSeverityCSSClassToIssueParent(modelElement: SParentElement, issue
     }
 }
 
-function removeCSSClassFromIssueParent(modelElement: SParentElement, issueMarker: SIssueMarker): void {
+function removeCSSClassFromIssueParent(modelElement: GParentElement, issueMarker: GIssueMarker): void {
     const severity = getSeverity(issueMarker);
     removeCssClasses(modelElement, [severity]);
 }
@@ -189,8 +197,8 @@ export class DeleteMarkersCommand extends FeedbackCommand {
     execute(context: CommandExecutionContext): CommandReturn {
         this.action.markers.forEach(marker => {
             const modelElement = context.root.index.getById(marker.elementId);
-            if (modelElement instanceof SParentElement) {
-                const issueMarker = getSIssueMarker(modelElement);
+            if (modelElement instanceof GParentElement) {
+                const issueMarker = getGIssueMarker(modelElement);
                 if (issueMarker) {
                     removeCSSClassFromIssueParent(modelElement, issueMarker);
                     for (let index = 0; index < issueMarker.issues.length; ++index) {

package/src/features/validation/validation-modules.ts

@@ -0,0 +1,53 @@
+/********************************************************************************
+ * Copyright (c) 2019-2023 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
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { FeatureModule, SetMarkersAction, TYPES, bindAsService, configureActionHandler, configureCommand } from '@eclipse-glsp/sprotty';
+import {
+    GModelElementComparator,
+    LeftToRightTopToBottomComparator,
+    MarkerNavigator,
+    MarkerNavigatorContextMenuItemProvider,
+    MarkerNavigatorKeyListener,
+    NavigateToMarkerAction,
+    NavigateToMarkerActionHandler
+} from './marker-navigator';
+import { ApplyMarkersCommand, DeleteMarkersCommand, SetMarkersActionHandler, ValidationFeedbackEmitter } from './validate';
+
+export const validationModule = new FeatureModule((bind, _unbind, isBound) => {
+    const context = { bind, isBound };
+    configureActionHandler(context, SetMarkersAction.KIND, SetMarkersActionHandler);
+    configureCommand(context, ApplyMarkersCommand);
+    configureCommand(context, DeleteMarkersCommand);
+    bind(ValidationFeedbackEmitter).toSelf().inSingletonScope();
+});
+
+export const markerNavigatorModule = new FeatureModule((bind, _unbind, isBound) => {
+    bind(GModelElementComparator).to(LeftToRightTopToBottomComparator).inSingletonScope();
+    bind(MarkerNavigator).toSelf().inSingletonScope();
+    configureActionHandler({ bind, isBound }, NavigateToMarkerAction.KIND, NavigateToMarkerActionHandler);
+});
+
+/**
+ * Feature module that is intended for the standalone deployment of GLSP (i.e. plain webapp)
+ * When integrated into an application frame (e.g Theia/VS Code) this module is typically omitted and/or replaced
+ * with an application native module.
+ */
+export const standaloneMarkerNavigatorModule = new FeatureModule(
+    bind => {
+        bindAsService(bind, TYPES.IContextMenuProvider, MarkerNavigatorContextMenuItemProvider);
+        bindAsService(bind, TYPES.KeyListener, MarkerNavigatorKeyListener);
+    },
+    { requires: markerNavigatorModule }
+);

package/src/features/viewport/glsp-scroll-mouse-listener.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021-2022 EclipseSource and others.
+ * Copyright (c) 2021-2023 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 } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
-import { EnableDefaultToolsAction, EnableToolsAction, IActionHandler, ICommand, ScrollMouseListener, SModelElement } from 'sprotty';
-import { MarqueeMouseTool } from '../tools/marquee-mouse-tool';
+import { Action, IActionHandler, ICommand, ScrollMouseListener, GModelElement } from '@eclipse-glsp/sprotty';
+import { EnableDefaultToolsAction, EnableToolsAction } from '../../base/tool-manager/tool';
+import { MarqueeMouseTool } from '../tools/marquee-selection/marquee-mouse-tool';
 
 @injectable()
 export class GLSPScrollMouseListener extends ScrollMouseListener implements IActionHandler {
@@ -32,7 +32,7 @@ export class GLSPScrollMouseListener extends ScrollMouseListener implements IAct
         }
     }
 
-    override mouseDown(target: SModelElement, event: MouseEvent): (Action | Promise<Action>)[] {
+    override mouseDown(target: GModelElement, event: MouseEvent): (Action | Promise<Action>)[] {
         if (this.preventScrolling) {
             return [];
         }