@eclipse-glsp/client 1.1.0-next.cab84ec.250 → 1.1.0-next.cc57a50.267

package/src/base/model/glsp-model-source.ts

@@ -0,0 +1,149 @@
+/********************************************************************************
+ * 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 { inject, injectable } from 'inversify';
+import {
+    Action,
+    ActionHandlerRegistry,
+    ActionMessage,
+    Disposable,
+    DisposableCollection,
+    GLSPClient,
+    ILogger,
+    ModelSource,
+    RequestModelAction,
+    SModelRootSchema,
+    TYPES
+} from '~glsp-sprotty';
+/**
+ * A helper interface that allows the client to mark actions that have been received from the server.
+ */
+export interface ServerAction extends Action {
+    _receivedFromServer: true;
+}
+
+export namespace ServerAction {
+    export function is(object: unknown): object is ServerAction {
+        return Action.is(object) && '_receivedFromServer' in object && object._receivedFromServer === true;
+    }
+
+    /**
+     * Mark the given action as {@link ServerAction} by attaching the "_receivedFromServer" property
+     * @param action The action that should be marked as server action
+     */
+    export function mark(action: Action): void {
+        (action as ServerAction)._receivedFromServer = true;
+    }
+}
+
+/**
+ * Central component for enabling the client-server action flow with the help of an underlying {@link GLSPClient}.
+ * Handles & forwards actions that are intended for the GLSP server. In addition, it handles {@link ActionMessage}s received
+ * from the server and dispatches the corresponding actions locally.
+ *
+ * Note that in sprotty a {@link ModelSource} is serving the model to the event cycle and
+ * is used to commit the local (i.e. client-side) model back to the source.
+ * However, in GLSP the update flow is reversed meaning that changes to the source model are applied
+ * on the server side and then an update is sent to the client.
+ */
+@injectable()
+export class GLSPModelSource extends ModelSource implements Disposable {
+    @inject(TYPES.ILogger)
+    protected logger: ILogger;
+
+    protected _sourceUri?: string;
+    protected _glspClient?: GLSPClient;
+    protected toDispose = new DisposableCollection();
+
+    clientId: string;
+
+    get glspClient(): GLSPClient | undefined {
+        return this._glspClient;
+    }
+
+    get sourceUri(): string | undefined {
+        return this._sourceUri;
+    }
+
+    async connect(client: GLSPClient, clientId?: string): Promise<GLSPClient> {
+        if (clientId) {
+            this.clientId = clientId;
+        }
+        await client.start();
+        this.toDispose.push(client.onActionMessage(message => this.messageReceived(message), this.clientId));
+        this._glspClient = client;
+        return this._glspClient;
+    }
+
+    protected messageReceived(message: ActionMessage): void {
+        if (this.clientId !== message.clientId) {
+            return;
+        }
+        const action = message.action;
+        ServerAction.mark(action);
+        this.logger.log(this, 'receiving', action);
+        this.actionDispatcher.dispatch(action);
+    }
+
+    override initialize(registry: ActionHandlerRegistry): void {
+        // Registering actions here is discouraged and it's recommended
+        // to implemented dedicated action handlers.
+        if (!this.clientId) {
+            this.clientId = this.viewerOptions.baseDiv;
+        }
+    }
+
+    handle(action: Action): void {
+        // Handling additional actions here is discouraged and it's recommended
+        // to implemented dedicated action handlers.
+        if (RequestModelAction.is(action)) {
+            this._sourceUri = action.options?.sourceUri.toString();
+        }
+        if (this.shouldForwardToServer(action)) {
+            this.forwardToServer(action);
+        }
+    }
+
+    protected forwardToServer(action: Action): void {
+        const message: ActionMessage = {
+            clientId: this.clientId,
+            action: action
+        };
+        this.logger.log(this, 'sending', message);
+        if (this.glspClient) {
+            this.glspClient.sendActionMessage(message);
+        } else {
+            throw new Error('GLSPClient is not connected');
+        }
+    }
+
+    protected shouldForwardToServer(action: Action): boolean {
+        return !ServerAction.is(action);
+    }
+
+    commitModel(newRoot: SModelRootSchema): SModelRootSchema {
+        /* In GLSP the model update flow is server-driven. i.e. changes to the graphical model are applied
+         * on server-side an only the server can issue a model update.
+         * The internal/local model should never be committed back to the model source i.e. GLSP server.
+         * => no-op implementation that simply returns the `newRoot`
+         */
+        return newRoot;
+    }
+
+    dispose(): void {
+        this.toDispose.dispose();
+    }
+}

