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

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
@@ -20,40 +20,35 @@ import { toAbsoluteBounds } from '../../utils/viewpoint-util';
 import { ModifyCSSFeedbackAction } from '../tool-feedback/css-feedback';
 import { isBoundsAwareMoveable, SResizeHandle } from './model';
 
+/**
+ * A `MovementRestrictor` is an optional service that can be used by tools to validate
+ * whether a certain move operation (e.g. `ChangeBoundsOperation`) in the diagram is valid.
+ */
 export interface IMovementRestrictor {
-    validate(newLocation: Point, element: SModelElement): boolean;
+    /**
+     * Validate whether moving the given element to a new given location is allowed.
+     * @param element The element that should be moved.
+     * @param newLocation The new location of the element.
+     * @returns `true` if the the element is movable and moving to the given location is allowed, `false` otherwise.
+     *          Should also return `false` if the newLocation is `undefined`:
+     */
+    validate(element: SModelElement, newLocation?: Point): boolean;
+    /**
+     * Feedback css-classes. Can be applied to elements that did fail the validation.
+     */
     cssClasses?: string[];
 }
 
-export function createMovementRestrictionFeedback(
-    element: SModelElement,
-    movementRestrictor: IMovementRestrictor
-): ModifyCSSFeedbackAction {
-    const elements: SModelElement[] = [element];
-    if (element instanceof SParentElement) {
-        element.children.filter(child => child instanceof SResizeHandle).forEach(e => elements.push(e));
-    }
-    return new ModifyCSSFeedbackAction(elements, movementRestrictor.cssClasses);
-}
-
-export function removeMovementRestrictionFeedback(
-    element: SModelElement,
-    movementRestrictor: IMovementRestrictor
-): ModifyCSSFeedbackAction {
-    const elements: SModelElement[] = [element];
-    if (element instanceof SParentElement) {
-        element.children.filter(child => child instanceof SResizeHandle).forEach(e => elements.push(e));
-    }
-
-    return new ModifyCSSFeedbackAction(elements, undefined, movementRestrictor.cssClasses);
-}
-
+/**
+ *  A `IMovementRestrictor` that checks for overlapping elements. Move operations
+ *  are only valid if the element does not collide with another element after moving.
+ */
 @injectable()
