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

package/src/features/select/select-mouse-listener.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,18 +13,25 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, BringToFrontAction, GModelElement, SelectAction, SelectMouseListener, Selectable } from '@eclipse-glsp/sprotty';
+import { Action, BringToFrontAction, GModelElement, SelectAction, SelectMouseListener } from '@eclipse-glsp/sprotty';
+import { inject, injectable, optional } from 'inversify';
 import { Ranked } from '../../base/ranked';
+import { SelectableElement } from '../../utils/gmodel-util';
+import { GResizeHandle } from '../change-bounds/model';
+import { ChangeBoundsManager } from '../tools/change-bounds/change-bounds-manager';
 
 /**
  * Ranked select mouse listener that is executed before default mouse listeners when using the RankedMouseTool.
  * This ensures that default mouse listeners are working on a model that has selection changes already applied.
  */
+@injectable()
 export class RankedSelectMouseListener extends SelectMouseListener implements Ranked {
     rank: number = Ranked.DEFAULT_RANK - 100; /* we want to be executed before all default mouse listeners */
 
+    @inject(ChangeBoundsManager) @optional() readonly changeBoundsManager?: ChangeBoundsManager;
+
     protected override handleSelectTarget(
-        selectableTarget: GModelElement & Selectable,
+        selectableTarget: SelectableElement,
         deselectedElements: GModelElement[],
         event: MouseEvent
     ): (Action | Promise<Action>)[] {
@@ -40,7 +47,7 @@ export class RankedSelectMouseListener extends SelectMouseListener implements Ra
         return result;
     }
 
-    protected override handleDeselectTarget(selectableTarget: GModelElement & Selectable, event: MouseEvent): (Action | Promise<Action>)[] {
+    protected override handleDeselectTarget(selectableTarget: SelectableElement, event: MouseEvent): (Action | Promise<Action>)[] {
         const result: Action[] = [];
         result.push(SelectAction.create({ selectedElementsIDs: [], deselectedElementsIDs: [selectableTarget.id] }));
         return result;
@@ -51,4 +58,12 @@ export class RankedSelectMouseListener extends SelectMouseListener implements Ra
         result.push(SelectAction.create({ selectedElementsIDs: [], deselectedElementsIDs: deselectedElements.map(e => e.id) }));
         return result;
     }
+
+    protected override handleButton(target: GModelElement, event: MouseEvent): (Action | Promise<Action>)[] | undefined {
+        if (target instanceof GResizeHandle && this.changeBoundsManager?.useSymmetricResize(event)) {
+            // avoid de-selecting elements when resizing with a modifier key
+            return [];
+        }
+        return super.handleButton(target, event);
+    }
 }

package/src/features/source-model-watcher/source-model-watcher-module.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
@@ -16,6 +16,9 @@
 import { FeatureModule, SourceModelChangedAction, configureActionHandler } from '@eclipse-glsp/sprotty';
 import { SourceModelChangedActionHandler } from './source-model-changed-action-handler';
 
-export const sourceModelWatcherModule = new FeatureModule((bind, _unbind, isBound) => {
-    configureActionHandler({ bind, isBound }, SourceModelChangedAction.KIND, SourceModelChangedActionHandler);
-});
+export const sourceModelWatcherModule = new FeatureModule(
+    (bind, _unbind, isBound) => {
+        configureActionHandler({ bind, isBound }, SourceModelChangedAction.KIND, SourceModelChangedActionHandler);
+    },
+    { featureId: Symbol('sourceModelWatcher') }
+);

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 EclipseSource and others.
+ * Copyright (c) 2023-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
@@ -18,9 +18,12 @@ import { FeatureModule, StatusAction, TYPES, bindAsService, configureActionHandl
 import '../../../css/status-overlay.css';
 import { StatusOverlay } from './status-overlay';
 
-export const statusModule = new FeatureModule((bind, unbind, isBound, rebind) => {
-    const context = { bind, unbind, isBound, rebind };
-    bindAsService(context, TYPES.IUIExtension, StatusOverlay);
-    bind(TYPES.IDiagramStartup).toService(StatusOverlay);
-    configureActionHandler(context, StatusAction.KIND, StatusOverlay);
-});
+export const statusModule = new FeatureModule(
+    (bind, unbind, isBound, rebind) => {
+        const context = { bind, unbind, isBound, rebind };
+        bindAsService(context, TYPES.IUIExtension, StatusOverlay);
+        bind(TYPES.IDiagramStartup).toService(StatusOverlay);
+        configureActionHandler(context, StatusAction.KIND, StatusOverlay);
+    },
+    { featureId: Symbol('status') }
+);

package/src/features/status/status-overlay.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 EclipseSource and others.
+ * Copyright (c) 2023-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,17 +13,18 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { IActionHandler, StatusAction, codiconCSSClasses } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
-import { AbstractUIExtension, IActionHandler, StatusAction, codiconCSSClasses } from '@eclipse-glsp/sprotty';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { EditorContextService } from '../../base/editor-context-service';
 import { IDiagramStartup } from '../../base/model/diagram-loader';
+import { GLSPAbstractUIExtension } from '../../base/ui-extension/ui-extension';
 
 /**
  * A reusable status overlay for rendering (icon + message) and handling of {@link StatusAction}'s.
  */
 @injectable()
-export class StatusOverlay extends AbstractUIExtension implements IActionHandler, IDiagramStartup {
+export class StatusOverlay extends GLSPAbstractUIExtension implements IActionHandler, IDiagramStartup {
     static readonly ID = 'glsp.server.status.overlay';
 
     @inject(GLSPActionDispatcher)

package/src/features/svg-metadata/svg-metadata-module.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
@@ -17,7 +17,10 @@
 import { FeatureModule, TYPES } from '@eclipse-glsp/sprotty';
 import { MetadataPlacer } from './metadata-placer';
 
-export const svgMetadataModule = new FeatureModule(bind => {
-    bind(MetadataPlacer).toSelf().inSingletonScope();
-    bind(TYPES.IVNodePostprocessor).toService(MetadataPlacer);
-});
+export const svgMetadataModule = new FeatureModule(
+    bind => {
+        bind(MetadataPlacer).toSelf().inSingletonScope();
+        bind(TYPES.IVNodePostprocessor).toService(MetadataPlacer);
+    },
+    { featureId: Symbol('svgMetadata') }
+);

package/src/features/tool-palette/tool-palette-module.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
@@ -18,10 +18,13 @@ import '../../../css/tool-palette.css';
 import { EnableDefaultToolsAction } from '../../base/tool-manager/tool';
 import { ToolPalette } from './tool-palette';
 
-export const toolPaletteModule = new FeatureModule((bind, _unbind, isBound, _rebind) => {
-    bindAsService(bind, TYPES.IUIExtension, ToolPalette);
-    bind(TYPES.IDiagramStartup).toService(ToolPalette);
-    configureActionHandler({ bind, isBound }, EnableDefaultToolsAction.KIND, ToolPalette);
-    configureActionHandler({ bind, isBound }, UpdateModelAction.KIND, ToolPalette);
-    configureActionHandler({ bind, isBound }, SetModelAction.KIND, ToolPalette);
-});
+export const toolPaletteModule = new FeatureModule(
+    (bind, _unbind, isBound, _rebind) => {
+        bindAsService(bind, TYPES.IUIExtension, ToolPalette);
+        bind(TYPES.IDiagramStartup).toService(ToolPalette);
+        configureActionHandler({ bind, isBound }, EnableDefaultToolsAction.KIND, ToolPalette);
+        configureActionHandler({ bind, isBound }, UpdateModelAction.KIND, ToolPalette);
+        configureActionHandler({ bind, isBound }, SetModelAction.KIND, ToolPalette);
+    },
+    { featureId: Symbol('toolPalette') }
+);

package/src/features/tool-palette/tool-palette.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,7 +14,6 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import {
-    AbstractUIExtension,
     Action,
     GModelRoot,
     IActionHandler,
@@ -31,18 +30,22 @@ import {
     codiconCSSClasses,
     matchesKeystroke
 } from '@eclipse-glsp/sprotty';
-import { inject, injectable, postConstruct } from 'inversify';
+import { inject, injectable, optional, postConstruct } from 'inversify';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { EditorContextService, IEditModeListener } from '../../base/editor-context-service';
 import { FocusTracker } from '../../base/focus/focus-tracker';
 import { IDiagramStartup } from '../../base/model/diagram-loader';
 import { EnableDefaultToolsAction, EnableToolsAction } from '../../base/tool-manager/tool';
+import { GLSPAbstractUIExtension } from '../../base/ui-extension/ui-extension';
+import { DebugManager } from '../debug/debug-manager';
+import { GridManager } from '../grid/grid-manager';
 import { MouseDeleteTool } from '../tools/deletion/delete-tool';
 import { MarqueeMouseTool } from '../tools/marquee-selection/marquee-mouse-tool';
+import { OriginViewportAction } from '../viewport/origin-viewport';
 
 const CLICKED_CSS_CLASS = 'clicked';
 const SEARCH_ICON_ID = 'search';
-const PALETTE_ICON_ID = 'symbol-color';
+const PALETTE_ICON_ID = 'tools';
 const CHEVRON_DOWN_ICON_ID = 'chevron-right';
 const PALETTE_HEIGHT = '500px';
 
@@ -62,7 +65,7 @@ export namespace EnableToolPaletteAction {
     }
 }
 @injectable()
-export class ToolPalette extends AbstractUIExtension implements IActionHandler, IEditModeListener, IDiagramStartup {
+export class ToolPalette extends GLSPAbstractUIExtension implements IActionHandler, IEditModeListener, IDiagramStartup {
     static readonly ID = 'tool-palette';
 
     @inject(GLSPActionDispatcher)
@@ -74,6 +77,14 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
     @inject(FocusTracker)
     protected focusTracker: FocusTracker;
 
+    @inject(GridManager)
+    @optional()
+    protected gridManager?: GridManager;
+
+    @inject(DebugManager)
+    @optional()
+    protected debugManager?: DebugManager;
+
     protected paletteItems: PaletteItem[];
     protected paletteItemsCopy: PaletteItem[] = [];
     protected dynamic = false;
@@ -202,6 +213,19 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
         const validateActionButton = this.createValidateButton();
         headerTools.appendChild(validateActionButton);
 
+        const resetViewportButton = this.createResetViewportButton();
+        headerTools.appendChild(resetViewportButton);
+
+        if (this.gridManager) {
+            const toggleGridButton = this.createToggleGridButton();
+            headerTools.appendChild(toggleGridButton);
+        }
+
+        if (this.debugManager) {
+            const toggleDebugButton = this.createToggleDebugButton();
+            headerTools.appendChild(toggleDebugButton);
+        }
+
         // Create button for Search
         const searchIcon = this.createSearchButton();
         headerTools.appendChild(searchIcon);
@@ -250,6 +274,58 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
         return validateActionButton;
     }
 
+    protected createResetViewportButton(): HTMLElement {
+        const resetViewportButton = createIcon('screen-normal');
+        resetViewportButton.title = 'Reset Viewport';
+        resetViewportButton.onclick = _event => {
+            this.actionDispatcher.dispatch(OriginViewportAction.create());
+            resetViewportButton.focus();
+        };
+        resetViewportButton.ariaLabel = resetViewportButton.title;
+        resetViewportButton.tabIndex = 1;
+        return resetViewportButton;
+    }
+
+    protected createToggleGridButton(): HTMLElement {
+        const toggleGridButton = createIcon('symbol-numeric');
+        toggleGridButton.title = 'Toggle Grid';
+        toggleGridButton.onclick = () => {
+            if (this.gridManager?.isGridVisible) {
+                toggleGridButton.classList.remove(CLICKED_CSS_CLASS);
+                this.gridManager?.setGridVisible(false);
+            } else {
+                toggleGridButton.classList.add(CLICKED_CSS_CLASS);
+                this.gridManager?.setGridVisible(true);
+            }
+        };
+        if (this.gridManager?.isGridVisible) {
+            toggleGridButton.classList.add(CLICKED_CSS_CLASS);
+        }
+        toggleGridButton.ariaLabel = toggleGridButton.title;
+        toggleGridButton.tabIndex = 1;
+        return toggleGridButton;
+    }
+
+    protected createToggleDebugButton(): HTMLElement {
+        const toggleDebugButton = createIcon('debug');
+        toggleDebugButton.title = 'Debug Mode';
+        toggleDebugButton.onclick = () => {
+            if (this.debugManager?.isDebugEnabled) {
+                toggleDebugButton.classList.remove(CLICKED_CSS_CLASS);
+                this.debugManager?.setDebugEnabled(false);
+            } else {
+                toggleDebugButton.classList.add(CLICKED_CSS_CLASS);
+                this.debugManager?.setDebugEnabled(true);
+            }
+        };
+        if (this.debugManager?.isDebugEnabled) {
+            toggleDebugButton.classList.add(CLICKED_CSS_CLASS);
+        }
+        toggleDebugButton.ariaLabel = toggleDebugButton.title;
+        toggleDebugButton.tabIndex = 1;
+        return toggleDebugButton;
+    }
+
     protected createSearchButton(): HTMLElement {
         const searchIcon = createIcon(SEARCH_ICON_ID);
         searchIcon.onclick = _ev => {
@@ -275,7 +351,7 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
         searchField.classList.add('search-input');
         searchField.id = this.containerElement.id + '_search_field';
         searchField.type = 'text';
-        searchField.placeholder = ' Search...';
+        searchField.placeholder = 'Search...';
         searchField.style.display = 'none';
         searchField.onkeyup = () => this.requestFilterUpdate(this.searchField.value);
         searchField.onkeydown = ev => this.clearOnEscape(ev);

package/src/features/tools/base-tools.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
@@ -13,20 +13,51 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable } from 'inversify';
 import { Action, Disposable, DisposableCollection, IActionHandler, TYPES } from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { EditorContextService } from '../../base/editor-context-service';
-import { IFeedbackActionDispatcher, IFeedbackEmitter } from '../../base/feedback/feedback-action-dispatcher';
+import { IFeedbackActionDispatcher, IFeedbackEmitter, MaybeActions } from '../../base/feedback/feedback-action-dispatcher';
+import { FeedbackEmitter } from '../../base/feedback/feedback-emitter';
 import { EnableToolsAction, Tool } from '../../base/tool-manager/tool';
 import { GLSPKeyTool } from '../../base/view/key-tool';
 import { GLSPMouseTool } from '../../base/view/mouse-tool';
 
+export interface FeedbackAwareTool extends Tool {
+    /**
+     * Creates a new feedback emitter helper object. While anything can serve as a feedback emitter,
+     * this method ensures that the emitter is stable and does not change between model updates.
+     */
+    createFeedbackEmitter(): FeedbackEmitter;
+
+    /**
+     * Registers `actions` to be sent out as feedback, i.e., changes that are re-established whenever the `GModelRoot`
+     * has been set or updated.
+     *
+     * @param feedbackActions the actions to be sent out.
+     * @param feedbackEmitter the emitter sending out feedback actions (this tool by default).
+     * @param cleanupActions the actions to be sent out when the feedback is de-registered through the returned Disposable.
+     * @returns A 'Disposable' that de-registers the feedback and cleans up any pending feedback with the given `cleanupActions`.
+     * @deprecated It is recommended to create a {@link createFeedbackEmitter dedicated emitter} per feedback instead of using the tool.
+     */
+    registerFeedback(feedbackActions: Action[], feedbackEmitter?: IFeedbackEmitter, cleanupActions?: MaybeActions): Disposable;
+
+    /**
+     * De-registers all feedback from the given `feedbackEmitter` (this tool by default) and cleans up any pending feedback with the
+     * given `cleanupActions`.
+     *
+     * @param feedbackEmitter the emitter to be deregistered (this tool by default).
+     * @param cleanupActions the actions to be dispatched right after the deregistration to clean up any pending feedback.
+     * @deprecated It is recommended to create a {@link createFeedbackEmitter dedicated emitter} per feedback and dispose it like that.
+     */
+    deregisterFeedback(feedbackEmitter?: IFeedbackEmitter, cleanupActions?: MaybeActions): void;
+}
+
 /**
  *  A reusable base implementation for edit {@link Tool}s.
  */
 @injectable()
-export abstract class BaseEditTool implements Tool {
+export abstract class BaseEditTool implements FeedbackAwareTool {
     @inject(TYPES.IFeedbackActionDispatcher) protected feedbackDispatcher: IFeedbackActionDispatcher;
     @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
     @inject(GLSPMouseTool) protected mouseTool: GLSPMouseTool;
@@ -47,32 +78,20 @@ export abstract class BaseEditTool implements Tool {
         return true;
     }
 
-    dispatchActions(actions: Action[]): void {
-        this.actionDispatcher.dispatchAll(actions);
+    dispatchActions(actions: Action[]): Promise<void> {
+        return this.actionDispatcher.dispatchAll(actions);
     }
 
-    /**
-     * Registers `actions` to be sent out as feedback, i.e., changes that are re-established whenever the `GModelRoot`
-     * has been set or updated.
-     *
-     * @param feedbackActions the actions to be sent out.
-     * @param feedbackEmitter the emitter sending out feedback actions (this tool by default).
-     * @param cleanupActions the actions to be sent out when the feedback is de-registered through the returned Disposable.
-     * @returns A 'Disposable' that de-registers the feedback and cleans up any pending feedback with the given `cleanupActions`.
-     */
-    registerFeedback(feedbackActions: Action[], feedbackEmitter?: IFeedbackEmitter, cleanupActions?: Action[]): Disposable {
-        return this.feedbackDispatcher.registerFeedback(feedbackEmitter ?? this, feedbackActions, cleanupActions);
+    createFeedbackEmitter(): FeedbackEmitter {
+        return this.feedbackDispatcher.createEmitter();
     }
 
-    /**
-     * De-registers all feedback from the given `feedbackEmitter` (this tool by default) and cleans up any pending feedback with the
-     * given `cleanupActions`.
-     *
-     * @param feedbackEmitter the emitter to be deregistered (this tool by default).
-     * @param cleanupActions the actions to be dispatched right after the deregistration to clean up any pending feedback.
-     */
-    deregisterFeedback(feedbackEmitter?: IFeedbackEmitter, cleanupActions?: Action[]): void {
-        this.feedbackDispatcher.deregisterFeedback(feedbackEmitter ?? this, cleanupActions);
+    registerFeedback(feedbackActions: Action[], feedbackEmitter: IFeedbackEmitter = this, cleanupActions?: MaybeActions): Disposable {
+        return this.feedbackDispatcher.registerFeedback(feedbackEmitter, feedbackActions, cleanupActions);
+    }
+
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter = this, cleanupActions?: MaybeActions): void {
+        this.feedbackDispatcher.deregisterFeedback(feedbackEmitter, cleanupActions);
     }
 }
 

package/src/features/tools/change-bounds/change-bounds-manager.ts

@@ -0,0 +1,203 @@
+/********************************************************************************
+ * Copyright (c) 2024 Axon Ivy AG 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 {
+    Dimension,
+    GModelElement,
+    ISnapper,
+    KeyboardModifier,
+    MousePositionTracker,
+    Movement,
+    Point,
+    TYPES,
+    Vector,
+    isBoundsAware,
+    isLocateable
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable, optional } from 'inversify';
+
+import {
+    CursorCSS,
+    ModifyCSSFeedbackAction,
+    applyCssClasses,
+    cursorFeedbackAction,
+    deleteCssClasses,
+    toggleCssClasses
+} from '../../../base/feedback/css-feedback';
+import { FeedbackEmitter } from '../../../base/feedback/feedback-emitter';
+import { isValidMove, minDimensions } from '../../../utils/layout-utils';
+import { LayoutAware } from '../../bounds/layout-data';
+import { GResizeHandle, ResizeHandleLocation } from '../../change-bounds/model';
+import {
+    IMovementRestrictor,
+    movementRestrictionFeedback,
+    removeMovementRestrictionFeedback
+} from '../../change-bounds/movement-restrictor';
+import { GridManager } from '../../grid/grid-manager';
+import { IHelperLineManager } from '../../helper-lines/helper-line-manager';
+import { InsertIndicator } from '../node-creation/insert-indicator';
+import { ChangeBoundsTracker, TrackedElementMove, TrackedElementResize, TrackedMove, TrackedResize } from './change-bounds-tracker';
+
+export const CSS_RESIZE_MODE = 'resize-mode';
+export const CSS_RESTRICTED_RESIZE = 'resize-not-allowed';
+export const CSS_ACTIVE_HANDLE = 'active';
+
+@injectable()
+export class ChangeBoundsManager {
+    constructor(
+        @inject(MousePositionTracker) readonly positionTracker: MousePositionTracker,
+        @optional() @inject(TYPES.IMovementRestrictor) readonly movementRestrictor?: IMovementRestrictor,
+        @optional() @inject(TYPES.ISnapper) readonly snapper?: ISnapper,
+        @optional() @inject(TYPES.IHelperLineManager) readonly helperLineManager?: IHelperLineManager,
+        @optional() @inject(GridManager) protected gridManager?: GridManager
+    ) {}
+
+    unsnapModifier(): KeyboardModifier | undefined {
+        return 'shift';
+    }
+
+    usePositionSnap(arg: MouseEvent | KeyboardEvent | any): boolean {
+        return typeof arg === 'boolean' ? arg : !(arg as MouseEvent | KeyboardEvent).shiftKey;
+    }
+
+    snapPosition(element: GModelElement, position: Point): Point {
+        return this.snapper?.snap(position, element) ?? position;
+    }
+
+    isValid(element: GModelElement): boolean {
+        return this.hasValidPosition(element) && this.hasValidSize(element);
+    }
+
+    hasValidPosition(element: GModelElement, position?: Point): boolean {
+        return !isLocateable(element) || isValidMove(element, position ?? element.position, this.movementRestrictor);
+    }
+
+    hasValidSize(element: GModelElement, size?: Dimension): boolean {
+        if (!isBoundsAware(element)) {
+            return true;
+        }
+        const dimension: Dimension = size ?? element.bounds;
+        const minimum = this.getMinimumSize(element);
+        if (dimension.width < minimum.width || dimension.height < minimum.height) {
+            return false;
+        }
+        return true;
+    }
+
+    getMinimumSize(element: GModelElement): Dimension {
+        if (!isBoundsAware(element)) {
+            return Dimension.EMPTY;
+        }
+        const definedMinimum = minDimensions(element);
+        const computedMinimum = LayoutAware.getComputedDimensions(element);
+        return computedMinimum
+            ? {
+                  width: Math.max(definedMinimum.width, computedMinimum.width),
+                  height: Math.max(definedMinimum.height, computedMinimum.height)
+              }
+            : definedMinimum;
+    }
+
+    useMovementRestriction(arg: MouseEvent | KeyboardEvent | any): boolean {
+        return this.usePositionSnap(arg);
+    }
+
+    restrictMovement(element: GModelElement, movement: Movement): Movement {
+        const minimumMovement = this.getMinimumMovement(element, movement);
+        if (!minimumMovement) {
+            return movement;
+        }
+        // minimum is given in absolute coordinates
+        // if minimum is not reached, reset to original position for that coordinate
+        const absVector = Vector.abs(movement.vector);
+        const targetPosition: Point = {
+            x: absVector.x < minimumMovement.x ? movement.from.x : movement.to.x,
+            y: absVector.y < minimumMovement.y ? movement.from.y : movement.to.y
+        };
+        return Point.move(movement.from, targetPosition);
+    }
+
+    protected getMinimumMovement(element: GModelElement, movement: Movement): Vector | undefined {
+        return element instanceof InsertIndicator && this.gridManager
+            ? this.gridManager.grid
+            : this.helperLineManager?.getMinimumMoveVector(element, true, movement.direction);
+    }
+
+    addMoveFeedback(feedback: FeedbackEmitter, trackedMove: TrackedMove, ctx?: GModelElement, event?: MouseEvent): FeedbackEmitter {
+        // cursor feedback on graph
+        feedback.add(cursorFeedbackAction(CursorCSS.MOVE), cursorFeedbackAction(CursorCSS.DEFAULT));
+
+        // restriction feedback on each element
+        trackedMove.elementMoves.forEach(move => this.addMoveRestrictionFeedback(feedback, move, ctx, event));
+
+        return feedback;
+    }
+
+    addResizeFeedback(feedback: FeedbackEmitter, resize: TrackedResize, ctx?: GModelElement, event?: MouseEvent): FeedbackEmitter {
+        // graph feedback
+        feedback.add(
+            ModifyCSSFeedbackAction.create({ add: [CSS_RESIZE_MODE] }),
+            ModifyCSSFeedbackAction.create({ remove: [CSS_RESIZE_MODE] })
+        );
+
+        // cursor feedback on graph
+        const cursorClass = GResizeHandle.getCursorCss(resize.handleMove.element);
+        feedback.add(cursorFeedbackAction(cursorClass), cursorFeedbackAction(CursorCSS.DEFAULT));
+
+        // handle feedback
+        const handle = resize.handleMove.element;
+        feedback.add(applyCssClasses(handle, CSS_ACTIVE_HANDLE), deleteCssClasses(handle, CSS_ACTIVE_HANDLE));
+        feedback.add(toggleCssClasses(handle, !resize.valid.size, CSS_RESTRICTED_RESIZE), deleteCssClasses(handle, CSS_RESTRICTED_RESIZE));
+
+        // restriction feedback on each element
+        resize.elementResizes.forEach(elementResize => {
+            this.addMoveRestrictionFeedback(feedback, elementResize, ctx, event);
+            feedback.add(
+                toggleCssClasses(elementResize.element, !elementResize.valid.size, CSS_RESTRICTED_RESIZE),
+                deleteCssClasses(elementResize.element, CSS_RESTRICTED_RESIZE)
+            );
+        });
+        return feedback;
+    }
+
+    addMoveRestrictionFeedback(
+        feedback: FeedbackEmitter,
+        change: TrackedElementResize | TrackedElementMove,
+        ctx?: GModelElement,
+        event?: MouseEvent
+    ): FeedbackEmitter {
+        if (this.movementRestrictor) {
+            const valid = TrackedElementMove.is(change) ? change.valid : change.valid.move;
+            feedback.add(
+                movementRestrictionFeedback(change.element, this.movementRestrictor, valid),
+                removeMovementRestrictionFeedback(change.element, this.movementRestrictor)
+            );
+        }
+        return feedback;
+    }
+
+    defaultResizeLocations(): ResizeHandleLocation[] {
+        return ResizeHandleLocation.CORNERS;
+    }
+
+    useSymmetricResize(arg: MouseEvent | KeyboardEvent | any): boolean {
+        return typeof arg === 'boolean' ? arg : (arg as MouseEvent | KeyboardEvent).ctrlKey;
+    }
+
+    createTracker(): ChangeBoundsTracker {
+        return new ChangeBoundsTracker(this);
+    }
+}