@eclipse-glsp/client 1.1.0-next.383e4e9.264 → 1.1.0-next.3d1b3e6.280

package/src/features/accessibility/search/search-palette.ts

@@ -35,6 +35,7 @@ import { AutocompleteSuggestion, IAutocompleteSuggestionProvider } from '../../a
 import { BaseAutocompletePalette } from '../../autocomplete-palette/base-autocomplete-palette';
 
 import { applyCssClasses, deleteCssClasses } from '../../../base/feedback/css-feedback';
+import { RepositionAction } from '../../../features/viewport/reposition';
 
 const CSS_SEARCH_HIDDEN = 'search-hidden';
 const CSS_SEARCH_HIGHLIGHTED = 'search-highlighted';
@@ -103,6 +104,7 @@ export class SearchAutocompletePalette extends BaseAutocompletePalette {
         super.initializeContents(containerElement);
 
         this.autocompleteWidget.inputField.placeholder = 'Search for elements';
+        containerElement.setAttribute('aria-label', 'Search Field');
     }
     protected getSuggestionProviders(root: Readonly<SModelRoot>, input: string): IAutocompleteSuggestionProvider[] {
         return [new RevealNamedElementAutocompleteSuggestionProvider(), new RevealEdgeElementAutocompleteSuggestionProvider()];
@@ -132,8 +134,8 @@ export class SearchAutocompletePalette extends BaseAutocompletePalette {
         if (labeledAction !== undefined) {
             const suggestions = this.getSuggestionsFromLabeledActions([labeledAction]);
 
-            const actions: CenterAction[] = [];
-            suggestions.map(currElem => actions.push(CenterAction.create([currElem.element.id], { animate: true, retainZoom: true })));
+            const actions: RepositionAction[] = [];
+            suggestions.map(currElem => actions.push(RepositionAction.create([currElem.element.id])));
 
             this.actionDispatcher.dispatchAll(actions);
             await this.applyCSS(

package/src/features/accessibility/search/search-tool.ts

@@ -16,8 +16,9 @@
 
 import { inject, injectable } from 'inversify';
 import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
-import { Action, KeyListener, KeyTool, SetUIExtensionVisibilityAction, SModelElement, Tool, TYPES } from '~glsp-sprotty';
+import { Action, KeyListener, KeyTool, SModelElement, SetUIExtensionVisibilityAction, TYPES } from '~glsp-sprotty';
 import { GLSPActionDispatcher } from '../../../base/action-dispatcher';
+import { Tool } from '../../../base/tool-manager/tool';
 import { AccessibleKeyShortcutProvider, SetAccessibleKeyShortcutAction } from '../key-shortcut/accessible-key-shortcut';
 import { SearchAutocompletePalette } from './search-palette';
 @injectable()
@@ -50,14 +51,12 @@ export class SearchAutocompletePaletteKeyListener extends KeyListener implements
     }
 
     registerShortcutKey(): void {
-        this.tool.actionDispatcher.onceModelInitialized().then(() => {
-            this.tool.actionDispatcher.dispatchAll([
-                SetAccessibleKeyShortcutAction.create({
-                    token: this.token,
-                    keys: [{ shortcuts: ['CTRL', 'F'], description: 'Activate search for elements', group: 'Search', position: 0 }]
-                })
-            ]);
-        });
+        this.tool.actionDispatcher.dispatchOnceModelInitialized(
+            SetAccessibleKeyShortcutAction.create({
+                token: this.token,
+                keys: [{ shortcuts: ['CTRL', 'F'], description: 'Activate search for elements', group: 'Search', position: 0 }]
+            })
+        );
     }
 
     override keyDown(element: SModelElement, event: KeyboardEvent): Action[] {

package/src/features/accessibility/toast/messages.json

@@ -0,0 +1,16 @@
+{
+  "navigation": {
+    "default_navigation_mode_activated": "Navigation On: Use arrow keys to select preceding (←) or succeding (→) elements. Use the up (↑) and down (↓) arrows to navigate paths. Press 'N' to exit.",
+    "default_navigation_mode_deactivated": "Navigation Off: Press 'N' for default navigation, 'ALT+N' for position based navigation.",
+    "local_navigation_mode_activated": "Position based Nav On: Navigate nearest elements using arrow keys: (↑) for above, (↓) for below, (←) for previous, (→) for next element. Press 'ALT+N' to exit.",
+    "local_navigation_mode_deactivated": "Position based Nav Off: Press 'N' for default navigation, 'ALT+N' for position based navigation."
+  },
+  "focus": {
+    "focus_on": "Currently focused: ",
+    "focus_off": "Currently no element is focused."
+  },
+  "resize": {
+    "resize_mode_activated": "Resize On: Use plus(+) and minus(-) to resize, 'CTRL'+'0' for default size. Press 'ESC' to exit.",
+    "resize_mode_deactivated": "Resize Off: Press 'ALT'+'A' for resize mode."
+  }
+}

package/src/features/accessibility/toast/toast-handler.ts

@@ -0,0 +1,69 @@
+/********************************************************************************
+ * Copyright (c) 2023 Business Informatics Group (TU Wien) 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 } from '~glsp-sprotty';
+
+export interface HideToastAction extends Action {
+    kind: typeof HideToastAction.KIND;
+    options: HideToastAction.Options;
+}
+
+export namespace HideToastAction {
+    export const KIND = 'hideToastMessageAction';
+
+    export type Options = Pick<ToastOptions, 'id' | 'timeout'>;
+
+    export function is(object: any): object is HideToastAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(options: Options): HideToastAction {
+        return { kind: KIND, options };
+    }
+}
+
+export interface ShowToastMessageAction extends Action {
+    kind: typeof ShowToastMessageAction.KIND;
+    options: ToastOptions;
+}
+
+export namespace ShowToastMessageAction {
+    export const KIND = 'showToastMessageAction';
+    export const TIMEOUT = 2000;
+
+    export type CreateOptions = Partial<ToastOptions> & Required<Pick<ToastOptions, 'message'>>;
+
+    export function is(object: any): object is ShowToastMessageAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(options: CreateOptions): ShowToastMessageAction {
+        return { kind: KIND, options: { ...options, position: options.position ?? 'center', id: options.id ?? Symbol('toast id') } };
+    }
+    export function createWithTimeout(options: CreateOptions): ShowToastMessageAction {
+        return {
+            kind: KIND,
+            options: { timeout: TIMEOUT, ...options, position: options.position ?? 'center', id: options.id ?? Symbol('toast id') }
+        };
+    }
+}
+
+export interface ToastOptions {
+    id: symbol;
+    timeout?: number;
+    position: 'left' | 'center' | 'right';
+    message: string;
+}

package/src/features/accessibility/toast/toast-module.ts

@@ -0,0 +1,36 @@
+/********************************************************************************
+ * Copyright (c) 2023 Business Informatics Group (TU Wien) 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 { ContainerModule } from 'inversify';
+import { bindAsService, BindingContext, configureActionHandler, TYPES } from '~glsp-sprotty';
+import '../../../../css/toast.css';
+import { HideToastAction, ShowToastMessageAction } from './toast-handler';
+import { Toast } from './toast-tool';
+
+/**
+ * Handles toast/user notification actions.
+ */
+
+export const glspToastModule = new ContainerModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    configureToastTool(context);
+});
+
+export function configureToastTool(context: BindingContext): void {
+    bindAsService(context, TYPES.IUIExtension, Toast);
+    context.bind(TYPES.IDiagramStartup).toService(Toast);
+    configureActionHandler(context, ShowToastMessageAction.KIND, Toast);
+    configureActionHandler(context, HideToastAction.KIND, Toast);
+}

package/src/features/accessibility/toast/toast-tool.ts

@@ -0,0 +1,108 @@
+/********************************************************************************
+ * Copyright (c) 2023 Business Informatics Group (TU Wien) 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 { injectable, inject } from 'inversify';
+import { Action, AbstractUIExtension, IActionHandler, ICommand, TYPES } from '~glsp-sprotty';
+import { IDiagramStartup } from '../../../base/model/diagram-loader';
+import { GLSPActionDispatcher } from '../../../base/action-dispatcher';
+import { EditorContextService } from '../../../base/editor-context-service';
+import { HideToastAction, ShowToastMessageAction, ToastOptions } from './toast-handler';
+
+/**
+ * This extension is used to create customized user notifications as toast messages.
+ */
+@injectable()
+export class Toast extends AbstractUIExtension implements IActionHandler, IDiagramStartup {
+    static readonly ID = 'toast';
+    protected messages: { [key: symbol]: ToastOptions } = {};
+
+    @inject(TYPES.IActionDispatcher) protected readonly actionDispatcher: GLSPActionDispatcher;
+    @inject(EditorContextService)
+    protected editorContext: EditorContextService;
+
+    id(): string {
+        return Toast.ID;
+    }
+    containerClass(): string {
+        return Toast.ID;
+    }
+
+    protected initializeContents(_containerElement: HTMLElement): void {
+        this.render();
+    }
+
+    handle(action: Action): ICommand | Action | void {
+        if (ShowToastMessageAction.is(action)) {
+            this.messages[action.options.id] = action.options;
+            this.render();
+
+            if (action.options.timeout) {
+                setTimeout(() => {
+                    this.delete(action.options.id);
+                }, action.options.timeout);
+            }
+        } else if (HideToastAction.is(action)) {
+            if (action.options.timeout) {
+                setTimeout(() => {
+                    this.delete(action.options.id);
+                }, action.options.timeout);
+            } else {
+                this.delete(action.options.id);
+            }
+        }
+    }
+
+    protected render(): void {
+        if (this.containerElement === undefined) {
+            return;
+        }
+
+        this.containerElement.innerHTML = '';
+
+        this.values(this.messages).forEach(message => {
+            this.containerElement.appendChild(this.createToastMessage(message));
+        });
+    }
+
+    protected delete(id: symbol): void {
+        delete this.messages[id];
+        this.render();
+    }
+
+    protected createToastMessage(option: ToastOptions): HTMLDivElement {
+        const cell = document.createElement('div');
+        cell.classList.add('toast-cell', `toast-column-${option.position}`);
+
+        const container = document.createElement('div');
+        container.classList.add('toast-container');
+
+        const text = document.createElement('span');
+        text.textContent = option.message;
+
+        container.appendChild(text);
+        cell.appendChild(container);
+
+        return cell;
+    }
+
+    preInitialize(): void {
+        this.show(this.editorContext.modelRoot);
+    }
+
+    values(obj: { [key: symbol]: ToastOptions }): ToastOptions[] {
+        return Object.getOwnPropertySymbols(obj).map(s => obj[s]);
+    }
+}

package/src/features/accessibility/view-key-tools/deselect-key-tool.ts

@@ -27,14 +27,14 @@ import {
     SwitchEditModeAction,
     isSelectable
 } from '~glsp-sprotty';
-import { GLSPTool } from '../../../base/tool-manager/glsp-tool-manager';
+import { Tool } from '../../../base/tool-manager/tool';
 import { SResizeHandle } from '../../change-bounds/model';
 
 /**
  * Deselects the element if there is no interaction possible with element.
  */
 @injectable()
-export class DeselectKeyTool implements GLSPTool {
+export class DeselectKeyTool implements Tool {
     static ID = 'glsp.deselect-key-tool';
 
     isEditTool = true;

package/src/features/accessibility/view-key-tools/movement-key-tool.ts

@@ -19,7 +19,7 @@ import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
 import { Action, ISnapper, KeyListener, KeyTool, SModelElement, TYPES } from '~glsp-sprotty';
 import { GLSPActionDispatcher } from '../../../base/action-dispatcher';
 import { SelectionService } from '../../../base/selection-service';
-import { GLSPTool } from '../../../base/tool-manager/glsp-tool-manager';
+import { Tool } from '../../../base/tool-manager/tool';
 import { GridSnapper } from '../../change-bounds/snap';
 import { AccessibleKeyShortcutProvider, SetAccessibleKeyShortcutAction } from '../key-shortcut/accessible-key-shortcut';
 import { MoveElementAction, MoveViewportAction } from '../move-zoom/move-handler';
@@ -28,7 +28,7 @@ import { MoveElementAction, MoveViewportAction } from '../move-zoom/move-handler
  * Moves viewport and elements when its focused and arrow keys are hit.
  */
 @injectable()
-export class MovementKeyTool implements GLSPTool {
+export class MovementKeyTool implements Tool {
     static ID = 'glsp.movement-key-tool';
 
     isEditTool = true;
@@ -74,14 +74,12 @@ export class MoveKeyListener extends KeyListener implements AccessibleKeyShortcu
     }
 
     registerShortcutKey(): void {
-        this.tool.actionDispatcher.onceModelInitialized().then(() => {
-            this.tool.actionDispatcher.dispatchAll([
-                SetAccessibleKeyShortcutAction.create({
-                    token: this.token,
-                    keys: [{ shortcuts: ['⬅  ⬆  ➡  ⬇'], description: 'Move element or viewport', group: 'Move', position: 0 }]
-                })
-            ]);
-        });
+        this.tool.actionDispatcher.dispatchOnceModelInitialized(
+            SetAccessibleKeyShortcutAction.create({
+                token: this.token,
+                keys: [{ shortcuts: ['⬅  ⬆  ➡  ⬇'], description: 'Move element or viewport', group: 'Move', position: 0 }]
+            })
+        );
     }
 
     override keyDown(element: SModelElement, event: KeyboardEvent): Action[] {

package/src/features/accessibility/view-key-tools/zoom-key-tool.ts

@@ -19,7 +19,7 @@ import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
 import { Action, CenterAction, KeyListener, KeyTool, SModelElement, TYPES } from '~glsp-sprotty';
 import { GLSPActionDispatcher } from '../../../base/action-dispatcher';
 import { SelectionService } from '../../../base/selection-service';
-import { GLSPTool } from '../../../base/tool-manager/glsp-tool-manager';
+import { Tool } from '../../../base/tool-manager/tool';
 import { SetAccessibleKeyShortcutAction } from '../key-shortcut/accessible-key-shortcut';
 import { ZoomElementAction, ZoomViewportAction } from '../move-zoom/zoom-handler';
 
@@ -27,7 +27,7 @@ import { ZoomElementAction, ZoomViewportAction } from '../move-zoom/zoom-handler
  * Zoom viewport and elements when its focused and arrow keys are hit.
  */
 @injectable()
-export class ZoomKeyTool implements GLSPTool {
+export class ZoomKeyTool implements Tool {
     static ID = 'glsp.zoom-key-tool';
 
     isEditTool = false;
@@ -62,19 +62,17 @@ export class ZoomKeyListener extends KeyListener {
     }
 
     registerShortcutKey(): void {
-        this.tool.actionDispatcher.onceModelInitialized().then(() => {
-            this.tool.actionDispatcher.dispatchAll([
-                SetAccessibleKeyShortcutAction.create({
-                    token: this.token,
-                    keys: [
-                        { shortcuts: ['+'], description: 'Zoom in to element or viewport', group: 'Zoom', position: 0 },
-                        { shortcuts: ['-'], description: 'Zoom out to element or viewport', group: 'Zoom', position: 1 },
-                        { shortcuts: ['CTRL', '0'], description: 'Reset zoom to default', group: 'Zoom', position: 2 },
-                        { shortcuts: ['CTRL', '+'], description: 'Zoom in via Grid', group: 'Zoom', position: 3 }
-                    ]
-                })
-            ]);
-        });
+        this.tool.actionDispatcher.dispatchOnceModelInitialized(
+            SetAccessibleKeyShortcutAction.create({
+                token: this.token,
+                keys: [
+                    { shortcuts: ['+'], description: 'Zoom in to element or viewport', group: 'Zoom', position: 0 },
+                    { shortcuts: ['-'], description: 'Zoom out to element or viewport', group: 'Zoom', position: 1 },
+                    { shortcuts: ['CTRL', '0'], description: 'Reset zoom to default', group: 'Zoom', position: 2 },
+                    { shortcuts: ['CTRL', '+'], description: 'Zoom in via Grid', group: 'Zoom', position: 3 }
+                ]
+            })
+        );
     }
 
     override keyDown(element: SModelElement, event: KeyboardEvent): Action[] {

package/src/features/bounds/bounds-module.ts

@@ -18,7 +18,6 @@ import {
     HBoxLayouter,
     HiddenBoundsUpdater,
     LayoutRegistry,
-    Layouter,
     RequestBoundsCommand,
     SetBoundsCommand,
     TYPES,
@@ -30,6 +29,7 @@ import {
 import { FreeFormLayouter } from './freeform-layout';
 import { GLSPHiddenBoundsUpdater } from './glsp-hidden-bounds-updater';
 import { HBoxLayouterExt } from './hbox-layout';
+import { LayouterExt } from './layouter';
 import { VBoxLayouterExt } from './vbox-layout';
 
 export const boundsModule = new FeatureModule((bind, _unbind, isBound, _rebind) => {
@@ -38,7 +38,7 @@ export const boundsModule = new FeatureModule((bind, _unbind, isBound, _rebind)
     configureCommand(context, RequestBoundsCommand);
     bind(HiddenBoundsUpdater).toSelf().inSingletonScope();
     bindAsService(context, TYPES.HiddenVNodePostprocessor, GLSPHiddenBoundsUpdater);
-    bind(TYPES.Layouter).to(Layouter).inSingletonScope();
+    bind(TYPES.Layouter).to(LayouterExt).inSingletonScope();
     bind(TYPES.LayoutRegistry).to(LayoutRegistry).inSingletonScope();
 
     configureLayout(context, VBoxLayouter.KIND, VBoxLayouterExt);

package/src/features/command-palette/command-palette-tool.ts

@@ -14,7 +14,8 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { inject, injectable, postConstruct } from 'inversify';
-import { CommandPaletteKeyListener, KeyListener, KeyTool, Tool } from '~glsp-sprotty';
+import { CommandPaletteKeyListener, KeyListener, KeyTool } from '~glsp-sprotty';
+import { Tool } from '../../base/tool-manager/tool';
 
 @injectable()
 export class CommandPaletteTool implements Tool {

package/src/features/command-palette/server-command-palette-provider.ts

@@ -38,7 +38,7 @@ export class ServerCommandPaletteActionProvider implements ICommandPaletteAction
     @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
     @inject(EditorContextService) protected editorContext: EditorContextService;
 
-    getActions(_root: Readonly<SModelElement>, text: string, _lastMousePosition?: Point, index?: number): Promise<LabeledAction[]> {
+    async getActions(_root: Readonly<SModelElement>, text: string, _lastMousePosition?: Point, index?: number): Promise<LabeledAction[]> {
         const requestAction = RequestContextActions.create({
             contextId: ServerCommandPalette.CONTEXT_ID,
             editorContext: this.editorContext.get({
@@ -46,7 +46,8 @@ export class ServerCommandPaletteActionProvider implements ICommandPaletteAction
                 [ServerCommandPalette.INDEX]: index ? index : 0
             })
         });
-        return this.actionDispatcher.requestUntil(requestAction).then(response => this.getPaletteActionsFromResponse(response));
+        const response = await this.actionDispatcher.requestUntil(requestAction);
+        return response ? this.getPaletteActionsFromResponse(response) : [];
     }
 
     getPaletteActionsFromResponse(action: Action): LabeledAction[] {

package/src/features/context-menu/context-menu-module.ts

@@ -14,21 +14,20 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { ContextMenuProviderRegistry, FeatureModule, IContextMenuService, TYPES, bindAsService } from '~glsp-sprotty';
-import { SelectionServiceAwareContextMenuMouseListener } from './selection-service-aware-context-menu-mouse-listener';
+import { GLSPContextMenuMouseListener } from './glsp-context-menu-mouse-listener';
 import { ServerContextMenuItemProvider } from './server-context-menu-provider';
 
 export const contextMenuModule = new FeatureModule(bind => {
-    bind(TYPES.IContextMenuServiceProvider).toProvider<IContextMenuService>(
-        ctx => () =>
-            new Promise<IContextMenuService>((resolve, reject) => {
-                if (ctx.container.isBound(TYPES.IContextMenuService)) {
-                    resolve(ctx.container.get<IContextMenuService>(TYPES.IContextMenuService));
-                } else {
-                    reject();
-                }
-            })
-    );
-    bindAsService(bind, TYPES.MouseListener, SelectionServiceAwareContextMenuMouseListener);
+    bind(TYPES.IContextMenuServiceProvider).toProvider<IContextMenuService>(ctx => async () => {
+        if (ctx.container.isBound(TYPES.IContextMenuService)) {
+            return ctx.container.get<IContextMenuService>(TYPES.IContextMenuService);
+        }
+        console.warn("'TYPES.IContextMenuService' is not bound. Use no-op implementation instead");
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        return { show: () => {} };
+    });
+
+    bindAsService(bind, TYPES.MouseListener, GLSPContextMenuMouseListener);
     bind(TYPES.IContextMenuProviderRegistry).to(ContextMenuProviderRegistry);
     bindAsService(bind, TYPES.IContextMenuItemProvider, ServerContextMenuItemProvider);
 });

package/src/features/context-menu/{selection-service-aware-context-menu-mouse-listener.ts → glsp-context-menu-mouse-listener.ts}

@@ -16,10 +16,9 @@
 import { inject, injectable, optional } from 'inversify';
 import { Action, ContextMenuProviderRegistry, IContextMenuServiceProvider, MouseListener, SModelElement, TYPES } from '~glsp-sprotty';
 import { FocusStateChangedAction } from '../../base/focus/focus-state-change-action';
-import { SelectionService } from '../../base/selection-service';
 
 @injectable()
-export class SelectionServiceAwareContextMenuMouseListener extends MouseListener {
+export class GLSPContextMenuMouseListener extends MouseListener {
     @inject(TYPES.IContextMenuServiceProvider)
     @optional()
     protected readonly contextMenuService?: IContextMenuServiceProvider;
@@ -28,9 +27,6 @@ export class SelectionServiceAwareContextMenuMouseListener extends MouseListener
     @optional()
     protected readonly menuProvider?: ContextMenuProviderRegistry;
 
-    @inject(SelectionService)
-    protected selectionService: SelectionService;
-
     /**
      * Opens the context menu.
      */

package/src/features/context-menu/server-context-menu-provider.ts

@@ -37,7 +37,7 @@ export class ServerContextMenuItemProvider implements IContextMenuItemProvider {
     @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
     @inject(EditorContextService) protected editorContext: EditorContextService;
 
-    getItems(root: Readonly<SModelElement>, lastMousePosition?: Point): Promise<LabeledAction[]> {
+    async getItems(root: Readonly<SModelElement>, _lastMousePosition?: Point): Promise<LabeledAction[]> {
         const selectedElementIds = Array.from(
             root.index
                 .all()
@@ -46,7 +46,8 @@ export class ServerContextMenuItemProvider implements IContextMenuItemProvider {
         );
         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));
+        const response = await this.actionDispatcher.requestUntil(requestAction);
+        return response ? this.getContextActionsFromResponse(response) : [];
     }
 
     getContextActionsFromResponse(action: Action): LabeledAction[] {

package/src/features/copy-paste/copy-paste-context-menu.ts

@@ -23,8 +23,8 @@ import {
     MenuItem,
     Point,
     SModelRoot,
-    ServerMessageAction,
-    ServerStatusAction,
+    MessageAction,
+    StatusAction,
     TYPES,
     hasStringProp,
     isSelected
@@ -83,10 +83,7 @@ export class InvokeCopyPasteActionHandler implements IActionHandler {
         const message = `Please use the browser's ${operation} command or shortcut.`;
         const timeout = 10000;
         const severity = 'WARNING';
-        this.dispatcher.dispatchAll([
-            ServerStatusAction.create(message, { severity, timeout }),
-            ServerMessageAction.create(message, { severity })
-        ]);
+        this.dispatcher.dispatchAll([StatusAction.create(message, { severity, timeout }), MessageAction.create(message, { severity })]);
     }
 }
 

package/src/features/hints/type-hints-module.ts

@@ -13,12 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { FeatureModule, SetTypeHintsAction, TYPES, configureActionHandler, configureCommand } from '~glsp-sprotty';
+import { FeatureModule, SetTypeHintsAction, TYPES, bindAsService, configureActionHandler, configureCommand } from '~glsp-sprotty';
 import { ApplyTypeHintsCommand, TypeHintProvider } from './type-hints';
 
-export const typeHintsModule = new FeatureModule((bind, _unbind, isBound) => {
-    bind(TypeHintProvider).toSelf().inSingletonScope();
-    bind(TYPES.ITypeHintProvider).toService(TypeHintProvider);
-    configureActionHandler({ bind, isBound }, SetTypeHintsAction.KIND, TypeHintProvider);
-    configureCommand({ bind, isBound }, ApplyTypeHintsCommand);
+export const typeHintsModule = new FeatureModule((bind, unbind, isBound) => {
+    const context = { bind, unbind, isBound };
+    bindAsService(context, TYPES.ITypeHintProvider, TypeHintProvider);
+    bind(TYPES.IDiagramStartup).toService(TypeHintProvider);
+    configureActionHandler(context, SetTypeHintsAction.KIND, TypeHintProvider);
+    configureCommand(context, ApplyTypeHintsCommand);
 });

package/src/features/hints/type-hints.ts

@@ -23,6 +23,8 @@ import {
     FeatureSet,
     IActionHandler,
     ICommand,
+    MaybePromise,
+    RequestTypeHintsAction,
     SEdge,
     SModelElement,
     SModelRoot,
@@ -36,8 +38,10 @@ import {
     editFeature,
     moveFeature
 } from '~glsp-sprotty';
+import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { IFeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
 import { FeedbackCommand } from '../../base/feedback/feedback-command';
+import { IDiagramStartup } from '../../base/model/diagram-loader';
 import { getElementTypeId, hasCompatibleType } from '../../utils/smodel-util';
 import { resizeFeature } from '../change-bounds/model';
 import { reconnectFeature } from '../reconnect/model';
@@ -149,10 +153,13 @@ export interface ITypeHintProvider {
 }
 
 @injectable()
-export class TypeHintProvider implements IActionHandler, ITypeHintProvider {
+export class TypeHintProvider implements IActionHandler, ITypeHintProvider, IDiagramStartup {
     @inject(TYPES.IFeedbackActionDispatcher)
     protected feedbackActionDispatcher: IFeedbackActionDispatcher;
 
+    @inject(GLSPActionDispatcher)
+    protected actionDispatcher: GLSPActionDispatcher;
+
     protected shapeHints: Map<string, ShapeTypeHint> = new Map();
     protected edgeHints: Map<string, EdgeTypeHint> = new Map();
 
@@ -192,6 +199,10 @@ export class TypeHintProvider implements IActionHandler, ITypeHintProvider {
     getEdgeTypeHint(input: SModelElement | SModelElement | string): EdgeTypeHint | undefined {
         return getTypeHint(input, this.edgeHints);
     }
+
+    postRequestModel(): MaybePromise<void> {
+        this.actionDispatcher.dispatch(RequestTypeHintsAction.create());
+    }
 }
 
 function getTypeHint<T extends TypeHint>(input: SModelElement | SModelElement | string, hints: Map<string, T>): T | undefined {

package/src/features/hover/hover-module.ts

@@ -16,8 +16,6 @@
 import {
     CenterCommand,
     ClosePopupActionHandler,
-    EnableDefaultToolsAction,
-    EnableToolsAction,
     FeatureModule,
     FitToScreenCommand,
     HoverFeedbackCommand,
@@ -34,6 +32,7 @@ import {
     configureCommand
 } from '~glsp-sprotty';
 import { FocusStateChangedAction } from '../../base/focus/focus-state-change-action';
+import { EnableDefaultToolsAction, EnableToolsAction } from '../../base/tool-manager/tool';
 import { GlspHoverMouseListener } from './hover';
 
 export const hoverModule = new FeatureModule((bind, _unbind, isBound) => {