@eclipse-glsp/client 2.2.0-next.336 → 2.2.0-next.338

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/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/base/selection-service.ts

@@ -39,7 +39,7 @@ import { inject, injectable, postConstruct, preDestroy } from 'inversify';
 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';
+import { IDiagramStartup } from './model/diagram-loader';
 
 export interface ISelectionListener {
     selectionChanged(root: Readonly<GModelRoot>, selectedElements: string[], deselectedElements?: string[]): void;

package/src/base/tool-manager/tool-manager.ts

@@ -29,7 +29,7 @@ import {
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
 import { EditorContextService, IEditModeListener } from '../editor-context-service';
-import { IDiagramStartup } from '../model';
+import { IDiagramStartup } from '../model/diagram-loader';
 import { Ranked } from '../ranked';
 import { EnableDefaultToolsAction, EnableToolsAction, Tool } from './tool';
 /**

package/src/base/ui-extension/ui-extension-registry.ts

@@ -16,7 +16,7 @@
 
 import { IUIExtension, LazyInjector, MaybePromise, TYPES, UIExtensionRegistry } from '@eclipse-glsp/sprotty';
 import { inject, injectable, optional } from 'inversify';
-import { IDiagramStartup } from '../model';
+import { IDiagramStartup } from '../model/diagram-loader';
 
 @injectable()
 export class GLSPUIExtensionRegistry extends UIExtensionRegistry implements IDiagramStartup {

package/src/base/view/key-tool.ts

@@ -15,7 +15,7 @@
  ********************************************************************************/
 import { Disposable, KeyListener, KeyTool, LazyInjector, MaybePromise, TYPES } from '@eclipse-glsp/sprotty';
 import { inject, injectable, optional } from 'inversify';
-import { IDiagramStartup } from '../model';
+import { IDiagramStartup } from '../model/diagram-loader';
 
 @injectable()
 export class GLSPKeyTool extends KeyTool implements IDiagramStartup {

package/src/base/view/mouse-tool.ts

@@ -25,7 +25,7 @@ import {
     TYPES
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable, optional } from 'inversify';
-import { IDiagramStartup } from '../model';
+import { IDiagramStartup } from '../model/diagram-loader';
 import { Ranked } from '../ranked';
 
 /**

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 Business Informatics Group (TU Wien) and others.
+ * Copyright (c) 2023-2024 Business Informatics Group (TU Wien) 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
@@ -35,9 +35,9 @@ import {
 } from '@eclipse-glsp/sprotty';
 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 { FeedbackEmitter } from '../../../base/feedback/feedback-emitter';
 import { SelectableBoundsAware, getElements, isSelectableAndBoundsAware } from '../../../utils/gmodel-util';
 import { isValidMove } from '../../../utils/layout-utils';
 import { outsideOfViewport } from '../../../utils/viewpoint-util';

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 Business Informatics Group (TU Wien) and others.
+ * Copyright (c) 2023-2024 Business Informatics Group (TU Wien) 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
@@ -31,12 +31,12 @@ import {
 } from '@eclipse-glsp/sprotty';
 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 { FeedbackEmitter } from '../../../base/feedback/feedback-emitter';
 import { Resizable, SelectableBoundsAware, getElements, isSelectableAndBoundsAware, toElementAndBounds } from '../../../utils/gmodel-util';
 import { isValidMove, isValidSize, minHeight, minWidth } from '../../../utils/layout-utils';
-import { Grid } from '../../grid';
+import { Grid } from '../../grid/grid';
 
 export enum ResizeType {
     Increase,

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 Business Informatics Group (TU Wien) and others.
+ * Copyright (c) 2023-2024 Business Informatics Group (TU Wien) 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
@@ -20,8 +20,8 @@ import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
 import { GLSPActionDispatcher } from '../../../base/action-dispatcher';
 import { SelectionService } from '../../../base/selection-service';
 import { Tool } from '../../../base/tool-manager/tool';
-import { Grid } from '../../grid';
-import { ChangeBoundsManager } from '../../tools';
+import { Grid } from '../../grid/grid';
+import { ChangeBoundsManager } from '../../tools/change-bounds/change-bounds-manager';
 import { AccessibleKeyShortcutProvider, SetAccessibleKeyShortcutAction } from '../key-shortcut/accessible-key-shortcut';
 import { MoveElementAction, MoveViewportAction } from '../move-zoom/move-handler';
 
@@ -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/bounds/set-bounds-feedback-command.ts

@@ -24,9 +24,9 @@ import {
     isLayoutContainer
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
-import { Ranked } from '../../base';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { FeedbackCommand } from '../../base/feedback/feedback-command';
+import { Ranked } from '../../base/ranked';
 import { LocalRequestBoundsAction } from './local-bounds';
 
 export interface SetBoundsFeedbackAction extends Omit<SetBoundsAction, 'kind'> {

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2023 EclipseSource and others.
+ * 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
@@ -15,6 +15,7 @@
  ********************************************************************************/
 import {
     Bounds,
+    Direction,
     GChildElement,
     GModelElement,
     GParentElement,
@@ -25,8 +26,8 @@ import {
     isMoveable,
     isSelectable
 } from '@eclipse-glsp/sprotty';
-import { CursorCSS } from '../../base';
-import { BoundsAwareModelElement, MoveableElement, ResizableModelElement } from '../../utils';
+import { CursorCSS } from '../../base/feedback/css-feedback';
+import { BoundsAwareModelElement, MoveableElement, ResizableModelElement } from '../../utils/gmodel-util';
 
 export const resizeFeature = Symbol('resizeFeature');
 
@@ -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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2023 EclipseSource and others.
+ * 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
@@ -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 { BoundsAwareModelElement } from '../../utils/gmodel-util';
 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/change-bounds/point-position-updater.spec.ts

@@ -18,7 +18,7 @@
 
 import { GModelElement } from '@eclipse-glsp/sprotty';
 import { expect } from 'chai';
-import { GridSnapper } from '../grid';
+import { GridSnapper } from './../grid/grid-snapper';
 import { PointPositionUpdater } from './point-position-updater';
 
 describe('PointPositionUpdater', () => {

package/src/features/debug/debug-bounds-decorator.tsx

@@ -15,11 +15,11 @@
  ********************************************************************************/
 /* eslint-disable max-len */
 
-import { Bounds, GModelElement, IVNodePostprocessor, Point, TYPES, isDecoration, isSizeable, setClass, svg } from '@eclipse-glsp/sprotty';
+import { Bounds, GModelElement, IVNodePostprocessor, Point, isDecoration, isSizeable, setClass, svg } from '@eclipse-glsp/sprotty';
 import { inject, injectable, optional } from 'inversify';
 import { VNode } from 'snabbdom';
 import { GGraph } from '../../model';
-import { BoundsAwareModelElement } from '../../utils';
+import { BoundsAwareModelElement } from '../../utils/gmodel-util';
 import { DebugManager } from './debug-manager';
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -29,7 +29,7 @@ export const CSS_DEBUG_BOUNDS = 'debug-bounds';
 
 @injectable()
 export class DebugBoundsDecorator implements IVNodePostprocessor {
-    @inject(TYPES.IDebugManager) @optional() protected debugManager?: DebugManager;
+    @inject(DebugManager) @optional() protected debugManager?: DebugManager;
 
     decorate(vnode: VNode, element: GModelElement): VNode {
         if (!this.debugManager?.isDebugEnabled) {
@@ -87,7 +87,7 @@ export class DebugBoundsDecorator implements IVNodePostprocessor {
     }
 
     protected renderTopLeftCorner(element: BoundsAwareModelElement): VNode {
-        const position = Bounds.topLeft(element.bounds);
+        const position = Bounds.position(element.bounds);
         const topLeft = Bounds.topLeft(element.bounds);
         const corner = Point.subtract(topLeft, position);
         return (
@@ -104,7 +104,7 @@ export class DebugBoundsDecorator implements IVNodePostprocessor {
     }
 
     protected renderTopRightCorner(element: BoundsAwareModelElement): VNode {
-        const position = Bounds.topLeft(element.bounds);
+        const position = Bounds.position(element.bounds);
         const topRight = Bounds.topRight(element.bounds);
         const corner = Point.subtract(topRight, position);
         return (
@@ -121,7 +121,7 @@ export class DebugBoundsDecorator implements IVNodePostprocessor {
     }
 
     protected renderBottomLeftCorner(element: BoundsAwareModelElement): VNode {
-        const position = Bounds.topLeft(element.bounds);
+        const position = Bounds.position(element.bounds);
         const bottomLeft = Bounds.bottomLeft(element.bounds);
         const corner = Point.subtract(bottomLeft, position);
         return (
@@ -138,7 +138,7 @@ export class DebugBoundsDecorator implements IVNodePostprocessor {
     }
 
     protected renderBottomRightCorner(element: BoundsAwareModelElement): VNode {
-        const position = Bounds.topLeft(element.bounds);
+        const position = Bounds.position(element.bounds);
         const bottomRight = Bounds.bottomRight(element.bounds);
         const corner = Point.subtract(bottomRight, position);
         return (
@@ -156,7 +156,7 @@ export class DebugBoundsDecorator implements IVNodePostprocessor {
 
     protected renderCenter(element: BoundsAwareModelElement): VNode {
         const bounds = element.bounds;
-        const position = Bounds.topLeft(bounds);
+        const position = Bounds.position(bounds);
         const center = Bounds.center(bounds);
         const corner = Point.subtract(center, position);
         return (

package/src/features/debug/debug-manager.ts

@@ -16,7 +16,8 @@
 
 import { IActionHandler, TYPES } from '@eclipse-glsp/sprotty';
 import { inject, injectable, postConstruct } from 'inversify';
-import { FeedbackEmitter, IFeedbackActionDispatcher } from '../../base';
+import { IFeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
+import { FeedbackEmitter } from '../../base/feedback/feedback-emitter';
 import { EnableDebugModeAction } from './debug-model';
 
 @injectable()

package/src/features/debug/debug-model.ts

@@ -16,8 +16,8 @@
 
 import { Action, CommandExecutionContext, CommandReturn, GModelRoot, TYPES, hasBooleanProp } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
-import { FeedbackCommand } from '../../base';
-import { addCssClasses, removeCssClasses } from '../../utils';
+import { FeedbackCommand } from '../../base/feedback/feedback-command';
+import { addCssClasses, removeCssClasses } from '../../utils/gmodel-util';
 
 export interface EnableDebugModeAction extends Action {
     kind: typeof EnableDebugModeAction.KIND;

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

@@ -25,7 +25,7 @@ export const debugModule = new FeatureModule((bind, unbind, isBound, rebind) =>
 
     configureCommand(context, EnableDebugModeCommand);
 
-    bindAsService(bind, TYPES.IDebugManager, DebugManager);
+    bind(DebugManager).toSelf().inSingletonScope();
     configureActionHandler(context, EnableDebugModeAction.KIND, DebugManager);
 
     bindAsService(context, TYPES.IVNodePostprocessor, DebugBoundsDecorator);