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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eclipse-glsp/client",
-  "version": "2.2.0-next.328+c2ca345",
+  "version": "2.2.0-next.329+d53e2e2",
   "description": "A sprotty-based client for GLSP",
   "keywords": [
     "eclipse",
@@ -46,7 +46,7 @@
     "watch": "tsc -w"
   },
   "dependencies": {
-    "@eclipse-glsp/sprotty": "2.2.0-next.328+c2ca345",
+    "@eclipse-glsp/sprotty": "2.2.0-next.329+d53e2e2",
     "autocompleter": "^9.1.0",
     "file-saver": "^2.0.5",
     "lodash": "4.17.21"
@@ -61,5 +61,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "c2ca34551f9d9268eae3be66de23e3782e880af1"
+  "gitHead": "d53e2e2ab356951621fb85eea3d0a32541ff9b23"
 }

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

@@ -205,7 +205,7 @@ export class MoveElementHandler implements IActionHandler {
     }
 
     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);
         }

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

@@ -13,8 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Bounds, BoundsAware, 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 { toAbsoluteBounds } from '../../utils/viewpoint-util';
 import { SResizeHandle, isBoundsAwareMoveable } from './model';
@@ -69,24 +69,7 @@ export class NoOverlapMovementRestrictor implements IMovementRestrictor {
     }
 
     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;
+        return Bounds.overlap(toAbsoluteBounds(element1), toAbsoluteBounds(element2));
     }
 }
 

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

@@ -14,7 +14,17 @@
  * 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,
+    GModelElement,
+    Locateable,
+    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';
@@ -26,8 +36,8 @@ import {
     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';
 
 export interface PositioningTool extends Tool {
@@ -88,7 +98,7 @@ export class MouseTrackingElementPositionListener extends DragAwareMouseListener
     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 });
+            targetPosition = Point.subtract(targetPosition, Dimension.center(element.bounds));
         }
         return targetPosition;
     }

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

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

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

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

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

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

package/src/features/viewport/reposition.ts

