@eclipse-glsp/client 2.3.0-next.322 → 2.3.0-next.366

package/src/base/feedback/feedback-action-dispatcher.ts

@@ -13,24 +13,23 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import {
-    Action,
-    ActionHandlerRegistry,
-    Command,
-    CommandActionHandler,
-    CommandExecutionContext,
-    Disposable,
-    IActionDispatcher,
-    ICommand,
-    ILogger,
-    TYPES,
-    toTypeGuard
-} from '@eclipse-glsp/sprotty';
-import { inject, injectable } from 'inversify';
-import { getFeedbackRank } from './feedback-command';
+import { Action, Command, CommandExecutionContext, Disposable, MaybeFunction, call, asArray as toArray } from '@eclipse-glsp/sprotty';
+import { FeedbackEmitter } from './feedback-emitter';
 
 export interface IFeedbackEmitter {}
 
+export const feedbackFeature = Symbol('feedbackFeature');
+
+export type MaybeActions = MaybeFunction<Action[] | Action | undefined>;
+
+export namespace MaybeActions {
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    export function asArray(actions?: MaybeActions): Action[] {
+        const cleanup = actions ? call(actions) : [];
+        return cleanup ? toArray(cleanup) : [];
+    }
+}
+
 /**
  * Dispatcher for actions that are meant to show visual feedback on
  * the diagram that is not part of the diagram sent from the server
@@ -52,7 +51,7 @@ export interface IFeedbackActionDispatcher {
      * @param cleanupActions the actions to be sent out when the feedback is de-registered through the returned Disposable.
      * @returns A 'Disposable' that de-registers the feedback and cleans up any pending feedback with the given `cleanupActions`.
      */
-    registerFeedback(feedbackEmitter: IFeedbackEmitter, feedbackActions: Action[], cleanupActions?: Action[]): Disposable;
+    registerFeedback(feedbackEmitter: IFeedbackEmitter, feedbackActions: Action[], cleanupActions?: MaybeActions): Disposable;
 
     /**
      * Deregisters a `feedbackEmitter` from this dispatcher and thereafter
@@ -64,7 +63,7 @@ export interface IFeedbackActionDispatcher {
      * to reset the normal state of the diagram without the feedback (e.g., reset a
      * CSS class that was set by a feedbackEmitter).
      */
-    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, cleanupActions?: Action[]): void;
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, cleanupActions?: MaybeActions): void;
 
     /**
      * Retrieve all `actions` sent out by currently registered `feedbackEmitter`.
@@ -80,78 +79,10 @@ export interface IFeedbackActionDispatcher {
      * Applies all current feedback commands to the given command execution context.
      */
     applyFeedbackCommands(context: CommandExecutionContext): Promise<void>;
-}
-
-@injectable()
-export class FeedbackActionDispatcher implements IFeedbackActionDispatcher {
-    protected registeredFeedback: Map<IFeedbackEmitter, Action[]> = new Map();
-
-    @inject(TYPES.IActionDispatcherProvider) protected actionDispatcher: () => Promise<IActionDispatcher>;
-    @inject(TYPES.ILogger) protected logger: ILogger;
-
-    @inject(ActionHandlerRegistry) protected actionHandlerRegistry: ActionHandlerRegistry;
-
-    registerFeedback(feedbackEmitter: IFeedbackEmitter, feedbackActions: Action[], cleanupActions?: Action[] | undefined): Disposable {
-        if (feedbackActions.length > 0) {
-            this.registeredFeedback.set(feedbackEmitter, feedbackActions);
-            this.dispatchFeedback(feedbackActions, feedbackEmitter);
-        }
-        return Disposable.create(() => this.deregisterFeedback(feedbackEmitter, cleanupActions));
-    }
-
-    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, cleanupActions?: Action[] | undefined): void {
-        this.registeredFeedback.delete(feedbackEmitter);
-        if (cleanupActions && cleanupActions.length > 0) {
-            this.dispatchFeedback(cleanupActions, feedbackEmitter);
-        }
-    }
 
