@eclipse-glsp/client 1.1.0-next.9fabd84.216 → 1.1.0-next.a6b28e7.258

package/src/{features/select → base}/selection-service.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,25 +13,32 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-/* eslint-disable import/no-deprecated,no-unused-expressions */
-import { Action, SModelElementSchema } from '@eclipse-glsp/protocol';
 import { AssertionError, expect } from 'chai';
 import { Container, injectable } from 'inversify';
-import { defaultModule, SGraphFactory, SModelRoot } from 'sprotty';
-import { TYPES } from '../../base/types';
-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,
+    defaultModule,
+    initializeContainer
+} from '~glsp-sprotty';
+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);
     }
 
@@ -47,38 +54,18 @@ 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
     }
 }
 
 function createContainer(): Container {
-    const container = new Container();
-    container.load(defaultModule);
+    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);
     return container;
 }
 
@@ -94,7 +81,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);
     });
 
@@ -200,7 +187,7 @@ describe('SelectionService', () => {
             selectionService.modelRootChanged(newRoot);
             assertSelectionAndFeedback(['node1'], ['node2']);
         });
-        it('Changing root with new selection correctly selects matchting elements and deselects not matching elements.', () => {
+        it('Changing root with new selection correctly selects matching elements and deselects not matching elements.', () => {
             assertSelectionAndFeedback([], []);
             selectionService.updateSelection(root, ['node1', 'node2'], []);
             assertSelectionAndFeedback(['node1', 'node2'], []);
@@ -211,118 +198,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);
         });
     });
 
@@ -367,14 +292,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

@@ -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,46 +13,76 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, distinctAdd, pluck, remove, SelectAction, SelectAllAction } from '@eclipse-glsp/protocol';
-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,
-    isSelectable,
     SChildElement,
-    Selectable,
-    SelectAllCommand as SprottySelectAllCommand,
-    SelectCommand as SprottySelectCommand,
     SModelElement,
-    SModelRoot
-} from 'sprotty';
-import { SModelRootListener } from '../../base/model/update-model-command';
-import { TYPES } from '../../base/types';
-import { getElements, getMatchingElements } from '../../utils/smodel-util';
-import { IFeedbackActionDispatcher } from '../tool-feedback/feedback-action-dispatcher';
-import { SelectFeedbackAction } from './select-feedback-action';
-
-export interface SelectionListener {
-    selectionChanged(root: Readonly<SModelRoot>, selectedElements: string[]): void;
+    SModelRoot,
+    SelectAction,
+    SelectAllAction,
+    Selectable,
+    SprottySelectAllCommand,
+    SprottySelectCommand,
+    TYPES,
+    hasArrayProp,
+    isSelectable,
+    pluck
+} from '~glsp-sprotty';
+import { getElements, getMatchingElements } from '../utils/smodel-util';
+import { ISModelRootListener } from './command-stack';
+import { IFeedbackActionDispatcher } from './feedback/feedback-action-dispatcher';
+
+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;
+    @inject(TYPES.IFeedbackActionDispatcher)
+    protected feedbackDispatcher: IFeedbackActionDispatcher;
 
-    constructor(@multiInject(TYPES.SelectionListener) @optional() protected selectionListeners: SelectionListener[] = []) {}
+    @inject(TYPES.ILogger)
+    protected logger: ILogger;
 
-    register(selectionListener: SelectionListener): void {
-        distinctAdd(this.selectionListeners, selectionListener);
+    @multiInject(TYPES.ISelectionListener)
+    @optional()
+    protected selectionListeners: ISelectionListener[] = [];
+
+    protected toDispose = new DisposableCollection();
+
+    @postConstruct()
+    protected initialize(): void {
+        this.toDispose.push(this.onSelectionChangedEmitter);
+        this.selectionListeners.forEach(listener =>
+            this.onSelectionChanged(change => listener.selectionChanged(change.root, change.selectedElements, change.deselectedElements))
+        );
+    }
+
+    @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 {
@@ -110,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);
         }
     }
 