package/src/base/ranked.ts

@@ -0,0 +1,42 @@
+/********************************************************************************
+ * 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 { AnyObject, hasNumberProp } from '~glsp-sprotty';
+
+/**
+ * A common interface for services/listeners that should be
+ * orderable by a type or rank/priority.
+ */
+export interface Ranked {
+    rank: number;
+}
+
+export namespace Ranked {
+    export const DEFAULT_RANK = 0;
+    export function is(object: unknown): object is Ranked {
+        return AnyObject.is(object) && hasNumberProp(object, 'rank');
+    }
+
+    /**
+     * Tries to retrieve the rank form the given object. If the object
+     * implements the {@link Ranked} interface the corresponding rank is returned
+     * otherwise the {@link DEFAULT_RANK} is returned.
+     * @param object
+     */
+    export function getRank(object: unknown): number {
+        return is(object) ? object.rank : DEFAULT_RANK;
+    }
+}

package/src/{features/select → base}/selection-service.spec.ts

@@ -15,20 +15,22 @@
  ********************************************************************************/
 import { AssertionError, expect } from 'chai';
 import { Container, injectable } from 'inversify';
-import { Action, SGraphFactory, SModelElementSchema, SModelRoot, TYPES, defaultModule, initializeContainer } from '~glsp-sprotty';
-import { IFeedbackActionDispatcher, IFeedbackEmitter } from '../tool-feedback/feedback-action-dispatcher';
-import { SelectFeedbackAction } from './select-feedback-action';
-import { SelectionListener, SelectionService } from './selection-service';
+import * as sinon from 'sinon';
+import { Action, Disposable, SGraphFactory, SModelElementSchema, SModelRoot, TYPES, initializeContainer } from '~glsp-sprotty';
+import { defaultModule } from './default.module';
+import { IFeedbackActionDispatcher, IFeedbackEmitter } from './feedback/feedback-action-dispatcher';
+import { ISelectionListener, SelectFeedbackAction, SelectionService } from './selection-service';
 
 @injectable()
 class MockFeedbackActionDispatcher implements IFeedbackActionDispatcher {
     protected feedbackEmitters: Map<IFeedbackEmitter, Action[]> = new Map();
 
-    registerFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void {
+    registerFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): Disposable {
         this.feedbackEmitters.set(feedbackEmitter, actions);
+        return Disposable.create(() => this.deregisterFeedback(feedbackEmitter));
     }
 
-    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void {
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, _actions?: Action[]): void {
         this.feedbackEmitters.delete(feedbackEmitter);
     }
 
@@ -44,27 +46,9 @@ class MockFeedbackActionDispatcher implements IFeedbackActionDispatcher {
     }
 }
 
