@eclipse-glsp/client 0.9.0 → 0.10.0-next.385713d.170

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/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 };

package/src/base/types.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,27 +13,34 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-export const GLSP_TYPES = {
-    IAsyncClipboardService: Symbol.for('IAsyncClipboardService'),
-    ICommandPaletteActionProviderRegistry: Symbol.for('ICommandPaletteActionProviderRegistry'),
-    IEditorContextServiceProvider: Symbol.for('IEditorContextProvider'),
-    IFeedbackActionDispatcher: Symbol.for('IFeedbackActionDispatcher'),
-    IToolFactory: Symbol.for('Factory<Tool>'),
-    ITypeHintProvider: Symbol.for('ITypeHintProvider'),
-    IMovementRestrictor: Symbol.for('IMovmementRestrictor'),
-    SelectionService: Symbol.for('SelectionService'),
-    SelectionListener: Symbol.for('SelectionListener'),
-    SModelRootListener: Symbol.for('SModelRootListener'),
-    MouseTool: Symbol.for('MouseTool'),
-    IContextMenuService: Symbol.for('IContextMenuService'),
-    IContextMenuServiceProvider: Symbol.for('IContextMenuServiceProvider'),
-    IContextMenuProviderRegistry: Symbol.for('IContextMenuProviderRegistry'),
-    IContextMenuProvider: Symbol.for('IContextMenuProvider'),
-    ICopyPasteHandler: Symbol.for('ICopyPasteHandler'),
-    IGLSPToolManager: Symbol.for('IGLSPToolManager'),
-    ITool: Symbol.for('ITool'),
-    IDefaultTool: Symbol.for('IDefaultTool'),
-    IEditModeListener: Symbol.for('IEditModeListener'),
-    LayoutRegistration: Symbol.for('LayoutRegistration'),
-    IMarqueeBehavior: Symbol.for('IMarqueeBehavior')
+import { TYPES as SprottyTYPES } from 'sprotty';
+/**
+ * Reexport of the TYPES namespace of sprotty augments with additional GLSP specific service
+ * identifiers.
+ */
+export const TYPES = {
+    ...SprottyTYPES,
+    IAsyncClipboardService: Symbol('IAsyncClipboardService'),
+    IEditorContextServiceProvider: Symbol('IEditorContextProvider'),
+    IFeedbackActionDispatcher: Symbol('IFeedbackActionDispatcher'),
+    IToolFactory: Symbol('Factory<Tool>'),
+    ITypeHintProvider: Symbol('ITypeHintProvider'),
+    IMovementRestrictor: Symbol('IMovementRestrictor'),
+    SelectionService: Symbol('SelectionService'),
+    SelectionListener: Symbol('SelectionListener'),
+    SModelRootListener: Symbol('SModelRootListener'),
+    MouseTool: Symbol('MouseTool'),
+    IContextMenuProvider: Symbol('IContextMenuProvider'),
+    ICopyPasteHandler: Symbol('ICopyPasteHandler'),
+    ITool: Symbol('ITool'),
+    IDefaultTool: Symbol('IDefaultTool'),
+    IEditModeListener: Symbol('IEditModeListener'),
+    IMarqueeBehavior: Symbol('IMarqueeBehavior')
 };
+
+/**
+ * Keep a reexport under the old deprecated namespace to avoid hard API breaks.
+ * This gives adopters a grace period but all deprecated API will be removed before the 1.0.0 release.
+ * @deprecated Please use `TYPES` from `@eclipse-glsp/client` instead
+ */
+export const GLSP_TYPES = TYPES;

package/src/base/view/view-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 { IView, ViewRegistry } from 'sprotty';
 
 @injectable()
 export class GLSPViewRegistry extends ViewRegistry {
-    register(key: string, instance: IView): void {
+    override register(key: string, instance: IView): void {
         if (key === undefined) {
             throw new Error('Key is undefined');
         }

package/src/features/change-bounds/model.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
@@ -51,14 +51,14 @@ export class SResizeHandle extends SChildElement implements Hoverable {
     static readonly TYPE = 'resize-handle';
 
     constructor(
-        public readonly location?: ResizeHandleLocation,
-        public readonly type: string = SResizeHandle.TYPE,
-        public readonly hoverFeedback: boolean = false
+        readonly location?: ResizeHandleLocation,
+        override readonly type: string = SResizeHandle.TYPE,
+        readonly hoverFeedback: boolean = false
     ) {
         super();
     }
 
-    hasFeature(feature: symbol): boolean {
+    override hasFeature(feature: symbol): boolean {
         return feature === hoverFeedbackFeature;
     }
 

package/src/features/change-bounds/movement-restrictor.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
@@ -33,7 +33,7 @@ export function createMovementRestrictionFeedback(
     if (element instanceof SParentElement) {
         element.children.filter(child => child instanceof SResizeHandle).forEach(e => elements.push(e));
     }
-    return new ModifyCSSFeedbackAction(elements, movementRestrictor.cssClasses);
+    return ModifyCSSFeedbackAction.create({ elements, add: movementRestrictor.cssClasses });
 }
 
 export function removeMovementRestrictionFeedback(
@@ -45,7 +45,7 @@ export function removeMovementRestrictionFeedback(
         element.children.filter(child => child instanceof SResizeHandle).forEach(e => elements.push(e));
     }
 
-    return new ModifyCSSFeedbackAction(elements, undefined, movementRestrictor.cssClasses);
+    return ModifyCSSFeedbackAction.create({ elements, remove: movementRestrictor.cssClasses });
 }
 
 @injectable()

package/src/features/change-bounds/snap.spec.ts

@@ -0,0 +1,89 @@
+/********************************************************************************
+ * Copyright (c) 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
+ * 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 { expect } from 'chai';
+import { SModelElement } from 'sprotty';
+import { GridSnapper, PointPositionUpdater } from './snap';
+
+describe('GridSnapper', () => {
+    it('snap', () => {
+        const element = new SModelElement();
+        const snapper = new GridSnapper();
+        expect(snapper.snap({ x: 0, y: 0 }, element)).to.be.deep.equals({ x: 0, y: 0 });
+        expect(snapper.snap({ x: 4, y: 5 }, element)).to.be.deep.equals({ x: 0, y: 10 });
+        expect(snapper.snap({ x: 8, y: 11 }, element)).to.be.deep.equals({ x: 10, y: 10 });
+        expect(snapper.snap({ x: -7, y: -4 }, element)).to.be.deep.equals({ x: -10, y: -0 });
+    });
+});
+
+describe('PointPositionUpdater', () => {
+    it('updatePosition with no last drag position', () => {
+        const element = new SModelElement();
+        const updater = new PointPositionUpdater();
+        expect(updater.updatePosition(element, { x: 0, y: 0 }, false)).to.be.undefined;
+        expect(updater.updatePosition(element, { x: 0, y: 0 }, true)).to.be.undefined;
+    });
+
+    it('update last position and reset', () => {
+        const updater = new PointPositionUpdater();
+        expect(updater.isLastDragPositionUndefined()).to.be.true;
+        updater.updateLastDragPosition({ x: 0, y: 0 });
+        expect(updater.isLastDragPositionUndefined()).to.be.false;
+        updater.resetPosition();
+        expect(updater.isLastDragPositionUndefined()).to.be.true;
+    });
+
+    it('updatePosition with no snapper', () => {
+        const element = new SModelElement();
+        const updater = new PointPositionUpdater();
+        resetUpdater(updater);
+        expect(updater.updatePosition(element, { x: 0, y: 0 }, false)).to.be.undefined;
+        expect(updater.updatePosition(element, { x: 0, y: 0 }, true)).to.be.undefined;
+
+        resetUpdater(updater);
+        expect(updater.updatePosition(element, { x: 5, y: 3 }, false)).to.be.deep.equals({ x: 5, y: 3 });
+        expect(updater.updatePosition(element, { x: 5, y: 3 }, true)).to.be.undefined;
+        expect(updater.updatePosition(element, { x: 11, y: 6 }, false)).to.be.deep.equals({ x: 6, y: 3 });
+        expect(updater.updatePosition(element, { x: -3, y: 2 }, true)).to.be.deep.equals({ x: -14, y: -4 });
+    });
+
+    it('updatePosition with snapper', () => {
+        const element = new SModelElement();
+        const snapper = new GridSnapper();
+        const updater = new PointPositionUpdater(snapper);
+        resetUpdater(updater);
+        expect(updater.updatePosition(element, { x: 0, y: 0 }, false)).to.be.undefined;
+        expect(updater.updatePosition(element, { x: 0, y: 0 }, true)).to.be.undefined;
+
+        resetUpdater(updater);
+        expect(updater.updatePosition(element, { x: 5, y: 3 }, true)).to.be.deep.equals({ x: 10, y: 0 });
+        expect(updater.updatePosition(element, { x: 5, y: 3 }, true)).to.be.undefined;
+        expect(updater.updatePosition(element, { x: 11, y: 6 }, true)).to.be.deep.equals({ x: 0, y: 10 });
+        expect(updater.updatePosition(element, { x: -3, y: 2 }, true)).to.be.deep.equals({ x: -10, y: -10 });
+
+        // disable snapping (alt key)
+        resetUpdater(updater);
+        expect(updater.updatePosition(element, { x: 5, y: 3 }, false)).to.be.deep.equals({ x: 5, y: 3 });
+        expect(updater.updatePosition(element, { x: 5, y: 3 }, false)).to.be.undefined;
+        expect(updater.updatePosition(element, { x: 11, y: 6 }, false)).to.be.deep.equals({ x: 6, y: 3 });
+        expect(updater.updatePosition(element, { x: -3, y: 2 }, false)).to.be.deep.equals({ x: -14, y: -4 });
+    });
+
+    function resetUpdater(updater: PointPositionUpdater): void {
+        updater.resetPosition();
+        updater.updateLastDragPosition({ x: 0, y: 0 });
+    }
+});

package/src/features/change-bounds/snap.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
@@ -15,7 +15,8 @@
  ********************************************************************************/
 import { Point } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
-import { ISnapper, SModelElement } from 'sprotty';
+import { findParentByFeature, ISnapper, isViewport, SModelElement } from 'sprotty';
+import { WriteablePoint } from '../../utils/layout-utils';
 
 @injectable()
 export class GridSnapper implements ISnapper {
@@ -34,3 +35,86 @@ export class GridSnapper implements ISnapper {
         };
     }
 }
+
+/**
+ * This class can be used to calculate the current position, when an element is
+ * moved. This includes node movements, node resizing (resize handle movement)
+ * or edge routing-point movements.
+ *
+ * You can initialize a this class with a optional {@link ISnapper}. If a
+ * snapper is present, the positions will be snapped to the defined grid.
+ */
+export class PointPositionUpdater {
+    protected lastDragPosition?: Point;
+    protected positionDelta: WriteablePoint = { x: 0, y: 0 };
+
+    constructor(protected snapper?: ISnapper) {}
+
+    /**
+     * Init the position with the {@link Point} of your mouse cursor.
+     * This method is normally called in the `mouseDown` event.
+     * @param mousePosition current mouse position e.g `{x: event.pageX, y: event.pageY }`
+     */
+    public updateLastDragPosition(mousePosition: Point): void {
+        this.lastDragPosition = mousePosition;
+    }
+
+    /**
+     * Check if the mouse is currently not in a drag mode.
+     * @returns true if the last drag position is undefined
+     */
+    public isLastDragPositionUndefined(): boolean {
+        return this.lastDragPosition === undefined;
+    }
+
+    /**
+     * Reset the updater for new movements.
+     * This method is normally called in the `mouseUp` event.
+     */
+    public resetPosition(): void {
+        this.lastDragPosition = undefined;
+        this.positionDelta = { x: 0, y: 0 };
+    }
+
+    /**
+     * Calculate the current position of your movement.
+     * This method is normally called in the `mouseMove` event.
+     * @param target node which is moved around
+     * @param mousePosition current mouse position e.g `{x: event.pageX, y: event.pageY }`
+     * @param isSnapEnabled if a snapper is defined you can disable it, e.g when a specific key is pressed `!event.altKey`
+     * @returns current position or undefined if updater has no last drag position initialized
+     */
+    public updatePosition(target: SModelElement, mousePosition: Point, isSnapEnabled: boolean): Point | undefined {
+        if (this.lastDragPosition) {
+            const newDragPosition = mousePosition;
+
+            const viewport = findParentByFeature(target, isViewport);
+            const zoom = viewport?.zoom ?? 1;
+            const dx = (mousePosition.x - this.lastDragPosition.x) / zoom;
+            const dy = (mousePosition.y - this.lastDragPosition.y) / zoom;
+            const deltaToLastPosition = { x: dx, y: dy };
+            this.lastDragPosition = newDragPosition;
+
+            // update position delta with latest delta
+            this.positionDelta.x += deltaToLastPosition.x;
+            this.positionDelta.y += deltaToLastPosition.y;
+
+            // snap our delta and only send update if the position actually changes
+            // otherwise accumulate delta until we do snap to an update
+            const positionUpdate = this.snap(this.positionDelta, target, isSnapEnabled);
+            if (positionUpdate.x === 0 && positionUpdate.y === 0) {
+                return undefined;
+            }
+
+            // we update our position so we update our delta by the snapped position
+            this.positionDelta.x -= positionUpdate.x;
+            this.positionDelta.y -= positionUpdate.y;
+            return positionUpdate;
+        }
+        return undefined;
+    }
+
+    protected snap(position: Point, element: SModelElement, isSnap: boolean): Point {
+        return isSnap && this.snapper ? this.snapper.snap(position, element) : { x: position.x, y: position.y };
+    }
+}

package/src/features/command-palette/di.config.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 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,12 +13,10 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import '../../../css/command-palette.css';
-
 import { ContainerModule } from 'inversify';
-import { CommandPalette, CommandPaletteActionProviderRegistry, TYPES } from 'sprotty';
-
-import { GLSP_TYPES } from '../../base/types';
+import { CommandPalette, CommandPaletteActionProviderRegistry } from 'sprotty';
+import '../../../css/command-palette.css';
+import { TYPES } from '../../base/types';
 import { CommandPaletteTool } from './command-palette-tool';
 import { ServerCommandPaletteActionProvider } from './server-command-palette-provider';
 
@@ -28,7 +26,7 @@ const glspCommandPaletteModule = new ContainerModule(bind => {
     bind(CommandPaletteActionProviderRegistry).toSelf().inSingletonScope();
     bind(TYPES.ICommandPaletteActionProviderRegistry).toService(CommandPaletteActionProviderRegistry);
     bind(TYPES.ICommandPaletteActionProvider).to(ServerCommandPaletteActionProvider);
-    bind(GLSP_TYPES.IDefaultTool).to(CommandPaletteTool);
+    bind(TYPES.IDefaultTool).to(CommandPaletteTool);
 });
 
 export default glspCommandPaletteModule;

package/src/features/command-palette/server-command-palette-provider.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,11 +13,12 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, isSetContextActionsAction, LabeledAction, Point, RequestContextActions } from '@eclipse-glsp/protocol';
+import { Action, LabeledAction, Point, RequestContextActions, SetContextActions } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { ICommandPaletteActionProvider, SModelElement, TYPES } from 'sprotty';
+import { ICommandPaletteActionProvider, SModelElement } from 'sprotty';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { EditorContextService } from '../../base/editor-context-service';
+import { TYPES } from '../../base/types';
 
 export namespace ServerCommandPalette {
     export const CONTEXT_ID = 'command-palette';
@@ -31,18 +32,18 @@ export class ServerCommandPaletteActionProvider implements ICommandPaletteAction
     @inject(EditorContextService) protected editorContext: EditorContextService;
 
     getActions(_root: Readonly<SModelElement>, text: string, _lastMousePosition?: Point, index?: number): Promise<LabeledAction[]> {
-        const requestAction = new RequestContextActions(
-            ServerCommandPalette.CONTEXT_ID,
-            this.editorContext.get({
+        const requestAction = RequestContextActions.create({
+            contextId: ServerCommandPalette.CONTEXT_ID,
+            editorContext: this.editorContext.get({
                 [ServerCommandPalette.TEXT]: text,
                 [ServerCommandPalette.INDEX]: index ? index : 0
             })
-        );
+        });
         return this.actionDispatcher.requestUntil(requestAction).then(response => this.getPaletteActionsFromResponse(response));
     }
 
     getPaletteActionsFromResponse(action: Action): LabeledAction[] {
-        if (isSetContextActionsAction(action)) {
+        if (SetContextActions.is(action)) {
             return action.actions;
         }
         return [];

package/src/features/context-menu/delete-element-context-menu.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,15 +13,15 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { DeleteElementOperation } from '@eclipse-glsp/protocol';
+import { DeleteElementOperation, Point } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { IContextMenuItemProvider, MenuItem, Point, SModelRoot } from 'sprotty';
+import { IContextMenuItemProvider, MenuItem, SModelRoot } from 'sprotty';
 import { EditorContextService, EditorContextServiceProvider } from '../../base/editor-context-service';
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
 
 @injectable()
 export class DeleteElementContextMenuItemProvider implements IContextMenuItemProvider {
-    @inject(GLSP_TYPES.IEditorContextServiceProvider) editorContextServiceProvider: EditorContextServiceProvider;
+    @inject(TYPES.IEditorContextServiceProvider) editorContextServiceProvider: EditorContextServiceProvider;
 
     async getItems(_root: Readonly<SModelRoot>, _lastMousePosition?: Point): Promise<MenuItem[]> {
         const editorContextService = await this.editorContextServiceProvider();
@@ -34,7 +34,7 @@ export class DeleteElementContextMenuItemProvider implements IContextMenuItemPro
             label: 'Delete',
             sortString: 'd',
             group: 'edit',
-            actions: [new DeleteElementOperation(editorContextService.selectedElements.map(e => e.id))],
+            actions: [DeleteElementOperation.create(editorContextService.selectedElements.map(e => e.id))],
             isEnabled: () => !editorContextService.isReadonly && editorContextService.selectedElements.length > 0
         };
     }

package/src/features/context-menu/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
@@ -14,7 +14,8 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { ContainerModule } from 'inversify';
-import { ContextMenuProviderRegistry, IContextMenuService, TYPES } from 'sprotty';
+import { ContextMenuProviderRegistry, IContextMenuService } from 'sprotty';
+import { TYPES } from '../../base/types';
 import { SelectionServiceAwareContextMenuMouseListener } from './selection-service-aware-context-menu-mouse-listener';
 import { ServerContextMenuItemProvider } from './server-context-menu-provider';