-export class NoOverlapMovmentRestrictor implements IMovementRestrictor {
+export class NoOverlapMovementRestrictor implements IMovementRestrictor {
     cssClasses = ['movement-not-allowed'];
 
-    validate(newLocation: Point, element: SModelElement): boolean {
-        if (!isBoundsAwareMoveable(element)) {
+    validate(element: SModelElement, newLocation?: Point): boolean {
+        if (!isBoundsAwareMoveable(element) || !newLocation) {
             return false;
         }
         // Create ghost element at the newLocation
@@ -71,27 +66,62 @@ export class NoOverlapMovmentRestrictor implements IMovementRestrictor {
                 .all()
                 .filter(e => e.id !== ghostElement.id && e !== ghostElement.root && e instanceof SNode)
                 .map(e => e as SModelElement & BoundsAware)
-        ).some(e => areOverlapping(e, ghostElement));
+        ).some(e => this.areOverlapping(e, ghostElement));
     }
-}
 
-export function areOverlapping(element1: SModelElement & BoundsAware, element2: SModelElement & BoundsAware): boolean {
-    const b1 = toAbsoluteBounds(element1);
-    const b2 = toAbsoluteBounds(element2);
-    const r1TopLeft: Point = b1;
-    const r1BottomRight = { x: b1.x + b1.width, y: b1.y + b1.height };
-    const r2TopLeft: Point = b2;
-    const r2BottomRight = { x: b2.x + b2.width, y: b2.y + b2.height };
+    protected areOverlapping(element1: SModelElement & BoundsAware, element2: SModelElement & BoundsAware): boolean {
+        const b1 = toAbsoluteBounds(element1);
+        const b2 = toAbsoluteBounds(element2);
+        const r1TopLeft: Point = b1;
+        const r1BottomRight = { x: b1.x + b1.width, y: b1.y + b1.height };
+        const r2TopLeft: Point = b2;
+        const r2BottomRight = { x: b2.x + b2.width, y: b2.y + b2.height };
+
+        // If one rectangle is on left side of other
+        if (r1TopLeft.x > r2BottomRight.x || r2TopLeft.x > r1BottomRight.x) {
+            return false;
+        }
+
+        // If one rectangle is above other
+        if (r1BottomRight.y < r2TopLeft.y || r2BottomRight.y < r1TopLeft.y) {
+            return false;
+        }
 
-    // If one rectangle is on left side of other
-    if (r1TopLeft.x > r2BottomRight.x || r2TopLeft.x > r1BottomRight.x) {
-        return false;
+        return true;
     }
+}
 
-    // If one rectangle is above other
-    if (r1BottomRight.y < r2TopLeft.y || r2BottomRight.y < r1TopLeft.y) {
-        return false;
+/**
+ * Utility function to create an action that applies the given {@link IMovementRestrictor.cssClasses} to the given element.
+ * @param element The element on which the css classes should be applied.
+ * @param movementRestrictor The movement restrictor whose cssClasses should be applied.
+ * @returns The corresponding {@link ModifyCSSFeedbackAction}
+ */
+export function createMovementRestrictionFeedback(
+    element: SModelElement,
+    movementRestrictor: IMovementRestrictor
+): ModifyCSSFeedbackAction {
+    const elements: SModelElement[] = [element];
+    if (element instanceof SParentElement) {
+        element.children.filter(child => child instanceof SResizeHandle).forEach(e => elements.push(e));
+    }
+    return ModifyCSSFeedbackAction.create({ elements, add: movementRestrictor.cssClasses });
+}
+
+/**
+ * Utility function to create an action that removes the given {@link IMovementRestrictor.cssClasses} from the given element.
+ * @param element The element from which the css classes should be removed.
+ * @param movementRestrictor The movement restrictor whose cssClasses should be removed.
+ * @returns The corresponding {@link ModifyCSSFeedbackAction}
+ */
+export function removeMovementRestrictionFeedback(
+    element: SModelElement,
+    movementRestrictor: IMovementRestrictor
+): ModifyCSSFeedbackAction {
+    const elements: SModelElement[] = [element];
+    if (element instanceof SParentElement) {
+        element.children.filter(child => child instanceof SResizeHandle).forEach(e => elements.push(e));
     }
 
-    return true;
+    return ModifyCSSFeedbackAction.create({ elements, remove: movementRestrictor.cssClasses });
 }

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
@@ -13,24 +13,111 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Point } from '@eclipse-glsp/protocol';
+import { Point, Writable } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
-import { ISnapper, SModelElement } from 'sprotty';
+import { findParentByFeature, ISnapper, isViewport, SModelElement } from 'sprotty';
 
+/**
+ * A {@link ISnapper} implementation that snaps all elements onto a fixed gride size.
+ * The default grid size is 10x10 pixel.
+ * To configure a custom grid size  bind the `TYPES.ISnapper` service identifier
+ * to constant value, e.g:
+ *
+ * ```ts
+ * bind(TYPES.ISnapper).toConstantValue(new GridSnapper({x:25 ,y:25 }));
+ * ```
+ */
 @injectable()
 export class GridSnapper implements ISnapper {
-    get gridX(): number {
-        return 10;
-    }
-
-    get gridY(): number {
-        return 10;
-    }
+    constructor(public grid: { x: number; y: number } = { x: 10, y: 10 }) {}
 
     snap(position: Point, element: SModelElement): Point {
         return {
-            x: Math.round(position.x / this.gridX) * this.gridX,
-            y: Math.round(position.y / this.gridY) * this.gridY
+            x: Math.round(position.x / this.grid.x) * this.grid.x,
+            y: Math.round(position.y / this.grid.y) * this.grid.y
         };
     }
 }
+
+/**
+ * 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: Writable<Point> = { 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';