-    getRegisteredFeedback(): Action[] {
-        const result: Action[] = [];
-        this.registeredFeedback.forEach(actions => result.push(...actions));
-        return result;
-    }
-
-    getRegisteredFeedbackEmitters(action: Action): IFeedbackEmitter[] {
-        const result: IFeedbackEmitter[] = [];
-        this.registeredFeedback.forEach((actions, emitter) => {
-            if (actions.includes(action)) {
-                result.push(emitter);
-            }
-        });
-        return result;
-    }
-
-    getFeedbackCommands(): Command[] {
-        return this.getRegisteredFeedback()
-            .flatMap(action => this.actionToCommands(action))
-            .sort((left, right) => getFeedbackRank(left) - getFeedbackRank(right));
-    }
-
-    async applyFeedbackCommands(context: CommandExecutionContext): Promise<void> {
-        const feedbackCommands = this.getFeedbackCommands() ?? [];
-        if (feedbackCommands?.length > 0) {
-            const results = feedbackCommands.map(command => command.execute(context));
-            await Promise.all(results);
-        }
-    }
-
-    protected actionToCommands(action: Action): ICommand[] {
-        return (
-            this.actionHandlerRegistry
-                ?.get(action.kind)
-                .filter(toTypeGuard(CommandActionHandler))
-                .map(handler => handler.handle(action)) ?? []
-        );
-    }
-
-    protected async dispatchFeedback(actions: Action[], feedbackEmitter: IFeedbackEmitter): Promise<void> {
-        try {
-            const actionDispatcher = await this.actionDispatcher();
-            await actionDispatcher.dispatchAll(actions);
-            this.logger.info(this, `Dispatched feedback actions for ${feedbackEmitter}`);
-        } catch (reason) {
-            this.logger.error(this, 'Failed to dispatch feedback actions', reason);
-        }
-    }
+    /**
+     * Creates a new feedback emitter helper object. While anything can serve as a feedback emitter,
+     * this method ensures that the emitter is stable and does not change between model updates.
+     */
+    createEmitter(): FeedbackEmitter;
 }

package/src/base/feedback/feedback-emitter.spec.ts

