@eclipse-glsp/client 1.1.0-RC10 → 1.1.0-next.0363f0b.261

package/src/features/tools/{edge-edit-tool.ts → edge-edit/edge-edit-tool.ts}

@@ -19,6 +19,7 @@ import {
     AnchorComputerRegistry,
     ChangeRoutingPointsOperation,
     Connectable,
+    Disposable,
     EdgeRouterRegistry,
     ISnapper,
     ReconnectEdgeOperation,
@@ -32,12 +33,13 @@ import {
     isConnectable,
     isSelected
 } from '~glsp-sprotty';
-import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-import { calcElementAndRoutingPoints, isRoutable, isRoutingHandle } from '../../utils/smodel-util';
-import { SReconnectHandle, isReconnectHandle, isReconnectable, isSourceRoutingHandle, isTargetRoutingHandle } from '../reconnect/model';
-import { SelectionListener, SelectionService } from '../select/selection-service';
-import { DrawFeedbackEdgeAction, RemoveFeedbackEdgeAction, feedbackEdgeId } from '../tool-feedback/creation-tool-feedback';
-import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
+import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
+import { CursorCSS, cursorFeedbackAction } from '../../../base/feedback/css-feedback';
+import { ISelectionListener, SelectionService } from '../../../base/selection-service';
+import { calcElementAndRoutingPoints, isRoutable, isRoutingHandle } from '../../../utils/smodel-util';
+import { SReconnectHandle, isReconnectHandle, isReconnectable, isSourceRoutingHandle, isTargetRoutingHandle } from '../../reconnect/model';
+import { BaseGLSPTool } from '../base-glsp-tool';
+import { DrawFeedbackEdgeAction, RemoveFeedbackEdgeAction, feedbackEdgeId } from '../edge-creation/dangling-edge-feedback';
 import {
     DrawFeedbackEdgeSourceAction,
     FeedbackEdgeRouteMovingMouseListener,
@@ -46,14 +48,13 @@ import {
     HideEdgeReconnectHandlesFeedbackAction,
     ShowEdgeReconnectHandlesFeedbackAction,
     SwitchRoutingModeAction
-} from '../tool-feedback/edge-edit-tool-feedback';
-import { BaseGLSPTool } from './base-glsp-tool';
+} from './edge-edit-tool-feedback';
 
 @injectable()
 export class EdgeEditTool extends BaseGLSPTool {
     static ID = 'glsp.edge-edit-tool';
 
-    @inject(TYPES.SelectionService) protected selectionService: SelectionService;
+    @inject(SelectionService) protected selectionService: SelectionService;
     @inject(AnchorComputerRegistry) protected anchorRegistry: AnchorComputerRegistry;
     @inject(EdgeRouterRegistry) @optional() readonly edgeRouterRegistry?: EdgeRouterRegistry;
     @inject(TYPES.ISnapper) @optional() readonly snapper?: ISnapper;
@@ -69,13 +70,19 @@ export class EdgeEditTool extends BaseGLSPTool {
 
     enable(): void {
         this.edgeEditListener = new EdgeEditListener(this);
-        this.mouseTool.register(this.edgeEditListener);
-        this.selectionService.register(this.edgeEditListener);
 
         // install feedback move mouse listener for client-side move updates
-        this.feedbackEdgeSourceMovingListener = new FeedbackEdgeSourceMovingMouseListener(this.anchorRegistry);
-        this.feedbackEdgeTargetMovingListener = new FeedbackEdgeTargetMovingMouseListener(this.anchorRegistry);
+        this.feedbackEdgeSourceMovingListener = new FeedbackEdgeSourceMovingMouseListener(this.anchorRegistry, this.feedbackDispatcher);
+        this.feedbackEdgeTargetMovingListener = new FeedbackEdgeTargetMovingMouseListener(this.anchorRegistry, this.feedbackDispatcher);
         this.feedbackMovingListener = new FeedbackEdgeRouteMovingMouseListener(this.edgeRouterRegistry, this.snapper);
+
+        this.toDisposeOnDisable.push(
+            Disposable.create(() => this.edgeEditListener.reset()),
+            this.mouseTool.registerListener(this.edgeEditListener),
+            this.feedbackEdgeSourceMovingListener,
+            this.feedbackEdgeTargetMovingListener,
+            this.selectionService.onSelectionChanged(change => this.edgeEditListener.selectionChanged(change.root, change.selectedElements))
+        );
     }
 
     registerFeedbackListeners(): void {
@@ -85,20 +92,15 @@ export class EdgeEditTool extends BaseGLSPTool {
     }
 
     deregisterFeedbackListeners(): void {
+        this.feedbackEdgeSourceMovingListener.dispose();
+        this.feedbackEdgeTargetMovingListener.dispose();
         this.mouseTool.deregister(this.feedbackEdgeSourceMovingListener);
         this.mouseTool.deregister(this.feedbackEdgeTargetMovingListener);
         this.mouseTool.deregister(this.feedbackMovingListener);
     }
-
-    disable(): void {
-        this.edgeEditListener.reset();
-        this.selectionService.deregister(this.edgeEditListener);
-        this.deregisterFeedbackListeners();
-        this.mouseTool.deregister(this.edgeEditListener);
-    }
 }
 
-class EdgeEditListener extends DragAwareMouseListener implements SelectionListener {
+export class EdgeEditListener extends DragAwareMouseListener implements ISelectionListener {
     // active selection data
     protected edge?: SRoutableElement;
     protected routingHandle?: SRoutingHandle;
@@ -132,7 +134,7 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
         if (isReconnectable(edge)) {
             feedbackActions.push(ShowEdgeReconnectHandlesFeedbackAction.create(this.edge.id));
         }
-        this.tool.dispatchFeedback(feedbackActions);
+        this.tool.registerFeedback(feedbackActions);
     }
 
     protected isEdgeSelected(): boolean {
@@ -142,14 +144,14 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
     protected setReconnectHandleSelected(edge: SRoutableElement, reconnectHandle: SReconnectHandle): void {
         if (this.edge && this.edge.target && this.edge.source) {
             if (isSourceRoutingHandle(edge, reconnectHandle)) {
-                this.tool.dispatchFeedback([
+                this.tool.registerFeedback([
                     HideEdgeReconnectHandlesFeedbackAction.create(),
                     cursorFeedbackAction(CursorCSS.EDGE_RECONNECT),
                     DrawFeedbackEdgeSourceAction.create({ elementTypeId: this.edge.type, targetId: this.edge.targetId })
                 ]);
                 this.reconnectMode = 'NEW_SOURCE';
             } else if (isTargetRoutingHandle(edge, reconnectHandle)) {
-                this.tool.dispatchFeedback([
+                this.tool.registerFeedback([
                     HideEdgeReconnectHandlesFeedbackAction.create(),
                     cursorFeedbackAction(CursorCSS.EDGE_CREATION_TARGET),
                     DrawFeedbackEdgeAction.create({ elementTypeId: this.edge.type, sourceId: this.edge.sourceId })
@@ -257,11 +259,11 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
                         (this.reconnectMode === 'NEW_SOURCE' && currentTarget.canConnect(this.edge, 'source')) ||
                         (this.reconnectMode === 'NEW_TARGET' && currentTarget.canConnect(this.edge, 'target'))
                     ) {
-                        this.tool.dispatchFeedback([cursorFeedbackAction(CursorCSS.EDGE_RECONNECT)]);
+                        this.tool.registerFeedback([cursorFeedbackAction(CursorCSS.EDGE_RECONNECT)]);
                         return [];
                     }
                 }
-                this.tool.dispatchFeedback([cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED)]);
+                this.tool.registerFeedback([cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED)]);
             }
         }
         return [];
@@ -314,7 +316,7 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
             result.push(SwitchRoutingModeAction.create({ elementsToDeactivate: [this.edge.id] }));
         }
         result.push(...[HideEdgeReconnectHandlesFeedbackAction.create(), cursorFeedbackAction(), RemoveFeedbackEdgeAction.create()]);
-        this.tool.deregisterFeedback(result);
+        this.tool.deregisterFeedback(undefined, result);
         this.tool.deregisterFeedbackListeners();
     }
 }

package/src/features/tools/{marquee-behavior.ts → marquee-selection/marquee-behavior.ts}

@@ -15,7 +15,7 @@
  ********************************************************************************/
 
 import { Bounds, Point, PointToPointLine } from '~glsp-sprotty';
-import { DrawMarqueeAction } from '../tool-feedback/marquee-tool-feedback';
+import { DrawMarqueeAction } from './marquee-tool-feedback';
 
 export interface IMarqueeBehavior {
     readonly entireElement: boolean;
@@ -77,7 +77,7 @@ export class MarqueeUtil {
         return horizontallyIn && verticallyIn;
     }
 
-    private isEntireEdgeMarked(points: Point[]): boolean {
+    protected isEntireEdgeMarked(points: Point[]): boolean {
         for (let i = 0; i < points.length; i++) {
             if (!this.pointInRect(points[i])) {
                 return false;
@@ -86,7 +86,7 @@ export class MarqueeUtil {
         return true;
     }
 
-    private isPartOfEdgeMarked(points: Point[]): boolean {
+    protected isPartOfEdgeMarked(points: Point[]): boolean {
         for (let i = 0; i < points.length - 1; i++) {
             if (this.isLineMarked(points[i], points[i + 1])) {
                 return true;
@@ -95,7 +95,7 @@ export class MarqueeUtil {
         return false;
     }
 
-    private isLineMarked(point1: Point, point2: Point): boolean {
+    protected isLineMarked(point1: Point, point2: Point): boolean {
         const line = new PointToPointLine(point1, point2);
         return (
             this.pointInRect(point1) ||
@@ -107,11 +107,11 @@ export class MarqueeUtil {
         );
     }
 
-    private lineIntersect(line: PointToPointLine, p1: Point, p2: Point): boolean {
+    protected lineIntersect(line: PointToPointLine, p1: Point, p2: Point): boolean {
         return line.intersection(new PointToPointLine(p1, p2)) !== undefined;
     }
 
-    private pointInRect(point: Point): boolean {
+    protected pointInRect(point: Point): boolean {
         const boolX =
             this.startPoint.x <= this.currentPoint.x
                 ? this.isBetween(point.x, this.startPoint.x, this.currentPoint.x)
@@ -123,7 +123,7 @@ export class MarqueeUtil {
         return boolX && boolY;
     }
 
-    private isElementBetweenXAxis(elementBounds: Bounds, marqueeLeft: number, marqueeRight: number): boolean {
+    protected isElementBetweenXAxis(elementBounds: Bounds, marqueeLeft: number, marqueeRight: number): boolean {
         const leftEdge = this.isBetween(elementBounds.x, marqueeLeft, marqueeRight);
         const rightEdge = this.isBetween(elementBounds.x + elementBounds.width, marqueeLeft, marqueeRight);
         if (this.marqueeBehavior.entireElement) {
@@ -137,7 +137,7 @@ export class MarqueeUtil {
         );
     }
 
-    private isElementBetweenYAxis(elementBounds: Bounds, marqueeTop: number, marqueeBottom: number): boolean {
+    protected isElementBetweenYAxis(elementBounds: Bounds, marqueeTop: number, marqueeBottom: number): boolean {
         const topEdge = this.isBetween(elementBounds.y, marqueeTop, marqueeBottom);
         const bottomEdge = this.isBetween(elementBounds.y + elementBounds.height, marqueeTop, marqueeBottom);
         if (this.marqueeBehavior.entireElement) {
@@ -151,7 +151,7 @@ export class MarqueeUtil {
         );
     }
 
-    private isBetween(x: number, lower: number, upper: number): boolean {
+    protected isBetween(x: number, lower: number, upper: number): boolean {
         return lower <= x && x <= upper;
     }
 }

package/src/features/tools/{marquee-mouse-tool.ts → marquee-selection/marquee-mouse-tool.ts}

@@ -29,12 +29,12 @@ import {
     isSelectable,
     isSelected
 } from '~glsp-sprotty';
-import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-import { getAbsolutePosition, toAbsoluteBounds } from '../../utils/viewpoint-util';
-import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
-import { RemoveMarqueeAction } from '../tool-feedback/marquee-tool-feedback';
-import { BaseGLSPTool } from './base-glsp-tool';
+import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
+import { CursorCSS, cursorFeedbackAction } from '../../../base/feedback/css-feedback';
+import { getAbsolutePosition, toAbsoluteBounds } from '../../../utils/viewpoint-util';
+import { BaseGLSPTool } from '../base-glsp-tool';
 import { IMarqueeBehavior, MarqueeUtil } from './marquee-behavior';
+import { RemoveMarqueeAction } from './marquee-tool-feedback';
 
 @injectable()
 export class MarqueeMouseTool extends BaseGLSPTool {
@@ -43,7 +43,6 @@ export class MarqueeMouseTool extends BaseGLSPTool {
     @inject(TYPES.DOMHelper) protected domHelper: DOMHelper;
     @inject(TYPES.IMarqueeBehavior) @optional() protected marqueeBehavior: IMarqueeBehavior;
 
-    protected marqueeMouseListener: MarqueeMouseListener;
     protected shiftKeyListener: ShiftKeyListener = new ShiftKeyListener();
 
     get id(): string {
@@ -51,16 +50,11 @@ export class MarqueeMouseTool extends BaseGLSPTool {
     }
 
     enable(): void {
-        this.marqueeMouseListener = new MarqueeMouseListener(this.domHelper, this.editorContext.modelRoot, this.marqueeBehavior);
-        this.mouseTool.register(this.marqueeMouseListener);
-        this.keyTool.register(this.shiftKeyListener);
-        this.dispatchFeedback([cursorFeedbackAction(CursorCSS.MARQUEE)]);
-    }
-
-    disable(): void {
-        this.mouseTool.deregister(this.marqueeMouseListener);
-        this.keyTool.deregister(this.shiftKeyListener);
-        this.deregisterFeedback([cursorFeedbackAction()]);
+        this.toDisposeOnDisable.push(
+            this.mouseTool.registerListener(new MarqueeMouseListener(this.domHelper, this.editorContext.modelRoot, this.marqueeBehavior)),
+            this.keyTool.registerListener(this.shiftKeyListener),
+            this.registerFeedback([cursorFeedbackAction(CursorCSS.MARQUEE)], this, [cursorFeedbackAction()])
+        );
     }
 }
 
@@ -114,16 +108,12 @@ export class MarqueeMouseListener extends DragAwareMouseListener {
             const nodeIdsSelected = this.nodes.filter(e => this.marqueeUtil.isNodeMarked(toAbsoluteBounds(e))).map(e => e.id);
             const edgeIdsSelected = this.edges.filter(e => this.isEdgeMarked(e)).map(e => this.domHelper.findSModelIdByDOMElement(e));
             const selected = nodeIdsSelected.concat(edgeIdsSelected);
-            return [
-                SelectAction.create({ deselectedElementsIDs: Array.from(target.root.index.all().map(e => e.id)) }),
-                SelectAction.create({ selectedElementsIDs: selected.concat(this.previouslySelected) }),
-                this.marqueeUtil.drawMarqueeAction()
-            ];
+            return [SelectAction.setSelection(selected.concat(this.previouslySelected)), this.marqueeUtil.drawMarqueeAction()];
         }
         return [];
     }
 
-    override mouseUp(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseUp(_target: SModelElement, event: MouseEvent): Action[] {
         this.isActive = false;
         if (event.shiftKey) {
             return [RemoveMarqueeAction.create()];

package/src/features/tools/marquee-selection/marquee-selection-module.ts

@@ -0,0 +1,32 @@
+/********************************************************************************
+ * 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, TYPES, bindAsService, configureCommand, configureModelElement } from '~glsp-sprotty';
+import { MarqueeMouseTool } from './marquee-mouse-tool';
+import { MarqueeTool } from './marquee-tool';
+import { DrawMarqueeCommand, MARQUEE, RemoveMarqueeCommand } from './marquee-tool-feedback';
+import { MarqueeNode } from './model';
+import { MarqueeView } from './view';
+
+export const marqueeSelectionToolModule = new FeatureModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    bindAsService(context, TYPES.IDefaultTool, MarqueeTool);
+    bindAsService(context, TYPES.ITool, MarqueeMouseTool);
+
+    configureCommand(context, DrawMarqueeCommand);
+    configureCommand(context, RemoveMarqueeCommand);
+
+    configureModelElement(context, MARQUEE, MarqueeNode, MarqueeView);
+});

package/src/features/{tool-feedback → tools/marquee-selection}/marquee-tool-feedback.ts

@@ -27,7 +27,7 @@ import {
     TYPES,
     hasObjectProp
 } from '~glsp-sprotty';
-import { FeedbackCommand } from './model';
+import { FeedbackCommand } from '../../../base/feedback/feedback-command';
 
 export interface DrawMarqueeAction extends Action {
     kind: typeof DrawMarqueeAction.KIND;

package/src/features/tools/{marquee-tool.ts → marquee-selection/marquee-tool.ts}

@@ -13,9 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable } from 'inversify';
-import { Action, EnableToolsAction, KeyListener, KeyTool, SModelElement } from '~glsp-sprotty';
-import { BaseGLSPTool } from '../tools/base-glsp-tool';
+import { injectable } from 'inversify';
+import { Action, EnableToolsAction, KeyListener, SModelElement } from '~glsp-sprotty';
+import { BaseGLSPTool } from '../base-glsp-tool';
 import { MarqueeMouseTool } from './marquee-mouse-tool';
 
 @injectable()
@@ -24,24 +24,18 @@ export class MarqueeTool extends BaseGLSPTool {
 
     protected marqueeKeyListener: MarqueeKeyListener = new MarqueeKeyListener();
 
-    @inject(KeyTool) protected readonly keytool: KeyTool;
-
     get id(): string {
         return MarqueeTool.ID;
     }
 
     enable(): void {
-        this.keyTool.register(this.marqueeKeyListener);
-    }
-
-    disable(): void {
-        this.keyTool.deregister(this.marqueeKeyListener);
+        this.toDisposeOnDisable.push(this.keyTool.registerListener(this.marqueeKeyListener));
     }
 }
 
 @injectable()
 export class MarqueeKeyListener extends KeyListener {
-    override keyDown(element: SModelElement, event: KeyboardEvent): Action[] {
+    override keyDown(_element: SModelElement, event: KeyboardEvent): Action[] {
         if (event.shiftKey) {
             return [EnableToolsAction.create([MarqueeMouseTool.ID])];
         }

package/src/features/{mouse-tool/di.config.ts → tools/node-creation/node-creation-module.ts}

@@ -13,14 +13,11 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { ContainerModule } from 'inversify';
-import { MouseTool, TYPES } from '~glsp-sprotty';
-import { RankingMouseTool } from './mouse-tool';
+import { FeatureModule, TYPES, TriggerNodeCreationAction, bindAsService, configureActionHandler } from '~glsp-sprotty';
+import { NodeCreationTool } from './node-creation-tool';
 
-const glspMouseToolModule = new ContainerModule((bind, _unbind, _isBound, rebind) => {
-    bind(RankingMouseTool).toSelf().inSingletonScope();
-    bind(TYPES.MouseTool).toService(RankingMouseTool);
-    rebind(MouseTool).toService(RankingMouseTool);
+export const nodeCreationToolModule = new FeatureModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    bindAsService(context, TYPES.ITool, NodeCreationTool);
+    configureActionHandler(context, TriggerNodeCreationAction.KIND, NodeCreationTool);
 });
-
-export default glspMouseToolModule;

package/src/features/tools/{node-creation-tool.ts → node-creation/node-creation-tool.ts}

@@ -18,8 +18,6 @@ import {
     Action,
     CreateNodeOperation,
     EnableDefaultToolsAction,
-    EnableToolsAction,
-    IActionHandler,
     ISnapper,
     SModelElement,
     SNode,
@@ -28,44 +26,29 @@ import {
     findParentByFeature,
     isCtrlOrCmd
 } from '~glsp-sprotty';
-import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-import { getAbsolutePosition } from '../../utils/viewpoint-util';
-import { Containable, isContainable } from '../hints/model';
-import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
-import { BaseGLSPTool } from './base-glsp-tool';
+import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
+import { CursorCSS, cursorFeedbackAction } from '../../../base/feedback/css-feedback';
+import { getAbsolutePosition } from '../../../utils/viewpoint-util';
+import { Containable, isContainable } from '../../hints/model';
+import { BaseGLSPCreationTool } from '../base-glsp-creation-tool';
 
 @injectable()
-export class NodeCreationTool extends BaseGLSPTool implements IActionHandler {
+export class NodeCreationTool extends BaseGLSPCreationTool<TriggerNodeCreationAction> {
     static ID = 'tool_create_node';
 
-    @inject(TYPES.ISnapper) @optional() readonly snapper?: ISnapper;
+    protected isTriggerAction = TriggerNodeCreationAction.is;
 
-    protected creationToolMouseListener: NodeCreationToolMouseListener;
-    protected triggerAction: TriggerNodeCreationAction;
+    @inject(TYPES.ISnapper) @optional() readonly snapper?: ISnapper;
 
     get id(): string {
         return NodeCreationTool.ID;
     }
 
-    enable(): void {
-        if (this.triggerAction === undefined) {
-            throw new TypeError(`Could not enable tool ${this.id}.The triggerAction cannot be undefined.`);
-        }
-        this.creationToolMouseListener = new NodeCreationToolMouseListener(this.triggerAction, this);
-        this.mouseTool.register(this.creationToolMouseListener);
-        this.dispatchFeedback([cursorFeedbackAction(CursorCSS.NODE_CREATION)]);
-    }
-
-    disable(): void {
-        this.mouseTool.deregister(this.creationToolMouseListener);
-        this.deregisterFeedback([cursorFeedbackAction()]);
-    }
-
-    handle(action: Action): Action | void {
-        if (TriggerNodeCreationAction.is(action)) {
-            this.triggerAction = action;
-            return EnableToolsAction.create([this.id]);
-        }
+    doEnable(): void {
+        this.toDisposeOnDisable.push(
+            this.mouseTool.registerListener(new NodeCreationToolMouseListener(this.triggerAction, this)),
+            this.registerFeedback([cursorFeedbackAction(CursorCSS.NODE_CREATION)], this, [cursorFeedbackAction()])
+        );
     }
 }
 
@@ -111,7 +94,7 @@ export class NodeCreationToolMouseListener extends DragAwareMouseListener {
             const feedback = this.creationAllowed(this.elementTypeId)
                 ? cursorFeedbackAction(CursorCSS.NODE_CREATION)
                 : cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED);
-            this.tool.dispatchFeedback([feedback]);
+            this.tool.registerFeedback([feedback]);
         }
         return [];
     }

package/src/features/tools/{enable-default-tools-on-focus-loss.ts → tool-focus-loss-module.ts}

@@ -14,12 +14,11 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { injectable } from 'inversify';
-import { Action, EnableDefaultToolsAction, IActionHandler, ICommand } from '~glsp-sprotty';
-import { FocusStateChangedAction } from '../../base/actions/focus-change-action';
+import { Action, EnableDefaultToolsAction, FeatureModule, IActionHandler, ICommand, configureActionHandler } from '~glsp-sprotty';
+import { FocusStateChangedAction } from '../../base/focus/focus-state-change-action';
 
 /**
  * Action handler that enables the default tools when the diagram lost focus.
- * @see FocusTracker
  * @see FocusStateChangedAction
  */
 @injectable()
@@ -30,3 +29,10 @@ export class EnableDefaultToolsOnFocusLossHandler implements IActionHandler {
         }
     }
 }
+
+/**
+ * Enables the default tools in the tool manager if the diagram looses focus.
+ */
+export const toolFocusLossModule = new FeatureModule((bind, _unbind, isBound) => {
+    configureActionHandler({ bind, isBound }, FocusStateChangedAction.KIND, EnableDefaultToolsOnFocusLossHandler);
+});

package/src/features/undo-redo/undo-redo-key-listener.ts

@@ -0,0 +1,32 @@
+/********************************************************************************
+ * Copyright (c) 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 { Action, KeyListener, RedoAction, SModelElement, UndoAction, isMac, matchesKeystroke } from '~glsp-sprotty';
+
+/**
+ * Key listener that listens to the typical keyboard shortcuts for undo/redo and dispatches the corresponding actions.
+ */
+export class GLSPUndoRedoKeyListener extends KeyListener {
+    override keyDown(element: SModelElement, event: KeyboardEvent): Action[] {
+        if (matchesKeystroke(event, 'KeyZ', 'ctrlCmd')) {
+            return [UndoAction.create()];
+        }
+        if (matchesKeystroke(event, 'KeyZ', 'ctrlCmd', 'shift') || (!isMac() && matchesKeystroke(event, 'KeyY', 'ctrlCmd'))) {
+            return [RedoAction.create()];
+        }
+        return [];
+    }
+}

package/src/features/undo-redo/undo-redo-module.ts

@@ -0,0 +1,28 @@
+/********************************************************************************
+ * Copyright (c) 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 { ContainerModule } from 'inversify';
+import { bindAsService, TYPES } from '~glsp-sprotty';
+import { GLSPUndoRedoKeyListener } from './undo-redo-key-listener';
+
+/**
+ * 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 undoRedoModule = new ContainerModule((bind, unbind, isBound, rebind) => {
+    bindAsService(bind, TYPES.KeyListener, GLSPUndoRedoKeyListener);
+});

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

@@ -27,12 +27,12 @@ import {
     SModelRoot,
     SNodeSchema,
     SParentElement,
-    TYPES,
-    decorationModule,
-    defaultModule
+    TYPES
 } from '~glsp-sprotty';
-import { markerNavigatorModule } from './di.config';
+import { defaultModule } from '../../base/default.module';
+import { decorationModule } from '../decoration/decoration-module';
 import { MarkerNavigator } from './marker-navigator';
+import { markerNavigatorModule } from './validation-modules';
 
 describe('MarkerNavigator', () => {
     const container = new Container();

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

@@ -16,7 +16,6 @@
 import { inject, injectable } from 'inversify';
 import {
     Action,
-    ActionDispatcher,
     BoundsAware,
     CenterAction,
     IActionHandler,
@@ -38,9 +37,10 @@ import {
     isSelectable,
     matchesKeystroke
 } from '~glsp-sprotty';
+import { GLSPActionDispatcher } from '../../base/action-dispatcher';
+import { SelectionService } from '../../base/selection-service';
 import { MarkerPredicates, collectIssueMarkers } from '../../utils/marker';
 import { getElements, isSelectableAndBoundsAware } from '../../utils/smodel-util';
-import { SelectionService } from '../select/selection-service';
 
 export interface NavigateToMarkerAction extends Action {
     kind: typeof NavigateToMarkerAction.KIND;
@@ -164,11 +164,11 @@ export class NavigateToMarkerActionHandler implements IActionHandler {
     @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);
@@ -206,7 +206,7 @@ export class NavigateToMarkerActionHandler implements IActionHandler {
 
 @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[]> {
         const selectedElementIds = Array.from(this.selectionService.getSelectedElementIDs());

package/src/features/validation/validate.ts

@@ -30,9 +30,9 @@ import {
     hasArrayProp
 } from '~glsp-sprotty';
 import { EditorContextService } from '../../base/editor-context-service';
+import { IFeedbackActionDispatcher, IFeedbackEmitter } from '../../base/feedback/feedback-action-dispatcher';
+import { FeedbackCommand } from '../../base/feedback/feedback-command';
 import { removeCssClasses } from '../../utils/smodel-util';
-import { IFeedbackActionDispatcher, IFeedbackEmitter } from '../tool-feedback/feedback-action-dispatcher';
-import { FeedbackCommand } from '../tool-feedback/model';
 import { GIssueMarker, createSIssue, getOrCreateSIssueMarker, getSIssueMarker, getSeverity } from './issue-marker';
 
 /**