@eclipse-glsp/client 1.1.0-next.fdfeeeb.193 → 2.1.0-next.12ca798.289

package/src/features/change-bounds/snap.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2022 EclipseSource and others.
+ * Copyright (c) 2020-2023 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,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Point, Writable } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
-import { findParentByFeature, ISnapper, isViewport, SModelElement } from 'sprotty';
+import { ISnapper, Point, GModelElement, Writable, findParentByFeature, isViewport } from '@eclipse-glsp/sprotty';
 
 /**
  * A {@link ISnapper} implementation that snaps all elements onto a fixed gride size.
@@ -31,7 +30,7 @@ import { findParentByFeature, ISnapper, isViewport, SModelElement } from 'sprott
 export class GridSnapper implements ISnapper {
     constructor(public grid: { x: number; y: number } = { x: 10, y: 10 }) {}
 
-    snap(position: Point, element: SModelElement): Point {
+    snap(position: Point, element: GModelElement): Point {
         return {
             x: Math.round(position.x / this.grid.x) * this.grid.x,
             y: Math.round(position.y / this.grid.y) * this.grid.y
@@ -87,7 +86,7 @@ export class PointPositionUpdater {
      * @param isSnapEnabled if a snapper is defined you can disable it, e.g when a specific key is pressed `!event.altKey`
      * @returns current position or undefined if updater has no last drag position initialized
      */
