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

package/src/base/command-stack.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 EclipseSource and others.
+ * Copyright (c) 2019-2022 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -15,19 +15,20 @@
  ********************************************************************************/
 import { RedoOperation, UndoOperation } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { CommandStack, IActionDispatcher, SModelRoot, TYPES } from 'sprotty';
+import { CommandStack, IActionDispatcher, SModelRoot } from 'sprotty';
+import { TYPES } from './types';
 
 @injectable()
 export class GLSPCommandStack extends CommandStack {
     @inject(TYPES.IActionDispatcherProvider) protected actionDispatcher: () => Promise<IActionDispatcher>;
 
-    undo(): Promise<SModelRoot> {
-        this.actionDispatcher().then(dispatcher => dispatcher.dispatch(new UndoOperation()));
+    override undo(): Promise<SModelRoot> {
+        this.actionDispatcher().then(dispatcher => dispatcher.dispatch(UndoOperation.create()));
         return this.thenUpdate();
     }
 
-    redo(): Promise<SModelRoot> {
-        this.actionDispatcher().then(dispatcher => dispatcher.dispatch(new RedoOperation()));
+    override redo(): Promise<SModelRoot> {
+        this.actionDispatcher().then(dispatcher => dispatcher.dispatch(RedoOperation.create()));
         return this.thenUpdate();
     }
 }

package/src/base/container-modules.ts

@@ -37,14 +37,14 @@ import glspDecorationModule from '../features/decoration/di.config';
 import glspEditLabelModule from '../features/edit-label/di.config';
 import modelHintsModule from '../features/hints/di.config';
 import glspHoverModule from '../features/hover/di.config';
-import layoutCommandsModule from '../features/layout/di.config';
-import modelSourceWatcherModule from '../features/model-source-watcher/di.config';
+import layoutModule from '../features/layout/di.config';
 import glspMouseToolModule from '../features/mouse-tool/di.config';
 import { navigationModule } from '../features/navigation/di.config';
 import glspSelectModule from '../features/select/di.config';
+import sourceModelWatcherModule from '../features/source-model-watcher/di.config';
 import toolFeedbackModule from '../features/tool-feedback/di.config';
 import toolPaletteModule from '../features/tool-palette/di.config';
-import toolsModule from '../features/tools/di.config';
+import { enableDefaultToolsOnFocusLossModule, toolsModule } from '../features/tools/di.config';
 import { markerNavigatorModule, validationModule } from '../features/validation/di.config';
 import glspViewportModule from '../features/viewport/di.config';
 import defaultGLSPModule from './di.config';
@@ -69,17 +69,18 @@ export const DEFAULT_MODULES = [
     glspServerCopyPasteModule,
     glspViewportModule,
     labelEditUiModule,
-    layoutCommandsModule,
+    layoutModule,
     markerNavigatorModule,
     modelHintsModule,
     modelSourceModule,
-    modelSourceWatcherModule,
+    sourceModelWatcherModule,
     navigationModule,
     openModule,
     toolPaletteModule,
     routingModule,
     toolFeedbackModule,
     toolsModule,
+    enableDefaultToolsOnFocusLossModule,
     validationModule,
     zorderModule
 ];

package/src/base/di.config.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 EclipseSource and others.
+ * Copyright (c) 2019-2022 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -16,7 +16,7 @@
 import { InitializeResult, SetEditModeAction } from '@eclipse-glsp/protocol';
 import '@vscode/codicons/dist/codicon.css';
 import { Container, ContainerModule } from 'inversify';
-import { ActionHandlerRegistry, configureActionHandler, configureCommand, ModelSource, SetModelCommand, TYPES } from 'sprotty';
+import { ActionHandlerRegistry, configureActionHandler, configureCommand, ModelSource, SetModelCommand } from 'sprotty';
 import '../../css/glsp-sprotty.css';
 import { GLSPActionDispatcher } from './action-dispatcher';
 import { FocusStateChangedAction } from './actions/focus-change-action';
@@ -28,13 +28,13 @@ import { GLSPModelRegistry } from './model/model-registry';
 import { FeedbackAwareUpdateModelCommand, SetModelActionHandler } from './model/update-model-command';
 import { SelectionClearingMouseListener } from './selection-clearing-mouse-listener';
 import { GLSPToolManager } from './tool-manager/glsp-tool-manager';
-import { GLSP_TYPES } from './types';
+import { TYPES } from './types';
 import { GLSPViewRegistry } from './view/view-registry';
 
 const defaultGLSPModule = new ContainerModule((bind, _unbind, isBound, rebind) => {
     const context = { bind, _unbind, isBound, rebind };
     bind(EditorContextService).toSelf().inSingletonScope();
-    bind(GLSP_TYPES.IEditorContextServiceProvider).toProvider<EditorContextService>(
+    bind(TYPES.IEditorContextServiceProvider).toProvider<EditorContextService>(
         ctx => () =>
             new Promise<EditorContextService>((resolve, reject) => {
                 if (ctx.container.isBound(EditorContextService)) {
@@ -58,7 +58,6 @@ const defaultGLSPModule = new ContainerModule((bind, _unbind, isBound, rebind) =
 
     rebind(TYPES.ICommandStack).to(GLSPCommandStack);
     bind(GLSPToolManager).toSelf().inSingletonScope();
-    bind(GLSP_TYPES.IGLSPToolManager).toService(GLSPToolManager);
     rebind(TYPES.IToolManager).toService(GLSPToolManager);
     bind(GLSPActionDispatcher).toSelf().inSingletonScope();
     rebind(TYPES.IActionDispatcher).toService(GLSPActionDispatcher);

package/src/base/drag-aware-mouse-listener.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 EclipseSource and others.
+ * Copyright (c) 2019-2022 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -28,19 +28,19 @@ export class DragAwareMouseListener extends MouseListener {
     private _isMouseDown = false;
     private _isMouseDrag = false;
 
-    mouseDown(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseDown(target: SModelElement, event: MouseEvent): Action[] {
         this._isMouseDown = true;
         return [];
     }
 
-    mouseMove(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseMove(target: SModelElement, event: MouseEvent): Action[] {
         if (this._isMouseDown) {
             this._isMouseDrag = true;
         }
         return [];
     }
 
-    mouseUp(element: SModelElement, event: MouseEvent): Action[] {
+    override mouseUp(element: SModelElement, event: MouseEvent): Action[] {
         this._isMouseDown = false;
         if (this._isMouseDrag) {
             this._isMouseDrag = false;

package/src/base/editor-context-service.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2021 EclipseSource and others.
+ * Copyright (c) 2020-2022 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,25 +13,45 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, Args, distinctAdd, EditMode, EditorContext, isSetEditModeAction, remove } from '@eclipse-glsp/protocol';
+import { Action, Args, distinctAdd, EditMode, EditorContext, remove, SetEditModeAction } from '@eclipse-glsp/protocol';
 import { inject, injectable, multiInject, optional } from 'inversify';
-import { IActionHandler, ModelSource, MousePositionTracker, SModelElement, SModelRoot, TYPES } from 'sprotty';
+import { IActionHandler, ModelSource, MousePositionTracker, SModelElement, SModelRoot } from 'sprotty';
 import { SelectionService } from '../features/select/selection-service';
 import { isSourceUriAware } from './source-uri-aware';
-import { GLSP_TYPES } from './types';
+import { TYPES } from './types';
 
 export interface EditModeListener {
     editModeChanged(newValue: string, oldvalue: string): void;
 }
 
+/**
+ * The `EditorContextService` is a central injectable component that gives read-only access to
+ * certain aspects of the diagram, such as the currently selected elements, the model root,
+ * the edit mode, the latest position of the mouse in the diagram.
+ *
+ * It has been introduced for two main reasons:
+ * 1. to simplify accessing the model root and the current selection from components that are
+ *    not commands,
+ * 2. to conveniently create an EditorContext, which is a context object sent as part of several
+ *    actions to the server to describe the current state of the editor (selection, last mouse
+ *    position, etc.).
+ */
 @injectable()
 export class EditorContextService implements IActionHandler {
-    @inject(GLSP_TYPES.SelectionService) protected selectionService: SelectionService;
-    @inject(MousePositionTracker) protected mousePositionTracker: MousePositionTracker;
-    @inject(TYPES.ModelSourceProvider) protected modelSource: () => Promise<ModelSource>;
-    protected _editMode: string;
+    @inject(TYPES.SelectionService)
+    protected selectionService: SelectionService;
+
+    @inject(MousePositionTracker)
+    protected mousePositionTracker: MousePositionTracker;
 
-    constructor(@multiInject(GLSP_TYPES.IEditModeListener) @optional() protected editModeListeners: EditModeListener[] = []) {}
+    @multiInject(TYPES.IEditModeListener)
+    @optional()
+    protected editModeListeners: EditModeListener[] = [];
+
+    @inject(TYPES.ModelSourceProvider)
+    protected modelSourceProvider: () => Promise<ModelSource>;
+
+    protected _editMode: string;
 
     register(editModeListener: EditModeListener): void {
         distinctAdd(this.editModeListeners, editModeListener);
@@ -58,7 +78,7 @@ export class EditorContextService implements IActionHandler {
     }
 
     handle(action: Action): void {
-        if (isSetEditModeAction(action)) {
+        if (SetEditModeAction.is(action)) {
             const oldValue = this._editMode;
             this._editMode = action.editMode;
             this.notifiyEditModeListeners(oldValue);
@@ -70,9 +90,9 @@ export class EditorContextService implements IActionHandler {
     }
 
     async getSourceUri(): Promise<string | undefined> {
-        const modelSource = await this.modelSource();
+        const modelSource = await this.modelSourceProvider();
         if (isSourceUriAware(modelSource)) {
-            return modelSource.getSourceURI();
+            return modelSource.sourceURI;
         }
         return undefined;
     }

package/src/base/focus-tracker.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021 EclipseSource and others.
+ * Copyright (c) 2021-2022 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -15,8 +15,9 @@
  ********************************************************************************/
 import { Action } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { IActionHandler, ICommand, TYPES, ViewerOptions } from 'sprotty';
-import { isFocusStateChangedAction } from './actions/focus-change-action';
+import { IActionHandler, ICommand, ViewerOptions } from 'sprotty';
+import { FocusStateChangedAction } from './actions/focus-change-action';
+import { TYPES } from './types';
 
 @injectable()
 export class FocusTracker implements IActionHandler {
@@ -30,7 +31,7 @@ export class FocusTracker implements IActionHandler {
     }
 
     handle(action: Action): void | Action | ICommand {
-        if (isFocusStateChangedAction(action)) {
+        if (FocusStateChangedAction.is(action)) {
             this._hasFocus = action.hasFocus;
             const placeholder = document.getElementById(this.options.baseDiv);
             if (!placeholder) {

package/src/base/model/model-registry.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021 EclipseSource and others.
+ * Copyright (c) 2021-2022 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -18,7 +18,7 @@ import { SModelElement, SModelRegistry } from 'sprotty';
 
 @injectable()
 export class GLSPModelRegistry extends SModelRegistry {
-    register(key: string, factory: (u: void) => SModelElement): void {
+    override register(key: string, factory: (u: void) => SModelElement): void {
         if (key === undefined) {
             throw new Error('Key is undefined');
         }

package/src/base/model/update-model-command.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 EclipseSource and others.
+ * Copyright (c) 2019-2022 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,31 +13,36 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, isSetModelAction, UpdateModelAction } from '@eclipse-glsp/protocol';
-import { inject, injectable, multiInject, optional, postConstruct } from 'inversify';
+import { Action, SetModelAction, toTypeGuard, UpdateModelAction } from '@eclipse-glsp/protocol';
+import { inject, injectable, multiInject, optional } from 'inversify';
 import {
     ActionHandlerRegistry,
+    Animation,
     Command,
     CommandActionHandler,
     CommandExecutionContext,
     CommandReturn,
     IActionHandler,
     ILogger,
+    MorphEdgesAnimation,
     SModelRoot,
-    TYPES,
+    UpdateAnimationData,
     UpdateModelCommand
 } from 'sprotty';
 import { IFeedbackActionDispatcher } from '../../features/tool-feedback/feedback-action-dispatcher';
 import { FeedbackCommand } from '../../features/tool-feedback/model';
-import { GLSP_TYPES } from '../types';
+import { TYPES } from '../types';
 
-/* ActionHandler that transforms a SetModelAction into an (feedback-aware) UpdateModelAction. This can be done because in sprotty
- *  UpdateModel behaves the same as SetModel if no model is present yet.*/
+/**
+ * ActionHandler that transforms a {@link SetModelAction} into an {@link UpdateModelAction} that can be handled
+ * by the {@link FeedbackAwareUpdateModelCommand}. This can be done because in sprotty an {@link UpdateModelCommand} and
+ * a {@link SetModelCommand} have the same behavior of no model is present yet.
+ */
 @injectable()
 export class SetModelActionHandler implements IActionHandler {
     handle(action: Action): Action | void {
-        if (isSetModelAction(action)) {
-            return new UpdateModelAction(action.newRoot, false);
+        if (SetModelAction.is(action)) {
+            return UpdateModelAction.create(action.newRoot, { animate: false });
         }
     }
 }
@@ -47,38 +52,41 @@ export interface SModelRootListener {
 }
 
 /**
- * A special`UpdateModelCommand` that retrieves all registered `actions` from the `IFeedbackActionDispatcher` (if present) and applies their
- * feedback to the `newRoot` before performing the update
+ * A special {@link UpdateModelCommand} that retrieves all registered {@link Action}s from the {@link IFeedbackActionDispatcher}
+ * (if present) and applies their feedback to the `newRoot` before performing the update. This enables persistent client-side feedback
+ * across model updates initiated by the GLSP server.
  */
 @injectable()
 export class FeedbackAwareUpdateModelCommand extends UpdateModelCommand {
-    @inject(TYPES.ILogger) protected logger: ILogger;
-    @inject(GLSP_TYPES.IFeedbackActionDispatcher) @optional() protected readonly feedbackActionDispatcher: IFeedbackActionDispatcher;
-    @inject(TYPES.ActionHandlerRegistryProvider) protected actionHandlerRegistryProvider: () => Promise<ActionHandlerRegistry>;
-    @multiInject(GLSP_TYPES.SModelRootListener) @optional() protected modelRootListeners: SModelRootListener[] = [];
+    @inject(TYPES.ILogger)
+    protected logger: ILogger;
 
-    protected actionHandlerRegistry?: ActionHandlerRegistry;
+    @inject(TYPES.IFeedbackActionDispatcher)
+    @optional()
+    protected feedbackActionDispatcher: IFeedbackActionDispatcher;
 
-    constructor(@inject(TYPES.Action) action: UpdateModelAction) {
-        super(action);
-    }
+    @multiInject(TYPES.SModelRootListener)
+    @optional()
+    protected modelRootListeners: SModelRootListener[] = [];
 
-    @postConstruct()
-    protected initialize(): void {
-        this.actionHandlerRegistryProvider().then(registry => (this.actionHandlerRegistry = registry));
+    protected actionHandlerRegistry?: ActionHandlerRegistry;
+
+    constructor(
+        @inject(TYPES.Action) action: UpdateModelAction,
+        @inject(TYPES.ActionHandlerRegistryProvider)
+        actionHandlerRegistryProvider: () => Promise<ActionHandlerRegistry>
+    ) {
+        super({ animate: true, ...action });
+        actionHandlerRegistryProvider().then(registry => (this.actionHandlerRegistry = registry));
     }
 
-    protected performUpdate(oldRoot: SModelRoot, newRoot: SModelRoot, context: CommandExecutionContext): CommandReturn {
+    protected override performUpdate(oldRoot: SModelRoot, newRoot: SModelRoot, context: CommandExecutionContext): CommandReturn {
         if (this.feedbackActionDispatcher && this.actionHandlerRegistry) {
-            // Create a temporary context wich defines the `newRoot` as `root`
+            // Create a temporary context which defines the `newRoot` as `root`
             // This way we do not corrupt the redo/undo behavior of the super class
             const tempContext: CommandExecutionContext = {
-                root: newRoot,
-                duration: context.duration,
-                logger: context.logger,
-                modelChanged: context.modelChanged,
-                modelFactory: context.modelFactory,
-                syncer: context.syncer
+                ...context,
+                root: newRoot
             };
 
             const feedbackCommands = this.getFeedbackCommands(this.actionHandlerRegistry);
@@ -92,19 +100,24 @@ export class FeedbackAwareUpdateModelCommand extends UpdateModelCommand {
     protected getFeedbackCommands(registry: ActionHandlerRegistry): Command[] {
         const result: Command[] = [];
         this.feedbackActionDispatcher.getRegisteredFeedback().forEach(action => {
-            const handler = registry.get(action.kind).find(h => h instanceof CommandActionHandler);
-            if (handler instanceof CommandActionHandler) {
-                result.push(handler.handle(action));
-            }
+            const commands = registry
+                .get(action.kind)
+                .filter<CommandActionHandler>(toTypeGuard(CommandActionHandler))
+                .map(handler => handler.handle(action));
+            result.push(...commands);
         });
-        // sort commands descanding by priority
-        return result.sort((a, b) => getPriority(b) - getPriority(a));
+        // sort commands descanting by priority
+        return result.sort((a, b) => this.getPriority(b) - this.getPriority(a));
+    }
+
+    protected getPriority(command: Partial<FeedbackCommand>): number {
+        return command.priority ?? 0;
     }
-}
 
-function getPriority(command: Command): number {
-    if (command instanceof FeedbackCommand) {
-        return command.priority;
+    // Override the `createAnimations` implementation and remove the animation for edge morphing. Otherwise routing & reconnect
+    // handles flicker after each server update.
+    protected override createAnimations(data: UpdateAnimationData, root: SModelRoot, context: CommandExecutionContext): Animation[] {
+        const animations = super.createAnimations(data, root, context);
+        return animations.filter(animation => !(animation instanceof MorphEdgesAnimation));
     }
-    return 0;
 }

package/src/base/model-initialization-constraint.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2021 EclipseSource and others.
+ * Copyright (c) 2020-2022 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,10 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, UpdateModelAction } from '@eclipse-glsp/protocol';
+import { Action, Deferred, SetModelAction, UpdateModelAction } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
 import { InitializeCanvasBoundsAction } from 'sprotty';
-import { Deferred } from 'sprotty/lib/utils/async';
 
 /**
  * The constraint defining when the initialization of the GLSP model is completed.
@@ -74,21 +73,20 @@ export abstract class ModelInitializationConstraint {
  */
 @injectable()
 export class DefaultModelInitializationConstraint extends ModelInitializationConstraint {
-    protected seenNonEmptyUpdateModel = false;
+    protected seenNonEmptyModelAction = false;
 
     isInitializedAfter(action: Action): boolean {
-        if (this.isNonEmptyUpdateModel(action)) {
-            this.seenNonEmptyUpdateModel = true;
-        } else if (this.seenNonEmptyUpdateModel && action.kind === InitializeCanvasBoundsAction.KIND) {
+        if (this.isNonEmptyModelAction(action)) {
+            this.seenNonEmptyModelAction = true;
+        } else if (this.seenNonEmptyModelAction && action.kind === InitializeCanvasBoundsAction.KIND) {
             return true;
         }
         return false;
     }
 
-    protected isNonEmptyUpdateModel(action: Action): boolean {
-        if (action && action.kind === UpdateModelAction.KIND) {
-            const updateModelAction = action as UpdateModelAction;
-            return updateModelAction.newRoot !== undefined && updateModelAction.newRoot.type !== 'NONE';
+    protected isNonEmptyModelAction(action: Action): boolean {
+        if (SetModelAction.is(action) || UpdateModelAction.is(action)) {
+            return action.newRoot.type !== 'NONE';
         }
         return false;
     }

package/src/base/selection-clearing-mouse-listener.ts

@@ -30,7 +30,7 @@ import { MouseListener, SModelElement } from 'sprotty';
  */
 @injectable()
 export class SelectionClearingMouseListener extends MouseListener {
-    mouseDown(_target: SModelElement, event: MouseEvent): never[] {
+    override mouseDown(_target: SModelElement, event: MouseEvent): never[] {
         const selection = document.getSelection();
         // eslint-disable-next-line no-null/no-null
         if (selection === null) {

package/src/base/source-uri-aware.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020 EclipseSource and others.
+ * Copyright (c) 2020-2022 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,10 +13,11 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-export abstract class SourceUriAware {
-    abstract getSourceURI(): string;
+import { AnyObject, hasStringProp } from '@eclipse-glsp/protocol';
+export interface SourceUriAware {
+    sourceURI: string;
 }
 
 export function isSourceUriAware(obj: any): obj is SourceUriAware {
-    return obj !== undefined && typeof obj.getSourceURI === 'function';
+    return AnyObject.is(obj) && hasStringProp(obj, 'sourceURI');
 }

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2021 EclipseSource and others.
+ * Copyright (c) 2020-2022 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -17,7 +17,7 @@ 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 { GLSP_TYPES } from '../types';
+import { TYPES } from '../types';
 
 export interface IGLSPToolManager extends ToolManager {
     /* Disables all actives tools and activates only default tool with non-edit function*/
@@ -28,9 +28,9 @@ export interface IGLSPToolManager extends ToolManager {
 export class GLSPToolManager extends ToolManager implements IGLSPToolManager, EditModeListener {
     protected editorContext?: EditorContextService;
 
-    @multiInject(GLSP_TYPES.ITool) @optional() tools: Tool[];
-    @multiInject(GLSP_TYPES.IDefaultTool) @optional() defaultTools: Tool[];
-    @inject(GLSP_TYPES.IEditorContextServiceProvider) contextServiceProvider: EditorContextServiceProvider;
+    @multiInject(TYPES.ITool) @optional() override tools: Tool[];
+    @multiInject(TYPES.IDefaultTool) @optional() override defaultTools: Tool[];
+    @inject(TYPES.IEditorContextServiceProvider) contextServiceProvider: EditorContextServiceProvider;
 
     @postConstruct()
     protected initialize(): void {
@@ -43,19 +43,19 @@ export class GLSPToolManager extends ToolManager implements IGLSPToolManager, Ed
         });
     }
 
-    registerDefaultTools(...tools: Tool[]): void {
+    override registerDefaultTools(...tools: Tool[]): void {
         for (const tool of tools) {
             distinctAdd(this.defaultTools, tool);
         }
     }
 
-    registerTools(...tools: Tool[]): void {
+    override registerTools(...tools: Tool[]): void {
         for (const tool of tools) {
             distinctAdd(this.tools, tool);
         }
     }
 
-    enable(toolIds: string[]): void {
+    override enable(toolIds: string[]): void {
         this.disableActiveTools();
         let tools = toolIds.map(id => this.tool(id));
         if (this.editorContext && this.editorContext.isReadonly) {
@@ -90,6 +90,6 @@ export interface GLSPTool extends Tool {
     isEditTool: boolean;
 }
 
-export function isGLSPTool(tool: Tool): tool is GLSPTool {
+export function isGLSPTool(tool: any): tool is GLSPTool {
     return 'isEditTool' in tool && typeof tool['isEditTool'] === 'boolean';
 }

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

@@ -0,0 +1,37 @@
+/********************************************************************************
+ * Copyright (c) 2022 STMicroelectronics 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, hasArrayProp } from '@eclipse-glsp/protocol';
+import { EnableDefaultToolsAction, EnableToolsAction } from 'sprotty/lib/base/tool-manager/tool';
+/* eslint-disable no-shadow */
+
+/**
+ * Use module augmentation to add the `is` utility function to the tool action namespaces provided by sprotty
+ */
+declare module 'sprotty/lib/base/tool-manager/tool' {
+    export namespace EnableDefaultToolsAction {
+        export function is(object: any): object is EnableDefaultToolsAction;
+    }
+    export namespace EnableToolsAction {
+        export function is(object: any): object is EnableToolsAction;
+    }
+}
+
+EnableDefaultToolsAction.is = (object: any): object is EnableDefaultToolsAction => Action.hasKind(object, EnableDefaultToolsAction.KIND);
+
+EnableToolsAction.is = (object: any): object is EnableToolsAction =>
+    Action.hasKind(object, EnableToolsAction.KIND) && hasArrayProp(object, 'toolIds');
+
+export { EnableDefaultToolsAction, EnableToolsAction };