@@ -14,7 +14,6 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { inject, injectable } from 'inversify';
 import {
     Action,
     Bounds,
@@ -23,14 +22,16 @@ import {
     GChildElement,
     GModelElement,
     GModelRoot,
+    Point,
     TYPES,
     Viewport,
     getRouteBounds,
     hasArrayProp,
     isViewport
 } from '@eclipse-glsp/sprotty';
-import { calcElementAndRoute } from '../../utils/gmodel-util';
+import { inject, injectable } from 'inversify';
 import { GEdge } from '../../model';
+import { calcElementAndRoute } from '../../utils/gmodel-util';
 
 export interface RepositionAction extends Action {
     kind: typeof RepositionAction.KIND;
@@ -83,25 +84,21 @@ export class RepositionCommand extends BoundsAwareViewportCommand {
         return this.action.elementIDs;
     }
 
-    getNewViewport(bounds: Bounds, model: GModelRoot): Viewport | undefined {
+    getNewViewport(combinedElementBounds: Bounds, model: GModelRoot): Viewport | undefined {
         if (!Dimension.isValid(model.canvasBounds)) {
             return undefined;
         }
 
         if (isViewport(model)) {
-            const zoom = model.zoom;
-            const c = Bounds.center(bounds);
-
-            if (this.isFullyVisible(bounds, model)) {
+            if (this.isFullyVisible(combinedElementBounds, model)) {
                 return undefined;
             } else {
-                return {
-                    scroll: {
-                        x: c.x - (0.5 * model.canvasBounds.width) / zoom,
-                        y: c.y - (0.5 * model.canvasBounds.height) / zoom
-                    },
-                    zoom: zoom
-                };
+                const zoom = model.zoom;
+                const centerOfElements = Bounds.center(combinedElementBounds);
+                const canvasCenter = Dimension.center(model.canvasBounds);
+                const scrollCenter = Point.subtract(centerOfElements, canvasCenter);
+                const scroll = Point.map(scrollCenter, coordinate => coordinate / zoom);
+                return { scroll, zoom };
             }
         }
 

package/src/utils/geometry-util.ts

@@ -14,88 +14,69 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { Bounds, Point } from '@eclipse-glsp/sprotty';
+import { Bounds } from '@eclipse-glsp/sprotty';
 
-export function left(bounds: Bounds): number {
-    return bounds.x;
-}
+/** @deprecated Use {@link Bounds.left} */
+export const left = Bounds.left;
 
-export function center(bounds: Bounds): number {
-    return bounds.x + (bounds.width >= 0 ? bounds.width * 0.5 : 0);
-}
+/** @deprecated Use {@link Bounds.centerX} */
+export const center = Bounds.center;
 
-export function right(bounds: Bounds): number {
-    return bounds.x + bounds.width;
-}
+/** @deprecated Use {@link Bounds.right} */
+export const right = Bounds.right;
 
-export function top(bounds: Bounds): number {
-    return bounds.y;
-}
+/** @deprecated Use {@link Bounds.top} */
+export const top = Bounds.top;
 
-export function middle(bounds: Bounds): number {
-    return bounds.y + (bounds.height >= 0 ? bounds.height * 0.5 : 0);
-}
+/** @deprecated Use {@link Bounds.middle} */
+export const middle = Bounds.middle;
 
-export function bottom(bounds: Bounds): number {
-    return bounds.y + bounds.height;
-}
+/** @deprecated Use {@link Bounds.bottom} */
+export const bottom = Bounds.bottom;
 
-export function topLeft(bounds: Bounds): Point {
-    return { x: left(bounds), y: top(bounds) };
-}
+/** @deprecated Use {@link Bounds.topLeft} */
+export const topLeft = Bounds.topLeft;
 
-export function topCenter(bounds: Bounds): Point {
-    return { x: center(bounds), y: top(bounds) };
-}
+/** @deprecated Use {@link Bounds.topCenter} */
+export const topCenter = Bounds.topCenter;
 
-export function topRight(bounds: Bounds): Point {
-    return { x: right(bounds), y: top(bounds) };
-}
+/** @deprecated Use {@link Bounds.topRight} */
+export const topRight = Bounds.topRight;
 
-export function middleLeft(bounds: Bounds): Point {
-    return { x: left(bounds), y: middle(bounds) };
-}
+/** @deprecated Use {@link Bounds.middleLeft} */
+export const middleLeft = Bounds.middleLeft;
 
-export function middleCenter(bounds: Bounds): Point {
-    return { x: center(bounds), y: middle(bounds) };
-}
+/** @deprecated Use {@link Bounds.middleCenter} */
+export const middleCenter = Bounds.middleCenter;
 
-export function middleRight(bounds: Bounds): Point {
-    return { x: right(bounds), y: middle(bounds) };
-}
+/** @deprecated Use {@link Bounds.middleRight} */
+export const middleRight = Bounds.middleRight;
 
-export function bottomLeft(bounds: Bounds): Point {
-    return { x: left(bounds), y: bottom(bounds) };
-}
+/** @deprecated Use {@link Bounds.bottomLeft} */
+export const bottomLeft = Bounds.bottomLeft;
 
-export function bottomCenter(bounds: Bounds): Point {
-    return { x: center(bounds), y: bottom(bounds) };
-}
+/** @deprecated Use {@link Bounds.bottomCenter} */
+export const bottomCenter = Bounds.bottomCenter;
 
-export function bottomRight(bounds: Bounds): Point {
-    return { x: right(bounds), y: bottom(bounds) };
-}
+/** @deprecated Use {@link Bounds.bottomRight} */
+export const bottomRight = Bounds.bottomRight;
 
-export function sortBy(rankFunc: (elem: Bounds) => number, ...points: Bounds[]): Bounds[] {
-    return points.sort(compareFunction(rankFunc));
-}
+/** @deprecated Use {@link Bounds.left} */
+export const sortBy = Bounds.sortBy;
 
-export function compareFunction<T>(rankFunc: (elem: T) => number): (left: T, right: T) => number {
-    return (elemLeft, elemRight) => rankFunc(elemLeft) - rankFunc(elemRight);
-}
+export const compareFunction =
+    <T>(rankFunc: (elem: T) => number): ((x: T, y: T) => number) =>
+    (x, y) =>
+        rankFunc(x) - rankFunc(y);
 
-export function isAbove(leftBounds: Bounds, rightBounds: Bounds): boolean {
-    return top(leftBounds) <= top(rightBounds);
-}
+/** @deprecated Use {@link Bounds.isAbove} */
+export const isAbove = Bounds.isAbove;
 
-export function isBelow(leftBounds: Bounds, rightBounds: Bounds): boolean {
-    return top(leftBounds) >= top(rightBounds);
-}
+/** @deprecated Use {@link Bounds.isBelow} */
+export const isBelow = Bounds.isBelow;
 
-export function isBefore(leftBounds: Bounds, rightBounds: Bounds): boolean {
-    return left(leftBounds) < left(rightBounds);
-}
+/** @deprecated Use {@link Bounds.isBefore} */
+export const isBefore = Bounds.isBefore;
 
-export function isAfter(leftBounds: Bounds, rightBounds: Bounds): boolean {
-    return left(leftBounds) >= left(rightBounds);
-}
+/** @deprecated Use {@link Bounds.isAfter} */
+export const isAfter = Bounds.isAfter;

package/src/utils/gmodel-util.ts

@@ -347,7 +347,7 @@ export function findTopLevelElementByFeature<T>(
 export function calculateDeltaBetweenPoints(target: Point, source: Point, element: GModelElement): Point {
     const delta = Point.subtract(target, source);
     const zoom = getZoom(element);
-    const adaptedDelta = { x: delta.x / zoom, y: delta.y / zoom };
+    const adaptedDelta = Point.divideScalar(delta, zoom);
     return adaptedDelta;
 }