@eclipse-glsp/client 2.2.0-next.335 → 2.2.0-next.337

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

@@ -0,0 +1,119 @@
+/********************************************************************************
+ * Copyright (c) 2019-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,
+    ActionHandlerRegistry,
+    Command,
+    CommandActionHandler,
+    CommandExecutionContext,
+    Disposable,
+    GModelElement,
+    IActionDispatcher,
+    ICommand,
+    ILogger,
+    TYPES,
+    toTypeGuard
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
+import { getFeedbackRank } from './feedback-command';
+import { FeedbackEmitter } from './feedback-emitter';
+import { IFeedbackActionDispatcher, IFeedbackEmitter, MaybeActions } from './feedback-action-dispatcher';
+
+@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?: 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);
+        }
+        return Disposable.create(() => this.deregisterFeedback(feedbackEmitter, cleanupActions));
+    }
+
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, cleanupActions?: MaybeActions): void {
+        this.registeredFeedback.delete(feedbackEmitter);
+        const actions = MaybeActions.asArray(cleanupActions);
+        if (actions.length > 0) {
+            this.dispatchFeedback(actions, 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)) ?? []
+        );
+    }
+
+    createEmitter(): FeedbackEmitter {
+        return new FeedbackEmitter(this);
+    }
+
+    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);
+        }
+    }
+}

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

@@ -13,26 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import {
-    Action,
-    ActionHandlerRegistry,
-    Command,
-    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';
+import { Action, Command, CommandExecutionContext, Disposable, MaybeFunction, call, asArray as toArray } from '@eclipse-glsp/sprotty';
+import { FeedbackEmitter } from './feedback-emitter';
 
 export interface IFeedbackEmitter {}
 
@@ -104,89 +86,3 @@ export interface IFeedbackActionDispatcher {
      */
     createEmitter(): FeedbackEmitter;
 }
-
-@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?: 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);
-        }
-        return Disposable.create(() => this.deregisterFeedback(feedbackEmitter, cleanupActions));
-    }
-
-    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, cleanupActions?: MaybeActions): void {
-        this.registeredFeedback.delete(feedbackEmitter);
-        const actions = MaybeActions.asArray(cleanupActions);
-        if (actions.length > 0) {
-            this.dispatchFeedback(actions, 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)) ?? []
-        );
-    }
-
-    createEmitter(): FeedbackEmitter {
-        return new FeedbackEmitter(this);
-    }
-
-    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);
-        }
-    }
-}

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/{feeback-emitter.ts → feedback-emitter.ts}

@@ -17,10 +17,14 @@
 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;
