@eclipse-glsp/client 2.2.0-next.328 → 2.2.0-next.330

package/src/features/helper-lines/helper-line-feedback.ts

@@ -36,25 +36,6 @@ import { inject, injectable } from 'inversify';
 import { partition } from 'lodash';
 import '../../../css/helper-lines.css';
 import { FeedbackCommand } from '../../base/feedback/feedback-command';
-import {
-    bottom,
-    bottomCenter,
-    bottomLeft,
-    bottomRight,
-    center,
-    isAbove,
-    isBefore,
-    left,
-    middle,
-    middleLeft,
-    middleRight,
-    right,
-    sortBy,
-    top,
-    topCenter,
-    topLeft,
-    topRight
-} from '../../utils/geometry-util';
 import {
     BoundsAwareModelElement,
     findTopLevelElementByFeature,
@@ -191,12 +172,12 @@ export class DrawHelperLinesFeedbackCommand extends FeedbackCommand {
         const helperLines: HelperLine[] = [];
         this.log('Find helperlines for viewport:', root);
         const viewportBounds = getViewportBounds(root, root.canvasBounds);
-        if (lineTypes.includes(HelperLineType.Center) && this.isAligned(center, viewportBounds, bounds, 2)) {
-            helperLines.push(new HelperLine(topCenter(viewportBounds), bottomCenter(viewportBounds), HelperLineType.Center));
+        if (lineTypes.includes(HelperLineType.Center) && this.isAligned(Bounds.centerX, viewportBounds, bounds, 2)) {
+            helperLines.push(new HelperLine(Bounds.topCenter(viewportBounds), Bounds.bottomCenter(viewportBounds), HelperLineType.Center));
             this.log('- Reference bounds center align with viewport.', viewportBounds);
         }
-        if (lineTypes.includes(HelperLineType.Middle) && this.isAligned(middle, viewportBounds, bounds, 2)) {
-            helperLines.push(new HelperLine(middleLeft(viewportBounds), middleRight(viewportBounds), HelperLineType.Middle));
+        if (lineTypes.includes(HelperLineType.Middle) && this.isAligned(Bounds.middle, viewportBounds, bounds, 2)) {
+            helperLines.push(new HelperLine(Bounds.middleLeft(viewportBounds), Bounds.middleRight(viewportBounds), HelperLineType.Middle));
             this.log('- Reference bounds middle align with viewport.', viewportBounds);
         }
         if (helperLines.length > 0) {
@@ -213,78 +194,90 @@ export class DrawHelperLinesFeedbackCommand extends FeedbackCommand {
     protected calcHelperLinesForBounds(elementBounds: Bounds, bounds: Bounds, lineTypes: HelperLineType[]): HelperLine[] {
         const helperLines: HelperLine[] = [];
 
-        if (lineTypes.includes(HelperLineType.Left) && this.isAligned(left, elementBounds, bounds, this.alignmentEpsilon)) {
-            const [above, below] = sortBy(top, elementBounds, bounds); // higher top-value ==> lower
-            helperLines.push(new HelperLine(bottomLeft(below), topLeft(above), HelperLineType.Left));
+        if (lineTypes.includes(HelperLineType.Left) && this.isAligned(Bounds.left, elementBounds, bounds, this.alignmentEpsilon)) {
+            const [above, below] = Bounds.sortBy(Bounds.top, elementBounds, bounds); // higher top-value ==> lower
+            helperLines.push(new HelperLine(Bounds.bottomLeft(below), Bounds.topLeft(above), HelperLineType.Left));
             this.log('- Reference bounds left align with element', elementBounds);
         }
 
-        if (lineTypes.includes(HelperLineType.Center) && this.isAligned(center, elementBounds, bounds, this.alignmentEpsilon)) {
-            const [above, below] = sortBy(top, elementBounds, bounds); // higher top-value ==> lower
-            helperLines.push(new HelperLine(topCenter(above), bottomCenter(below), HelperLineType.Center));
+        if (lineTypes.includes(HelperLineType.Center) && this.isAligned(Bounds.centerX, elementBounds, bounds, this.alignmentEpsilon)) {
+            const [above, below] = Bounds.sortBy(Bounds.top, elementBounds, bounds); // higher top-value ==> lower
+            helperLines.push(new HelperLine(Bounds.topCenter(above), Bounds.bottomCenter(below), HelperLineType.Center));
             this.log('- Reference bounds center align with element', elementBounds);
         }
 
-        if (lineTypes.includes(HelperLineType.Right) && this.isAligned(right, elementBounds, bounds, this.alignmentEpsilon)) {
-            const [above, below] = sortBy(top, elementBounds, bounds); // higher top-value ==> lower
-            helperLines.push(new HelperLine(bottomRight(below), topRight(above), HelperLineType.Right));
+        if (lineTypes.includes(HelperLineType.Right) && this.isAligned(Bounds.right, elementBounds, bounds, this.alignmentEpsilon)) {
+            const [above, below] = Bounds.sortBy(Bounds.top, elementBounds, bounds); // higher top-value ==> lower
+            helperLines.push(new HelperLine(Bounds.bottomRight(below), Bounds.topRight(above), HelperLineType.Right));
             this.log('- Reference bounds right align with element', elementBounds);
         }
 
-        if (lineTypes.includes(HelperLineType.Bottom) && this.isAligned(bottom, elementBounds, bounds, this.alignmentEpsilon)) {
-            const [before, after] = sortBy(left, elementBounds, bounds); // higher left-value ==> more to the right
-            helperLines.push(new HelperLine(bottomLeft(before), bottomRight(after), HelperLineType.Bottom));
+        if (lineTypes.includes(HelperLineType.Bottom) && this.isAligned(Bounds.bottom, elementBounds, bounds, this.alignmentEpsilon)) {
+            const [before, after] = Bounds.sortBy(Bounds.left, elementBounds, bounds); // higher left-value ==> more to the right
+            helperLines.push(new HelperLine(Bounds.bottomLeft(before), Bounds.bottomRight(after), HelperLineType.Bottom));
             this.log('- Reference bounds bottom align with element', elementBounds);
         }
 
-        if (lineTypes.includes(HelperLineType.Middle) && this.isAligned(middle, elementBounds, bounds, this.alignmentEpsilon)) {
-            const [before, after] = sortBy(left, elementBounds, bounds); // higher left-value ==> more to the right
-            helperLines.push(new HelperLine(middleLeft(before), middleRight(after), HelperLineType.Middle));
+        if (lineTypes.includes(HelperLineType.Middle) && this.isAligned(Bounds.centerY, elementBounds, bounds, this.alignmentEpsilon)) {
+            const [before, after] = Bounds.sortBy(Bounds.left, elementBounds, bounds); // higher left-value ==> more to the right
+            helperLines.push(new HelperLine(Bounds.middleLeft(before), Bounds.middleRight(after), HelperLineType.Middle));
             this.log('- Reference bounds middle align with element', elementBounds);
         }
 
-        if (lineTypes.includes(HelperLineType.Top) && this.isAligned(top, elementBounds, bounds, this.alignmentEpsilon)) {
-            const [before, after] = sortBy(left, elementBounds, bounds); // higher left-value ==> more to the right
-            helperLines.push(new HelperLine(topLeft(before), topRight(after), HelperLineType.Top));
+        if (lineTypes.includes(HelperLineType.Top) && this.isAligned(Bounds.top, elementBounds, bounds, this.alignmentEpsilon)) {
+            const [before, after] = Bounds.sortBy(Bounds.left, elementBounds, bounds); // higher left-value ==> more to the right
+            helperLines.push(new HelperLine(Bounds.topLeft(before), Bounds.topRight(after), HelperLineType.Top));
             this.log('- Reference bounds top align with element', elementBounds);
         }
 
-        if (lineTypes.includes(HelperLineType.LeftRight) && this.isMatch(left(elementBounds), right(bounds), this.alignmentEpsilon)) {
-            if (isAbove(bounds, elementBounds)) {
-                helperLines.push(new HelperLine(bottomLeft(elementBounds), topRight(bounds), HelperLineType.RightLeft));
+        if (
+            lineTypes.includes(HelperLineType.LeftRight) &&
+            this.isMatch(Bounds.left(elementBounds), Bounds.right(bounds), this.alignmentEpsilon)
+        ) {
+            if (Bounds.isAbove(bounds, elementBounds)) {
+                helperLines.push(new HelperLine(Bounds.bottomLeft(elementBounds), Bounds.topRight(bounds), HelperLineType.RightLeft));
                 this.log('- Reference bounds right aligns with element left', elementBounds);
             } else {
-                helperLines.push(new HelperLine(topLeft(elementBounds), bottomRight(bounds), HelperLineType.RightLeft));
+                helperLines.push(new HelperLine(Bounds.topLeft(elementBounds), Bounds.bottomRight(bounds), HelperLineType.RightLeft));
                 this.log('- Reference bounds right aligns with element left', elementBounds);
             }
         }
 
-        if (lineTypes.includes(HelperLineType.LeftRight) && this.isMatch(right(elementBounds), left(bounds), this.alignmentEpsilon)) {
-            if (isAbove(bounds, elementBounds)) {
-                helperLines.push(new HelperLine(bottomRight(elementBounds), topLeft(bounds), HelperLineType.LeftRight));
+        if (
+            lineTypes.includes(HelperLineType.LeftRight) &&
+            this.isMatch(Bounds.right(elementBounds), Bounds.left(bounds), this.alignmentEpsilon)
+        ) {
+            if (Bounds.isAbove(bounds, elementBounds)) {
+                helperLines.push(new HelperLine(Bounds.bottomRight(elementBounds), Bounds.topLeft(bounds), HelperLineType.LeftRight));
                 this.log('- Reference bounds left aligns with element right', elementBounds);
             } else {
-                helperLines.push(new HelperLine(topRight(elementBounds), bottomLeft(bounds), HelperLineType.LeftRight));
+                helperLines.push(new HelperLine(Bounds.topRight(elementBounds), Bounds.bottomLeft(bounds), HelperLineType.LeftRight));
                 this.log('- Reference bounds left aligns with element right', elementBounds);
             }
         }
 
-        if (lineTypes.includes(HelperLineType.TopBottom) && this.isMatch(top(elementBounds), bottom(bounds), this.alignmentEpsilon)) {
-            if (isBefore(bounds, elementBounds)) {
-                helperLines.push(new HelperLine(topRight(elementBounds), bottomLeft(bounds), HelperLineType.BottomTop));
+        if (
+            lineTypes.includes(HelperLineType.TopBottom) &&
+            this.isMatch(Bounds.top(elementBounds), Bounds.bottom(bounds), this.alignmentEpsilon)
+        ) {
+            if (Bounds.isBefore(bounds, elementBounds)) {
+                helperLines.push(new HelperLine(Bounds.topRight(elementBounds), Bounds.bottomLeft(bounds), HelperLineType.BottomTop));
                 this.log('- Reference bounds bottom aligns with element top', elementBounds);
             } else {
-                helperLines.push(new HelperLine(topLeft(elementBounds), bottomRight(bounds), HelperLineType.BottomTop));
+                helperLines.push(new HelperLine(Bounds.topLeft(elementBounds), Bounds.bottomRight(bounds), HelperLineType.BottomTop));
                 this.log('- Reference bounds bottom aligns with element top', elementBounds);
             }
         }
 
-        if (lineTypes.includes(HelperLineType.TopBottom) && this.isMatch(bottom(elementBounds), top(bounds), this.alignmentEpsilon)) {
-            if (isBefore(bounds, elementBounds)) {
-                helperLines.push(new HelperLine(bottomRight(elementBounds), topLeft(bounds), HelperLineType.TopBottom));
+        if (
+            lineTypes.includes(HelperLineType.TopBottom) &&
+            this.isMatch(Bounds.bottom(elementBounds), Bounds.top(bounds), this.alignmentEpsilon)
+        ) {
+            if (Bounds.isBefore(bounds, elementBounds)) {
+                helperLines.push(new HelperLine(Bounds.bottomRight(elementBounds), Bounds.topLeft(bounds), HelperLineType.TopBottom));
                 this.log('- Reference bounds top aligns with element bottom', elementBounds);
             } else {
-                helperLines.push(new HelperLine(bottomLeft(elementBounds), topRight(bounds), HelperLineType.TopBottom));
+                helperLines.push(new HelperLine(Bounds.bottomLeft(elementBounds), Bounds.topRight(bounds), HelperLineType.TopBottom));
                 this.log('- Reference bounds top aligns with element bottom', elementBounds);
             }
         }

package/src/features/helper-lines/helper-line-manager-default.ts

@@ -13,18 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import {
-    Action,
-    DisposableCollection,
-    GModelElement,
-    GModelRoot,
-    IActionHandler,
-    MoveAction,
-    Point,
-    SetBoundsAction,
-    TYPES
-} from '@eclipse-glsp/sprotty';
+import { Action, GModelElement, GModelRoot, IActionHandler, MoveAction, Point, SetBoundsAction, TYPES } from '@eclipse-glsp/sprotty';
 import { inject, injectable, optional, postConstruct } from 'inversify';
+import { FeedbackEmitter } from '../../base';
 import { IFeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
 import { ISelectionListener, SelectionService } from '../../base/selection-service';
 import { SetBoundsFeedbackAction } from '../bounds/set-bounds-feedback-command';
@@ -95,10 +86,11 @@ export class HelperLineManager implements IActionHandler, ISelectionListener, IH
     @optional() @inject(TYPES.IHelperLineOptions) protected userOptions?: IHelperLineOptions;
 
     protected options: Required<IHelperLineOptions>;
-    protected feedback: DisposableCollection = new DisposableCollection();
+    protected feedback: FeedbackEmitter;
 
     @postConstruct()
     protected init(): void {
+        this.feedback = this.feedbackDispatcher.createEmitter();
         this.options = { ...DEFAULT_HELPER_LINE_OPTIONS, ...this.userOptions };
         this.selectionService.onSelectionChanged(change =>
             this.selectionChanged(change.root, change.selectedElements, change.deselectedElements)
@@ -118,9 +110,7 @@ export class HelperLineManager implements IActionHandler, ISelectionListener, IH
     }
 
     protected handleMoveInitializedAction(_action: MoveInitializedEventAction): void {
-        this.feedback.dispose();
-        const feedback = this.createHelperLineFeedback(this.selectionService.getSelectedElementIDs());
-        this.feedback.push(this.feedbackDispatcher.registerFeedback(this, [feedback], [RemoveHelperLinesFeedbackAction.create()]));
+        this.submitHelperLineFeedback();
     }
 
     protected handleMoveFinishedAction(_action: MoveFinishedEventAction): void {
@@ -129,22 +119,23 @@ export class HelperLineManager implements IActionHandler, ISelectionListener, IH
 
     protected handleMoveAction(action: MoveAction): void {
         if (!action.finished) {
-            const elementIds = action.moves.map(move => move.elementId);
-            const feedback = this.createHelperLineFeedback(elementIds);
-            this.feedback.push(this.feedbackDispatcher.registerFeedback(this, [feedback], [RemoveHelperLinesFeedbackAction.create()]));
+            this.submitHelperLineFeedback(action.moves.map(move => move.elementId));
         } else {
             this.feedback.dispose();
         }
     }
 
+    protected submitHelperLineFeedback(elementIds: string[] = this.selectionService.getSelectedElementIDs()): void {
+        const feedback = this.createHelperLineFeedback(elementIds);
+        this.feedback.add(feedback, [RemoveHelperLinesFeedbackAction.create()]).submit();
+    }
+
     protected createHelperLineFeedback(elementIds: string[]): DrawHelperLinesFeedbackAction {
         return DrawHelperLinesFeedbackAction.create({ elementIds, ...this.options });
     }
 
     protected handleSetBoundsAction(action: SetBoundsAction | SetBoundsFeedbackAction): void {
-        const elementIds = action.bounds.map(bound => bound.elementId);
-        const feedback = this.createHelperLineFeedback(elementIds);
-        this.feedback.push(this.feedbackDispatcher.registerFeedback(this, [feedback], [RemoveHelperLinesFeedbackAction.create()]));
+        this.submitHelperLineFeedback(action.bounds.map(bound => bound.elementId));
     }
 
     selectionChanged(root: Readonly<GModelRoot>, selectedElements: string[], deselectedElements?: string[] | undefined): void {

package/src/features/helper-lines/model.ts

@@ -14,7 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { Args, Bounds, GChildElement, GModelElement, GShapeElement, Point } from '@eclipse-glsp/sprotty';
+import { Args, Bounds, Direction, GChildElement, GModelElement, GShapeElement, Point, Vector } from '@eclipse-glsp/sprotty';
 import { v4 as uuid } from 'uuid';
 import { ArgsAware } from '../../base/args-feature';
 import { ResizeHandleLocation } from '../change-bounds/model';
@@ -98,30 +98,8 @@ export function isSelectionBounds(element: GModelElement): element is SelectionB
     return element.type === SELECTION_BOUNDS;
 }
 
-export const Direction = {
-    Left: 'left',
-    Right: 'right',
-    Up: 'up',
-    Down: 'down'
-} as const;
-
-// allow any string to be set as helper line type to support customization
-export type Direction = (typeof Direction)[keyof typeof Direction];
-
-export function getDirectionOf(point: Point): Direction[] {
-    const directions: Direction[] = [];
-    if (point.x < 0) {
-        directions.push(Direction.Left);
-    } else if (point.x > 0) {
-        directions.push(Direction.Right);
-    }
-    if (point.y < 0) {
-        directions.push(Direction.Up);
-    } else if (point.y > 0) {
-        directions.push(Direction.Down);
-    }
-    return directions;
-}
+// kept for backwards compatibility after moving the definition
+export const getDirectionOf = Vector.direction;
 
 export function getDirectionFrom(resize?: ResizeHandleLocation): Direction[] {
     if (resize === ResizeHandleLocation.TopLeft) {
@@ -138,3 +116,6 @@ export function getDirectionFrom(resize?: ResizeHandleLocation): Direction[] {
     }
     return [];
 }
+
+// re-export for backwards compatibility after moving the definition
+export { Direction } from '@eclipse-glsp/sprotty';

package/src/features/hints/type-hint-provider.spec.ts

@@ -35,6 +35,7 @@ import {
 import { expect } from 'chai';
 import { Container } from 'inversify';
 import * as sinon from 'sinon';
+import { FeedbackEmitter } from '../../base';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { FeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
 import { GEdge } from '../../model';
@@ -45,7 +46,9 @@ import { ApplyTypeHintsAction, ApplyTypeHintsCommand, ITypeHintProvider, TypeHin
 describe('TypeHintProvider', () => {
     const container = new Container();
     container.bind(GLSPActionDispatcher).toConstantValue(sinon.createStubInstance(GLSPActionDispatcher));
-    container.bind(TYPES.IFeedbackActionDispatcher).toConstantValue(sinon.createStubInstance(FeedbackActionDispatcher));
+    const stub = sinon.createStubInstance(FeedbackActionDispatcher);
+    stub.createEmitter.returns(new FeedbackEmitter(stub));
+    container.bind(TYPES.IFeedbackActionDispatcher).toConstantValue(stub);
     const typeHintProvider = container.resolve(TypeHintProvider);
 
     describe('getShapeTypeHint', () => {

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

@@ -35,8 +35,9 @@ import {
     isConnectable,
     moveFeature
 } from '@eclipse-glsp/sprotty';
-import { inject, injectable } from 'inversify';
+import { inject, injectable, postConstruct } from 'inversify';
 
+import { FeedbackEmitter } from '../../base';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { IFeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
 import { FeedbackCommand } from '../../base/feedback/feedback-command';
@@ -204,15 +205,21 @@ export class TypeHintProvider implements IActionHandler, ITypeHintProvider, IDia
     @inject(GLSPActionDispatcher)
     protected actionDispatcher: GLSPActionDispatcher;
 
+    protected typeHintsFeedback: FeedbackEmitter;
     protected shapeHints: Map<string, ShapeTypeHint> = new Map();
     protected edgeHints: Map<string, EdgeTypeHint> = new Map();
 
+    @postConstruct()
+    protected init(): void {
+        this.typeHintsFeedback = this.feedbackActionDispatcher.createEmitter();
+    }
+
     handle(action: SetTypeHintsAction): void {
         this.shapeHints.clear();
         this.edgeHints.clear();
         action.shapeHints.forEach(hint => this.shapeHints.set(hint.elementTypeId, hint));
         action.edgeHints.forEach(hint => this.edgeHints.set(hint.elementTypeId, hint));
-        this.feedbackActionDispatcher.registerFeedback(this, [ApplyTypeHintsAction.create()]);
+        this.typeHintsFeedback.add(ApplyTypeHintsAction.create()).submit();
     }
 
     getShapeTypeHint(input: GModelElement | GModelElementSchema | string): ShapeTypeHint | undefined {

package/src/features/layout/layout-elements-action.ts

@@ -13,17 +13,18 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable, optional } from 'inversify';
 import {
     Action,
     ChangeBoundsOperation,
+    Dimension,
     ElementAndBounds,
     ElementMove,
+    GModelElement,
     IActionDispatcher,
     IActionHandler,
     ICommand,
     MoveAction,
-    GModelElement,
+    Point,
     SetBoundsAction,
     TYPES,
     Writable,
@@ -31,9 +32,10 @@ import {
     hasNumberProp,
     hasStringProp
 } from '@eclipse-glsp/sprotty';
+import { inject, injectable, optional } from 'inversify';
 import { SelectionService } from '../../base/selection-service';
-import { toValidElementAndBounds, toValidElementMove } from '../../utils/layout-utils';
 import { BoundsAwareModelElement, getElements } from '../../utils/gmodel-util';
+import { toValidElementAndBounds, toValidElementMove } from '../../utils/layout-utils';
 import { isBoundsAwareMoveable, isResizable } from '../change-bounds/model';
 import { IMovementRestrictor } from '../change-bounds/movement-restrictor';
 
@@ -227,12 +229,13 @@ export class ResizeElementsActionHandler extends LayoutElementsActionHandler {
     resizeWidthAndHeight(elements: BoundsAwareModelElement[], reduceFn: ReduceFunction): void {
         const targetWidth = reduceFn(...elements.map(element => element.bounds.width));
         const targetHeight = reduceFn(...elements.map(element => element.bounds.height));
+        const targetDimension: Dimension = { width: targetWidth, height: targetHeight };
         this.dispatchResizeActions(elements, (element, bounds) => {
             // resize around center and middle (horizontal & vertical)
-            const halfDiffWidth = 0.5 * (targetWidth - element.bounds.width);
-            const halfDiffHeight = 0.5 * (targetHeight - element.bounds.height);
-            bounds.newPosition = { x: element.bounds.x - halfDiffWidth, y: element.bounds.y - halfDiffHeight };
-            bounds.newSize = { width: targetWidth, height: targetHeight };
+            const difference = Dimension.subtract(targetDimension, element.bounds);
+            const center = Dimension.center(difference);
+            bounds.newPosition = Point.subtract(element.bounds, center);
+            bounds.newSize = targetDimension;
         });
     }
 

package/src/features/select/select-mouse-listener.ts

@@ -13,8 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, BringToFrontAction, GModelElement, SelectAction, SelectMouseListener, Selectable } from '@eclipse-glsp/sprotty';
+import { Action, BringToFrontAction, GModelElement, SelectAction, SelectMouseListener } from '@eclipse-glsp/sprotty';
 import { Ranked } from '../../base/ranked';
+import { SelectableElement } from '../../utils';
 
 /**
  * Ranked select mouse listener that is executed before default mouse listeners when using the RankedMouseTool.
@@ -24,7 +25,7 @@ export class RankedSelectMouseListener extends SelectMouseListener implements Ra
     rank: number = Ranked.DEFAULT_RANK - 100; /* we want to be executed before all default mouse listeners */
 
     protected override handleSelectTarget(
-        selectableTarget: GModelElement & Selectable,
+        selectableTarget: SelectableElement,
         deselectedElements: GModelElement[],
         event: MouseEvent
     ): (Action | Promise<Action>)[] {
@@ -40,7 +41,7 @@ export class RankedSelectMouseListener extends SelectMouseListener implements Ra
         return result;
     }
 
-    protected override handleDeselectTarget(selectableTarget: GModelElement & Selectable, event: MouseEvent): (Action | Promise<Action>)[] {
+    protected override handleDeselectTarget(selectableTarget: SelectableElement, event: MouseEvent): (Action | Promise<Action>)[] {
         const result: Action[] = [];
         result.push(SelectAction.create({ selectedElementsIDs: [], deselectedElementsIDs: [selectableTarget.id] }));
         return result;

package/src/features/tools/base-tools.ts

@@ -13,11 +13,12 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable } from 'inversify';
 import { Action, Disposable, DisposableCollection, IActionHandler, TYPES } from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { EditorContextService } from '../../base/editor-context-service';
-import { IFeedbackActionDispatcher, IFeedbackEmitter } from '../../base/feedback/feedback-action-dispatcher';
+import { FeedbackEmitter } from '../../base/feedback/feeback-emitter';
+import { IFeedbackActionDispatcher, IFeedbackEmitter, MaybeActions } from '../../base/feedback/feedback-action-dispatcher';
 import { EnableToolsAction, Tool } from '../../base/tool-manager/tool';
 import { GLSPKeyTool } from '../../base/view/key-tool';
 import { GLSPMouseTool } from '../../base/view/mouse-tool';
@@ -47,8 +48,12 @@ export abstract class BaseEditTool implements Tool {
         return true;
     }
 
-    dispatchActions(actions: Action[]): void {
-        this.actionDispatcher.dispatchAll(actions);
+    dispatchActions(actions: Action[]): Promise<void> {
+        return this.actionDispatcher.dispatchAll(actions);
+    }
+
+    createFeedbackEmitter(): FeedbackEmitter {
+        return this.feedbackDispatcher.createEmitter();
     }
 
     /**
@@ -59,9 +64,10 @@ export abstract class BaseEditTool implements Tool {
      * @param feedbackEmitter the emitter sending out feedback actions (this tool by default).
      * @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`.
+     * @deprecated It is recommended to create a {@link createFeedbackEmitter dedicated emitter} per feedback instead of using the tool.
      */
-    registerFeedback(feedbackActions: Action[], feedbackEmitter?: IFeedbackEmitter, cleanupActions?: Action[]): Disposable {
-        return this.feedbackDispatcher.registerFeedback(feedbackEmitter ?? this, feedbackActions, cleanupActions);
+    registerFeedback(feedbackActions: Action[], feedbackEmitter: IFeedbackEmitter = this, cleanupActions?: MaybeActions): Disposable {
+        return this.feedbackDispatcher.registerFeedback(feedbackEmitter, feedbackActions, cleanupActions);
     }
 
     /**
@@ -70,9 +76,10 @@ export abstract class BaseEditTool implements Tool {
      *
      * @param feedbackEmitter the emitter to be deregistered (this tool by default).
      * @param cleanupActions the actions to be dispatched right after the deregistration to clean up any pending feedback.
+     * @deprecated It is recommended to create a {@link createFeedbackEmitter dedicated emitter} per feedback and dispose it like that.
      */
-    deregisterFeedback(feedbackEmitter?: IFeedbackEmitter, cleanupActions?: Action[]): void {
-        this.feedbackDispatcher.deregisterFeedback(feedbackEmitter ?? this, cleanupActions);
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter = this, cleanupActions?: MaybeActions): void {
+        this.feedbackDispatcher.deregisterFeedback(feedbackEmitter, cleanupActions);
     }
 }