@eclipse-glsp/client 2.5.0 → 2.6.0-next.11

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/bounds/glsp-hidden-bounds-updater.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2024 EclipseSource and others.
+ * Copyright (c) 2022-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
@@ -65,6 +65,10 @@ export class GLSPHiddenBoundsUpdater extends HiddenBoundsUpdater {
     }
 
     override postUpdate(cause?: Action): void {
+        if (cause === undefined || cause.kind !== RequestBoundsAction.KIND) {
+            return;
+        }
+
         if (LocalRequestBoundsAction.is(cause) && cause.elementIDs) {
             this.focusOnElements(cause.elementIDs);
         }

package/src/features/change-bounds/movement-restrictor.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,11 +13,23 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Bounds, Dimension, GModelElement, GNode, GParentElement, Point, isBoundsAware, isMoveable } from '@eclipse-glsp/sprotty';
+import {
+    Bounds,
+    Dimension,
+    GChildElement,
+    GModelElement,
+    GNode,
+    GParentElement,
+    isBoundsAware,
+    isMoveable,
+    Point,
+    toTypeGuard
+} from '@eclipse-glsp/sprotty';
 import { injectable } from 'inversify';
-import { ModifyCSSFeedbackAction } from '../../base/feedback/css-feedback';
-import { BoundsAwareModelElement } from '../../utils/gmodel-util';
+import { CSS_GHOST_ELEMENT, ModifyCSSFeedbackAction } from '../../base/feedback/css-feedback';
+import { BoundsAwareModelElement, getChildren, getParents } from '../../utils/gmodel-util';
 import { toAbsoluteBounds } from '../../utils/viewpoint-util';