@@ -46,6 +50,17 @@ export class FeedbackEmitter implements IFeedbackEmitter, Disposable {
         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.
@@ -56,9 +71,9 @@ export class FeedbackEmitter implements IFeedbackEmitter, Disposable {
      */
     remove(action: Action): this {
         const idx = this.feedbackActions.indexOf(action);
-        if (idx) {
-            delete this.feedbackActions[idx];
-            delete this.cleanupActions[idx];
+        if (idx >= 0) {
+            this.feedbackActions.splice(idx, 1);
+            this.cleanupActions.splice(idx, 1);
         }
         return this;
     }
@@ -79,8 +94,12 @@ export class FeedbackEmitter implements IFeedbackEmitter, Disposable {
         // 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);
-        this.deregistration = this.feedbackDispatcher.registerFeedback(this, actions, () => cleanupActions.flatMap(MaybeActions.asArray));
-        this.clear();
+        if (actions.length > 0 || cleanupActions.length > 0) {
+            this.deregistration = this.feedbackDispatcher.registerFeedback(this, actions, () =>
+                cleanupActions.flatMap(MaybeActions.asArray)
+            );
+            this.clear();
+        }
         return this;
     }
 

package/src/base/feedback/index.ts

@@ -14,8 +14,9 @@
  * 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-action-dispatcher-default';
 export * from './feedback-command';
+export * from './feedback-emitter';
 export * from './set-model-command';
 export * from './update-model-command';

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

@@ -18,8 +18,8 @@ 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 { FeedbackEmitter } from './feedback/feedback-emitter';
 import { ISelectionListener, SelectFeedbackAction, SelectionService } from './selection-service';
 
 @injectable()

package/src/features/accessibility/view-key-tools/movement-key-tool.ts

@@ -41,7 +41,7 @@ export class MovementKeyTool implements Tool {
     @inject(TYPES.ISnapper) @optional() readonly snapper?: ISnapper;
     @inject(TYPES.IActionDispatcher) readonly actionDispatcher: GLSPActionDispatcher;
     @inject(TYPES.Grid) @optional() protected grid: Grid;
-    @inject(TYPES.IChangeBoundsManager) readonly changeBoundsManager: ChangeBoundsManager;
+    @inject(ChangeBoundsManager) readonly changeBoundsManager: ChangeBoundsManager;
 
     get id(): string {
         return MovementKeyTool.ID;

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

@@ -15,6 +15,7 @@
  ********************************************************************************/
 import {
     Bounds,
+    Direction,
     GChildElement,
     GModelElement,
     GParentElement,
@@ -47,6 +48,20 @@ export enum ResizeHandleLocation {
 }
 
 export namespace ResizeHandleLocation {
+    export const CORNERS: ResizeHandleLocation[] = [
+        ResizeHandleLocation.TopLeft,
+        ResizeHandleLocation.TopRight,
+        ResizeHandleLocation.BottomRight,
+        ResizeHandleLocation.BottomLeft
+    ];
+    export const CROSS: ResizeHandleLocation[] = [
+        ResizeHandleLocation.Top,
+        ResizeHandleLocation.Right,
+        ResizeHandleLocation.Bottom,
+        ResizeHandleLocation.Left
+    ];
+    export const ALL = Object.values(ResizeHandleLocation).filter(value => typeof value !== 'function') as ResizeHandleLocation[];
+
     export function opposite(location: ResizeHandleLocation): ResizeHandleLocation {
         switch (location) {
             case ResizeHandleLocation.TopLeft:
@@ -67,6 +82,27 @@ export namespace ResizeHandleLocation {
                 return ResizeHandleLocation.Right;
         }
     }
+
+    export function direction(location: ResizeHandleLocation): Direction[] {
+        switch (location) {
+            case ResizeHandleLocation.TopLeft:
+                return [Direction.Up, Direction.Left];
+            case ResizeHandleLocation.Top:
+                return [Direction.Up];
+            case ResizeHandleLocation.TopRight:
+                return [Direction.Up, Direction.Right];
+            case ResizeHandleLocation.Right:
+                return [Direction.Right];
+            case ResizeHandleLocation.BottomRight:
+                return [Direction.Down, Direction.Right];
+            case ResizeHandleLocation.Bottom:
+                return [Direction.Down];
+            case ResizeHandleLocation.BottomLeft:
+                return [Direction.Down, Direction.Left];
+            case ResizeHandleLocation.Left:
+                return [Direction.Left];
+        }
+    }
 }
 
 export function isBoundsAwareMoveable(element: GModelElement): element is BoundsAwareModelElement & MoveableElement {
@@ -182,19 +218,8 @@ export class SResizeHandle extends GChildElement implements Hoverable {
     }
 }
 
-export function addResizeHandles(
-    element: ResizableModelElement,
-    locations: ResizeHandleLocation[] = [
-        ResizeHandleLocation.TopLeft,
-        ResizeHandleLocation.Top,
-        ResizeHandleLocation.BottomLeft,
-        ResizeHandleLocation.BottomRight
-    ]
-): void {
-    for (const location of Object.values(ResizeHandleLocation)) {
-        if (typeof location === 'function') {
-            continue;
-        }
+export function addResizeHandles(element: ResizableModelElement, locations: ResizeHandleLocation[] = ResizeHandleLocation.CORNERS): void {
+    for (const location of ResizeHandleLocation.ALL) {
         const existing = element.children.find(child => child instanceof SResizeHandle && child.location === location);
         if (locations.includes(location) && !existing) {
             // add missing handle

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

@@ -13,12 +13,12 @@
  *
  * 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 { Bounds, Dimension, GModelElement, GNode, GParentElement, Point, isBoundsAware, isMoveable } from '@eclipse-glsp/sprotty';
 import { injectable } from 'inversify';
 import { ModifyCSSFeedbackAction } from '../../base/feedback/css-feedback';
 import { BoundsAwareModelElement } from '../../utils';
 import { toAbsoluteBounds } from '../../utils/viewpoint-util';
-import { SResizeHandle, isBoundsAwareMoveable } from './model';
+import { SResizeHandle } from './model';
 
 /**
  * A `MovementRestrictor` is an optional service that can be used by tools to validate
@@ -48,27 +48,27 @@ export class NoOverlapMovementRestrictor implements IMovementRestrictor {
     cssClasses = ['movement-not-allowed'];
 
     validate(element: GModelElement, newLocation?: Point): boolean {
-        if (!isBoundsAwareMoveable(element) || !newLocation) {
+        if (!isMoveable(element) || !newLocation) {
             return false;
         }
         // Create ghost element at the newLocation
+        const dimensions: Dimension = isBoundsAware(element) ? element.bounds : { width: 1, height: 1 };
         const ghostElement = Object.create(element) as BoundsAwareModelElement;
-        ghostElement.bounds = {
-            x: newLocation.x,
-            y: newLocation.y,
-            width: element.bounds.width,
-            height: element.bounds.height
-        };
+        ghostElement.bounds = { ...dimensions, ...newLocation };
         ghostElement.type = 'Ghost';
         ghostElement.id = element.id;
         return !Array.from(
             element.root.index
                 .all()
-                .filter(e => e.id !== ghostElement.id && e !== ghostElement.root && e instanceof GNode)
-                .map(e => e as BoundsAwareModelElement)
+                .filter(node => node.id !== ghostElement.id && node !== ghostElement.root && node instanceof GNode)
+                .map(node => node as BoundsAwareModelElement)
         ).some(e => this.areOverlapping(e, ghostElement));
     }
 
+    protected isBoundsRelevant(element: GModelElement, ghostElement: BoundsAwareModelElement): element is BoundsAwareModelElement {
+        return element.id !== ghostElement.id && element !== ghostElement.root && element instanceof GNode && isBoundsAware(element);
+    }
+
     protected areOverlapping(element1: BoundsAwareModelElement, element2: BoundsAwareModelElement): boolean {
         return Bounds.overlap(toAbsoluteBounds(element1), toAbsoluteBounds(element2));
     }

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

@@ -35,15 +35,12 @@ export class CopyPasteStartup implements IDiagramStartup, Disposable {
         }
         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);