@eclipse-glsp/client 0.9.0-next.d0112315 → 0.9.0-next.f12e3d87

package/lib/features/tools/change-bounds-tool.js

@@ -1,17 +1,4 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -21,41 +8,11 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spread = (this && this.__spread) || function () {
-    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
-    return ar;
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
+var ChangeBoundsTool_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChangeBoundsListener = exports.ChangeBoundsTool = void 0;
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2021 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
@@ -69,19 +26,19 @@ exports.ChangeBoundsListener = exports.ChangeBoundsTool = void 0;
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-var inversify_1 = require("inversify");
-var sprotty_1 = require("sprotty");
-var drag_aware_mouse_listener_1 = require("../../base/drag-aware-mouse-listener");
-var operation_1 = require("../../base/operations/operation");
-var types_1 = require("../../base/types");
-var layout_utils_1 = require("../../utils/layout-utils");
-var smodel_util_1 = require("../../utils/smodel-util");
-var model_1 = require("../change-bounds/model");
-var movement_restrictor_1 = require("../change-bounds/movement-restrictor");
-var selection_service_1 = require("../select/selection-service");
-var change_bounds_tool_feedback_1 = require("../tool-feedback/change-bounds-tool-feedback");
-var css_feedback_1 = require("../tool-feedback/css-feedback");
-var base_glsp_tool_1 = require("./base-glsp-tool");
+const inversify_1 = require("inversify");
+const sprotty_1 = require("sprotty");
+const drag_aware_mouse_listener_1 = require("../../base/drag-aware-mouse-listener");
+const operation_1 = require("../../base/operations/operation");
+const types_1 = require("../../base/types");
+const layout_utils_1 = require("../../utils/layout-utils");
+const smodel_util_1 = require("../../utils/smodel-util");
+const model_1 = require("../change-bounds/model");
+const movement_restrictor_1 = require("../change-bounds/movement-restrictor");
+const selection_service_1 = require("../select/selection-service");
+const change_bounds_tool_feedback_1 = require("../tool-feedback/change-bounds-tool-feedback");
+const css_feedback_1 = require("../tool-feedback/css-feedback");
+const base_glsp_tool_1 = require("./base-glsp-tool");
 /**
  * The change bounds tool has the license to move multiple elements or resize a single element by implementing the ChangeBounds operation.
  * In contrast to Sprotty's implementation this tool only sends a `ChangeBoundsOperationAction` when an operation has finished and does not
@@ -92,23 +49,14 @@ var base_glsp_tool_1 = require("./base-glsp-tool");
  * | Move      | MoveAction       | ChangeBoundsOperationAction
  * | Resize    | SetBoundsAction  | ChangeBoundsOperationAction
  *
- * To provide a visual client updates during move we install the `FeedbackMoveMouseListener` and to provide visual client updates during resize
- * and send the server updates we install the `ChangeBoundsListener`.
+ * To provide a visual client updates during move we install the `FeedbackMoveMouseListener` and to provide visual client updates during
+ * resize and send the server updates we install the `ChangeBoundsListener`.
  */
-var ChangeBoundsTool = /** @class */ (function (_super) {
-    __extends(ChangeBoundsTool, _super);
-    function ChangeBoundsTool() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ChangeBoundsTool_1 = ChangeBoundsTool;
-    Object.defineProperty(ChangeBoundsTool.prototype, "id", {
-        get: function () {
-            return ChangeBoundsTool_1.ID;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ChangeBoundsTool.prototype.enable = function () {
+let ChangeBoundsTool = ChangeBoundsTool_1 = class ChangeBoundsTool extends base_glsp_tool_1.BaseGLSPTool {
+    get id() {
+        return ChangeBoundsTool_1.ID;
+    }
+    enable() {
         // install feedback move mouse listener for client-side move updates
         this.feedbackMoveMouseListener = this.createMoveMouseListener();
         this.mouseTool.register(this.feedbackMoveMouseListener);
@@ -116,57 +64,53 @@ var ChangeBoundsTool = /** @class */ (function (_super) {
         this.changeBoundsListener = this.createChangeBoundsListener();
         this.mouseTool.register(this.changeBoundsListener);
         this.selectionService.register(this.changeBoundsListener);
-    };
-    ChangeBoundsTool.prototype.createMoveMouseListener = function () {
+    }
+    createMoveMouseListener() {
         return new change_bounds_tool_feedback_1.FeedbackMoveMouseListener(this);
-    };
-    ChangeBoundsTool.prototype.createChangeBoundsListener = function () {
+    }
+    createChangeBoundsListener() {
         return new ChangeBoundsListener(this);
-    };
-    ChangeBoundsTool.prototype.disable = function () {
+    }
+    disable() {
         this.mouseTool.deregister(this.changeBoundsListener);
         this.selectionService.deregister(this.changeBoundsListener);
         this.mouseTool.deregister(this.feedbackMoveMouseListener);
         this.deregisterFeedback([], this.feedbackMoveMouseListener);
-        this.deregisterFeedback([new change_bounds_tool_feedback_1.HideChangeBoundsToolResizeFeedbackAction], this.changeBoundsListener);
-    };
-    var ChangeBoundsTool_1;
-    ChangeBoundsTool.ID = 'glsp.change-bounds-tool';
-    __decorate([
-        inversify_1.inject(types_1.GLSP_TYPES.SelectionService),
-        __metadata("design:type", selection_service_1.SelectionService)
-    ], ChangeBoundsTool.prototype, "selectionService", void 0);
-    __decorate([
-        inversify_1.inject(sprotty_1.EdgeRouterRegistry),
-        inversify_1.optional(),
-        __metadata("design:type", sprotty_1.EdgeRouterRegistry)
-    ], ChangeBoundsTool.prototype, "edgeRouterRegistry", void 0);
-    __decorate([
-        inversify_1.inject(sprotty_1.TYPES.ISnapper),
-        inversify_1.optional(),
-        __metadata("design:type", Object)
-    ], ChangeBoundsTool.prototype, "snapper", void 0);
-    __decorate([
-        inversify_1.inject(types_1.GLSP_TYPES.IMovementRestrictor),
-        inversify_1.optional(),
-        __metadata("design:type", Object)
-    ], ChangeBoundsTool.prototype, "movementRestrictor", void 0);
-    ChangeBoundsTool = ChangeBoundsTool_1 = __decorate([
-        inversify_1.injectable()
-    ], ChangeBoundsTool);
-    return ChangeBoundsTool;
-}(base_glsp_tool_1.BaseGLSPTool));
+        this.deregisterFeedback([new change_bounds_tool_feedback_1.HideChangeBoundsToolResizeFeedbackAction()], this.changeBoundsListener);
+    }
+};
+ChangeBoundsTool.ID = 'glsp.change-bounds-tool';
+__decorate([
+    inversify_1.inject(types_1.GLSP_TYPES.SelectionService),
+    __metadata("design:type", selection_service_1.SelectionService)
+], ChangeBoundsTool.prototype, "selectionService", void 0);
+__decorate([
+    inversify_1.inject(sprotty_1.EdgeRouterRegistry),
+    inversify_1.optional(),
+    __metadata("design:type", sprotty_1.EdgeRouterRegistry)
+], ChangeBoundsTool.prototype, "edgeRouterRegistry", void 0);
+__decorate([
+    inversify_1.inject(sprotty_1.TYPES.ISnapper),
+    inversify_1.optional(),
+    __metadata("design:type", Object)
+], ChangeBoundsTool.prototype, "snapper", void 0);
+__decorate([
+    inversify_1.inject(types_1.GLSP_TYPES.IMovementRestrictor),
+    inversify_1.optional(),
+    __metadata("design:type", Object)
+], ChangeBoundsTool.prototype, "movementRestrictor", void 0);
+ChangeBoundsTool = ChangeBoundsTool_1 = __decorate([
+    inversify_1.injectable()
+], ChangeBoundsTool);
 exports.ChangeBoundsTool = ChangeBoundsTool;
-var ChangeBoundsListener = /** @class */ (function (_super) {
-    __extends(ChangeBoundsListener, _super);
-    function ChangeBoundsListener(tool) {
-        var _this = _super.call(this) || this;
-        _this.tool = tool;
-        _this.positionDelta = { x: 0, y: 0 };
-        return _this;
-    }
-    ChangeBoundsListener.prototype.mouseDown = function (target, event) {
-        _super.prototype.mouseDown.call(this, target, event);
+class ChangeBoundsListener extends drag_aware_mouse_listener_1.DragAwareMouseListener {
+    constructor(tool) {
+        super();
+        this.tool = tool;
+        this.positionDelta = { x: 0, y: 0 };
+    }
+    mouseDown(target, event) {
+        super.mouseDown(target, event);
         if (event.button !== 0) {
             return [];
         }
@@ -184,116 +128,120 @@ var ChangeBoundsListener = /** @class */ (function (_super) {
             this.reset();
         }
         return [];
-    };
-    ChangeBoundsListener.prototype.mouseMove = function (target, event) {
-        _super.prototype.mouseMove.call(this, target, event);
+    }
+    mouseMove(target, event) {
+        super.mouseMove(target, event);
         if (this.isMouseDrag && this.activeResizeHandle) {
             // rely on the FeedbackMoveMouseListener to update the element bounds of selected elements
             // consider resize handles ourselves
-            var actions = [css_feedback_1.cursorFeedbackAction(css_feedback_1.CursorCSS.RESIZE), css_feedback_1.applyCssClasses(this.activeResizeHandle, ChangeBoundsListener.CSS_CLASS_ACTIVE)];
-            var positionUpdate = this.updatePosition(target, event);
+            const actions = [
+                css_feedback_1.cursorFeedbackAction(this.activeResizeHandle.isNwSeResize() ? css_feedback_1.CursorCSS.RESIZE_NWSE : css_feedback_1.CursorCSS.RESIZE_NESW),
+                css_feedback_1.applyCssClasses(this.activeResizeHandle, ChangeBoundsListener.CSS_CLASS_ACTIVE)
+            ];
+            const positionUpdate = this.updatePosition(target, event);
             if (positionUpdate) {
-                var resizeActions = this.handleResizeOnClient(positionUpdate);
-                actions.push.apply(actions, __spread(resizeActions));
+                const resizeActions = this.handleResizeOnClient(positionUpdate);
+                actions.push(...resizeActions);
             }
             return actions;
         }
         return [];
-    };
-    ChangeBoundsListener.prototype.draggingMouseUp = function (target, event) {
+    }
+    draggingMouseUp(target, event) {
         if (this.lastDragPosition === undefined) {
             this.resetPosition();
             return [];
         }
-        var actions = [];
+        const actions = [];
         if (this.activeResizeHandle) {
             // Resize
-            actions.push.apply(actions, __spread(this.handleResize(this.activeResizeHandle)));
+            actions.push(...this.handleResize(this.activeResizeHandle));
         }
         else {
             // Move
-            actions.push.apply(actions, __spread(this.handleMoveOnServer(target)));
+            actions.push(...this.handleMoveOnServer(target));
         }
         this.resetPosition();
         return actions;
-    };
-    ChangeBoundsListener.prototype.handleMoveOnServer = function (target) {
-        var operations = [];
-        operations.push.apply(operations, __spread(this.handleMoveElementsOnServer(target)));
-        operations.push.apply(operations, __spread(this.handleMoveRoutingPointsOnServer(target)));
+    }
+    handleMoveOnServer(target) {
+        const operations = [];
+        operations.push(...this.handleMoveElementsOnServer(target));
+        operations.push(...this.handleMoveRoutingPointsOnServer(target));
         if (operations.length > 0) {
             return [new operation_1.CompoundOperation(operations)];
         }
         return operations;
-    };
-    ChangeBoundsListener.prototype.handleMoveElementsOnServer = function (target) {
-        var _this = this;
-        var result = [];
-        var newBounds = [];
-        smodel_util_1.forEachElement(target, smodel_util_1.isNonRoutableSelectedMovableBoundsAware, function (element) {
-            _this.createElementAndBounds(element).forEach(function (bounds) { return newBounds.push(bounds); });
+    }
+    handleMoveElementsOnServer(target) {
+        const result = [];
+        const newBounds = [];
+        const selectedElements = [];
+        smodel_util_1.forEachElement(target, smodel_util_1.isNonRoutableSelectedMovableBoundsAware, element => {
+            selectedElements.push(element);
         });
+        const selectionSet = new Set(selectedElements);
+        selectedElements.filter(element => !this.isChildOfSelected(selectionSet, element))
+            .map(element => this.createElementAndBounds(element))
+            .forEach(bounds => newBounds.push(...bounds));
         if (newBounds.length > 0) {
             result.push(new operation_1.ChangeBoundsOperation(newBounds));
         }
         return result;
-    };
-    ChangeBoundsListener.prototype.handleMoveRoutingPointsOnServer = function (target) {
-        var _this = this;
-        var result = [];
-        var newRoutingPoints = [];
-        smodel_util_1.forEachElement(target, smodel_util_1.isNonRoutableSelectedMovableBoundsAware, function (element) {
+    }
+    isChildOfSelected(selectedElements, element) {
+        while (element instanceof sprotty_1.SChildElement) {
+            element = element.parent;
+            if (selectedElements.has(element)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    handleMoveRoutingPointsOnServer(target) {
+        const result = [];
+        const newRoutingPoints = [];
+        smodel_util_1.forEachElement(target, smodel_util_1.isNonRoutableSelectedMovableBoundsAware, element => {
             //  If client routing is enabled -> delegate routingpoints of connected edges to server
-            if (_this.tool.edgeRouterRegistry && element instanceof sprotty_1.SConnectableElement) {
-                element.incomingEdges.map(smodel_util_1.toElementAndRoutingPoints).forEach(function (ear) { return newRoutingPoints.push(ear); });
-                element.outgoingEdges.map(smodel_util_1.toElementAndRoutingPoints).forEach(function (ear) { return newRoutingPoints.push(ear); });
+            if (this.tool.edgeRouterRegistry && element instanceof sprotty_1.SConnectableElement) {
+                element.incomingEdges.map(smodel_util_1.toElementAndRoutingPoints).forEach(ear => newRoutingPoints.push(ear));
+                element.outgoingEdges.map(smodel_util_1.toElementAndRoutingPoints).forEach(ear => newRoutingPoints.push(ear));
             }
         });
         if (newRoutingPoints.length > 0) {
             result.push(new operation_1.ChangeRoutingPointsOperation(newRoutingPoints));
         }
         return result;
-    };
-    ChangeBoundsListener.prototype.handleResize = function (activeResizeHandle) {
-        var actions = [];
+    }
+    handleResize(activeResizeHandle) {
+        const actions = [];
         actions.push(css_feedback_1.cursorFeedbackAction(css_feedback_1.CursorCSS.DEFAULT));
         actions.push(css_feedback_1.deleteCssClasses(activeResizeHandle, ChangeBoundsListener.CSS_CLASS_ACTIVE));
-        var resizeElement = sprotty_1.findParentByFeature(activeResizeHandle, model_1.isResizable);
+        const resizeElement = sprotty_1.findParentByFeature(activeResizeHandle, model_1.isResizable);
         if (this.isActiveResizeElement(resizeElement)) {
-            this.createChangeBoundsAction(resizeElement).forEach(function (action) { return actions.push(action); });
+            this.createChangeBoundsAction(resizeElement).forEach(action => actions.push(action));
         }
         return actions;
-    };
-    ChangeBoundsListener.prototype.selectionChanged = function (root, selectedElements) {
-        var e_1, _a;
+    }
+    selectionChanged(root, selectedElements) {
         if (this.activeResizeElement) {
             if (selectedElements.includes(this.activeResizeElement.id)) {
                 // our active element is still selected, nothing to do
                 return;
             }
-            try {
-                // try to find some other selected element and mark that active
-                for (var _b = __values(selectedElements.reverse()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var elementId = _c.value;
-                    var element = root.index.getById(elementId);
-                    if (element && this.setActiveResizeElement(element)) {
-                        return;
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            // try to find some other selected element and mark that active
+            for (const elementId of selectedElements.reverse()) {
+                const element = root.index.getById(elementId);
+                if (element && this.setActiveResizeElement(element)) {
+                    return;
                 }
-                finally { if (e_1) throw e_1.error; }
             }
             this.reset();
         }
-    };
-    ChangeBoundsListener.prototype.setActiveResizeElement = function (target) {
+    }
+    setActiveResizeElement(target) {
         // check if we have a selected, moveable element (multi-selection allowed)
-        var moveableElement = sprotty_1.findParentByFeature(target, model_1.isBoundsAwareMoveable);
+        const moveableElement = sprotty_1.findParentByFeature(target, model_1.isBoundsAwareMoveable);
         if (sprotty_1.isSelected(moveableElement)) {
             // only allow one element to have the element resize handles
             this.activeResizeElement = moveableElement;
@@ -303,59 +251,64 @@ var ChangeBoundsListener = /** @class */ (function (_super) {
             return true;
         }
         return false;
-    };
-    ChangeBoundsListener.prototype.isActiveResizeElement = function (element) {
+    }
+    isActiveResizeElement(element) {
         return element !== undefined && this.activeResizeElement !== undefined && element.id === this.activeResizeElement.id;
-    };
-    ChangeBoundsListener.prototype.initPosition = function (event) {
+    }
+    initPosition(event) {
         this.lastDragPosition = { x: event.pageX, y: event.pageY };
         if (this.activeResizeHandle) {
-            var resizeElement = sprotty_1.findParentByFeature(this.activeResizeHandle, model_1.isResizable);
-            this.initialBounds = { x: resizeElement.bounds.x, y: resizeElement.bounds.y, width: resizeElement.bounds.width, height: resizeElement.bounds.height };
+            const resizeElement = sprotty_1.findParentByFeature(this.activeResizeHandle, model_1.isResizable);
+            this.initialBounds = {
+                x: resizeElement.bounds.x,
+                y: resizeElement.bounds.y,
+                width: resizeElement.bounds.width,
+                height: resizeElement.bounds.height
+            };
         }
-    };
-    ChangeBoundsListener.prototype.updatePosition = function (target, event) {
+    }
+    updatePosition(target, event) {
         if (this.lastDragPosition) {
-            var newDragPosition = { x: event.pageX, y: event.pageY };
-            var viewport = sprotty_1.findParentByFeature(target, sprotty_1.isViewport);
-            var zoom = viewport ? viewport.zoom : 1;
-            var dx = (event.pageX - this.lastDragPosition.x) / zoom;
-            var dy = (event.pageY - this.lastDragPosition.y) / zoom;
-            var deltaToLastPosition = { x: dx, y: dy };
+            const newDragPosition = { x: event.pageX, y: event.pageY };
+            const viewport = sprotty_1.findParentByFeature(target, sprotty_1.isViewport);
+            const zoom = viewport ? viewport.zoom : 1;
+            const dx = (event.pageX - this.lastDragPosition.x) / zoom;
+            const dy = (event.pageY - this.lastDragPosition.y) / zoom;
+            const deltaToLastPosition = { x: dx, y: dy };
             this.lastDragPosition = newDragPosition;
             // update position delta with latest delta
             this.positionDelta.x += deltaToLastPosition.x;
             this.positionDelta.y += deltaToLastPosition.y;
             // snap our delta and only send update if the position actually changes
             // otherwise accumulate delta until we do snap to an update
-            var positionUpdate = this.snap(this.positionDelta, target, !event.shiftKey);
+            const positionUpdate = this.snap(this.positionDelta, target, !event.altKey);
             if (positionUpdate.x === 0 && positionUpdate.y === 0) {
                 return undefined;
             }
-            // we update our position so we need to reset our delta
-            this.positionDelta.x = 0;
-            this.positionDelta.y = 0;
+            // we update our position so we update our delta by the snapped position
+            this.positionDelta.x -= positionUpdate.x;
+            this.positionDelta.y -= positionUpdate.y;
             return positionUpdate;
         }
         return undefined;
-    };
-    ChangeBoundsListener.prototype.reset = function () {
+    }
+    reset() {
         if (this.activeResizeElement && model_1.isResizable(this.activeResizeElement)) {
             this.tool.dispatchFeedback([new change_bounds_tool_feedback_1.HideChangeBoundsToolResizeFeedbackAction()], this);
         }
         this.tool.dispatchActions([css_feedback_1.cursorFeedbackAction(css_feedback_1.CursorCSS.DEFAULT)]);
         this.resetPosition();
-    };
-    ChangeBoundsListener.prototype.resetPosition = function () {
+    }
+    resetPosition() {
         this.activeResizeHandle = undefined;
         this.lastDragPosition = undefined;
         this.positionDelta = { x: 0, y: 0 };
-    };
-    ChangeBoundsListener.prototype.handleResizeOnClient = function (positionUpdate) {
+    }
+    handleResizeOnClient(positionUpdate) {
         if (!this.activeResizeHandle) {
             return [];
         }
-        var resizeElement = sprotty_1.findParentByFeature(this.activeResizeHandle, model_1.isResizable);
+        const resizeElement = sprotty_1.findParentByFeature(this.activeResizeHandle, model_1.isResizable);
         if (this.isActiveResizeElement(resizeElement)) {
             switch (this.activeResizeHandle.location) {
                 case model_1.ResizeHandleLocation.TopLeft:
@@ -369,25 +322,25 @@ var ChangeBoundsListener = /** @class */ (function (_super) {
             }
         }
         return [];
-    };
-    ChangeBoundsListener.prototype.handleTopLeftResize = function (resizeElement, positionUpdate) {
+    }
+    handleTopLeftResize(resizeElement, positionUpdate) {
         return this.createSetBoundsAction(resizeElement, resizeElement.bounds.x + positionUpdate.x, resizeElement.bounds.y + positionUpdate.y, resizeElement.bounds.width - positionUpdate.x, resizeElement.bounds.height - positionUpdate.y);
-    };
-    ChangeBoundsListener.prototype.handleTopRightResize = function (resizeElement, positionUpdate) {
+    }
+    handleTopRightResize(resizeElement, positionUpdate) {
         return this.createSetBoundsAction(resizeElement, resizeElement.bounds.x, resizeElement.bounds.y + positionUpdate.y, resizeElement.bounds.width + positionUpdate.x, resizeElement.bounds.height - positionUpdate.y);
-    };
-    ChangeBoundsListener.prototype.handleBottomLeftResize = function (resizeElement, positionUpdate) {
+    }
+    handleBottomLeftResize(resizeElement, positionUpdate) {
         return this.createSetBoundsAction(resizeElement, resizeElement.bounds.x + positionUpdate.x, resizeElement.bounds.y, resizeElement.bounds.width - positionUpdate.x, resizeElement.bounds.height + positionUpdate.y);
-    };
-    ChangeBoundsListener.prototype.handleBottomRightResize = function (resizeElement, positionUpdate) {
+    }
+    handleBottomRightResize(resizeElement, positionUpdate) {
         return this.createSetBoundsAction(resizeElement, resizeElement.bounds.x, resizeElement.bounds.y, resizeElement.bounds.width + positionUpdate.x, resizeElement.bounds.height + positionUpdate.y);
-    };
-    ChangeBoundsListener.prototype.createChangeBoundsAction = function (element) {
+    }
+    createChangeBoundsAction(element) {
         if (this.isValidBoundChange(element, element.bounds, element.bounds)) {
             return [new operation_1.ChangeBoundsOperation([smodel_util_1.toElementAndBounds(element)])];
         }
         else if (this.initialBounds) {
-            var actions = [];
+            const actions = [];
             if (this.tool.movementRestrictor) {
                 actions.push(movement_restrictor_1.removeMovementRestrictionFeedback(element, this.tool.movementRestrictor));
             }
@@ -395,47 +348,44 @@ var ChangeBoundsListener = /** @class */ (function (_super) {
             return actions;
         }
         return [];
-    };
-    ChangeBoundsListener.prototype.createElementAndBounds = function (element) {
+    }
+    createElementAndBounds(element) {
         if (this.isValidBoundChange(element, element.bounds, element.bounds)) {
             return [smodel_util_1.toElementAndBounds(element)];
         }
         return [];
-    };
-    ChangeBoundsListener.prototype.createSetBoundsAction = function (element, x, y, width, height) {
-        var newPosition = { x: x, y: y };
-        var newSize = { width: width, height: height };
-        var result = [];
+    }
+    createSetBoundsAction(element, x, y, width, height) {
+        const newPosition = { x, y };
+        const newSize = { width, height };
+        const result = [];
         if (this.isValidBoundChange(element, newPosition, newSize)) {
             if (this.tool.movementRestrictor) {
                 result.push(movement_restrictor_1.removeMovementRestrictionFeedback(element, this.tool.movementRestrictor));
             }
-            result.push(new sprotty_1.SetBoundsAction([{ elementId: element.id, newPosition: newPosition, newSize: newSize }]));
+            result.push(new sprotty_1.SetBoundsAction([{ elementId: element.id, newPosition, newSize }]));
         }
         else if (this.isValidSize(element, newSize)) {
             if (this.tool.movementRestrictor) {
                 result.push(movement_restrictor_1.createMovementRestrictionFeedback(element, this.tool.movementRestrictor));
             }
-            result.push(new sprotty_1.SetBoundsAction([{ elementId: element.id, newPosition: newPosition, newSize: newSize }]));
+            result.push(new sprotty_1.SetBoundsAction([{ elementId: element.id, newPosition, newSize }]));
         }
         return result;
-    };
-    ChangeBoundsListener.prototype.snap = function (position, element, isSnap) {
-        return isSnap && this.tool.snapper
-            ? this.tool.snapper.snap(position, element)
-            : { x: position.x, y: position.y };
-    };
-    ChangeBoundsListener.prototype.isValidBoundChange = function (element, newPosition, newSize) {
+    }
+    snap(position, element, isSnap) {
+        return isSnap && this.tool.snapper ? this.tool.snapper.snap(position, element) : { x: position.x, y: position.y };
+    }
+    isValidBoundChange(element, newPosition, newSize) {
         return this.isValidSize(element, newSize) && this.isValidMove(element, newPosition);
-    };
-    ChangeBoundsListener.prototype.isValidSize = function (element, size) {
+    }
+    isValidSize(element, size) {
         return layout_utils_1.isValidSize(element, size);
-    };
-    ChangeBoundsListener.prototype.isValidMove = function (element, newPosition) {
+    }
+    isValidMove(element, newPosition) {
         return layout_utils_1.isValidMove(element, newPosition, this.tool.movementRestrictor);
-    };
-    ChangeBoundsListener.CSS_CLASS_ACTIVE = 'active';
-    return ChangeBoundsListener;
-}(drag_aware_mouse_listener_1.DragAwareMouseListener));
+    }
+}
 exports.ChangeBoundsListener = ChangeBoundsListener;
+ChangeBoundsListener.CSS_CLASS_ACTIVE = 'active';
 //# sourceMappingURL=change-bounds-tool.js.map