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

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,61 @@
  *
  * 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
-} from 'sprotty';
-
-import { GLSP_TYPES } from '../../base/types';
+import { ContextMenuProviderRegistry, IContextMenuServiceProvider, MouseListener, SModelElement } from 'sprotty';
+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;
-
-    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)
-            );
+    @inject(TYPES.IContextMenuServiceProvider)
+    @optional()
+    protected readonly contextMenuService?: IContextMenuServiceProvider;
+
+    @inject(TYPES.IContextMenuProviderRegistry)
+    @optional()
+    protected readonly menuProvider?: ContextMenuProviderRegistry;
+
+    @inject(TYPES.SelectionService)
+    protected selectionService: SelectionService;
+
+    /**
+     * Opens the context menu.
+     */
+    override contextMenu(target: SModelElement, event: MouseEvent): (Action | Promise<Action>)[] {
+        return this.openContextMenu(target, event);
+    }
+
+    /**
+     * Opens the context menu.
+     *
+     *   - 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(target: SModelElement, event: MouseEvent): Promise<Action>[] {
+        if (!this.contextMenuService || !this.menuProvider) {
+            return [];
+        }
+
+        const mousePosition = { x: event.x, y: event.y };
+
+        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();
         }
-        return [];
     }
 }

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();
         }

package/src/features/copy-paste/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
@@ -15,19 +15,13 @@
  ********************************************************************************/
 import { ContainerModule } from 'inversify';
 import { configureActionHandler } from 'sprotty';
-import { GLSP_TYPES } from '../../base/types';
-import {
-    CopyPasteContextMenuItemProvider,
-    InvokeCopyAction,
-    InvokeCopyPasteActionHandler,
-    InvokeCutAction,
-    InvokePasteAction
-} from './copy-paste-context-menu';
+import { TYPES } from '../../base/types';
+import { CopyPasteContextMenuItemProvider, InvokeCopyPasteAction, InvokeCopyPasteActionHandler } from './copy-paste-context-menu';
 import { LocalClipboardService, ServerCopyPasteHandler } from './copy-paste-handler';
 
 export const glspServerCopyPasteModule = new ContainerModule((bind, _unbind, isBound) => {
-    bind(GLSP_TYPES.ICopyPasteHandler).to(ServerCopyPasteHandler);
-    bind(GLSP_TYPES.IAsyncClipboardService).to(LocalClipboardService).inSingletonScope();
+    bind(TYPES.ICopyPasteHandler).to(ServerCopyPasteHandler);
+    bind(TYPES.IAsyncClipboardService).to(LocalClipboardService).inSingletonScope();
 });
 
 /**
@@ -36,9 +30,7 @@ export const glspServerCopyPasteModule = new ContainerModule((bind, _unbind, isB
  * `CopyPasteMenuContribution` in `glsp-theia-integration` instead.
  */
 export const copyPasteContextMenuModule = new ContainerModule((bind, _unbind, isBound) => {
-    bind(GLSP_TYPES.IContextMenuProvider).to(CopyPasteContextMenuItemProvider).inSingletonScope();
+    bind(TYPES.IContextMenuProvider).to(CopyPasteContextMenuItemProvider).inSingletonScope();
     bind(InvokeCopyPasteActionHandler).toSelf().inSingletonScope();
-    configureActionHandler({ bind, isBound }, InvokeCopyAction.KIND, InvokeCopyPasteActionHandler);
-    configureActionHandler({ bind, isBound }, InvokeCutAction.KIND, InvokeCopyPasteActionHandler);
-    configureActionHandler({ bind, isBound }, InvokePasteAction.KIND, InvokeCopyPasteActionHandler);
+    configureActionHandler({ bind, isBound }, InvokeCopyPasteAction.KIND, InvokeCopyPasteActionHandler);
 });

package/src/features/decoration/decoration-placer.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,13 +15,13 @@
  ********************************************************************************/
 import { Point } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
-import { Decoration, DecorationPlacer, isSizeable, ORIGIN_POINT, SChildElement, SModelElement, SRoutableElement } from 'sprotty';
+import { Decoration, DecorationPlacer, isSizeable, SChildElement, SModelElement, SRoutableElement } from 'sprotty';
 
 @injectable()
 export class GlspDecorationPlacer extends DecorationPlacer {
     protected static readonly DECORATION_OFFSET: Point = { x: 12, y: 10 };
 
-    protected getPosition(element: SModelElement & Decoration): Point {
+    protected override getPosition(element: SModelElement & Decoration): Point {
         if (element instanceof SChildElement && element.parent instanceof SRoutableElement) {
             return super.getPosition(element);
         }
@@ -31,6 +31,6 @@ export class GlspDecorationPlacer extends DecorationPlacer {
                 y: GlspDecorationPlacer.DECORATION_OFFSET.y * element.bounds.height
             };
         }
-        return ORIGIN_POINT;
+        return Point.ORIGIN;
     }
 }