+import { ContainerElement, isContainable } from '../hints/model';
 import { GResizeHandle } from './model';
 
 /**
@@ -39,34 +51,75 @@ export interface IMovementRestrictor {
     cssClasses?: string[];
 }
 
+export interface MoveElementContext {
+    element: GModelElement;
+    elementAtNewLocation: BoundsAwareModelElement;
+    parentContainers: ContainerElement[];
+    childNodes: GNode[];
+}
+
 /**
  *  A `IMovementRestrictor` that checks for overlapping elements. Move operations
- *  are only valid if the element does not collide with another element after moving.
+ *  are only valid if the element does not collide with another element/node after moving.
  */
 @injectable()
 export class NoOverlapMovementRestrictor implements IMovementRestrictor {
     cssClasses = ['movement-not-allowed'];
 
     validate(element: GModelElement, newLocation?: Point): boolean {
-        if (!isMoveable(element) || !newLocation) {
+        if (!(element instanceof GChildElement) || !isMoveable(element) || !newLocation) {
             return false;
         }
-        // Create ghost element at the newLocation
+
+        const moveContext = this.createMoveElementContext(element, newLocation);
+        const elementsToValidate = Array.from(element.root.index.all()).filter(e =>
+            this.isBoundsRelevant(e, moveContext)
+        ) as BoundsAwareModelElement[];
+
+        const valid = !elementsToValidate.some(e => this.areOverlapping(e, moveContext.elementAtNewLocation));
+        return valid;
+    }
+
+    protected createMoveElementContext(element: GModelElement, newLocation: Point): MoveElementContext {
+        const parentContainers = getParents(element, isContainable);
+        const childNodes = getChildren(element, toTypeGuard(GNode));
+        // Create a mock element at the newLocation for overlap checking
         const dimensions: Dimension = isBoundsAware(element) ? element.bounds : { width: 1, height: 1 };
-        const ghostElement = Object.create(element) as BoundsAwareModelElement;
-        ghostElement.bounds = { ...dimensions, ...newLocation };
-        ghostElement.type = 'Ghost';
-        ghostElement.id = element.id;
-        return !Array.from(
-            element.root.index
-                .all()
-                .filter(node => node.id !== ghostElement.id && node !== ghostElement.root && node instanceof GNode)
-                .map(node => node as BoundsAwareModelElement)
-        ).some(e => this.areOverlapping(e, ghostElement));
+        const elementAtNewLocation = Object.create(element) as BoundsAwareModelElement as BoundsAwareModelElement;
+        elementAtNewLocation.bounds = { ...dimensions, ...newLocation };
+
+        return {
+            element,
+            elementAtNewLocation,
+            parentContainers,
+            childNodes
+        };
     }
 
-    protected isBoundsRelevant(element: GModelElement, ghostElement: BoundsAwareModelElement): element is BoundsAwareModelElement {
-        return element.id !== ghostElement.id && element !== ghostElement.root && element instanceof GNode && isBoundsAware(element);
+    protected isBoundsRelevant(element: GModelElement, moveContext: MoveElementContext): element is BoundsAwareModelElement {
+        // Only consider GNodes that are not the element being moved (or one of its children)
+        if (
+            !(element instanceof GNode) ||
+            element.id === moveContext.element.id ||
+            moveContext.childNodes.some(child => child.id === element.id)
+        ) {
+            return false;
+        }
+
+        // Do not consider parent containers of the element being moved
+        if (moveContext.parentContainers.length > 0 && moveContext.parentContainers.some(container => container.id === element.id)) {
+            return false;
+        }
+
+        // If the element is a ghost element (node creation), don't consider overlap checks for potential parent containers
+        if (
+            moveContext.element.cssClasses?.includes(CSS_GHOST_ELEMENT) &&
+            isContainable(element) &&
+            element.isContainableElement(moveContext.element.type)
+        ) {
+            return false;
+        }
+        return true;
     }
 
     protected areOverlapping(element1: BoundsAwareModelElement, element2: BoundsAwareModelElement): boolean {

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

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2023 EclipseSource and others.
+ * Copyright (c) 2020-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,21 +14,23 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 /* eslint-disable deprecation/deprecation */
-import { inject, injectable } from 'inversify';
 import {
     Action,
+    ClientMenuItem,
+    GModelRoot,
     IActionDispatcher,
     IActionHandler,
     IContextMenuItemProvider,
-    MenuItem,
-    Point,
-    GModelRoot,
     MessageAction,
+    Point,
     StatusAction,
     TYPES,
     hasStringProp,
     isSelected
 } from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
+import { EditorContextService } from '../../base/editor-context-service';
+import { messages } from '../../base/messages';
 
 /**
  * An `InvokeCopyPasteAction` is dispatched by the client to initiate a cut, copy or paste operation.
@@ -89,39 +91,41 @@ export class InvokeCopyPasteActionHandler implements IActionHandler {
 
 @injectable()
 export class CopyPasteContextMenuItemProvider implements IContextMenuItemProvider {
-    getItems(root: Readonly<GModelRoot>, _lastMousePosition?: Point): Promise<MenuItem[]> {
+    @inject(EditorContextService)
+    protected editorContext: EditorContextService;
+
+    async getItems(root: Readonly<GModelRoot>, _lastMousePosition?: Point): Promise<ClientMenuItem[]> {
+        if (this.editorContext.isReadonly) {
+            return [];
+        }
         const hasSelectedElements = Array.from(root.index.all().filter(isSelected)).length > 0;
-        return Promise.resolve([
-            this.createCopyMenuItem(hasSelectedElements),
-            this.createCutMenuItem(hasSelectedElements),
-            this.createPasteMenuItem()
-        ]);
+        return [this.createCopyMenuItem(hasSelectedElements), this.createCutMenuItem(hasSelectedElements), this.createPasteMenuItem()];
     }
 
-    protected createPasteMenuItem(): MenuItem {
+    protected createPasteMenuItem(): ClientMenuItem {
         return {
             id: 'paste',
-            label: 'Paste',
+            label: messages.context_menu.paste,
             group: 'copy-paste',
             actions: [InvokeCopyPasteAction.create('paste')],
             isEnabled: () => true
         };
     }
 
-    protected createCutMenuItem(hasSelectedElements: boolean): MenuItem {
+    protected createCutMenuItem(hasSelectedElements: boolean): ClientMenuItem {
         return {
             id: 'cut',
-            label: 'Cut',
+            label: messages.context_menu.cut,
             group: 'copy-paste',
             actions: [InvokeCopyPasteAction.create('cut')],
             isEnabled: () => hasSelectedElements
         };
     }
 
-    protected createCopyMenuItem(hasSelectedElements: boolean): MenuItem {
+    protected createCopyMenuItem(hasSelectedElements: boolean): ClientMenuItem {
         return {
             id: 'copy',
-            label: 'Copy',
+            label: messages.context_menu.copy,
             group: 'copy-paste',
             actions: [InvokeCopyPasteAction.create('copy')],
             isEnabled: () => hasSelectedElements

package/src/features/decoration/decoration-module.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
@@ -20,6 +20,7 @@ import { GlspDecorationPlacer } from './decoration-placer';
 export const decorationModule = new FeatureModule(
     bind => {
         bindAsService(bind, TYPES.IVNodePostprocessor, GlspDecorationPlacer);
+        bind(TYPES.ISvgExportPostprocessor).toService(GlspDecorationPlacer);
     },
     { featureId: Symbol('decoration') }
 );

package/src/features/decoration/decoration-placer.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2023 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,12 +13,37 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Decoration, DecorationPlacer, GChildElement, GModelElement, GRoutableElement, Point, isSizeable } from '@eclipse-glsp/sprotty';
-import { injectable } from 'inversify';
+import {
+    Action,
+    DOMHelper,
+    Decoration,
+    DecorationPlacer,
+    GChildElement,
+    GModelElement,
+    GRoutableElement,
+    ISvgExportPostProcessor,
+    LazyInjector,
+    Point,
+    TYPES,
+    isDecoration,
+    isSizeable
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
+import { EditorContextService } from '../../base/editor-context-service';
+import { filter } from '../../utils/gmodel-util';
 
 @injectable()
-export class GlspDecorationPlacer extends DecorationPlacer {
+export class GlspDecorationPlacer extends DecorationPlacer implements ISvgExportPostProcessor {
     protected static readonly DECORATION_OFFSET: Point = { x: 12, y: 10 };
+    @inject(TYPES.DOMHelper)
+    protected domHelper: DOMHelper;
+
+    @inject(LazyInjector)
+    protected lazyInjector: LazyInjector;
+
+    get editorContextService(): EditorContextService {
+        return this.lazyInjector.get(EditorContextService);
+    }
 
     protected override getPosition(element: GModelElement & Decoration): Point {
         if (element instanceof GChildElement && element.parent instanceof GRoutableElement) {
@@ -32,4 +57,24 @@ export class GlspDecorationPlacer extends DecorationPlacer {
         }
         return Point.ORIGIN;
     }
+    // HiddenVNodePostprocessor implementation
+    override postUpdate(cause?: Action): void;
+    // ISvgExportPostProcessor implementation
+    override postUpdate(element: SVGSVGElement, cause?: Action): void;
+    override postUpdate(elementOrCause?: SVGSVGElement | Action, _cause?: Action): void {
+        // Called as HiddenVNodePostprocessor => no-op
+        if (!elementOrCause || Action.is(elementOrCause)) {
+            return;
+        }
+
+        // Called as ISvgExportPostProcessor
+        // Adjust the position of all decorations in the exported SVG
+        const svg = elementOrCause;
+        const translate = `translate(-${GlspDecorationPlacer.DECORATION_OFFSET.x}px, -${GlspDecorationPlacer.DECORATION_OFFSET.y}px)`;
+        filter(this.editorContextService.modelRoot.index, isDecoration).forEach(decoration => {
+            const domId = this.domHelper.createUniqueDOMElementId(decoration);
+            const element = svg.querySelector<SVGElement>(`#${domId}`);
+            element!.style.transform = translate;
+        });
+    }
 }