@@ -0,0 +1,176 @@
+/********************************************************************************
+ * Copyright (c) 2024 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, Command, CommandExecutionContext, Disposable } from '@eclipse-glsp/sprotty';
+import { expect } from 'chai';
+import { IFeedbackActionDispatcher, IFeedbackEmitter } from './feedback-action-dispatcher';
+import { FeedbackEmitter } from './feedback-emitter';
+
+class MockFeedbackActionDispatcher implements IFeedbackActionDispatcher {
+    protected feedbackEmitters: Map<IFeedbackEmitter, Action[]> = new Map();
+
+    registerFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): Disposable {
+        this.feedbackEmitters.set(feedbackEmitter, actions);
+        return Disposable.create(() => this.deregisterFeedback(feedbackEmitter));
+    }
+
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, _actions?: Action[]): void {
+        this.feedbackEmitters.delete(feedbackEmitter);
+    }
+
+    getRegisteredFeedback(): Action[] {
+        const result: Action[] = [];
+        this.feedbackEmitters.forEach((value, key) => result.push(...value));
+        return result;
+    }
+
+    getFeedbackCommands(): Command[] {
+        return [];
+    }
+
+    createEmitter(): FeedbackEmitter {
+        return new FeedbackEmitter(this);
+    }
+
+    async applyFeedbackCommands(context: CommandExecutionContext): Promise<void> {}
+}
+
+describe('FeedbackEmitter', () => {
+    describe('Initial State', () => {
+        it('On creation nothing should be submitted.', () => {
+            const feedbackActionDispatcher = new MockFeedbackActionDispatcher();
+            const feedback = feedbackActionDispatcher.createEmitter();
+            feedback.submit();
+            expect(feedbackActionDispatcher['feedbackEmitters']).to.be.empty;
+        });
+    });
+
+    describe('Adding Feedback', () => {
+        it('Should add an action as part of the emitter feedback.', () => {
+            const feedbackActionDispatcher = new MockFeedbackActionDispatcher();
+            const feedback = feedbackActionDispatcher.createEmitter();
+            const action: Action = { kind: 'action' };
+            feedback.add(action);
+            expect(feedback['feedbackActions']).to.deep.equal([action]);
+        });
+
+        it('Should add an action and cleanup action as part of the emitter feedback.', () => {
+            const feedbackActionDispatcher = new MockFeedbackActionDispatcher();
+            const feedback = feedbackActionDispatcher.createEmitter();
+            const action: Action = { kind: 'action' };
+            const cleanupAction: Action = { kind: 'cleanup' };
+            feedback.add(action, cleanupAction);
+            expect(feedback['feedbackActions']).to.deep.equal([action]);
+            expect(feedback['cleanupActions']).to.deep.equal([cleanupAction]);
+        });
+    });
+
+    describe('Merging Feedback', () => {
+        it('Should merge the feedback of another emitter into this emitter.', () => {
+            const feedbackActionDispatcher = new MockFeedbackActionDispatcher();
+            const feedback1 = feedbackActionDispatcher.createEmitter();
+            const feedback2 = feedbackActionDispatcher.createEmitter();
+            const action1: Action = { kind: 'action1' };
+            const action2: Action = { kind: 'action2' };
+            feedback1.add(action1);
+            feedback2.add(action2);
+            feedback1.merge(feedback2);
+            expect(feedback1['feedbackActions']).to.deep.equal([action1, action2]);
+        });
+    });
+
+    describe('Removing Feedback', () => {
+        it('Should remove the action from the emitter feedback.', () => {
+            const feedbackActionDispatcher = new MockFeedbackActionDispatcher();
+            const feedback = feedbackActionDispatcher.createEmitter();
+            const action: Action = { kind: 'action' };
+            feedback.add(action);
+            feedback.remove(action);
+            expect(feedback['feedbackActions']).to.be.empty;
+        });
+
+        it('Should remove the action together with the cleanup action from the emitter feedback.', () => {
+            const feedbackActionDispatcher = new MockFeedbackActionDispatcher();
+            const feedback = feedbackActionDispatcher.createEmitter();
+            const action: Action = { kind: 'action' };
+            const cleanupAction: Action = { kind: 'cleanup' };
+            feedback.add(action, cleanupAction);
+            feedback.remove(action);
+            expect(feedback['feedbackActions']).to.be.empty;
+            expect(feedback['cleanupActions']).to.be.empty;
+        });
+    });
+
+    describe('Clearing Feedback', () => {
+        it('Should clear any pending feedback actions and cleanup actions.', () => {
+            const feedbackActionDispatcher = new MockFeedbackActionDispatcher();
+            const feedback = feedbackActionDispatcher.createEmitter();
+            const action: Action = { kind: 'action' };
+            const cleanupAction: Action = { kind: 'cleanup' };
+            feedback.add(action, cleanupAction);
+            feedback.clear();
+            expect(feedback['feedbackActions']).to.be.empty;
+            expect(feedback['cleanupActions']).to.be.empty;
+        });
+    });
+
+    describe('Submitting Feedback', () => {
+        it('Should register any pending actions as feedback.', () => {
+            const feedbackActionDispatcher = new MockFeedbackActionDispatcher();
+            const feedback = feedbackActionDispatcher.createEmitter();
+            const action: Action = { kind: 'action' };
+            feedback.add(action);
+            feedback.submit();
+            expect(feedbackActionDispatcher['feedbackEmitters'].size).to.equal(1);
+            expect(feedbackActionDispatcher['feedbackEmitters'].get(feedback)).to.deep.equal([action]);
+        });
+    });
+
+    describe('Discarding Feedback', () => {
+        it('Should remove the registered feedback without calling any cleanup actions.', () => {
+            const feedbackActionDispatcher = new MockFeedbackActionDispatcher();
+            const feedback = feedbackActionDispatcher.createEmitter();
+            const action: Action = { kind: 'action' };
+            feedback.add(action);
+            feedback.submit();
+            feedback.discard();
+            expect(feedbackActionDispatcher['feedbackEmitters']).to.be.empty;
+        });
+    });
+
+    describe('Reverting Feedback', () => {
+        it('Should remove the registered feedback and call the registered cleanup actions.', () => {
+            const feedbackActionDispatcher = new MockFeedbackActionDispatcher();
+            const feedback = feedbackActionDispatcher.createEmitter();
+            const action: Action = { kind: 'action' };
+            const cleanupAction: Action = { kind: 'cleanup' };
+            feedback.add(action, cleanupAction);
+            feedback.submit();
+            feedback.revert();
+            expect(feedbackActionDispatcher['feedbackEmitters']).to.be.empty;
+        });
+    });
+
+    describe('Disposing Feedback', () => {
+        it('Should dispose the registered feedback and any pending feedback actions.', () => {
+            const feedbackActionDispatcher = new MockFeedbackActionDispatcher();
+            const feedback = feedbackActionDispatcher.createEmitter();
+            const action: Action = { kind: 'action' };
+            feedback.add(action);
+            feedback.dispose();
+            expect(feedbackActionDispatcher['feedbackEmitters']).to.be.empty;
+        });
+    });
+});

package/src/base/feedback/feedback-emitter.ts

@@ -0,0 +1,134 @@
+/********************************************************************************
+ * Copyright (c) 2024 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, Disposable, arrayOf } from '@eclipse-glsp/sprotty';
+import { IFeedbackActionDispatcher, IFeedbackEmitter, MaybeActions } from './feedback-action-dispatcher';
+
+// counter for internal id, mainly useful for debugging
+let idCounter = 0;
+
+/**
+ * A helper object to collect, submit and undo feedback consisting of several actions.
+ */
+export class FeedbackEmitter implements IFeedbackEmitter, Disposable {
+    protected id = idCounter++;
+    protected feedbackActions: (Action | undefined)[] = [];
+    protected cleanupActions: MaybeActions[] = [];
+    protected deregistration?: Disposable;
+
+    constructor(protected feedbackDispatcher: IFeedbackActionDispatcher) {}
+
+    /**
+     * Adds an action as part of this emitters feedback. Please note that the action is only applied as feedback
+     * once the {@link submit} method is called.
+     *
+     * @param action feedback action
+     * @param cleanupAction action that undoes the feedback action. This is only triggered when {@link revert} or {@link dispose} is called.
+     */
+    add(action?: Action, cleanupAction?: MaybeActions): this {
+        if (!action && !cleanupAction) {
+            return this;
+        }
+        const idx = this.feedbackActions.length;
+        this.feedbackActions[idx] = action;
+        if (cleanupAction) {
+            this.cleanupActions[idx] = cleanupAction;
+        }
+        return this;
+    }
+
+    /**
+     * Merges the feedback of another emitter into this emitter.
+     *
+     * @param feedback feedback to merge
+     */
+    merge(feedback: FeedbackEmitter): this {
+        this.feedbackActions.push(...feedback.feedbackActions);
+        this.cleanupActions.push(...feedback.cleanupActions);
+        return this;
+    }
+
+    /**
+     * Removes the action as part of this emitters feedback. If the action cannot be found, this is a no-op.
+     * Please note that this also removed the corresponding cleanup action.
+     * If the feedback has already been submitted as part of the {@link submit} method, the whole feedback must be de-registered
+     * or a new feedback without the given action needs to be registered.
+     *
+     * @param action feedback action
+     */
+    remove(action: Action): this {
+        const idx = this.feedbackActions.indexOf(action);
+        if (idx >= 0) {
+            this.feedbackActions.splice(idx, 1);
+            this.cleanupActions.splice(idx, 1);
+        }
+        return this;
+    }
+
+    /**
+     * Clears any, not yet registered feedback actions and their corresponding cleanup actions.
+     */
+    clear(): this {
+        this.feedbackActions = [];
+        this.cleanupActions = [];
+        return this;
+    }
+
+    /**
+     * Registers any pending actions as feedback. Any previously submitted feedback becomes invalid.
+     */
+    submit(): this {
+        // with 'arrayOf' we skip undefined entries that are created for non-cleanup actions or cleanup-only actions
+        const actions = arrayOf(...this.feedbackActions);
+        const cleanupActions = arrayOf(...this.cleanupActions);
+        if (actions.length > 0 || cleanupActions.length > 0) {
+            this.deregistration = this.feedbackDispatcher.registerFeedback(this, actions, () =>
+                cleanupActions.flatMap(MaybeActions.asArray)
+            );
+            this.clear();
+        }
+        return this;
+    }
+
+    /**
+     * Removes the registered feedback WITHOUT calling any potential cleanup actions
+     * Any pending actions can still be registerd with the {@link submit} method.
+     */
+    discard(): this {
+        this.feedbackDispatcher.deregisterFeedback(this);
+        this.deregistration = undefined;
+        return this;
+    }
+
+    /**
+     * Removes the registered feedback and calls the registered cleanup actions.
+     * Any pending actions can still be registerd with the {@link submit} method.
+     */
+    revert(): this {
+        this.deregistration?.dispose();
+        this.deregistration = undefined;
+        return this;
+    }
+
+    /**
+     * Disposes any registered feedback and any pending, not yet registered feedback actions.
+     */
+    dispose(): this {
+        this.revert();
+        this.clear();
+        return this;
+    }
+}

