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

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

@@ -20,17 +20,34 @@ import {
     CommandActionHandler,
     CommandExecutionContext,
     Disposable,
+    GModelElement,
     IActionDispatcher,
     ICommand,
     ILogger,
+    MaybeFunction,
     TYPES,
+    call,
+    asArray as toArray,
     toTypeGuard
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
 import { getFeedbackRank } from './feedback-command';
+import { FeedbackEmitter } from './feeback-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 +69,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 +81,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,6 +97,12 @@ export interface IFeedbackActionDispatcher {
      * Applies all current feedback commands to the given command execution context.
      */
     applyFeedbackCommands(context: CommandExecutionContext): Promise<void>;
+
+    /**
+     * 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;
 }
 
 @injectable()
@@ -91,7 +114,14 @@ export class FeedbackActionDispatcher implements IFeedbackActionDispatcher {
 
     @inject(ActionHandlerRegistry) protected actionHandlerRegistry: ActionHandlerRegistry;
 
-    registerFeedback(feedbackEmitter: IFeedbackEmitter, feedbackActions: Action[], cleanupActions?: Action[] | undefined): Disposable {
+    registerFeedback(feedbackEmitter: IFeedbackEmitter, feedbackActions: Action[], cleanupActions?: MaybeActions): Disposable {
+        if (feedbackEmitter instanceof GModelElement) {
+            this.logger.log(
+                this,
+                // eslint-disable-next-line max-len
+                'GModelElements as feedback emitters are discouraged, as they usually change between model updates and are considered unstable.'
+            );
+        }
         if (feedbackActions.length > 0) {
             this.registeredFeedback.set(feedbackEmitter, feedbackActions);
             this.dispatchFeedback(feedbackActions, feedbackEmitter);
@@ -99,10 +129,11 @@ export class FeedbackActionDispatcher implements IFeedbackActionDispatcher {
         return Disposable.create(() => this.deregisterFeedback(feedbackEmitter, cleanupActions));
     }
 
-    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, cleanupActions?: Action[] | undefined): void {
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, cleanupActions?: MaybeActions): void {
         this.registeredFeedback.delete(feedbackEmitter);
-        if (cleanupActions && cleanupActions.length > 0) {
-            this.dispatchFeedback(cleanupActions, feedbackEmitter);
+        const actions = MaybeActions.asArray(cleanupActions);
+        if (actions.length > 0) {
+            this.dispatchFeedback(actions, feedbackEmitter);
         }
     }
 
@@ -145,6 +176,10 @@ export class FeedbackActionDispatcher implements IFeedbackActionDispatcher {
         );
     }
 
+    createEmitter(): FeedbackEmitter {
+        return new FeedbackEmitter(this);
+    }
+
     protected async dispatchFeedback(actions: Action[], feedbackEmitter: IFeedbackEmitter): Promise<void> {
         try {
             const actionDispatcher = await this.actionDispatcher();

package/src/base/feedback/index.ts

@@ -14,6 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 export * from './css-feedback';
+export * from './feeback-emitter';
 export * from './feedback-action-dispatcher';
 export * from './feedback-command';
 export * from './set-model-command';

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

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

package/src/base/selection-service.ts

@@ -28,7 +28,6 @@ import {
     LazyInjector,
     SelectAction,
     SelectAllAction,
-    Selectable,
     SprottySelectAllCommand,
     SprottySelectCommand,
     TYPES,
@@ -37,7 +36,7 @@ import {
     pluck
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable, postConstruct, preDestroy } from 'inversify';
-import { getElements, getMatchingElements } from '../utils/gmodel-util';
+import { SelectableElement, getElements, getMatchingElements } from '../utils/gmodel-util';
 import { IGModelRootListener } from './editor-context-service';
 import { IFeedbackActionDispatcher } from './feedback/feedback-action-dispatcher';
 import { IDiagramStartup } from './model';
@@ -164,7 +163,7 @@ export class SelectionService implements IGModelRootListener, Disposable, IDiagr
         return this.root;
     }
 
-    getSelectedElements(): Readonly<GModelElement & Selectable>[] {
+    getSelectedElements(): Readonly<SelectableElement>[] {
         return !this.root ? [] : getElements(this.root.index, Array.from(this.selectedElementIDs), isSelectable);
     }
 

package/src/features/accessibility/element-navigation/local-element-navigator.ts

@@ -13,13 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { BoundsAware, EdgeRouterRegistry, GConnectableElement, GModelElement, GModelRoot, TYPES } from '@eclipse-glsp/sprotty';
+import { EdgeRouterRegistry, GConnectableElement, GModelElement, GModelRoot, TYPES } from '@eclipse-glsp/sprotty';
 import { inject, injectable, optional } from 'inversify';
 import { GLSPActionDispatcher } from '../../../base/action-dispatcher';
 import { applyCssClasses, deleteCssClasses } from '../../../base/feedback/css-feedback';
-import { SelectableBoundsAware } from '../../../utils/gmodel-util';
-import { ElementNavigator } from './element-navigator';
 import { GEdge } from '../../../model';
+import { BoundsAwareModelElement, SelectableBoundsAware } from '../../../utils/gmodel-util';
+import { ElementNavigator } from './element-navigator';
 
 @injectable()
 export class LocalElementNavigator implements ElementNavigator {
@@ -91,7 +91,7 @@ export class LocalElementNavigator implements ElementNavigator {
 
     protected getIterables(
         current: SelectableBoundsAware,
-        previousCurrent?: GModelElement & BoundsAware,
+        previousCurrent?: BoundsAwareModelElement,
         predicate: (element: GModelElement) => boolean = () => true
     ): GModelElement[] {
         const elements: GModelElement[] = [];

package/src/features/accessibility/move-zoom/move-handler.ts

@@ -17,7 +17,6 @@
 import {
     Action,
     ChangeBoundsOperation,
-    DisposableCollection,
     ElementAndBounds,
     ElementMove,
     GModelRoot,
@@ -34,8 +33,9 @@ import {
     isBoundsAware,
     isViewport
 } from '@eclipse-glsp/sprotty';
-import { inject, injectable, optional } from 'inversify';
+import { inject, injectable, optional, postConstruct } from 'inversify';
 import { DebouncedFunc, debounce } from 'lodash';
+import { FeedbackEmitter } from '../../../base';
 import { EditorContextService } from '../../../base/editor-context-service';
 import { IFeedbackActionDispatcher } from '../../../base/feedback/feedback-action-dispatcher';
 import { SelectableBoundsAware, getElements, isSelectableAndBoundsAware } from '../../../utils/gmodel-util';
@@ -164,7 +164,12 @@ export class MoveElementHandler implements IActionHandler {
     readonly movementRestrictor?: IMovementRestrictor;
 
     protected debouncedChangeBounds?: DebouncedFunc<() => void>;
-    protected disposableFeedback = new DisposableCollection();
+    protected moveFeedback: FeedbackEmitter;
+
+    @postConstruct()
+    protected init(): void {
+        this.moveFeedback = this.feedbackDispatcher.createEmitter();
+    }
 
     handle(action: Action): void | Action | ICommand {
         if (MoveElementAction.is(action)) {
@@ -199,13 +204,13 @@ export class MoveElementHandler implements IActionHandler {
 
         this.dispatcher.dispatchAll(viewportActions);
         const moveAction = MoveAction.create(elementMoves, { animate: false });
-        this.disposableFeedback.push(this.feedbackDispatcher.registerFeedback(this, [moveAction]));
+        this.moveFeedback.add(moveAction).submit();
 
         this.scheduleChangeBounds(this.toElementAndBounds(elementMoves));
     }
 
     protected getTargetBounds(element: SelectableBoundsAware, action: MoveElementAction): Point {
-        let position = { x: element.bounds.x + action.moveX, y: element.bounds.y + action.moveY };
+        let position = Point.add(element.bounds, { x: action.moveX, y: action.moveY });
         if (this.snapper && action.snap) {
             position = this.snapper.snap(position, element);
         }
@@ -219,7 +224,7 @@ export class MoveElementHandler implements IActionHandler {
     protected scheduleChangeBounds(elementAndBounds: ElementAndBounds[]): void {
         this.debouncedChangeBounds?.cancel();
         this.debouncedChangeBounds = debounce(() => {
-            this.disposableFeedback.dispose();
+            this.moveFeedback.dispose();
             this.dispatcher.dispatchAll([ChangeBoundsOperation.create(elementAndBounds)]);
             this.debouncedChangeBounds = undefined;
         }, 300);

package/src/features/accessibility/resize-key-tool/resize-key-handler.ts

@@ -18,7 +18,6 @@ import {
     Action,
     ChangeBoundsOperation,
     Dimension,
-    DisposableCollection,
     ElementAndBounds,
     GModelElement,
     GParentElement,
@@ -30,13 +29,13 @@ import {
     SetBoundsAction,
     TYPES
 } from '@eclipse-glsp/sprotty';
-import { inject, injectable, optional } from 'inversify';
+import { inject, injectable, optional, postConstruct } from 'inversify';
 import { DebouncedFunc, debounce } from 'lodash';
+import { FeedbackEmitter } from '../../../base';
 import { EditorContextService } from '../../../base/editor-context-service';
 import { IFeedbackActionDispatcher } from '../../../base/feedback/feedback-action-dispatcher';
-import { SelectableBoundsAware, getElements, isSelectableAndBoundsAware, toElementAndBounds } from '../../../utils/gmodel-util';
+import { Resizable, SelectableBoundsAware, getElements, isSelectableAndBoundsAware, toElementAndBounds } from '../../../utils/gmodel-util';
 import { isValidMove, isValidSize, minHeight, minWidth } from '../../../utils/layout-utils';
-import { Resizable } from '../../change-bounds/model';
 import { GridSnapper } from '../../change-bounds/snap';
 
 export enum ResizeType {
@@ -79,7 +78,7 @@ export class ResizeElementHandler implements IActionHandler {
     protected feedbackDispatcher: IFeedbackActionDispatcher;
 
     protected debouncedChangeBounds?: DebouncedFunc<() => void>;
-    protected disposableFeedback = new DisposableCollection();
+    protected resizeFeedback: FeedbackEmitter;
 
     // Default x resize used if GridSnapper is not provided
     static readonly defaultResizeX = 20;
@@ -96,6 +95,11 @@ export class ResizeElementHandler implements IActionHandler {
         }
     }
 
+    @postConstruct()
+    protected init(): void {
+        this.resizeFeedback = this.feedbackDispatcher.createEmitter();
+    }
+
     handle(action: Action): void | Action | ICommand {
         if (ResizeElementAction.is(action)) {
             this.handleResizeElement(action);
@@ -106,11 +110,11 @@ export class ResizeElementHandler implements IActionHandler {
         const elements = getElements(this.editorContextService.modelRoot.index, action.elementIds, isSelectableAndBoundsAware);
         const elementAndBounds = this.computeElementAndBounds(elements, action);
 
-        this.disposableFeedback.push(this.feedbackDispatcher.registerFeedback(this, [SetBoundsAction.create(elementAndBounds)]));
+        this.resizeFeedback.add(SetBoundsAction.create(elementAndBounds)).submit();
 
         this.debouncedChangeBounds?.cancel();
         this.debouncedChangeBounds = debounce(() => {
-            this.disposableFeedback.dispose();
+            this.resizeFeedback.dispose();
             this.dispatcher.dispatchAll([ChangeBoundsOperation.create(elementAndBounds)]);
             this.debouncedChangeBounds = undefined;
         }, 300);

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

@@ -14,24 +14,20 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import {
-    BoundsAware,
     GChildElement,
     GModelElement,
     GParentElement,
     Hoverable,
-    Locateable,
-    Selectable,
     hoverFeedbackFeature,
     isBoundsAware,
     isMoveable,
     isSelectable
 } from '@eclipse-glsp/sprotty';
+import { BoundsAwareModelElement, MoveableElement, ResizableModelElement } from '../../utils';
 
 export const resizeFeature = Symbol('resizeFeature');
 
-export interface Resizable extends BoundsAware, Selectable {}
-
-export function isResizable(element: GModelElement): element is GParentElement & Resizable {
+export function isResizable(element: GModelElement): element is ResizableModelElement {
     return isBoundsAware(element) && isSelectable(element) && element instanceof GParentElement && element.hasFeature(resizeFeature);
 }
 
@@ -43,15 +39,17 @@ export enum ResizeHandleLocation {
     BottomRight = 'bottom-right'
 }
 
-export function isBoundsAwareMoveable(element: GModelElement): element is GModelElement & Locateable & BoundsAware {
+export function isBoundsAwareMoveable(element: GModelElement): element is BoundsAwareModelElement & MoveableElement {
     return isMoveable(element) && isBoundsAware(element);
 }
 
 export class SResizeHandle extends GChildElement implements Hoverable {
     static readonly TYPE = 'resize-handle';
 
+    override readonly parent: ResizableModelElement;
+
     constructor(
-        readonly location?: ResizeHandleLocation,
+        readonly location: ResizeHandleLocation,
         override readonly type: string = SResizeHandle.TYPE,
         readonly hoverFeedback: boolean = false
     ) {
@@ -87,11 +85,25 @@ export class SResizeHandle extends GChildElement implements Hoverable {
     }
 }
 
-export function addResizeHandles(element: GParentElement): void {
-    element.add(new SResizeHandle(ResizeHandleLocation.TopLeft));
-    element.add(new SResizeHandle(ResizeHandleLocation.TopRight));
-    element.add(new SResizeHandle(ResizeHandleLocation.BottomLeft));
-    element.add(new SResizeHandle(ResizeHandleLocation.BottomRight));
+export function addResizeHandles(
+    element: ResizableModelElement,
+    locations: ResizeHandleLocation[] = [
+        ResizeHandleLocation.TopLeft,
+        ResizeHandleLocation.TopRight,
+        ResizeHandleLocation.BottomLeft,
+        ResizeHandleLocation.BottomRight
+    ]
+): void {
+    for (const location of Object.values(ResizeHandleLocation)) {
+        const existing = element.children.find(child => child instanceof SResizeHandle && child.location === location);
+        if (locations.includes(location) && !existing) {
+            // add missing handle
+            element.add(new SResizeHandle(location));
+        } else if (!locations.includes(location) && existing) {
+            // remove existing handle
+            element.remove(existing);
+        }
+    }
 }
 
 export function removeResizeHandles(element: GParentElement): void {

package/src/features/change-bounds/movement-restrictor.ts

@@ -13,9 +13,10 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Bounds, GModelElement, GNode, GParentElement, Point } from '@eclipse-glsp/sprotty';
 import { injectable } from 'inversify';
-import { BoundsAware, Point, GModelElement, GNode, GParentElement } from '@eclipse-glsp/sprotty';
 import { ModifyCSSFeedbackAction } from '../../base/feedback/css-feedback';
+import { BoundsAwareModelElement } from '../../utils';
 import { toAbsoluteBounds } from '../../utils/viewpoint-util';
 import { SResizeHandle, isBoundsAwareMoveable } from './model';
 
@@ -51,7 +52,7 @@ export class NoOverlapMovementRestrictor implements IMovementRestrictor {
             return false;
         }
         // Create ghost element at the newLocation
-        const ghostElement = Object.create(element) as GModelElement & BoundsAware;
+        const ghostElement = Object.create(element) as BoundsAwareModelElement;
         ghostElement.bounds = {
             x: newLocation.x,
             y: newLocation.y,
@@ -64,29 +65,12 @@ export class NoOverlapMovementRestrictor implements IMovementRestrictor {
             element.root.index
                 .all()
                 .filter(e => e.id !== ghostElement.id && e !== ghostElement.root && e instanceof GNode)
-                .map(e => e as GModelElement & BoundsAware)
+                .map(e => e as BoundsAwareModelElement)
         ).some(e => this.areOverlapping(e, ghostElement));
     }
 
-    protected areOverlapping(element1: GModelElement & BoundsAware, element2: GModelElement & BoundsAware): boolean {
-        const b1 = toAbsoluteBounds(element1);
-        const b2 = toAbsoluteBounds(element2);
-        const r1TopLeft: Point = b1;
-        const r1BottomRight = { x: b1.x + b1.width, y: b1.y + b1.height };
-        const r2TopLeft: Point = b2;
-        const r2BottomRight = { x: b2.x + b2.width, y: b2.y + b2.height };
-
-        // If one rectangle is on left side of other
-        if (r1TopLeft.x > r2BottomRight.x || r2TopLeft.x > r1BottomRight.x) {
-            return false;
-        }
-
-        // If one rectangle is above other
-        if (r1BottomRight.y < r2TopLeft.y || r2BottomRight.y < r1TopLeft.y) {
-            return false;
-        }
-
-        return true;
+    protected areOverlapping(element1: BoundsAwareModelElement, element2: BoundsAwareModelElement): boolean {
+        return Bounds.overlap(toAbsoluteBounds(element1), toAbsoluteBounds(element2));
     }
 }
 

package/src/features/element-template/mouse-tracking-element-position-listener.ts

@@ -14,35 +14,55 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { Action, Disposable, GModelElement, Locateable, MoveAction, Point, isBoundsAware, isMoveable } from '@eclipse-glsp/sprotty';
+import {
+    Action,
+    Dimension,
+    Disposable,
+    ElementMove,
+    GModelElement,
+    MoveAction,
+    Point,
+    isBoundsAware,
+    isMoveable
+} from '@eclipse-glsp/sprotty';
 import { injectable } from 'inversify';
 import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
 import { CSS_HIDDEN, ModifyCSSFeedbackAction } from '../../base/feedback/css-feedback';
+import { FeedbackEmitter } from '../../base/feedback/feeback-emitter';
 import { IFeedbackEmitter } from '../../base/feedback/feedback-action-dispatcher';
 import { Tool } from '../../base/tool-manager/tool';
+import { MoveableElement } from '../../utils';
 import { getAbsolutePosition } from '../../utils/viewpoint-util';
 import {
     IMovementRestrictor,
     createMovementRestrictionFeedback,
     removeMovementRestrictionFeedback
 } from '../change-bounds/movement-restrictor';
-import { PositionSnapper } from '../change-bounds/position-snapper';
 import { PointPositionUpdater } from '../change-bounds/point-position-updater';
+import { PositionSnapper } from '../change-bounds/position-snapper';
 import { useSnap } from '../change-bounds/snap';
+import { MoveFinishedEventAction } from '../tools';
 
 export interface PositioningTool extends Tool {
     readonly positionSnapper: PositionSnapper;
     readonly movementRestrictor?: IMovementRestrictor;
 
+    createFeedbackEmitter(): FeedbackEmitter;
+    /**
+     * @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;
+    /**
+     * @deprecated It is recommended to create a {@link createFeedbackEmitter dedicated emitter} per feedback and dispose it like that.
+     */
     deregisterFeedback(feedbackEmitter?: IFeedbackEmitter, cleanupActions?: Action[]): void;
 }
 
 @injectable()
 export class MouseTrackingElementPositionListener extends DragAwareMouseListener {
-    currentPosition?: Point;
-
     protected positionUpdater: PointPositionUpdater;
+    protected moveGhostFeedback: FeedbackEmitter;
+    protected currentPosition?: Point;
 
     constructor(
         protected elementId: string,
@@ -51,6 +71,7 @@ export class MouseTrackingElementPositionListener extends DragAwareMouseListener
     ) {
         super();
         this.positionUpdater = new PointPositionUpdater(this.tool.positionSnapper);
+        this.moveGhostFeedback = this.tool.createFeedbackEmitter();
     }
 
     override mouseMove(target: GModelElement, event: MouseEvent): Action[] {
@@ -59,59 +80,48 @@ export class MouseTrackingElementPositionListener extends DragAwareMouseListener
         if (!element || !isMoveable(element)) {
             return [];
         }
-        let targetPosition = this.getTargetPosition(target, event, element);
         if (this.positionUpdater.isLastDragPositionUndefined()) {
-            this.positionUpdater.updateLastDragPosition(targetPosition);
+            this.positionUpdater.updateLastDragPosition(element.position);
         }
-        const delta = this.positionUpdater.updatePosition(element, targetPosition, useSnap(event));
+        const mousePosition = getAbsolutePosition(target, event);
+        const delta = this.positionUpdater.updatePosition(element, mousePosition, useSnap(event));
         if (!delta) {
             return [];
         }
-        targetPosition = this.validateMove(this.currentPosition ?? targetPosition, targetPosition, element, false);
-        const moveGhostElement = MoveAction.create(
-            [
-                {
-                    elementId: element.id,
-                    fromPosition: this.currentPosition,
-                    toPosition: targetPosition
-                }
-            ],
-            { animate: false, finished: false }
-        );
-        this.currentPosition = targetPosition;
-        this.tool.registerFeedback([moveGhostElement], this);
-        return element.cssClasses?.includes(CSS_HIDDEN)
-            ? [ModifyCSSFeedbackAction.create({ elements: [element.id], remove: [CSS_HIDDEN] })]
-            : [];
+        const toPosition = this.getElementTargetPosition(mousePosition, element, event);
+        const elementMove = { elementId: element.id, toPosition: toPosition };
+        this.addMoveFeeback(element, elementMove);
+        this.currentPosition = toPosition;
+        // since we are moving a ghost element that is feedback-only and will be removed anyway,
+        // we just send a MoveFinishedEventAction instead of reseting the position with a MoveAction and the finished flag set to true.
+        this.moveGhostFeedback.add(MoveAction.create([elementMove], { animate: false }), MoveFinishedEventAction.create()).submit();
+        return [];
     }
 
-    protected getTargetPosition(target: GModelElement, event: MouseEvent, element: GModelElement & Locateable): Point {
-        let targetPosition = getAbsolutePosition(target, event);
-        if (this.cursorPosition === 'middle' && isBoundsAware(element)) {
-            targetPosition = Point.subtract(targetPosition, { x: element.bounds.width / 2, y: element.bounds.height / 2 });
-        }
-        return targetPosition;
+    protected getElementTargetPosition(mousePosition: Point, element: MoveableElement, event: MouseEvent): Point {
+        const unsnappedPosition =
+            this.cursorPosition === 'middle' && isBoundsAware(element)
+                ? Point.subtract(mousePosition, Dimension.center(element.bounds))
+                : mousePosition;
+        return this.tool.positionSnapper.snapPosition(unsnappedPosition, element, useSnap(event));
     }
 
-    protected snap(position: Point, element: GModelElement, isSnap = true): Point {
-        return this.tool.positionSnapper.snapPosition(position, element, isSnap);
-    }
-
-    protected validateMove(startPosition: Point, toPosition: Point, element: GModelElement, isFinished: boolean): Point {
-        let newPosition = toPosition;
+    protected addMoveFeeback(element: MoveableElement, elementMove: ElementMove): void {
         if (this.tool.movementRestrictor) {
-            const valid = this.tool.movementRestrictor.validate(element, toPosition);
-            let action;
-            if (!valid) {
-                action = createMovementRestrictionFeedback(element, this.tool.movementRestrictor);
-                if (isFinished) {
-                    newPosition = startPosition;
-                }
+            if (!this.tool.movementRestrictor.validate(element, elementMove.toPosition)) {
+                this.moveGhostFeedback.add(
+                    createMovementRestrictionFeedback(element, this.tool.movementRestrictor),
+                    removeMovementRestrictionFeedback(element, this.tool.movementRestrictor)
+                );
             } else {
-                action = removeMovementRestrictionFeedback(element, this.tool.movementRestrictor);
+                this.moveGhostFeedback.add(removeMovementRestrictionFeedback(element, this.tool.movementRestrictor));
             }
-            this.tool.registerFeedback([action], this, [removeMovementRestrictionFeedback(element, this.tool.movementRestrictor)]);
         }
-        return newPosition;
+        this.moveGhostFeedback.add(ModifyCSSFeedbackAction.create({ elements: [element.id], remove: [CSS_HIDDEN] }));
+    }
+
+    override dispose(): void {
+        this.moveGhostFeedback.dispose();
+        super.dispose();
     }
 }