@eclipse-glsp/client 0.9.0 → 0.10.0-next.17bfb07.173

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,9 +13,9 @@
  *
  * 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';
 
 @injectable()
 export class GridSnapper implements ISnapper {
@@ -34,3 +34,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: 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';
 

package/src/features/context-menu/selection-service-aware-context-menu-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
@@ -13,39 +13,67 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Action } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
 import {
-    Action,
     ContextMenuProviderRegistry,
     findParentByFeature,
     IContextMenuServiceProvider,
     isSelectable,
     MouseListener,
-    SModelElement,
-    TYPES
+    SModelElement
 } from 'sprotty';
-
-import { GLSP_TYPES } from '../../base/types';
+import { FocusStateChangedAction } from '../../base/actions/focus-change-action';
+import { TYPES } from '../../base/types';
 import { SelectionService } from '../select/selection-service';
 
 @injectable()
 export class SelectionServiceAwareContextMenuMouseListener extends MouseListener {
     @inject(TYPES.IContextMenuServiceProvider) @optional() protected readonly contextMenuService: IContextMenuServiceProvider;
     @inject(TYPES.IContextMenuProviderRegistry) @optional() protected readonly menuProvider: ContextMenuProviderRegistry;
-    @inject(GLSP_TYPES.SelectionService) protected selectionService: SelectionService;
+    @inject(TYPES.SelectionService) protected selectionService: SelectionService;
 
-    mouseDown(target: SModelElement, event: MouseEvent): (Action | Promise<Action>)[] {
+    /**
+     * Opens the context menu on right-click.
+     */
+    override mouseDown(target: SModelElement, event: MouseEvent): (Action | Promise<Action>)[] {
         if (event.button === 2 && this.contextMenuService && this.menuProvider) {
-            const mousePosition = { x: event.x, y: event.y };
-            const selectableTarget = findParentByFeature(target, isSelectable);
-            if (selectableTarget) {
-                selectableTarget.selected = true;
-                this.selectionService.updateSelection(target.root, [selectableTarget.id], []);
-            }
-            Promise.all([this.contextMenuService(), this.menuProvider.getItems(target.root, mousePosition)]).then(
-                ([menuService, menuItems]) => menuService.show(menuItems, mousePosition)
-            );
+            return this.openContextMenu(event, target);
         }
         return [];
     }
+
+    /**
+     * Opens the context menu.
+     *
+     *   - query the element on the click-target
+     *   - select the element
+     *   - query the context menu service and the context menu elements
+     *   - show the context menu
+     *   - send a focus state change to indicate that the diagram becomes inactive, once the context menu is shown
+     *
+     * When the context menu is closed, we focus the diagram element again.
+     */
+    protected openContextMenu(event: MouseEvent, target: SModelElement): Promise<Action>[] {
+        const mousePosition = { x: event.x, y: event.y };
+        const selectableTarget = findParentByFeature(target, isSelectable);
+        if (selectableTarget) {
+            selectableTarget.selected = true;
+            this.selectionService.updateSelection(target.root, [selectableTarget.id], []);
+        }
+
+        const result = Promise.all([this.contextMenuService(), this.menuProvider.getItems(target.root, mousePosition)])
+            .then(([menuService, menuItems]) => menuService.show(menuItems, mousePosition, () => this.focusEventTarget(event)))
+            .then((): Action => FocusStateChangedAction.create(false));
+
+        return [result];
+    }
+
+    protected focusEventTarget(event: MouseEvent): void {
+        const targetElement = event.target instanceof SVGElement ? event.target : undefined;
+        const svgParentElement = targetElement?.closest('svg');
+        if (svgParentElement) {
+            svgParentElement.focus();
+        }
+    }
 }

package/src/features/context-menu/server-context-menu-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 { IContextMenuItemProvider, isSelected, SModelElement, TYPES } from 'sprotty';
+import { IContextMenuItemProvider, isSelected, SModelElement } from 'sprotty';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { EditorContextService } from '../../base/editor-context-service';
+import { TYPES } from '../../base/types';
 
 export namespace ServerContextMenu {
     export const CONTEXT_ID = 'context-menu';
@@ -35,13 +36,13 @@ export class ServerContextMenuItemProvider implements IContextMenuItemProvider {
                 .filter(isSelected)
                 .map(e => e.id)
         );
-        const context = this.editorContext.getWithSelection(selectedElementIds);
-        const requestAction = new RequestContextActions(ServerContextMenu.CONTEXT_ID, context);
+        const editorContext = this.editorContext.getWithSelection(selectedElementIds);
+        const requestAction = RequestContextActions.create({ contextId: ServerContextMenu.CONTEXT_ID, editorContext });
         return this.actionDispatcher.requestUntil(requestAction).then(response => this.getContextActionsFromResponse(response));
     }
 
     getContextActionsFromResponse(action: Action): LabeledAction[] {
-        if (isSetContextActionsAction(action)) {
+        if (SetContextActions.is(action)) {
             return action.actions;
         }
         return [];

package/src/features/copy-paste/copy-paste-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,45 +13,52 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, GLSPServerStatusAction, Point, ServerMessageAction } from '@eclipse-glsp/protocol';
+/* eslint-disable deprecation/deprecation */
+import { Action, hasStringProp, Point, ServerMessageAction, ServerStatusAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { IActionDispatcher, IActionHandler, IContextMenuItemProvider, isSelected, MenuItem, SModelRoot, TYPES } from 'sprotty';
+import { IActionDispatcher, IActionHandler, IContextMenuItemProvider, isSelected, MenuItem, SModelRoot } from 'sprotty';
+import { TYPES } from '../../base/types';
 
-export class InvokeCopyAction implements Action {
-    static readonly KIND = 'invoke-copy';
-    constructor(public readonly kind = InvokeCopyAction.KIND) {}
+/**
+ * An `InvokeCopyPasteAction` is dispatched by the client to initiate a cut, copy or paste operation.
+ */
+export interface InvokeCopyPasteAction extends Action {
+    kind: typeof InvokeCopyPasteAction.KIND;
+    command: 'copy' | 'cut' | 'paste';
 }
 
-export class InvokePasteAction implements Action {
-    static readonly KIND = 'invoke-paste';
-    constructor(public readonly kind = InvokePasteAction.KIND) {}
-}
+export namespace InvokeCopyPasteAction {
+    export const KIND = 'invokeCopyPaste';
+
+    export function is(object: any): object is InvokeCopyPasteAction {
+        return Action.hasKind(object, KIND) && hasStringProp(object, 'command');
+    }
 
-export class InvokeCutAction implements Action {
-    static readonly KIND = 'invoke-cut';
-    constructor(public readonly kind = InvokeCutAction.KIND) {}
+    export function create(command: 'copy' | 'cut' | 'paste'): InvokeCopyPasteAction {
+        return { kind: KIND, command };
+    }
 }
 
 @injectable()
 export class InvokeCopyPasteActionHandler implements IActionHandler {
     @inject(TYPES.IActionDispatcher) protected dispatcher: IActionDispatcher;
-    handle(action: Action): void {
-        switch (action.kind) {
-            case InvokeCopyAction.KIND:
+    handle(action: InvokeCopyPasteAction): void {
+        switch (action.command) {
+            case 'copy':
                 if (supportsCopy()) {
                     document.execCommand('copy');
                 } else {
                     this.notifyUserToUseShortcut('copy');
                 }
                 break;
-            case InvokePasteAction.KIND:
+            case 'paste':
                 if (supportsPaste()) {
                     document.execCommand('paste');
                 } else {
                     this.notifyUserToUseShortcut('paste');
                 }
                 break;
-            case InvokeCutAction.KIND:
+            case 'cut':
                 if (supportsCut()) {
                     document.execCommand('cut');
                 } else {
@@ -66,8 +73,8 @@ export class InvokeCopyPasteActionHandler implements IActionHandler {
         const timeout = 10000;
         const severity = 'WARNING';
         this.dispatcher.dispatchAll([
-            { kind: GLSPServerStatusAction.KIND, severity, timeout, message } as GLSPServerStatusAction,
-            { kind: ServerMessageAction.KIND, severity, timeout, message } as ServerMessageAction
+            ServerStatusAction.create(message, { severity, timeout }),
+            ServerMessageAction.create(message, { severity, timeout })
         ]);
     }
 }
@@ -88,7 +95,7 @@ export class CopyPasteContextMenuItemProvider implements IContextMenuItemProvide
             id: 'paste',
             label: 'Paste',
             group: 'copy-paste',
-            actions: [new InvokePasteAction()],
+            actions: [InvokeCopyPasteAction.create('paste')],
             isEnabled: () => true
         };
     }
@@ -98,7 +105,7 @@ export class CopyPasteContextMenuItemProvider implements IContextMenuItemProvide
             id: 'cut',
             label: 'Cut',
             group: 'copy-paste',
-            actions: [new InvokeCutAction()],
+            actions: [InvokeCopyPasteAction.create('cut')],
             isEnabled: () => hasSelectedElements
         };
     }
@@ -108,7 +115,7 @@ export class CopyPasteContextMenuItemProvider implements IContextMenuItemProvide
             id: 'copy',
             label: 'Copy',
             group: 'copy-paste',
-            actions: [new InvokeCopyAction()],
+            actions: [InvokeCopyPasteAction.create('copy')],
             isEnabled: () => hasSelectedElements
         };
     }

package/src/features/copy-paste/copy-paste-handler.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,11 +15,11 @@
  ********************************************************************************/
 import { ClipboardData, CutOperation, PasteOperation, RequestClipboardDataAction, SetClipboardDataAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { TYPES, ViewerOptions } from 'sprotty';
+import { ViewerOptions } from 'sprotty';
 import { v4 as uuid } from 'uuid';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { EditorContextService } from '../../base/editor-context-service';
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
 
 export interface ICopyPasteHandler {
     handleCopy(event: ClipboardEvent): void;
@@ -96,7 +96,7 @@ const CLIPBOARD_DATA_FORMAT = 'text/plain';
 export class ServerCopyPasteHandler implements ICopyPasteHandler {
     @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
     @inject(TYPES.ViewerOptions) protected viewerOptions: ViewerOptions;
-    @inject(GLSP_TYPES.IAsyncClipboardService) protected clipboadService: IAsyncClipboardService;
+    @inject(TYPES.IAsyncClipboardService) protected clipboadService: IAsyncClipboardService;
     @inject(EditorContextService) protected editorContext: EditorContextService;
 
     handleCopy(event: ClipboardEvent): void {
@@ -118,7 +118,7 @@ export class ServerCopyPasteHandler implements ICopyPasteHandler {
     handleCut(event: ClipboardEvent): void {
         if (event.clipboardData && this.shouldCopy(event)) {
             this.handleCopy(event);
-            this.actionDispatcher.dispatch(new CutOperation(this.editorContext.get()));
+            this.actionDispatcher.dispatch(CutOperation.create(this.editorContext.get()));
             event.preventDefault();
         }
     }
@@ -128,7 +128,7 @@ export class ServerCopyPasteHandler implements ICopyPasteHandler {
             const clipboardId = getClipboardIdFromDataTransfer(event.clipboardData);
             const clipboardData = this.clipboadService.get(clipboardId);
             if (clipboardData) {
-                this.actionDispatcher.dispatch(new PasteOperation(clipboardData, this.editorContext.get()));
+                this.actionDispatcher.dispatch(PasteOperation.create({ clipboardData, editorContext: this.editorContext.get() }));
             }
             event.preventDefault();
         }