package/src/base/model/diagram-loader.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 EclipseSource and others.
+ * Copyright (c) 2023-2024 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
@@ -21,6 +21,7 @@ import {
     EMPTY_ROOT,
     GLSPClient,
     InitializeParameters,
+    LazyInjector,
     MaybePromise,
     RequestModelAction,
     SetModelAction,
@@ -28,7 +29,7 @@ import {
     TYPES,
     hasNumberProp
 } from '@eclipse-glsp/sprotty';
-import { inject, injectable, multiInject, optional, postConstruct } from 'inversify';
+import { inject, injectable } from 'inversify';
 import { GLSPActionDispatcher } from '../action-dispatcher';
 import { Ranked } from '../ranked';
 import { GLSPModelSource } from './glsp-model-source';
@@ -69,22 +70,27 @@ export interface IDiagramOptions {
  */
 export interface IDiagramStartup extends Partial<Ranked> {
     /**
-     * Hook for services that should be executed before the underlying GLSP client is configured and the server is initialized.
+     * Hook for services that want to execute code before the diagram loading routine is started. This is the
+     * first hook that is invoked directly after {@link DiagramLoader.load} is called.
+     */
+    preLoadDiagram?(): MaybePromise<void>;
+    /**
+     * Hook for services that want to execute code before the underlying GLSP client is configured and the server is initialized.
      */
     preInitialize?(): MaybePromise<void>;
     /**
-     * Hook for services that should be executed before the initial model loading request (i.e. `RequestModelAction`) but
+     * Hook for services that want to execute code before the initial model loading request (i.e. `RequestModelAction`) but
      * after the underlying GLSP client has been configured and the server is initialized.
      */
     preRequestModel?(): MaybePromise<void>;
     /**
-     * Hook for services that should be executed after the initial model loading request (i.e. `RequestModelAction`).
+     * Hook for services that want to execute code after the initial model loading request (i.e. `RequestModelAction`).
      * Note that this hook is invoked directly after the `RequestModelAction` has been dispatched. It does not necessarily wait
      * until the client-server update roundtrip is completed. If you need to wait until the diagram is fully initialized use the
      * {@link postModelInitialization} hook.
      */
     postRequestModel?(): MaybePromise<void>;
-    /* Hook for services that should be executed after the diagram model is fully initialized
+    /* Hook for services that want to execute code after the diagram model is fully initialized
      * (i.e. `ModelInitializationConstraint` is completed).
      */
     postModelInitialization?(): MaybePromise<void>;
@@ -95,7 +101,8 @@ export namespace IDiagramStartup {
         return (
             AnyObject.is(object) &&
             hasNumberProp(object, 'rank', true) &&
-            ('preInitialize' in object ||
+            ('preLoadDiagram' in object ||
+                'preInitialize' in object ||
                 'preRequestModel' in object ||
                 'postRequestModel' in object ||
                 'postModelInitialization' in object)
@@ -144,22 +151,22 @@ export class DiagramLoader {
     @inject(GLSPActionDispatcher)
     protected actionDispatcher: GLSPActionDispatcher;
 
-    @multiInject(TYPES.IDiagramStartup)
-    @optional()
-    protected diagramStartups: IDiagramStartup[] = [];
-
     @inject(GLSPModelSource)
     protected modelSource: GLSPModelSource;
 
     @inject(ModelInitializationConstraint)
     protected modelInitializationConstraint: ModelInitializationConstraint;
 
-    @postConstruct()
-    protected postConstruct(): void {
-        this.diagramStartups.sort((a, b) => Ranked.getRank(a) - Ranked.getRank(b));
+    @inject(LazyInjector)
+    protected lazyInjector: LazyInjector;
+
+    get diagramStartups(): IDiagramStartup[] {
+        return this.lazyInjector.getAll<IDiagramStartup>(TYPES.IDiagramStartup);
     }
 
     async load(options: DiagramLoadingOptions = {}): Promise<void> {
+        this.diagramStartups.sort(Ranked.sort);
+        await this.invokeStartupHook('preLoadDiagram');
         const resolvedOptions: ResolvedDiagramLoadingOptions = {
             requestModelOptions: {
                 sourceUri: this.options.sourceUri ?? '',
@@ -185,7 +192,11 @@ export class DiagramLoader {
 
     protected async invokeStartupHook(hook: keyof Omit<IDiagramStartup, 'rank'>): Promise<void> {
         for (const startup of this.diagramStartups) {
-            await startup[hook]?.();
+            try {
+                await startup[hook]?.();
+            } catch (err) {
+                console.error(`Error invoking diagram startup hook '${hook}':`, '\n', err);
+            }
         }
     }
 

package/src/base/model/model-registry.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021-2023 EclipseSource and others.
+ * Copyright (c) 2021-2024 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
@@ -32,7 +32,11 @@ export class GModelRegistry extends SModelRegistry {
         }
         if (this.hasKey(key)) {
             // do not throw error but log overwriting
-            console.log(`Factory for model element '${key}' will be overwritten.`);
+            console.log(`Key is already registered: ${key}.Factory for model element '${key}' will be overwritten.`);
+            console.warn(
+                'Implicit overwriting by registering the same key twice is deprecated' +
+                    "\n Use 'overrideModelElement()' instead of 'configureModelElement()' for explicit overwriting."
+            );
         }
         this.elements.set(key, factory);
     }

package/src/base/mouse-position-tracker.ts

@@ -0,0 +1,48 @@
+/********************************************************************************
+ * Copyright (c) 2024 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
+    rank: number;
+ * 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,
+    DOMHelper,
+    GModelElement,
+    MousePositionTracker,
+    Point,
+    TYPES,
+    ViewerOptions,
+    getAbsoluteClientBounds
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
+import { Ranked } from './ranked';
+
+@injectable()
+export class GLSPMousePositionTracker extends MousePositionTracker implements Ranked {
+    /* we want to be executed before all default mouse listeners since we are just tracking the position and others may need it */
+    rank = Ranked.DEFAULT_RANK - 200;
+
+    @inject(TYPES.ViewerOptions) protected viewerOptions: ViewerOptions;
+    @inject(TYPES.DOMHelper) protected domHelper: DOMHelper;
+
+    override mouseMove(target: GModelElement, event: MouseEvent): (Action | Promise<Action>)[] {
+        // we cannot simply use the offsetX and offsetY properties of the event since they also consider nested HTML elements
+        // such as foreignObjects or the projection bars divs. Instead, we manually translate the client coordinates to the diagram
+        const clientToRoot = getAbsoluteClientBounds(target.root, this.domHelper, this.viewerOptions);
+        const clientToPosition = { x: event.clientX, y: event.clientY };
+        const rootToPosition = Point.subtract(clientToPosition, clientToRoot);
+        const positionOnDiagram = target.root.parentToLocal(rootToPosition);
+        this.lastPosition = positionOnDiagram;
+        return [];
+    }
+}

package/src/base/selection-service.spec.ts

@@ -19,6 +19,7 @@ import { Container, injectable } from 'inversify';
 import * as sinon from 'sinon';
 import { defaultModule } from './default.module';
 import { IFeedbackActionDispatcher, IFeedbackEmitter } from './feedback/feedback-action-dispatcher';
+import { FeedbackEmitter } from './feedback/feedback-emitter';
 import { ISelectionListener, SelectFeedbackAction, SelectionService } from './selection-service';
 
 @injectable()
@@ -49,6 +50,10 @@ class MockFeedbackActionDispatcher implements IFeedbackActionDispatcher {
         return [];
     }
 
+    createEmitter(): FeedbackEmitter {
+        return new FeedbackEmitter(this);
+    }
+
     async applyFeedbackCommands(context: CommandExecutionContext): Promise<void> {}
 }