-    public updatePosition(target: SModelElement, mousePosition: Point, isSnapEnabled: boolean): Point | undefined {
+    public updatePosition(target: GModelElement, mousePosition: Point, isSnapEnabled: boolean): Point | undefined {
         if (this.lastDragPosition) {
             const newDragPosition = mousePosition;
 
@@ -117,7 +116,7 @@ export class PointPositionUpdater {
         return undefined;
     }
 
-    protected snap(position: Point, element: SModelElement, isSnap: boolean): Point {
+    protected snap(position: Point, element: GModelElement, isSnap: boolean): Point {
         return isSnap && this.snapper ? this.snapper.snap(position, element) : { x: position.x, y: position.y };
     }
 }

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

@@ -0,0 +1,26 @@
+/********************************************************************************
+ * Copyright (c) 2019-2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { CommandPalette, CommandPaletteActionProviderRegistry, FeatureModule, TYPES, bindAsService } from '@eclipse-glsp/sprotty';
+import '../../../css/command-palette.css';
+import { CommandPaletteTool } from './command-palette-tool';
+import { ServerCommandPaletteActionProvider } from './server-command-palette-provider';
+
+export const commandPaletteModule = new FeatureModule(bind => {
+    bindAsService(bind, TYPES.IUIExtension, CommandPalette);
+    bind(TYPES.ICommandPaletteActionProviderRegistry).to(CommandPaletteActionProviderRegistry).inSingletonScope();
+    bindAsService(bind, TYPES.ICommandPaletteActionProvider, ServerCommandPaletteActionProvider);
+    bindAsService(bind, TYPES.IDefaultTool, CommandPaletteTool);
+});

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020 EclipseSource and others.
+ * Copyright (c) 2019-2023 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -14,7 +14,8 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { inject, injectable, postConstruct } from 'inversify';
-import { CommandPaletteKeyListener, KeyListener, KeyTool, Tool } from 'sprotty';
+import { CommandPaletteKeyListener, KeyListener, KeyTool } from '@eclipse-glsp/sprotty';
+import { Tool } from '../../base/tool-manager/tool';
 
 @injectable()
 export class CommandPaletteTool implements Tool {
@@ -25,7 +26,7 @@ export class CommandPaletteTool implements Tool {
 
     @postConstruct()
     protected postConstruct(): void {
-        this.commandPaletteKeyListener = this.createCommandPaleteKeyListener();
+        this.commandPaletteKeyListener = this.createCommandPaletteKeyListener();
     }
 
     get id(): string {
@@ -40,7 +41,7 @@ export class CommandPaletteTool implements Tool {
         this.keyTool.deregister(this.commandPaletteKeyListener);
     }
 
-    protected createCommandPaleteKeyListener(): KeyListener {
+    protected createCommandPaletteKeyListener(): KeyListener {
         return new CommandPaletteKeyListener();
     }
 }

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2022 EclipseSource and others.
+ * Copyright (c) 2019-2023 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,19 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, LabeledAction, Point, RequestContextActions, SetContextActions } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { ICommandPaletteActionProvider, SModelElement } from 'sprotty';
+import {
+    Action,
+    ICommandPaletteActionProvider,
+    LabeledAction,
+    Point,
+    RequestContextActions,
+    GModelElement,
+    SetContextActions,
+    TYPES
+} from '@eclipse-glsp/sprotty';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { EditorContextService } from '../../base/editor-context-service';
-import { TYPES } from '../../base/types';
 
 export namespace ServerCommandPalette {
     export const CONTEXT_ID = 'command-palette';
@@ -31,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<GModelElement>, text: string, _lastMousePosition?: Point, index?: number): Promise<LabeledAction[]> {
         const requestAction = RequestContextActions.create({
             contextId: ServerCommandPalette.CONTEXT_ID,
             editorContext: this.editorContext.get({
@@ -39,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

@@ -0,0 +1,33 @@
+/********************************************************************************
+ * Copyright (c) 2019-2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { ContextMenuProviderRegistry, FeatureModule, IContextMenuService, TYPES, bindAsService } from '@eclipse-glsp/sprotty';
+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 => 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/delete-element-context-menu.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2022 EclipseSource and others.
+ * Copyright (c) 2019-2023 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,17 +13,15 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { DeleteElementOperation, Point } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { IContextMenuItemProvider, MenuItem, SModelRoot } from 'sprotty';
+import { DeleteElementOperation, IContextMenuItemProvider, MenuItem, Point, GModelRoot, TYPES } from '@eclipse-glsp/sprotty';
 import { EditorContextService, EditorContextServiceProvider } from '../../base/editor-context-service';
-import { TYPES } from '../../base/types';
 
 @injectable()
 export class DeleteElementContextMenuItemProvider implements IContextMenuItemProvider {
     @inject(TYPES.IEditorContextServiceProvider) editorContextServiceProvider: EditorContextServiceProvider;
 
-    async getItems(_root: Readonly<SModelRoot>, _lastMousePosition?: Point): Promise<MenuItem[]> {
+    async getItems(_root: Readonly<GModelRoot>, _lastMousePosition?: Point): Promise<MenuItem[]> {
         const editorContextService = await this.editorContextServiceProvider();
         return [this.createDeleteMenuItem(editorContextService)];
     }

package/src/features/context-menu/glsp-context-menu-mouse-listener.ts

@@ -0,0 +1,106 @@
+/********************************************************************************
+ * Copyright (c) 2019-2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import {
+    Action,
+    ContextMenuProviderRegistry,
+    GModelElement,
+    IContextMenuService,
+    IContextMenuServiceProvider,
+    MouseListener,
+    SelectAction,
+    TYPES,
+    findParentByFeature,
+    isSelectable
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable, optional, postConstruct } from 'inversify';
+import { GLSPActionDispatcher } from '../../base/action-dispatcher';
+import { FocusStateChangedAction } from '../../base/focus/focus-state-change-action';
+
+@injectable()
+export class GLSPContextMenuMouseListener extends MouseListener {
+    @inject(TYPES.IContextMenuServiceProvider)
+    @optional()
+    protected contextMenuServiceProvider?: IContextMenuServiceProvider;
+
+    @inject(TYPES.IContextMenuProviderRegistry)
+    @optional()
+    protected menuProvider?: ContextMenuProviderRegistry;
+
+    @inject(GLSPActionDispatcher)
+    protected actionDispatcher: GLSPActionDispatcher;
+
+    protected menuService?: IContextMenuService;
+
+    @postConstruct()
+    protected initialize(): void {
+        this.contextMenuServiceProvider?.().then(menuService => (this.menuService = menuService));
+    }
+
+    /**
+     * Opens the context menu.
+     */
+    override contextMenu(target: GModelElement, event: MouseEvent): (Action | Promise<Action>)[] {
+        return this.openContextMenu(target, event);
+    }
+
+    /**
+     * Opens the context menu.
+     *
+     *   - update selection state (if context menu target is selectable)
+     *   - 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: GModelElement, event: MouseEvent): Promise<Action>[] {
+        if (!this.menuService || !this.menuProvider) {
+            return [];
+        }
+
+        return [this.showContextMenuItems(target, event)];
+    }
+
+    protected async showContextMenuItems(target: GModelElement, event: MouseEvent): Promise<Action> {
+        await this.handleContextElementSelection(target, event);
+        const mousePosition = { x: event.x, y: event.y };
+
+        const menuItems = await this.menuProvider!.getItems(target.root, mousePosition);
+        this.menuService!.show(menuItems, mousePosition, () => this.focusEventTarget(event));
+        return FocusStateChangedAction.create(false);
+    }
+
+    // Clear selection the context menu target is not selectable
+    // Otherwise either maintain current selection if target is already selected or single select the current target.
+    protected async handleContextElementSelection(target: GModelElement, event: MouseEvent): Promise<void> {
+        const selectableTarget = findParentByFeature(target, isSelectable);
+        if (!selectableTarget) {
+            return this.actionDispatcher.dispatch(SelectAction.setSelection([]));
+        }
+        if (!selectableTarget.selected) {
+            return this.actionDispatcher.dispatch(SelectAction.setSelection([selectableTarget.id]));
+        }
+        return;
+    }
+
+    protected focusEventTarget(event: MouseEvent): void {
+        const targetElement = event.target instanceof SVGElement ? event.target : undefined;
+        const svgParentElement = targetElement?.closest('svg');
+        if (svgParentElement) {
+            svgParentElement.focus();
+        }
+    }
+}

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2022 EclipseSource and others.
+ * Copyright (c) 2019-2023 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,20 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, LabeledAction, Point, RequestContextActions, SetContextActions } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { IContextMenuItemProvider, isSelected, SModelElement } from 'sprotty';
+import {
+    Action,
+    IContextMenuItemProvider,
+    LabeledAction,
+    Point,
+    RequestContextActions,
+    GModelElement,
+    SetContextActions,
+    TYPES,
+    isSelected
+} from '@eclipse-glsp/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';
@@ -29,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<GModelElement>, _lastMousePosition?: Point): Promise<LabeledAction[]> {
         const selectedElementIds = Array.from(
             root.index
                 .all()
@@ -38,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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2022 EclipseSource and others.
+ * Copyright (c) 2020-2023 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,10 +14,21 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 /* 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 } from 'sprotty';
-import { TYPES } from '../../base/types';
+import {
+    Action,
+    IActionDispatcher,
+    IActionHandler,
+    IContextMenuItemProvider,
+    MenuItem,
+    Point,
+    GModelRoot,
+    MessageAction,
+    StatusAction,
+    TYPES,
+    hasStringProp,
+    isSelected
+} from '@eclipse-glsp/sprotty';
 
 /**
  * An `InvokeCopyPasteAction` is dispatched by the client to initiate a cut, copy or paste operation.
@@ -72,16 +83,13 @@ 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, timeout })
-        ]);
+        this.dispatcher.dispatchAll([StatusAction.create(message, { severity, timeout }), MessageAction.create(message, { severity })]);
     }
 }
 
 @injectable()
 export class CopyPasteContextMenuItemProvider implements IContextMenuItemProvider {
-    getItems(root: Readonly<SModelRoot>, _lastMousePosition?: Point): Promise<MenuItem[]> {
+    getItems(root: Readonly<GModelRoot>, _lastMousePosition?: Point): Promise<MenuItem[]> {
         const hasSelectedElements = Array.from(root.index.all().filter(isSelected)).length > 0;
         return Promise.resolve([
             this.createCopyMenuItem(hasSelectedElements),

package/src/features/copy-paste/copy-paste-handler.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2022 EclipseSource and others.
+ * Copyright (c) 2019-2023 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,13 +13,19 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { ClipboardData, CutOperation, PasteOperation, RequestClipboardDataAction, SetClipboardDataAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { ViewerOptions } from 'sprotty';
 import { v4 as uuid } from 'uuid';
+import {
+    ClipboardData,
+    CutOperation,
+    PasteOperation,
+    RequestClipboardDataAction,
+    SetClipboardDataAction,
+    TYPES,
+    ViewerOptions
+} from '@eclipse-glsp/sprotty';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { EditorContextService } from '../../base/editor-context-service';
-import { TYPES } from '../../base/types';
 
 export interface ICopyPasteHandler {
     handleCopy(event: ClipboardEvent): void;
@@ -96,7 +102,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(TYPES.IAsyncClipboardService) protected clipboadService: IAsyncClipboardService;
+    @inject(TYPES.IAsyncClipboardService) protected clipboardService: IAsyncClipboardService;
     @inject(EditorContextService) protected editorContext: EditorContextService;
 
     handleCopy(event: ClipboardEvent): void {
@@ -105,13 +111,13 @@ export class ServerCopyPasteHandler implements ICopyPasteHandler {
             event.clipboardData.setData(CLIPBOARD_DATA_FORMAT, toClipboardId(clipboardId));
             this.actionDispatcher
                 .request<SetClipboardDataAction>(RequestClipboardDataAction.create(this.editorContext.get()))
-                .then(action => this.clipboadService.put(action.clipboardData, clipboardId));
+                .then(action => this.clipboardService.put(action.clipboardData, clipboardId));
             event.preventDefault();
         } else {
             if (event.clipboardData) {
                 event.clipboardData.clearData();
             }
-            this.clipboadService.clear();
+            this.clipboardService.clear();
         }
     }
 
@@ -126,7 +132,7 @@ export class ServerCopyPasteHandler implements ICopyPasteHandler {
     handlePaste(event: ClipboardEvent): void {
         if (event.clipboardData && this.shouldPaste(event)) {
             const clipboardId = getClipboardIdFromDataTransfer(event.clipboardData);
-            const clipboardData = this.clipboadService.get(clipboardId);
+            const clipboardData = this.clipboardService.get(clipboardId);
             if (clipboardData) {
                 this.actionDispatcher.dispatch(PasteOperation.create({ clipboardData, editorContext: this.editorContext.get() }));
             }
@@ -134,19 +140,15 @@ export class ServerCopyPasteHandler implements ICopyPasteHandler {
         }
     }
 
-    protected shouldCopy(_event: ClipboardEvent): boolean | null {
+    protected shouldCopy(_event: ClipboardEvent): boolean {
         return this.editorContext.get().selectedElementIds.length > 0 && this.isDiagramActive();
     }
 
-    protected shouldPaste(_event: ClipboardEvent): boolean | null {
+    protected shouldPaste(_event: ClipboardEvent): boolean {
         return this.isDiagramActive();
     }
 
-    private isDiagramActive(): boolean | null {
-        return (
-            document.activeElement instanceof SVGElement &&
-            document.activeElement.parentElement &&
-            document.activeElement.parentElement.id === this.viewerOptions.baseDiv
-        );
+    private isDiagramActive(): boolean {
+        return document.activeElement?.parentElement?.id === this.viewerOptions.baseDiv;
     }
 }

package/src/features/copy-paste/copy-paste-modules.ts

@@ -0,0 +1,35 @@
+/********************************************************************************
+ * Copyright (c) 2019-2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { bindAsService, FeatureModule, TYPES } from '@eclipse-glsp/sprotty';
+import { LocalClipboardService, ServerCopyPasteHandler } from './copy-paste-handler';
+import { CopyPasteStartup } from './copy-paste-standalone';
+
+export const copyPasteModule = new FeatureModule((bind, _unbind, isBound) => {
+    bind(TYPES.ICopyPasteHandler).to(ServerCopyPasteHandler);
+    bind(TYPES.IAsyncClipboardService).to(LocalClipboardService).inSingletonScope();
+});
+
+/**
+ * Feature module that is intended for the standalone deployment of GLSP (i.e. plain webapp)
+ * When integrated into an application frame (e.g Theia/VS Code) this module is typically omitted and/or replaced
+ * with an application native module.
+ */
+export const standaloneCopyPasteModule = new FeatureModule(
+    (bind, _unbind, isBound) => {
+        bindAsService(bind, TYPES.IDiagramStartup, CopyPasteStartup);
+    },
+    { requires: copyPasteModule }
+);

package/src/features/copy-paste/copy-paste-standalone.ts

@@ -0,0 +1,65 @@
+/********************************************************************************
+ * Copyright (c) 2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { Disposable, DisposableCollection, TYPES } from '@eclipse-glsp/sprotty';
+import { inject, injectable, optional, preDestroy } from 'inversify';
+import { IDiagramStartup } from '../../base/model/diagram-loader';
+import { ICopyPasteHandler } from './copy-paste-handler';
+/**
+ * Startup service to hook up the copy&paste event handler
+ */
+@injectable()
+export class CopyPasteStartup implements IDiagramStartup, Disposable {
+    @inject(TYPES.ICopyPasteHandler)
+    @optional()
+    protected copyPasteHandler?: ICopyPasteHandler;
+
+    protected toDispose = new DisposableCollection();
+
+    postModelInitialization(): void {
+        if (!this.copyPasteHandler) {
+            return;
+        }
+        const copyListener = (e: ClipboardEvent): void => {
+            this.copyPasteHandler?.handleCopy(e);
+            e.preventDefault();
+        };
+        const cutListener = (e: ClipboardEvent): void => {
+            this.copyPasteHandler?.handleCut(e);
+            e.preventDefault();
+        };
+        const pasteListener = (e: ClipboardEvent): void => {
+            this.copyPasteHandler?.handlePaste(e);
+            e.preventDefault();
+        };
+        window.addEventListener('copy', copyListener);
+        window.addEventListener('cut', cutListener);
+        window.addEventListener('paste', pasteListener);
+
+        this.toDispose.push(
+            Disposable.create(() => {
+                window.removeEventListener('copy', copyListener);
+                window.removeEventListener('cut', cutListener);
+                window.removeEventListener('paste', pasteListener);
+            })
+        );
+    }
+
+    @preDestroy()
+    dispose(): void {
+        this.toDispose.dispose();
+    }
+}

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

@@ -0,0 +1,22 @@
+/********************************************************************************
+ * Copyright (c) 2019-2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { FeatureModule, TYPES, bindAsService } from '@eclipse-glsp/sprotty';
+import '../../../css/decoration.css';
+import { GlspDecorationPlacer } from './decoration-placer';
+
+export const decorationModule = new FeatureModule(bind => {
+    bindAsService(bind, TYPES.IVNodePostprocessor, GlspDecorationPlacer);
+});