@@ -118,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> {
@@ -127,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);
     }
 
     /**
@@ -163,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();
     }
 
@@ -174,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;
@@ -201,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();
     }
 
@@ -233,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/source-uri-aware.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,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { AnyObject, hasStringProp } from '@eclipse-glsp/protocol';
+import { AnyObject, hasStringProp } from '~glsp-sprotty';
 export interface SourceUriAware {
     sourceURI: string;
 }

package/src/base/tool-manager/glsp-tool-manager.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,19 +13,12 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { distinctAdd, EditMode } from '@eclipse-glsp/protocol';
 import { inject, injectable, multiInject, optional, postConstruct } from 'inversify';
-import { Tool, ToolManager } from 'sprotty';
-import { EditModeListener, EditorContextService, EditorContextServiceProvider } from '../editor-context-service';
-import { TYPES } from '../types';
-
-export interface IGLSPToolManager extends ToolManager {
-    /* Disables all actives tools and activates only default tool with non-edit function*/
-    disableEditTools(): void;
-}
+import { AnyObject, EditMode, TYPES, Tool, ToolManager, distinctAdd, hasBooleanProp, hasFunctionProp, hasStringProp } from '~glsp-sprotty';
+import { EditorContextService, EditorContextServiceProvider, IEditModeListener } from '../editor-context-service';
 
 @injectable()
-export class GLSPToolManager extends ToolManager implements IGLSPToolManager, EditModeListener {
+export class GLSPToolManager extends ToolManager implements IEditModeListener {
     protected editorContext?: EditorContextService;
 
     @multiInject(TYPES.ITool) @optional() override tools: Tool[];
@@ -38,7 +31,7 @@ export class GLSPToolManager extends ToolManager implements IGLSPToolManager, Ed
         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;
         });
     }
@@ -59,7 +52,7 @@ export class GLSPToolManager extends ToolManager implements IGLSPToolManager, Ed
         this.disableActiveTools();
         let tools = toolIds.map(id => this.tool(id));
         if (this.editorContext && this.editorContext.isReadonly) {
-            tools = tools.filter(tool => tool && (!isGLSPTool(tool) || tool.isEditTool === false));
+            tools = tools.filter(tool => tool && (!GLSPTool.is(tool) || tool.isEditTool === false));
         }
         tools.forEach(tool => {
             if (tool !== undefined) {
@@ -71,10 +64,10 @@ export class GLSPToolManager extends ToolManager implements IGLSPToolManager, Ed
 
     disableEditTools(): void {
         this.disableActiveTools();
-        this.enable(this.defaultTools.filter(tool => !isGLSPTool(tool) || tool.isEditTool === false).map(tool => tool.id));
+        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;
         }
@@ -90,6 +83,14 @@ export interface GLSPTool extends Tool {
     isEditTool: boolean;
 }
 
-export function isGLSPTool(tool: any): tool is GLSPTool {
-    return 'isEditTool' in tool && typeof tool['isEditTool'] === 'boolean';
+export namespace GLSPTool {
+    export function is(object: unknown): object is GLSPTool {
+        return (
+            AnyObject.is(object) &&
+            hasStringProp(object, 'id') &&
+            hasFunctionProp(object, 'enable') &&
+            hasFunctionProp(object, 'disable') &&
+            hasBooleanProp(object, 'isEditTool')
+        );
+    }
 }

package/src/{features/rank/model.ts → base/view/key-tool.ts}

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 EclipseSource and others.
+ * 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
@@ -13,17 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { injectable } from 'inversify';
+import { Disposable, KeyListener, KeyTool } from '~glsp-sprotty';
 
-export const DEFAULT_RANK = 0;
-
-export interface Ranked {
-    rank: number;
-}
-
-export function isRanked(arg: any): arg is Ranked {
-    return arg !== undefined && arg.rank !== undefined && typeof arg.rank === 'number';
-}
-
-export function getRank(arg: any): number {
-    return isRanked(arg) ? arg.rank : DEFAULT_RANK;
+@injectable()
+export class GLSPKeyTool extends KeyTool {
+    registerListener(keyListener: KeyListener): Disposable {
+        super.register(keyListener);
+        return Disposable.create(() => this.deregister(keyListener));
+    }
 }