package/src/features/decoration/di.config.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,11 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import '../../../css/decoration.css';
-
 import { ContainerModule } from 'inversify';
-import { TYPES } from 'sprotty';
-
+import '../../../css/decoration.css';
+import { TYPES } from '../../base/types';
 import { GlspDecorationPlacer } from './decoration-placer';
 
 const glspDecorationModule = new ContainerModule((bind, _unbind, isBound) => {

package/src/features/edit-label/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
@@ -14,16 +14,15 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { ContainerModule } from 'inversify';
-import { ApplyLabelEditCommand, configureCommand, TYPES } from 'sprotty';
-
-import { GLSP_TYPES } from '../../base/types';
+import { ApplyLabelEditCommand, configureCommand } from 'sprotty';
+import { TYPES } from '../../base/types';
 import { DirectLabelEditTool } from './edit-label-tool';
 import { BalloonLabelValidationDecorator, ServerEditLabelValidator } from './edit-label-validator';
 
 const glspEditLabelModule = new ContainerModule((bind, _unbind, isBound, _rebind) => {
     bind(TYPES.IEditLabelValidator).to(ServerEditLabelValidator);
     bind(TYPES.IEditLabelValidationDecorator).to(BalloonLabelValidationDecorator);
-    bind(GLSP_TYPES.IDefaultTool).to(DirectLabelEditTool);
+    bind(TYPES.IDefaultTool).to(DirectLabelEditTool);
     configureCommand({ bind, isBound }, ApplyLabelEditCommand);
 });
 

package/src/features/edit-label/edit-label-tool.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
@@ -15,7 +15,6 @@
  ********************************************************************************/
 import { injectable } from 'inversify';
 import { EditLabelKeyListener, EditLabelMouseListener, KeyListener, MouseListener } from 'sprotty';
-
 import { BaseGLSPTool } from '../tools/base-glsp-tool';
 
 @injectable()

package/src/features/edit-label/edit-label-validator.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,10 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { isSetEditValidationResultAction, RequestEditValidationAction, ValidationStatus } from '@eclipse-glsp/protocol';
+import { Action, RequestEditValidationAction, SetEditValidationResultAction, ValidationStatus } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import {
-    Action,
     EditableLabel,
     EditLabelValidationResult,
     IEditLabelValidationDecorator,
@@ -25,7 +24,6 @@ import {
     SModelElement,
     TYPES
 } from 'sprotty';
-
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 
 export namespace LabelEditValidation {
@@ -41,11 +39,9 @@ export namespace LabelEditValidation {
         }
         return { message, severity };
     }
-}
 
-export class ValidateLabelEditAction extends RequestEditValidationAction {
-    constructor(value: string, labelId: string) {
-        super(LabelEditValidation.CONTEXT_ID, labelId, value);
+    export function createValidationRequestAction(value: string, labelId: string): RequestEditValidationAction {
+        return RequestEditValidationAction.create({ contextId: CONTEXT_ID, modelElementId: labelId, text: value });
     }
 }
 
@@ -54,12 +50,12 @@ export class ServerEditLabelValidator implements IEditLabelValidator {
     @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
 
     validate(value: string, label: EditableLabel & SModelElement): Promise<EditLabelValidationResult> {
-        const action = new ValidateLabelEditAction(value, label.id);
+        const action = LabelEditValidation.createValidationRequestAction(value, label.id);
         return this.actionDispatcher.requestUntil(action).then(response => this.getValidationResultFromResponse(response));
     }
 
     getValidationResultFromResponse(action: Action): EditLabelValidationResult {
-        if (isSetEditValidationResultAction(action)) {
+        if (SetEditValidationResultAction.is(action)) {
             return LabelEditValidation.toEditLabelValidationResult(action.status);
         }
         return { severity: 'ok' as Severity };

package/src/features/hints/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,12 +16,12 @@
 import { SetTypeHintsAction } from '@eclipse-glsp/protocol';
 import { ContainerModule } from 'inversify';
 import { configureActionHandler, configureCommand } from 'sprotty';
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
 import { ApplyTypeHintsCommand, TypeHintProvider } from './type-hints';
 
 const modelHintsModule = new ContainerModule((bind, _unbind, isBound) => {
     bind(TypeHintProvider).toSelf().inSingletonScope();
-    bind(GLSP_TYPES.ITypeHintProvider).toService(TypeHintProvider);
+    bind(TYPES.ITypeHintProvider).toService(TypeHintProvider);
     configureActionHandler({ bind, isBound }, SetTypeHintsAction.KIND, TypeHintProvider);
     configureCommand({ bind, isBound }, ApplyTypeHintsCommand);
 });

package/src/features/hints/type-hints.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,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, EdgeTypeHint, isSetTypeHintsAction, ShapeTypeHint, TypeHint } from '@eclipse-glsp/protocol';
+import { Action, EdgeTypeHint, SetTypeHintsAction, ShapeTypeHint, TypeHint } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import {
     CommandExecutionContext,
@@ -29,10 +29,9 @@ import {
     SEdge,
     SModelElement,
     SModelRoot,
-    SShapeElement,
-    TYPES
+    SShapeElement
 } from 'sprotty';
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
 import { getElementTypeId, hasCompatibleType } from '../../utils/smodel-util';
 import { resizeFeature } from '../change-bounds/model';
 import { reconnectFeature } from '../reconnect/model';
@@ -40,19 +39,35 @@ import { IFeedbackActionDispatcher } from '../tool-feedback/feedback-action-disp
 import { FeedbackCommand } from '../tool-feedback/model';
 import { Containable, containerFeature, reparentFeature } from './model';
 
-@injectable()
-export class ApplyTypeHintsAction implements Action {
-    readonly kind = ApplyTypeHintsCommand.KIND;
+/**
+ * Is dispatched by the {@link TypeHintProvider} to apply the type hints received from the server
+ * onto the graphical model. The action is dispatched as persistent feedback to ensure the applied type hints
+ * don't get lost after a server-side model update.
+ */
+export interface ApplyTypeHintsAction extends Action {
+    kind: typeof ApplyTypeHintsAction.KIND;
+}
+
+export namespace ApplyTypeHintsAction {
+    export const KIND = 'applyTypeHints';
+
+    export function is(object: any): object is ApplyTypeHintsAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(): ApplyTypeHintsAction {
+        return { kind: KIND };
+    }
 }
 
 @injectable()
 export class ApplyTypeHintsCommand extends FeedbackCommand {
-    public static KIND = 'applyTypeHints';
-    public readonly priority = 10;
+    public static KIND = ApplyTypeHintsAction.KIND;
+    public override readonly priority = 10;
 
-    @inject(GLSP_TYPES.ITypeHintProvider) protected typeHintProvider: ITypeHintProvider;
+    @inject(TYPES.ITypeHintProvider) protected typeHintProvider: ITypeHintProvider;
 
-    constructor(@inject(TYPES.Action) protected action: ApplyTypeHintsAction) {
+    constructor(@inject(TYPES.Action) protected action: Action) {
         super();
     }
 
@@ -69,7 +84,7 @@ export class ApplyTypeHintsCommand extends FeedbackCommand {
 
     protected applyEdgeTypeHint(element: SModelElement): void {
         const hint = this.typeHintProvider.getEdgeTypeHint(element);
-        if (hint && isModifiableFetureSet(element.features)) {
+        if (hint && isModifiableFeatureSet(element.features)) {
             addOrRemove(element.features, deletableFeature, hint.deletable);
             addOrRemove(element.features, editFeature, hint.routable);
             addOrRemove(element.features, reconnectFeature, hint.repositionable);
@@ -78,7 +93,7 @@ export class ApplyTypeHintsCommand extends FeedbackCommand {
 
     protected applyShapeTypeHint(element: SModelElement): void {
         const hint = this.typeHintProvider.getShapeTypeHint(element);
-        if (hint && isModifiableFetureSet(element.features)) {
+        if (hint && isModifiableFeatureSet(element.features)) {
             addOrRemove(element.features, deletableFeature, hint.deletable);
             addOrRemove(element.features, moveFeature, hint.repositionable);
             addOrRemove(element.features, resizeFeature, hint.resizable);
@@ -119,7 +134,7 @@ function addOrRemove(features: Set<symbol>, feature: symbol, add: boolean): void
     }
 }
 
-function isModifiableFetureSet(featureSet?: FeatureSet): featureSet is FeatureSet & Set<symbol> {
+function isModifiableFeatureSet(featureSet?: FeatureSet): featureSet is FeatureSet & Set<symbol> {
     return featureSet !== undefined && featureSet instanceof Set;
 }
 
@@ -131,17 +146,17 @@ export interface ITypeHintProvider {
 
 @injectable()
 export class TypeHintProvider implements IActionHandler, ITypeHintProvider {
-    @inject(GLSP_TYPES.IFeedbackActionDispatcher)
+    @inject(TYPES.IFeedbackActionDispatcher)
     protected feedbackActionDispatcher: IFeedbackActionDispatcher;
 
     protected shapeHints: Map<string, ShapeTypeHint> = new Map();
     protected edgeHints: Map<string, EdgeTypeHint> = new Map();
 
     handle(action: Action): ICommand | Action | void {
-        if (isSetTypeHintsAction(action)) {
+        if (SetTypeHintsAction.is(action)) {
             action.shapeHints.forEach(hint => this.shapeHints.set(hint.elementTypeId, hint));
             action.edgeHints.forEach(hint => this.edgeHints.set(hint.elementTypeId, hint));
-            this.feedbackActionDispatcher.registerFeedback(this, [new ApplyTypeHintsAction()]);
+            this.feedbackActionDispatcher.registerFeedback(this, [ApplyTypeHintsAction.create()]);
         }
     }