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

package/src/features/bounds/local-bounds.ts

@@ -31,6 +31,7 @@ import {
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
 import { ServerAction } from '../../base/model/glsp-model-source';
+import { LayoutAware } from './layout-data';
 
 export interface LocalRequestBoundsAction extends RequestBoundsAction {
     elementIDs?: string[];
@@ -41,9 +42,11 @@ export namespace LocalRequestBoundsAction {
         return RequestBoundsAction.is(object) && !ServerAction.is(object) && hasArrayProp(object, 'elementIDs', true);
     }
 
-    export function create(newRoot: GModelRootSchema, elementIDs?: string[]): LocalRequestBoundsAction {
+    export function create(newRoot: GModelRoot, elementIDs?: string[]): LocalRequestBoundsAction;
+    export function create(newRoot: GModelRootSchema, elementIDs?: string[]): LocalRequestBoundsAction;
+    export function create(newRoot: GModelRoot | GModelRootSchema, elementIDs?: string[]): LocalRequestBoundsAction {
         return {
-            ...RequestBoundsAction.create(newRoot),
+            ...RequestBoundsAction.create(newRoot as unknown as GModelRootSchema),
             elementIDs
         };
     }
@@ -55,7 +58,7 @@ export namespace LocalRequestBoundsAction {
         elementIDs?: string[]
     ): CommandResult {
         // do not modify the main model (modelChanged = false) but request local bounds calculation on hidden model
-        actionDispatcher.dispatch(LocalRequestBoundsAction.create(root as unknown as GModelRootSchema, elementIDs));
+        actionDispatcher.dispatch(LocalRequestBoundsAction.create(root, elementIDs));
         return {
             model: root,
             modelChanged: false,
@@ -65,7 +68,7 @@ export namespace LocalRequestBoundsAction {
 }
 
 export namespace LocalComputedBoundsAction {
-    export function is(object: unknown): object is RequestBoundsAction {
+    export function is(object: unknown): object is ComputedBoundsAction & ServerAction {
         return ComputedBoundsAction.is(object) && ServerAction.is(object);
     }
 
@@ -94,9 +97,22 @@ export class LocalComputedBoundsCommand extends Command {
             }
             // apply computed bounds from the hidden model and return updated model to render new main model
             this.computedBoundsApplicator.apply(context.root as unknown as GModelRootSchema, this.action);
+            this.action.layoutData?.forEach(({ elementId, layoutData }) => {
+                const element = context.root.index.getById(elementId);
+                if (element !== undefined) {
+                    LayoutAware.setLayoutData(element, layoutData);
+                }
+            });
             return context.root;
         }
 
+        this.action.layoutData?.forEach(({ elementId, layoutData }) => {
+            const element = context.root.index.getById(elementId);
+            if (element !== undefined) {
+                LayoutAware.setLayoutData(element, layoutData);
+            }
+        });
+
         // computed bounds action from server -> we do not care and do not trigger any update of the main model
         return {
             model: context.root,

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/bounds/vbox-layout.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021-2023 EclipseSource and others.
+ * Copyright (c) 2021-2024 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,22 +13,23 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { injectable } from 'inversify';
 import {
     Bounds,
     BoundsData,
     Dimension,
     GChildElement,
-    LayoutContainer,
-    Point,
     GModelElement,
     GParentElement,
+    LayoutContainer,
+    Point,
     StatefulLayouter,
     VBoxLayoutOptions,
     VBoxLayouter,
     isBoundsAware,
     isLayoutableChild
 } from '@eclipse-glsp/sprotty';
+import { injectable } from 'inversify';
+import { LayoutAware } from './layout-data';
 
 export interface VBoxLayoutOptionsExt extends VBoxLayoutOptions {
     hGrab: boolean;
@@ -79,7 +80,9 @@ export class VBoxLayouterExt extends VBoxLayouter {
 
         if (maxWidth > 0 && maxHeight > 0) {
             const offset = this.layoutChildren(container, layouter, options, width, height, grabHeight, grabbingChildren);
-            boundsData.bounds = this.getFinalContainerBounds(container, offset, options, childrenSize.width, childrenSize.height);
+            const computed = this.getComputedContainerDimensions(options, childrenSize.width, childrenSize.height);
+            LayoutAware.setComputedDimensions(boundsData, computed);
+            boundsData.bounds = this.getFinalContainerBounds(container, offset, options, computed.width, computed.height);
             boundsData.boundsChanged = true;
         }
     }
@@ -223,24 +226,29 @@ export class VBoxLayouterExt extends VBoxLayouter {
         return (element as any).layoutOptions;
     }
 
+    protected getComputedContainerDimensions(options: VBoxLayoutOptionsExt, maxWidth: number, maxHeight: number): Dimension {
+        return {
+            width: maxWidth + options.paddingLeft + options.paddingRight,
+            height: maxHeight + options.paddingTop + options.paddingBottom
+        };
+    }
+
     protected override getFinalContainerBounds(
         container: GParentElement & LayoutContainer,
         lastOffset: Point,
         options: VBoxLayoutOptionsExt,
-        maxWidth: number,
-        maxHeight: number
+        computedWidth: number,
+        computedHeight: number
     ): Bounds {
         const elementOptions = this.getElementLayoutOptions(container);
         const width = elementOptions?.prefWidth ?? options.minWidth;
         const height = elementOptions?.prefHeight ?? options.minHeight;
-
         const result = {
             x: container.bounds.x,
             y: container.bounds.y,
-            width: Math.max(width, maxWidth + options.paddingLeft + options.paddingRight),
-            height: Math.max(height, maxHeight + options.paddingTop + options.paddingBottom)
+            width: Math.max(width, computedWidth),
+            height: Math.max(height, computedHeight)
         };
-
         return result;
     }
 

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
@@ -14,45 +14,109 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import {
-    BoundsAware,
+    Bounds,
+    Direction,
     GChildElement,
     GModelElement,
     GParentElement,
     Hoverable,
-    Locateable,
-    Selectable,
+    Point,
     hoverFeedbackFeature,
     isBoundsAware,
     isMoveable,
     isSelectable
 } from '@eclipse-glsp/sprotty';
+import { CursorCSS } from '../../base/feedback/css-feedback';
+import { BoundsAwareModelElement, MoveableElement, ResizableModelElement } from '../../utils/gmodel-util';
 
 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);
 }
 
 // eslint-disable-next-line no-shadow
 export enum ResizeHandleLocation {
     TopLeft = 'top-left',
+    Top = 'top',
     TopRight = 'top-right',
+    Right = 'right',
+    BottomRight = 'bottom-right',
+    Bottom = 'bottom',
     BottomLeft = 'bottom-left',
-    BottomRight = 'bottom-right'
+    Left = 'left'
 }
 
-export function isBoundsAwareMoveable(element: GModelElement): element is GModelElement & Locateable & BoundsAware {
+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: ResizeHandleLocation[] = [...ResizeHandleLocation.CORNERS, ...ResizeHandleLocation.CROSS];
+
+    export function opposite(location: ResizeHandleLocation): ResizeHandleLocation {
+        switch (location) {
+            case ResizeHandleLocation.TopLeft:
+                return ResizeHandleLocation.BottomRight;
+            case ResizeHandleLocation.Top:
+                return ResizeHandleLocation.Bottom;
+            case ResizeHandleLocation.TopRight:
+                return ResizeHandleLocation.BottomLeft;
+            case ResizeHandleLocation.Right:
+                return ResizeHandleLocation.Left;
+            case ResizeHandleLocation.BottomRight:
+                return ResizeHandleLocation.TopLeft;
+            case ResizeHandleLocation.Bottom:
+                return ResizeHandleLocation.Top;
+            case ResizeHandleLocation.BottomLeft:
+                return ResizeHandleLocation.TopRight;
+            case ResizeHandleLocation.Left:
+                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 {
     return isMoveable(element) && isBoundsAware(element);
 }
 
-export class SResizeHandle extends GChildElement implements Hoverable {
+export class GResizeHandle extends GChildElement implements Hoverable {
     static readonly TYPE = 'resize-handle';
 
+    override readonly parent: ResizableModelElement;
+
     constructor(
-        readonly location?: ResizeHandleLocation,
-        override readonly type: string = SResizeHandle.TYPE,
+        readonly location: ResizeHandleLocation,
+        override readonly type: string = GResizeHandle.TYPE,
         readonly hoverFeedback: boolean = false
     ) {
         super();
@@ -66,18 +130,34 @@ export class SResizeHandle extends GChildElement implements Hoverable {
         return this.location === ResizeHandleLocation.TopLeft;
     }
 
-    isSeResize(): boolean {
-        return this.location === ResizeHandleLocation.BottomRight;
+    isNResize(): boolean {
+        return this.location === ResizeHandleLocation.Top;
     }
 
     isNeResize(): boolean {
         return this.location === ResizeHandleLocation.TopRight;
     }
 
+    isEResize(): boolean {
+        return this.location === ResizeHandleLocation.Right;
+    }
+
+    isSeResize(): boolean {
+        return this.location === ResizeHandleLocation.BottomRight;
+    }
+
+    isSResize(): boolean {
+        return this.location === ResizeHandleLocation.Bottom;
+    }
+
     isSwResize(): boolean {
         return this.location === ResizeHandleLocation.BottomLeft;
     }
 
+    isWResize(): boolean {
+        return this.location === ResizeHandleLocation.Left;
+    }
+
     isNwSeResize(): boolean {
         return this.isNwResize() || this.isSeResize();
     }
@@ -85,15 +165,77 @@ export class SResizeHandle extends GChildElement implements Hoverable {
     isNeSwResize(): boolean {
         return this.isNeResize() || this.isSwResize();
     }
+
+    static getHandlePosition(handle: GResizeHandle): Point;
+    static getHandlePosition(parent: ResizableModelElement, location: ResizeHandleLocation): Point;
+    static getHandlePosition(bounds: Bounds, location: ResizeHandleLocation): Point;
+    static getHandlePosition(first: ResizableModelElement | GResizeHandle | Bounds, second?: ResizeHandleLocation): Point {
+        const bounds = GResizeHandle.is(first) ? first.parent.bounds : first instanceof GModelElement ? first.bounds : first;
+        const location = GResizeHandle.is(first) ? first.location : second!;
+        switch (location) {
+            case ResizeHandleLocation.TopLeft:
+                return Bounds.topLeft(bounds);
+            case ResizeHandleLocation.Top:
+                return Bounds.topCenter(bounds);
+            case ResizeHandleLocation.TopRight:
+                return Bounds.topRight(bounds);
+            case ResizeHandleLocation.Right:
+                return Bounds.middleRight(bounds);
+            case ResizeHandleLocation.BottomRight:
+                return Bounds.bottomRight(bounds);
+            case ResizeHandleLocation.Bottom:
+                return Bounds.bottomCenter(bounds);
+            case ResizeHandleLocation.BottomLeft:
+                return Bounds.bottomLeft(bounds);
+            case ResizeHandleLocation.Left:
+                return Bounds.middleLeft(bounds);
+        }
+    }
+
+    static getCursorCss(handle: GResizeHandle): string {
+        switch (handle.location) {
+            case ResizeHandleLocation.TopLeft:
+                return CursorCSS.RESIZE_NW;
+            case ResizeHandleLocation.Top:
+                return CursorCSS.RESIZE_N;
+            case ResizeHandleLocation.TopRight:
+                return CursorCSS.RESIZE_NE;
+            case ResizeHandleLocation.Right:
+                return CursorCSS.RESIZE_E;
+            case ResizeHandleLocation.BottomRight:
+                return CursorCSS.RESIZE_SE;
+            case ResizeHandleLocation.Bottom:
+                return CursorCSS.RESIZE_S;
+            case ResizeHandleLocation.BottomLeft:
+                return CursorCSS.RESIZE_SW;
+            case ResizeHandleLocation.Left:
+                return CursorCSS.RESIZE_W;
+        }
+    }
+
+    static is(handle: unknown): handle is GResizeHandle {
+        return typeof handle === 'object' && !!handle && 'type' in handle && handle.type === GResizeHandle.TYPE;
+    }
 }
 
-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.CORNERS): void {
+    for (const location of ResizeHandleLocation.ALL) {
+        const existing = element.children.find(child => child instanceof GResizeHandle && child.location === location);
+        if (locations.includes(location) && !existing) {
+            // add missing handle
+            element.add(new GResizeHandle(location));
+        } else if (!locations.includes(location) && existing) {
+            // remove existing handle
+            element.remove(existing);
+        }
+    }
 }
 
 export function removeResizeHandles(element: GParentElement): void {
-    element.removeAll(child => child instanceof SResizeHandle);
+    element.removeAll(child => child instanceof GResizeHandle);
 }
+
+export {
+    /** @deprecated Use {@link GResizeHandle} instead */
+    GResizeHandle as SResizeHandle
+};

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,11 +13,12 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Bounds, Dimension, GModelElement, GNode, GParentElement, Point, isBoundsAware, isMoveable } 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/gmodel-util';
 import { toAbsoluteBounds } from '../../utils/viewpoint-util';
-import { SResizeHandle, isBoundsAwareMoveable } from './model';
+import { GResizeHandle } from './model';
 
 /**
  * A `MovementRestrictor` is an optional service that can be used by tools to validate
@@ -47,46 +48,29 @@ 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 ghostElement = Object.create(element) as GModelElement & BoundsAware;
-        ghostElement.bounds = {
-            x: newLocation.x,
-            y: newLocation.y,
-            width: element.bounds.width,
-            height: element.bounds.height
-        };
+        const dimensions: Dimension = isBoundsAware(element) ? element.bounds : { width: 1, height: 1 };
+        const ghostElement = Object.create(element) as BoundsAwareModelElement;
+        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 GModelElement & BoundsAware)
+                .filter(node => node.id !== ghostElement.id && node !== ghostElement.root && node instanceof GNode)
+                .map(node => node 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;
-        }
+    protected isBoundsRelevant(element: GModelElement, ghostElement: BoundsAwareModelElement): element is BoundsAwareModelElement {
+        return element.id !== ghostElement.id && element !== ghostElement.root && element instanceof GNode && isBoundsAware(element);
+    }
 
-        return true;
+    protected areOverlapping(element1: BoundsAwareModelElement, element2: BoundsAwareModelElement): boolean {
+        return Bounds.overlap(toAbsoluteBounds(element1), toAbsoluteBounds(element2));
     }
 }
 
@@ -102,7 +86,7 @@ export function createMovementRestrictionFeedback(
 ): ModifyCSSFeedbackAction {
     const elements: GModelElement[] = [element];
     if (element instanceof GParentElement) {
-        element.children.filter(child => child instanceof SResizeHandle).forEach(e => elements.push(e));
+        element.children.filter(child => child instanceof GResizeHandle).forEach(e => elements.push(e));
     }
     return ModifyCSSFeedbackAction.create({ elements, add: movementRestrictor.cssClasses });
 }
@@ -119,8 +103,18 @@ export function removeMovementRestrictionFeedback(
 ): ModifyCSSFeedbackAction {
     const elements: GModelElement[] = [element];
     if (element instanceof GParentElement) {
-        element.children.filter(child => child instanceof SResizeHandle).forEach(e => elements.push(e));
+        element.children.filter(child => child instanceof GResizeHandle).forEach(e => elements.push(e));
     }
 
     return ModifyCSSFeedbackAction.create({ elements, remove: movementRestrictor.cssClasses });
 }
+
+export function movementRestrictionFeedback(
+    element: GModelElement,
+    movementRestrictor: IMovementRestrictor,
+    valid: boolean
+): ModifyCSSFeedbackAction {
+    return valid
+        ? removeMovementRestrictionFeedback(element, movementRestrictor)
+        : createMovementRestrictionFeedback(element, movementRestrictor);
+}

package/src/features/change-bounds/{snap.spec.ts → point-position-updater.spec.ts}

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2023 EclipseSource and others.
+ * Copyright (c) 2022-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,22 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+/* eslint-disable import/no-deprecated */
+/* eslint-disable deprecation/deprecation */
 
 import { GModelElement } from '@eclipse-glsp/sprotty';
 import { expect } from 'chai';
+import { GridSnapper } from './../grid/grid-snapper';
 import { PointPositionUpdater } from './point-position-updater';
-import { GridSnapper } from './snap';
-
-describe('GridSnapper', () => {
-    it('snap', () => {
-        const element = new GModelElement();
-        const snapper = new GridSnapper();
-        expect(snapper.snap({ x: 0, y: 0 }, element)).to.be.deep.equals({ x: 0, y: 0 });
-        expect(snapper.snap({ x: 4, y: 5 }, element)).to.be.deep.equals({ x: 0, y: 10 });
-        expect(snapper.snap({ x: 8, y: 11 }, element)).to.be.deep.equals({ x: 10, y: 10 });
-        expect(snapper.snap({ x: -7, y: -4 }, element)).to.be.deep.equals({ x: -10, y: -0 });
-    });
-});
 
 describe('PointPositionUpdater', () => {
     it('updatePosition with no last drag position', () => {

package/src/features/change-bounds/point-position-updater.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2023 EclipseSource and others.
+ * Copyright (c) 2020-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
@@ -14,6 +14,9 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 /* eslint-disable @typescript-eslint/no-shadow */
+/* eslint-disable import/no-deprecated */
+/* eslint-disable deprecation/deprecation */
+
 import { GModelElement, ISnapper, Point, Writable } from '@eclipse-glsp/sprotty';
 import { calculateDeltaBetweenPoints } from '../../utils/gmodel-util';
 import { isMouseEvent } from '../../utils/html-utils';
@@ -29,6 +32,9 @@ import { useSnap } from './snap';
  *
  * You can initialize a this class with a optional {@link ISnapper}. If a
  * snapper is present, the positions will be snapped to the defined grid.
+ *
+ * @deprecated The use of this class is discouraged. Use the {@link ChangeBoundsManager.createTracker}
+ * instead which centralized a few aspects of the tracking.
  */
 export class PointPositionUpdater {
     protected positionSnapper: PositionSnapper;

package/src/features/change-bounds/position-snapper.ts

@@ -18,6 +18,10 @@ import { inject, injectable, optional } from 'inversify';
 import { IHelperLineManager } from '../helper-lines/helper-line-manager';
 import { Direction, HelperLine, isHelperLine } from '../helper-lines/model';
 
+/**
+ * @deprecated The use of this class is discouraged. Use the {@link ChangeBoundsManager.createTracker}
+ * instead which centralized a few aspects of the tracking.
+ */
 @injectable()
 export class PositionSnapper {
     constructor(

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2023 EclipseSource and others.
+ * Copyright (c) 2020-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
@@ -14,35 +14,18 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 /* eslint-disable @typescript-eslint/no-shadow */
-import { GModelElement, ISnapper, KeyboardModifier, Point } from '@eclipse-glsp/sprotty';
-import { injectable } from 'inversify';
+import { KeyboardModifier } from '@eclipse-glsp/sprotty';
 
 /**
- * A {@link ISnapper} implementation that snaps all elements onto a fixed gride size.
- * The default grid size is 10x10 pixel.
- * To configure a custom grid size  bind the `TYPES.ISnapper` service identifier
- * to constant value, e.g:
- *
- * ```ts
- * bind(TYPES.ISnapper).toConstantValue(new GridSnapper({x:25 ,y:25 }));
- * ```
+ * @deprecated Use {@link ChangeBoundsManager.useSnap} instead which may be customized.
  */
-@injectable()
-export class GridSnapper implements ISnapper {
-    constructor(public grid: { x: number; y: number } = { x: 10, y: 10 }) {}
-
-    snap(position: Point, _element: GModelElement): Point {
-        return {
-            x: Math.round(position.x / this.grid.x) * this.grid.x,
-            y: Math.round(position.y / this.grid.y) * this.grid.y
-        };
-    }
-}
-
 export function useSnap(event: MouseEvent | KeyboardEvent): boolean {
     return !event.shiftKey;
 }
 
+/**
+ * @deprecated Use {@link ChangeBoundsManager.unsnapModifier} instead which may be customized.
+ */
 export function unsnapModifier(): KeyboardModifier {
     return 'shift';
 }