@eclipse-glsp/client 2.6.0-next.436 → 2.6.0-next.6

package/src/base/tool-manager/tool-manager.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2024 EclipseSource and others.
+ * Copyright (c) 2019-2025 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
@@ -133,8 +133,8 @@ export class ToolManager implements IToolManager, IDiagramStartup, IEditModeList
         this.actives.splice(0, this.actives.length);
     }
 
-    enableDefaultTools(): void {
-        if (this.defaultToolsEnabled) {
+    enableDefaultTools(force = false): void {
+        if (this.defaultToolsEnabled && !force) {
             return;
         }
         this.enable(pluck(this.defaultTools, 'id'));
@@ -171,7 +171,7 @@ export class ToolManager implements IToolManager, IDiagramStartup, IEditModeList
         if (newValue === EditMode.READONLY) {
             this.disableEditTools();
         } else if (newValue === EditMode.EDITABLE) {
-            this.enableDefaultTools();
+            this.enableDefaultTools(true);
         }
     }
 }

package/src/default-modules.ts

@@ -47,6 +47,7 @@ import { labelEditModule } from './features/label-edit/label-edit-module';
 import { layoutModule } from './features/layout/layout-module';
 import { navigationModule } from './features/navigation/navigation-module';
 import { routingModule } from './features/routing/routing-module';
+import { searchPaletteDefaultSuggestionsModule, searchPaletteModule } from './features/search-palette/search-palette-module';
 import { selectModule } from './features/select/select-module';
 import { sourceModelWatcherModule } from './features/source-model-watcher/source-model-watcher-module';
 import { statusModule } from './features/status/status-module';
@@ -101,7 +102,9 @@ export const DEFAULT_MODULES = [
     zorderModule,
     svgMetadataModule,
     statusModule,
-    resizeModule
+    resizeModule,
+    searchPaletteModule,
+    searchPaletteDefaultSuggestionsModule
 ] as const;
 
 /**

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

@@ -17,9 +17,8 @@
 import { FeatureModule } from '@eclipse-glsp/sprotty';
 import { configureElementNavigationTool } from './element-navigation/element-navigation-module';
 import { configureFocusTrackerTool } from './focus-tracker/focus-tracker-module';
-import { configureKeyboardControlTools } from './keyboard-pointer/keyboard-pointer-module';
 import { configureKeyboardToolPaletteTool } from './keyboard-tool-palette/keyboard-tool-palette-module';
-import { configureSearchPaletteModule } from './search/search-palette-module';
+import { configureKeyboardControlTools } from './keyboard/keyboard-module';
 import { configureToastTool } from './toast/toast-module';
 import { configureViewKeyTools } from './view-key-tools/view-key-tools-module';
 
@@ -30,7 +29,6 @@ export const accessibilityModule = new FeatureModule(
     (bind, unbind, isBound, rebind) => {
         const context = { bind, unbind, isBound, rebind };
         configureViewKeyTools(context);
-        configureSearchPaletteModule(context);
         configureKeyboardToolPaletteTool(context);
         configureKeyboardControlTools(context);
         configureElementNavigationTool(context);

package/src/features/accessibility/edge-autocomplete/edge-autocomplete-palette.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023-2024 Business Informatics Group (TU Wien) and others.
+ * Copyright (c) 2023-2025 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
@@ -29,76 +29,89 @@ import {
 } from '@eclipse-glsp/sprotty';
 import { injectable } from 'inversify';
 import { CloseReason, toActionArray } from '../../../base/auto-complete/auto-complete-widget';
-import { AutocompleteSuggestion, IAutocompleteSuggestionProvider } from '../../../base/auto-complete/autocomplete-suggestion-providers';
+import { IAutocompleteSuggestionProvider, type AutocompleteSuggestion } from '../../../base/auto-complete/autocomplete-suggestion-provider';
 import { EnableDefaultToolsAction } from '../../../base/tool-manager/tool';
 import { GEdge } from '../../../model';
-import { SearchAutocompletePalette } from '../search/search-palette';
+import { SearchAutocompletePalette, SearchAutocompleteSuggestion } from '../../search-palette/search-palette';
 import { SetEdgeTargetSelectionAction } from './action';
-import { EdgeAutocompleteContext } from './edge-autocomplete-context';
 
 export namespace EdgeAutocompletePaletteMetadata {
     export const ID = 'edge-autocomplete-palette';
 }
 
+export interface EdgeAutocompleteContext {
+    role: 'source' | 'target';
+    triggerAction: TriggerEdgeCreationAction;
+    sourceId?: string;
+    targetId?: string;
+}
+
+export type EdgeAutocompletePaletteStages = 'initial' | 'source' | 'target' | 'reloading';
+
 @injectable()
 export class EdgeAutocompletePalette extends SearchAutocompletePalette implements IActionHandler {
-    protected context?: EdgeAutocompleteContext;
-
-    protected readonly targetSuggestionProvider = new PossibleEdgeTargetAutocompleteSuggestionProvider();
+    protected edgeAutocompleteContext?: EdgeAutocompleteContext;
+    protected stage: EdgeAutocompletePaletteStages = 'initial';
 
     override id(): string {
         return EdgeAutocompletePaletteMetadata.ID;
     }
 
+    override get searchContext(): string[] {
+        return [EdgeAutocompletePaletteMetadata.ID];
+    }
+
     handle(action: Action): Action | void {
         if (TriggerEdgeCreationAction.is(action)) {
-            this.context = {
-                trigger: action,
+            this.stage = 'source';
+            this.edgeAutocompleteContext = {
+                triggerAction: action,
                 role: 'source'
             };
-            this.targetSuggestionProvider.setContext(action, this.context);
         }
     }
 
     protected override onBeforeShow(containerElement: HTMLElement, root: Readonly<GModelRoot>, ...contextElementIds: string[]): void {
         super.onBeforeShow(containerElement, root, ...contextElementIds);
 
-        this.autocompleteWidget.inputField.placeholder = `Search for ${this.context?.role} elements`;
+        this.autocompleteWidget.inputField.placeholder = `Search for ${this.edgeAutocompleteContext?.role} elements`;
     }
 
-    protected override getSuggestionProviders(root: Readonly<GModelRoot>, input: string): IAutocompleteSuggestionProvider[] {
-        return [this.targetSuggestionProvider];
+    protected async reload(): Promise<void> {
+        this.stage = 'reloading';
+        this.hide();
     }
 
-    protected reload(): void {
-        const context = this.context;
-        this.hide();
-        this.context = context;
-        this.actionDispatcher.dispatch(
-            SetUIExtensionVisibilityAction.create({
-                extensionId: EdgeAutocompletePaletteMetadata.ID,
-                visible: true
-            })
-        );
+    protected override async provideSearchSuggestions(root: Readonly<GModelRoot>, input: string): Promise<SearchAutocompleteSuggestion[]> {
+        return (
+            await Promise.all(
+                this.suggestionRegistry
+                    .providersForContext(this.searchContext)
+                    .flatMap(provider => provider.getSuggestions(root, input, this.edgeAutocompleteContext))
+            )
+        )
+            .flat(1)
+            .filter(SearchAutocompleteSuggestion.is);
     }
 
-    protected override executeSuggestion(input: LabeledAction | Action[] | Action): void {
+    protected override async executeSuggestion(input: LabeledAction | Action[] | Action): Promise<void> {
         const action = toActionArray(input)[0] as SetEdgeTargetSelectionAction;
 
-        if (this.context?.role === 'source') {
-            this.context.sourceId = action.elementId;
-            this.context.role = 'target';
+        if (this.edgeAutocompleteContext?.role === 'source') {
+            this.edgeAutocompleteContext.sourceId = action.elementId;
+            this.edgeAutocompleteContext.role = 'target';
             this.reload();
-        } else if (this.context?.role === 'target') {
-            this.context.targetId = action.elementId;
+        } else if (this.edgeAutocompleteContext?.role === 'target') {
+            this.edgeAutocompleteContext.targetId = action.elementId;
         }
-        if (this.context?.sourceId !== undefined && this.context?.targetId !== undefined) {
-            this.actionDispatcher.dispatchAll([
+
+        if (this.edgeAutocompleteContext?.sourceId !== undefined && this.edgeAutocompleteContext?.targetId !== undefined) {
+            await this.actionDispatcher.dispatchAll([
                 CreateEdgeOperation.create({
-                    elementTypeId: this.context.trigger.elementTypeId,
-                    sourceElementId: this.context.sourceId,
-                    targetElementId: this.context.targetId,
-                    args: this.context.trigger.args
+                    elementTypeId: this.edgeAutocompleteContext.triggerAction.elementTypeId,
+                    sourceElementId: this.edgeAutocompleteContext.sourceId,
+                    targetElementId: this.edgeAutocompleteContext.targetId,
+                    args: this.edgeAutocompleteContext.triggerAction.args
                 }),
                 EnableDefaultToolsAction.create()
             ]);
@@ -107,41 +120,51 @@ export class EdgeAutocompletePalette extends SearchAutocompletePalette implement
     }
 
     protected override autocompleteHide(reason: CloseReason): void {
-        if (reason !== 'submission') {
+        if (this.stage === 'reloading') {
+            // Wait until the auto complete is closed before reloading
+            if (reason === 'blur') {
+                this.actionDispatcher.dispatch(
+                    SetUIExtensionVisibilityAction.create({
+                        extensionId: EdgeAutocompletePaletteMetadata.ID,
+                        visible: true
+                    })
+                );
+                this.stage = 'target';
+            }
+        } else if (reason !== 'submission') {
             this.hide();
         }
     }
 }
 
 @injectable()
-export class PossibleEdgeTargetAutocompleteSuggestionProvider implements IAutocompleteSuggestionProvider {
-    protected proxyEdge?: GEdge;
-    protected context?: EdgeAutocompleteContext;
-
-    setContext(triggerAction: TriggerEdgeCreationAction, edgeAutocompleteContext: EdgeAutocompleteContext): void {
-        this.proxyEdge = new GEdge();
-        this.proxyEdge.type = triggerAction.elementTypeId;
-        this.context = edgeAutocompleteContext;
-    }
+export class SetEdgeTargetGridSuggestionProvider implements IAutocompleteSuggestionProvider {
+    id = 'glsp.set-edge-target-autocomplete-suggestions';
 
-    isAllowedSource(element: GModelElement | undefined, role: 'source' | 'target'): boolean {
-        return element !== undefined && this.proxyEdge !== undefined && isConnectable(element) && element.canConnect(this.proxyEdge, role);
+    canHandle(searchContext: string): boolean {
+        return searchContext === EdgeAutocompletePaletteMetadata.ID;
     }
 
-    async retrieveSuggestions(root: Readonly<GModelRoot>, text: string): Promise<AutocompleteSuggestion[]> {
-        const context = this.context;
-        if (this.context === undefined) {
+    async getSuggestions(root: Readonly<GModelRoot>, text: string, context: EdgeAutocompleteContext): Promise<AutocompleteSuggestion[]> {
+        if (context === undefined) {
             return [];
         }
 
-        const nodes = toArray(root.index.all().filter(element => this.isAllowedSource(element, context!.role))) as GEdge[];
+        const proxyEdge = new GEdge();
+        proxyEdge.type = context.triggerAction.elementTypeId;
+
+        const nodes = toArray(root.index.all().filter(element => this.isAllowedSource(proxyEdge, element, context.role))) as GEdge[];
         return nodes.map(node => ({
             element: node,
             action: {
                 label: `[${node.type}] ${name(node) ?? '<no-name>'}`,
-                actions: [SetEdgeTargetSelectionAction.create(node.id, context!.role)],
+                actions: [SetEdgeTargetSelectionAction.create(node.id, context.role)],
                 icon: codiconCSSString('arrow-both')
             }
         }));
     }
+
+    protected isAllowedSource(proxyEdge: GEdge, element: GModelElement | undefined, role: 'source' | 'target'): boolean {
+        return element !== undefined && proxyEdge !== undefined && isConnectable(element) && element.canConnect(proxyEdge, role);
+    }
 }

package/src/features/accessibility/element-navigation/diagram-navigation-tool.ts

@@ -38,7 +38,6 @@ import { GEdge } from '../../../model';
 import { SelectableBoundsAware } from '../../../utils/gmodel-util';
 import { BaseTool } from '../../tools/base-tools';
 import { RepositionAction } from '../../viewport/reposition';
-import { SearchAutocompletePaletteTool } from '../search/search-tool';
 import { ShowToastMessageAction } from '../toast/toast-handler';
 import { ElementNavigator } from './element-navigator';
 
@@ -144,7 +143,7 @@ export class ElementNavigatorKeyListener extends KeyListener {
             if (this.mode !== NavigationMode.POSITION) {
                 this.clean();
                 this.tool.dispatchActions([
-                    EnableToolsAction.create([ElementNavigatorTool.ID, SearchAutocompletePaletteTool.ID, AvailableShortcutsTool.ID]),
+                    EnableToolsAction.create([ElementNavigatorTool.ID, AvailableShortcutsTool.ID]),
                     ShowToastMessageAction.create({
                         id: Symbol.for(ElementNavigatorKeyListener.name),
                         message: messages.navigation.local_navigation_mode_activated
@@ -180,9 +179,8 @@ export class ElementNavigatorKeyListener extends KeyListener {
         if (this.matchesActivateDefaultNavigation(event)) {
             if (this.mode !== NavigationMode.DEFAULT) {
                 this.clean();
-
                 this.tool.dispatchActions([
-                    EnableToolsAction.create([ElementNavigatorTool.ID, SearchAutocompletePaletteTool.ID, AvailableShortcutsTool.ID]),
+                    EnableToolsAction.create([ElementNavigatorTool.ID, AvailableShortcutsTool.ID]),
                     ShowToastMessageAction.create({
                         id: Symbol.for(ElementNavigatorKeyListener.name),
                         message: messages.navigation.default_navigation_mode_activated

package/src/features/accessibility/{keyboard-pointer/keyboard-pointer-module.ts → keyboard/keyboard-module.ts}

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023-2024 Business Informatics Group (TU Wien) and others.
+ * Copyright (c) 2023-2025 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
@@ -23,15 +23,19 @@ import {
     configureActionHandler
 } from '@eclipse-glsp/sprotty';
 import { SetEdgeTargetSelectionAction } from '../edge-autocomplete/action';
-import { EdgeAutocompletePalette } from '../edge-autocomplete/edge-autocomplete-palette';
+import { EdgeAutocompletePalette, SetEdgeTargetGridSuggestionProvider } from '../edge-autocomplete/edge-autocomplete-palette';
 import { EdgeAutocompletePaletteTool } from '../edge-autocomplete/edge-autocomplete-tool';
 import { GlobalKeyListenerTool } from '../global-keylistener-tool';
 import { EnableKeyboardGridAction, KeyboardGridCellSelectedAction } from '../keyboard-grid/action';
 import { KeyboardGrid } from '../keyboard-grid/keyboard-grid';
-import { GridSearchPalette } from '../keyboard-grid/keyboard-grid-search-palette';
+import {
+    GridSearchPalette,
+    RevealGridEdgeSuggestionProvider,
+    RevealGridNamedElementSuggestionProvider
+} from '../keyboard-grid/keyboard-grid-search-palette';
 import { KeyboardNodeGrid } from '../keyboard-grid/keyboard-node-grid';
-import { SetKeyboardPointerRenderPositionAction } from './actions';
-import { KeyboardPointer } from './keyboard-pointer';
+import { SetKeyboardPointerRenderPositionAction } from '../keyboard-pointer/actions';
+import { KeyboardPointer } from '../keyboard-pointer/keyboard-pointer';
 
 /**
  * Handles the pointer used via grid to position new elements.
@@ -55,6 +59,7 @@ export function configureKeyboardControlTools(context: BindingContext): void {
 
     bindAsService(context, TYPES.IUIExtension, EdgeAutocompletePalette);
     bindAsService(context, TYPES.IDefaultTool, EdgeAutocompletePaletteTool);
+    bindAsService(context, TYPES.IAutocompleteSuggestionProvider, SetEdgeTargetGridSuggestionProvider);
 
     configureActionHandler(context, EnableKeyboardGridAction.KIND, KeyboardGrid);
     configureActionHandler(context, KeyboardGridCellSelectedAction.KIND, KeyboardPointer);
@@ -63,4 +68,6 @@ export function configureKeyboardControlTools(context: BindingContext): void {
     configureActionHandler(context, SetEdgeTargetSelectionAction.KIND, EdgeAutocompletePalette);
 
     bindAsService(context, TYPES.IUIExtension, GridSearchPalette);
+    bindAsService(context, TYPES.IAutocompleteSuggestionProvider, RevealGridEdgeSuggestionProvider);
+    bindAsService(context, TYPES.IAutocompleteSuggestionProvider, RevealGridNamedElementSuggestionProvider);
 }

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 Business Informatics Group (TU Wien) and others.
+ * Copyright (c) 2023-2025 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
@@ -15,36 +15,40 @@
  ********************************************************************************/
 import '../../../../css/keyboard.css';
 
-import { Action, GModelElement, GModelRoot, SetUIExtensionVisibilityAction } from '@eclipse-glsp/sprotty';
+import { Action, GModelElement, SetUIExtensionVisibilityAction } from '@eclipse-glsp/sprotty';
 import { injectable } from 'inversify';
-import { IAutocompleteSuggestionProvider } from '../../../base/auto-complete/autocomplete-suggestion-providers';
-import {
-    RevealEdgeElementAutocompleteSuggestionProvider,
-    RevealNamedElementAutocompleteSuggestionProvider,
-    SearchAutocompletePalette
-} from '../search/search-palette';
-import { KeyboardGridMetadata } from './constants';
 import { GEdge } from '../../../model';
-
-export namespace GridSearchPaletteMetadata {
-    export const ID = 'grid-search-palette';
-}
+import { SearchAutocompletePalette } from '../../search-palette/search-palette';
+import { RevealEdgeElementSuggestionProvider } from '../../search-palette/suggestions/edge-element-suggestions';
+import { RevealNamedElementSuggestionProvider } from '../../search-palette/suggestions/named-element-suggestions';
+import { KeyboardGridMetadata } from './constants';
 
 @injectable()
 export class GridSearchPalette extends SearchAutocompletePalette {
+    static override readonly ID: string = 'glsp.grid-search-palette';
+
     override id(): string {
-        return GridSearchPaletteMetadata.ID;
+        return GridSearchPalette.ID;
     }
 
-    protected override getSuggestionProviders(root: Readonly<GModelRoot>, input: string): IAutocompleteSuggestionProvider[] {
-        return [new GridRevealNamedElementSuggestionProvider(), new GridRevealEdgeSuggestionProvider()];
+    override get searchContext(): string[] {
+        return [GridSearchPalette.ID];
     }
 }
 
-export class GridRevealEdgeSuggestionProvider extends RevealEdgeElementAutocompleteSuggestionProvider {
-    protected override getActions(edge: GEdge): Action[] {
+@injectable()
+export class RevealGridEdgeSuggestionProvider extends RevealEdgeElementSuggestionProvider {
+    override get id(): string {
+        return 'glsp.reveal-grid-edge-suggestion';
+    }
+
+    override canHandle(searchContext: string): boolean {
+        return searchContext === GridSearchPalette.ID;
+    }
+
+    protected override createActions(edge: GEdge): Action[] {
         return [
-            ...super.getActions(edge),
+            ...super.createActions(edge),
             SetUIExtensionVisibilityAction.create({
                 extensionId: KeyboardGridMetadata.ID,
                 visible: true
@@ -52,10 +56,20 @@ export class GridRevealEdgeSuggestionProvider extends RevealEdgeElementAutocompl
         ];
     }
 }
-export class GridRevealNamedElementSuggestionProvider extends RevealNamedElementAutocompleteSuggestionProvider {
-    protected override getActions(nameable: GModelElement): Action[] {
+
+@injectable()
+export class RevealGridNamedElementSuggestionProvider extends RevealNamedElementSuggestionProvider {
+    override get id(): string {
+        return 'glsp.reveal-grid-named-element-suggestion';
+    }
+
+    override canHandle(searchContext: string): boolean {
+        return searchContext === GridSearchPalette.ID;
+    }
+
+    protected override createActions(nameable: GModelElement): Action[] {
         return [
-            ...super.getActions(nameable),
+            ...super.createActions(nameable),
             SetUIExtensionVisibilityAction.create({
                 extensionId: KeyboardGridMetadata.ID,
                 visible: true

package/src/features/accessibility/keyboard-grid/keyboard-node-grid.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023-2024 Business Informatics Group (TU Wien) and others.
+ * Copyright (c) 2023-2025 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
@@ -21,7 +21,7 @@ import { KeyboardPointerMetadata } from '../keyboard-pointer/constants';
 import { KeyboardPointer } from '../keyboard-pointer/keyboard-pointer';
 import { KeyboardNodeGridMetadata } from './constants';
 import { KeyboardGrid } from './keyboard-grid';
-import { GridSearchPaletteMetadata } from './keyboard-grid-search-palette';
+import { GridSearchPalette } from './keyboard-grid-search-palette';
 
 @injectable()
 export class KeyboardNodeGrid extends KeyboardGrid {
@@ -52,7 +52,7 @@ export class KeyboardNodeGrid extends KeyboardGrid {
             event.preventDefault();
             this.actionDispatcher.dispatch(
                 SetUIExtensionVisibilityAction.create({
-                    extensionId: GridSearchPaletteMetadata.ID,
+                    extensionId: GridSearchPalette.ID,
                     visible: true
                 })
             );

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

@@ -14,14 +14,16 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { CommandPalette } from '@eclipse-glsp/sprotty';
+import { Bounds, CommandPalette, getWindowScroll, GModelElement, GModelRoot } from '@eclipse-glsp/sprotty';
 import { injectable } from 'inversify';
 import { CSS_HIDDEN_EXTENSION_CLASS, CSS_UI_EXTENSION_CLASS } from '../../base/ui-extension/ui-extension';
+import { getElements, isSelectableAndBoundsAware } from '../../utils/gmodel-util';
 
 @injectable()
 export class GlspCommandPalette extends CommandPalette {
     protected override initializeContents(containerElement: HTMLElement): void {
         super.initializeContents(containerElement);
+        containerElement.style.position = '';
         containerElement.classList.add(CSS_UI_EXTENSION_CLASS);
     }
 
@@ -32,4 +34,42 @@ export class GlspCommandPalette extends CommandPalette {
             this.containerElement?.classList.add(CSS_HIDDEN_EXTENSION_CLASS);
         }
     }
+
+    protected override onBeforeShow(containerElement: HTMLElement, root: Readonly<GModelRoot>, ...selectedElementIds: string[]): void {
+        let x = this.xOffset;
+        let y = this.yOffset;
+
+        const selectedElements = getElements(root.index, selectedElementIds, isSelectableAndBoundsAware);
+        if (selectedElements.length === 1) {
+            const bounds = this.getAbsoluteBounds(selectedElements[0]);
+            x += bounds.x + bounds.width;
+            y += bounds.y;
+        } else {
+            const bounds = this.getAbsoluteBounds(root);
+            x += bounds.x;
+            y += bounds.y;
+        }
+        containerElement.style.left = `${x}px`;
+        containerElement.style.top = `${y}px`;
+        containerElement.style.width = `${this.defaultWidth}px`;
+    }
+
+    protected getAbsoluteBounds(element: Readonly<GModelElement>): Bounds {
+        let x = 0;
+        let y = 0;
+        let width = 0;
+        let height = 0;
+
+        const svgElementId = this.domHelper.createUniqueDOMElementId(element);
+        const svgElement = document.getElementById(svgElementId);
+        if (svgElement) {
+            const rect = svgElement.getBoundingClientRect();
+            const scroll = getWindowScroll();
+            x = rect.left + scroll.x;
+            y = rect.top + scroll.y;
+            width = rect.width;
+            height = rect.height;
+        }
+        return { x, y, width, height };
+    }
 }

package/src/features/context-menu/delete-element-context-menu.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2024 EclipseSource and others.
+ * Copyright (c) 2019-2025 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,10 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { DeleteElementOperation, GModelRoot, IContextMenuItemProvider, MenuItem, Point, TYPES } from '@eclipse-glsp/sprotty';
+import { ClientMenuItem, DeleteElementOperation, GModelRoot, IContextMenuItemProvider, Point, TYPES } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
 import { EditorContextService, EditorContextServiceProvider } from '../../base/editor-context-service';
+import { messages } from '../../base/messages';
 
 @injectable()
 export class DeleteElementContextMenuItemProvider implements IContextMenuItemProvider {
@@ -26,14 +27,17 @@ export class DeleteElementContextMenuItemProvider implements IContextMenuItemPro
     @inject(EditorContextService)
     protected editorContext: EditorContextService;
 
-    async getItems(_root: Readonly<GModelRoot>, _lastMousePosition?: Point): Promise<MenuItem[]> {
+    async getItems(_root: Readonly<GModelRoot>, _lastMousePosition?: Point): Promise<ClientMenuItem[]> {
+        if (this.editorContext.isReadonly) {
+            return [];
+        }
         return [this.createDeleteMenuItem()];
     }
 
-    protected createDeleteMenuItem(): MenuItem {
+    protected createDeleteMenuItem(): ClientMenuItem {
         return {
             id: 'delete',
-            label: 'Delete',
+            label: messages.context_menu.delete,
             sortString: 'd',
             group: 'edit',
             actions: [DeleteElementOperation.create(this.editorContext.selectedElements.map(e => e.id))],

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2024 EclipseSource and others.
+ * Copyright (c) 2019-2025 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,11 +14,11 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import {
-    Action,
+    ClientMenuItem,
     GModelElement,
     IActionDispatcher,
     IContextMenuItemProvider,
-    LabeledAction,
+    MenuItem,
     Point,
     RequestContextActions,
     SetContextActions,
@@ -37,7 +37,7 @@ export class ServerContextMenuItemProvider implements IContextMenuItemProvider {
     @inject(TYPES.IActionDispatcher) protected actionDispatcher: IActionDispatcher;
     @inject(EditorContextService) protected editorContext: EditorContextService;
 
-    async getItems(root: Readonly<GModelElement>, _lastMousePosition?: Point): Promise<LabeledAction[]> {
+    async getItems(root: Readonly<GModelElement>, _lastMousePosition?: Point): Promise<ClientMenuItem[]> {
         const selectedElementIds = Array.from(
             root.index
                 .all()
@@ -50,10 +50,9 @@ export class ServerContextMenuItemProvider implements IContextMenuItemProvider {
         return response ? this.getContextActionsFromResponse(response) : [];
     }
 
-    getContextActionsFromResponse(action: Action): LabeledAction[] {
-        if (SetContextActions.is(action)) {
-            return action.actions;
-        }
-        return [];
+    getContextActionsFromResponse(action: SetContextActions): ClientMenuItem[] {
+        return action.actions
+            .filter(item => MenuItem.is(item)) //
+            .map(item => ClientMenuItem.convert(item));
     }
 }