-class MockSelectionListener implements SelectionListener {
-    private called = 0;
-    private root: SModelRoot;
-    private selectedElements: string[] = [];
-
-    selectionChanged(newRoot: Readonly<SModelRoot>, selectedElements: string[]): void {
-        this.called++;
-        this.root = newRoot;
-        this.selectedElements = selectedElements;
-    }
-
-    getRoot(): SModelRoot {
-        return this.root;
-    }
-
-    getSelectedElements(): string[] {
-        return this.selectedElements;
-    }
-
-    getCalled(): number {
-        return this.called;
+class MockSelectionListener implements ISelectionListener {
+    selectionChanged(root: Readonly<SModelRoot>, selectedElements: string[], deselectedElements: string[] | undefined): void {
+        // no.op
     }
 }
 
@@ -72,9 +56,7 @@ function createContainer(): Container {
     const container = initializeContainer(new Container(), defaultModule);
     // eslint-disable-next-line deprecation/deprecation
     container.rebind(TYPES.IModelFactory).to(SGraphFactory).inSingletonScope();
-    container.bind(TYPES.IFeedbackActionDispatcher).to(MockFeedbackActionDispatcher).inSingletonScope();
-    container.bind(SelectionService).toSelf().inSingletonScope();
-    container.bind(TYPES.SelectionService).toService(SelectionService);
+    container.rebind(TYPES.IFeedbackActionDispatcher).to(MockFeedbackActionDispatcher).inSingletonScope();
     return container;
 }
 
@@ -90,7 +72,7 @@ describe('SelectionService', () => {
         // eslint-disable-next-line deprecation/deprecation
         graphFactory = container.get<SGraphFactory>(TYPES.IModelFactory);
         root = createRoot('node1', 'node2', 'node3', 'node4', 'node5');
-        selectionService = container.get<SelectionService>(TYPES.SelectionService);
+        selectionService = container.get<SelectionService>(SelectionService);
         feedbackDispatcher = container.get<MockFeedbackActionDispatcher>(TYPES.IFeedbackActionDispatcher);
     });
 
@@ -207,118 +189,56 @@ describe('SelectionService', () => {
         });
     });
     describe('Listeners', () => {
+        const sandbox = sinon.createSandbox();
+        const listener = sandbox.createStubInstance(MockSelectionListener);
+
+        beforeEach(() => {
+            selectionService.onSelectionChanged(change =>
+                listener.selectionChanged(change.root, change.selectedElements, change.deselectedElements)
+            );
+        });
+
+        afterEach(() => {
+            selectionService.dispose();
+            sandbox.reset();
+        });
         it('A registered listener should be notified of a single selection change.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
             selectionService.updateSelection(root, ['node1', 'node1'], []);
-            assertListener(listener, root, ['node1'], 1);
+            assertListener(listener, root, ['node1'], [], 1);
         });
         it('A registered listener should be notified of a multi-selection change.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
             selectionService.updateSelection(root, ['node1', 'node2', 'node3'], []);
-            assertListener(listener, root, ['node1', 'node2', 'node3'], 1);
+            assertListener(listener, root, ['node1', 'node2', 'node3'], [], 1);
         });
         it('A registered listener should be notified of series of selection changes.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
             selectionService.updateSelection(root, ['node1'], []);
-            assertListener(listener, root, ['node1'], 1);
+            assertListener(listener, root, ['node1'], [], 1);
             selectionService.updateSelection(root, ['node2'], ['node1']);
-            assertListener(listener, root, ['node2'], 2);
+            assertListener(listener, root, ['node2'], ['node1'], 2);
             selectionService.updateSelection(root, ['node3', 'node4'], []);
-            assertListener(listener, root, ['node2', 'node3', 'node4'], 3);
+            assertListener(listener, root, ['node2', 'node3', 'node4'], [], 3);
             selectionService.updateSelection(root, [], ['node4']);
-            assertListener(listener, root, ['node2', 'node3'], 4);
-        });
-        it('A registered listener should receive the selected elements in the right order.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
-            selectionService.updateSelection(root, ['node2', 'node1'], []);
-            expect(() => assertListener(listener, root, ['node1', 'node2'], 1)).to.throw(AssertionError, 'ordered members');
+            assertListener(listener, root, ['node2', 'node3'], ['node4'], 4);
         });
         it('A registered listener should be notified of root changes.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
             selectionService.updateSelection(root, [], []);
-            assertListener(listener, root, [], 1);
+            assertListener(listener, root, [], [], 1);
 
             const newRoot = createRoot('node1', 'newNode2', 'newNode3');
             selectionService.updateSelection(newRoot, [], []);
-            assertListener(listener, newRoot, [], 2);
-        });
-        it('Registering an already registered listener should have no effect.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            selectionService.register(listener);
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
-            selectionService.updateSelection(root, ['node1', 'node2', 'node3'], []);
-            assertListener(listener, root, ['node1', 'node2', 'node3'], 1);
-            selectionService.register(listener);
-            selectionService.updateSelection(root, [], ['node2']);
-            assertListener(listener, root, ['node1', 'node3'], 2);
+            assertListener(listener, newRoot, [], [], 2);
         });
         it('Selecting the same elements consecutively should not trigger a listener update.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
             selectionService.updateSelection(root, ['node1'], []);
-            assertListener(listener, root, ['node1'], 1);
+            assertListener(listener, root, ['node1'], [], 1);
             selectionService.updateSelection(root, ['node1'], []);
-            assertListener(listener, root, ['node1'], 1);
+            assertListener(listener, root, ['node1'], [], 1);
         });
         it('Selecting a not-existing elements should not trigger a listener update.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
             selectionService.updateSelection(root, ['node1'], []);
-            assertListener(listener, root, ['node1'], 1);
+            assertListener(listener, root, ['node1'], [], 1);
             selectionService.updateSelection(root, ['not-existing'], []);
-            assertListener(listener, root, ['node1'], 1);
-        });
-        it('All registered listeners should be called on selection changes.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            const listener2: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            selectionService.register(listener2);
-            assertListener(listener, undefined, [], 0);
-            assertListener(listener2, undefined, [], 0);
-            selectionService.updateSelection(root, ['node1'], []);
-            assertListener(listener, root, ['node1'], 1);
-            assertListener(listener2, root, ['node1'], 1);
-            selectionService.updateSelection(root, ['node2'], ['node1']);
-            assertListener(listener, root, ['node2'], 2);
-            assertListener(listener2, root, ['node2'], 2);
-            selectionService.updateSelection(root, ['node3', 'node4'], []);
-            assertListener(listener, root, ['node2', 'node3', 'node4'], 3);
-            assertListener(listener2, root, ['node2', 'node3', 'node4'], 3);
-            selectionService.updateSelection(root, [], ['node4']);
-            assertListener(listener, root, ['node2', 'node3'], 4);
-            assertListener(listener2, root, ['node2', 'node3'], 4);
-        });
-        it('A deregistered listener should not receive further updates.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
-            selectionService.updateSelection(root, ['node1'], []);
-            assertListener(listener, root, ['node1'], 1);
-            selectionService.deregister(listener);
-            selectionService.updateSelection(root, ['node2'], ['node1']);
-            assertListener(listener, root, ['node1'], 1);
-            selectionService.updateSelection(root, ['node3', 'node4'], []);
-            assertListener(listener, root, ['node1'], 1);
-            selectionService.updateSelection(root, [], ['node4']);
-            assertListener(listener, root, ['node1'], 1);
-
-            const newRoot = createRoot('node1', 'newNode2', 'newNode3');
-            selectionService.updateSelection(newRoot, [], []);
-            assertListener(listener, root, ['node1'], 1);
+            assertListener(listener, root, ['node1'], [], 1);
         });
     });
 
@@ -363,14 +283,15 @@ describe('SelectionService', () => {
     }
 
     function assertListener(
-        listener: MockSelectionListener,
+        listener: sinon.SinonStubbedInstance<MockSelectionListener>,
         expectedRoot: SModelRoot | undefined,
         expectedSelection: string[],
+        expectedDeselection: string[],
         expectedCalled: number
     ): void {
-        expect(listener.getRoot()).to.equal(expectedRoot);
-        expect(listener.getSelectedElements()).to.have.lengthOf(expectedSelection.length);
-        expect(listener.getSelectedElements()).to.have.ordered.members(expectedSelection);
-        expect(listener.getCalled()).to.equal(expectedCalled);
+        expect(listener.selectionChanged.callCount).to.be.equal(expectedCalled);
+        expect(listener.selectionChanged.lastCall.args[0]).to.be.deep.equals(expectedRoot);
+        expect(listener.selectionChanged.lastCall.args[1]).to.be.deep.equals(expectedSelection);
+        expect(listener.selectionChanged.lastCall.args[2]).to.be.deep.equals(expectedDeselection);
     }
 });

package/src/{features/select → base}/selection-service.ts

@@ -13,11 +13,15 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable, multiInject, optional } from 'inversify';
+import { inject, injectable, multiInject, optional, postConstruct, preDestroy } from 'inversify';
 import {
     Action,
     Command,
     CommandExecutionContext,
+    Disposable,
+    DisposableCollection,
+    Emitter,
+    Event,
     ILogger,
     SChildElement,
     SModelElement,
@@ -28,36 +32,57 @@ import {
     SprottySelectAllCommand,
     SprottySelectCommand,
     TYPES,
-    distinctAdd,
+    hasArrayProp,
     isSelectable,
-    pluck,
-    remove
+    pluck
 } from '~glsp-sprotty';
-import { SModelRootListener } from '../../base/model/update-model-command';
-import { getElements, getMatchingElements } from '../../utils/smodel-util';
-import { IFeedbackActionDispatcher } from '../tool-feedback/feedback-action-dispatcher';
-import { SelectFeedbackAction } from './select-feedback-action';
+import { getElements, getMatchingElements } from '../utils/smodel-util';
+import { ISModelRootListener } from './command-stack';
+import { IFeedbackActionDispatcher } from './feedback/feedback-action-dispatcher';
 
-export interface SelectionListener {
-    selectionChanged(root: Readonly<SModelRoot>, selectedElements: string[]): void;
+export interface ISelectionListener {
+    selectionChanged(root: Readonly<SModelRoot>, selectedElements: string[], deselectedElements?: string[]): void;
+}
+
+export interface SelectionChange {
+    root: Readonly<SModelRoot>;
+    selectedElements: string[];
+    deselectedElements: string[];
 }
 
 @injectable()
-export class SelectionService implements SModelRootListener {
-    private root: Readonly<SModelRoot>;
-    private selectedElementIDs: Set<string> = new Set();
+export class SelectionService implements ISModelRootListener, Disposable {
+    protected root: Readonly<SModelRoot>;
+    protected selectedElementIDs: Set<string> = new Set();
+
+    @inject(TYPES.IFeedbackActionDispatcher)
+    protected feedbackDispatcher: IFeedbackActionDispatcher;
+
+    @inject(TYPES.ILogger)
+    protected logger: ILogger;
+
+    @multiInject(TYPES.ISelectionListener)
+    @optional()
+    protected selectionListeners: ISelectionListener[] = [];
 
-    @inject(TYPES.IFeedbackActionDispatcher) protected feedbackDispatcher: IFeedbackActionDispatcher;
-    @inject(TYPES.ILogger) protected logger: ILogger;
+    protected toDispose = new DisposableCollection();
 
-    constructor(@multiInject(TYPES.SelectionListener) @optional() protected selectionListeners: SelectionListener[] = []) {}
+    @postConstruct()
+    protected initialize(): void {
+        this.toDispose.push(this.onSelectionChangedEmitter);
+        this.selectionListeners.forEach(listener =>
+            this.onSelectionChanged(change => listener.selectionChanged(change.root, change.selectedElements, change.deselectedElements))
+        );
+    }
 
-    register(selectionListener: SelectionListener): void {
-        distinctAdd(this.selectionListeners, selectionListener);
+    @preDestroy()
+    dispose(): void {
+        this.toDispose.dispose();
     }
 
-    deregister(selectionListener: SelectionListener): void {
-        remove(this.selectionListeners, selectionListener);
+    protected onSelectionChangedEmitter = new Emitter<SelectionChange>();
+    get onSelectionChanged(): Event<SelectionChange> {
+        return this.onSelectionChangedEmitter.event;
     }
 
     modelRootChanged(root: Readonly<SModelRoot>): void {
@@ -115,7 +140,7 @@ export class SelectionService implements SModelRootListener {
         const rootChanged = prevRoot !== root;
         if (rootChanged || selectionChanged) {
             // notify listeners after the feedback action
-            this.notifyListeners(this.root, this.selectedElementIDs);
+            this.notifyListeners(this.root, this.selectedElementIDs, deselectedElementIDs);
         }
     }
 
@@ -123,8 +148,12 @@ export class SelectionService implements SModelRootListener {
         this.feedbackDispatcher.registerFeedback(this, actions);
     }
 
-    notifyListeners(root: SModelRoot, selectedElementIDs: Set<string>): void {
-        this.selectionListeners.forEach(listener => listener.selectionChanged(root, Array.from(selectedElementIDs)));
+    notifyListeners(root: SModelRoot, selectedElementIDs: Set<string>, deselectedElementIDs: Set<string>): void {
+        this.onSelectionChangedEmitter.fire({
+            root,
+            selectedElements: Array.from(selectedElementIDs),
+            deselectedElements: Array.from(deselectedElementIDs)
+        });
     }
 
     getModelRoot(): Readonly<SModelRoot> {
@@ -132,7 +161,7 @@ export class SelectionService implements SModelRootListener {
     }
 
     getSelectedElements(): Readonly<SModelElement & Selectable>[] {
-        return getElements(this.root.index, Array.from(this.selectedElementIDs), isSelectable);
+        return !this.root ? [] : getElements(this.root.index, Array.from(this.selectedElementIDs), isSelectable);
     }
 
     /**
@@ -168,10 +197,7 @@ export class SelectCommand extends Command {
     protected selected: SModelElement[] = [];
     protected deselected: SModelElement[] = [];
 
-    constructor(
-        @inject(TYPES.Action) public action: SelectAction,
-        @inject(TYPES.SelectionService) public selectionService: SelectionService
-    ) {
+    constructor(@inject(TYPES.Action) public action: SelectAction, @inject(SelectionService) public selectionService: SelectionService) {
         super();
     }
 
@@ -179,7 +205,9 @@ export class SelectCommand extends Command {
         const model = context.root;
         const selectionGuard = (element: any): element is SModelElement => element instanceof SChildElement && isSelectable(element);
         const selectedElements = getElements(model.index, this.action.selectedElementsIDs, selectionGuard);
-        const deselectedElements = getElements(model.index, this.action.deselectedElementsIDs, selectionGuard);
+        const deselectedElements = this.action.deselectAll
+            ? this.selectionService.getSelectedElements()
+            : getElements(model.index, this.action.deselectedElementsIDs, selectionGuard);
 
         this.selectionService.updateSelection(model, pluck(selectedElements, 'id'), pluck(deselectedElements, 'id'));
         return model;
@@ -206,10 +234,7 @@ export class SelectAllCommand extends Command {
     static readonly KIND = SprottySelectAllCommand.KIND;
     protected previousSelection: Map<string, boolean> = new Map<string, boolean>();
 
-    constructor(
-        @inject(TYPES.Action) public action: SelectAllAction,
-        @inject(TYPES.SelectionService) public selectionService: SelectionService
-    ) {
+    constructor(@inject(TYPES.Action) public action: SelectAllAction, @inject(SelectionService) public selectionService: SelectionService) {
         super();
     }
 
@@ -238,3 +263,31 @@ export class SelectAllCommand extends Command {
         return context.root;
     }
 }
+
+export interface SelectFeedbackAction extends Omit<SelectAction, 'kind'>, Action {
+    kind: typeof SelectFeedbackAction.KIND;
+}
+
+export namespace SelectFeedbackAction {
+    export const KIND = 'selectFeedback';
+
+    export function is(object: any): object is SelectFeedbackAction {
+        return Action.hasKind(object, KIND) && hasArrayProp(object, 'selectedElementsIDs') && hasArrayProp(object, 'deselectedElementsIDs');
+    }
+
+    export function create(options?: { selectedElementsIDs?: string[]; deselectedElementsIDs?: string[] | boolean }): SelectFeedbackAction {
+        return { ...SelectAction.create(options), kind: KIND };
+    }
+
+    export function addSelection(selectedElementsIDs: string[]): SelectFeedbackAction {
+        return { ...SelectAction.addSelection(selectedElementsIDs), kind: KIND };
+    }
+
+    export function removeSelection(deselectedElementsIDs: string[]): SelectFeedbackAction {
+        return { ...SelectAction.removeSelection(deselectedElementsIDs), kind: KIND };
+    }
+
+    export function setSelection(selectedElementsIDs: string[]): SelectFeedbackAction {
+        return { ...SelectAction.setSelection(selectedElementsIDs), kind: KIND };
+    }
+}

package/src/base/tool-manager/glsp-tool-manager.ts

@@ -15,10 +15,10 @@
  ********************************************************************************/
 import { inject, injectable, multiInject, optional, postConstruct } from 'inversify';
 import { AnyObject, EditMode, TYPES, Tool, ToolManager, distinctAdd, hasBooleanProp, hasFunctionProp, hasStringProp } from '~glsp-sprotty';
-import { EditModeListener, EditorContextService, EditorContextServiceProvider } from '../editor-context-service';
+import { EditorContextService, EditorContextServiceProvider, IEditModeListener } from '../editor-context-service';
 
 @injectable()
-export class GLSPToolManager extends ToolManager implements EditModeListener {
+export class GLSPToolManager extends ToolManager implements IEditModeListener {
     protected editorContext?: EditorContextService;
 
     @multiInject(TYPES.ITool) @optional() override tools: Tool[];
@@ -31,7 +31,7 @@ export class GLSPToolManager extends ToolManager implements EditModeListener {
         this.registerDefaultTools(...this.defaultTools);
         this.enableDefaultTools();
         this.contextServiceProvider().then(editorContext => {
-            editorContext.register(this);
+            editorContext.onEditModeChanged(change => this.editModeChanged(change.newValue, change.oldValue));
             this.editorContext = editorContext;
         });
     }
@@ -67,7 +67,7 @@ export class GLSPToolManager extends ToolManager implements EditModeListener {
         this.enable(this.defaultTools.filter(tool => !GLSPTool.is(tool) || tool.isEditTool === false).map(tool => tool.id));
     }
 
-    editModeChanged(oldValue: string, newValue: string): void {
+    editModeChanged(newValue: string, oldValue: string): void {
         if (oldValue === newValue) {
             return;
         }