@eclipse-glsp/client 0.10.0-next.6bee8eb.163 → 0.10.0-next.88e4725.166

package/src/features/tool-palette/tool-palette.ts

@@ -13,11 +13,10 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { isSetContextActionsAction, RequestContextActions, RequestMarkersAction, SetContextActions } from '@eclipse-glsp/protocol';
+import { Action, PaletteItem, RequestContextActions, RequestMarkersAction, SetContextActions } from '@eclipse-glsp/protocol';
 import { inject, injectable, postConstruct } from 'inversify';
 import {
     AbstractUIExtension,
-    Action,
     EnableDefaultToolsAction,
     EnableToolsAction,
     IActionHandler,
@@ -33,7 +32,6 @@ import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { EditModeListener, EditorContextService } from '../../base/editor-context-service';
 import { MouseDeleteTool } from '../tools/delete-tool';
 import { MarqueeMouseTool } from '../tools/marquee-mouse-tool';
-import { PaletteItem } from './palette-item';
 
 const CLICKED_CSS_CLASS = 'clicked';
 const SEARCH_ICON_ID = 'search';
@@ -41,12 +39,21 @@ const PALETTE_ICON_ID = 'symbol-color';
 const CHEVRON_DOWN_ICON_ID = 'chevron-right';
 const PALETTE_HEIGHT = '500px';
 
-@injectable()
-export class EnableToolPaletteAction implements Action {
-    static readonly KIND = 'enableToolPalette';
-    readonly kind = EnableToolPaletteAction.KIND;
+export interface EnableToolPaletteAction extends Action {
+    kind: typeof EnableToolPaletteAction.KIND;
 }
 
+export namespace EnableToolPaletteAction {
+    export const KIND = 'enableToolPalette';
+
+    export function is(object: any): object is EnableToolPaletteAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(): EnableToolPaletteAction {
+        return { kind: KIND };
+    }
+}
 @injectable()
 export class ToolPalette extends AbstractUIExtension implements IActionHandler, EditModeListener {
     static readonly ID = 'tool-palette';
@@ -215,7 +222,7 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
         validateActionButton.title = 'Validate model';
         validateActionButton.onclick = _event => {
             const modelIds: string[] = [this.modelRootId];
-            this.actionDispatcher.dispatch(new RequestMarkersAction(modelIds));
+            this.actionDispatcher.dispatch(RequestMarkersAction.create(modelIds));
         };
         return validateActionButton;
     }
@@ -284,7 +291,7 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
     protected onClickStaticToolButton(button: HTMLElement, toolId?: string) {
         return (_ev: MouseEvent) => {
             if (!this.editorContext.isReadonly) {
-                const action = toolId ? new EnableToolsAction([toolId]) : new EnableDefaultToolsAction();
+                const action = toolId ? EnableToolsAction.create([toolId]) : EnableDefaultToolsAction.create();
                 this.actionDispatcher.dispatch(action);
                 this.changeActiveButton(button);
                 button.focus();
@@ -307,23 +314,30 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
 
     handle(action: Action): ICommand | Action | void {
         if (action.kind === EnableToolPaletteAction.KIND) {
-            const requestAction = new RequestContextActions(ToolPalette.ID, {
-                selectedElementIds: []
+            const requestAction = RequestContextActions.create({
+                contextId: ToolPalette.ID,
+                editorContext: {
+                    selectedElementIds: []
+                }
             });
             this.actionDispatcher.requestUntil(requestAction).then(response => {
-                if (isSetContextActionsAction(response)) {
+                if (SetContextActions.is(response)) {
                     this.paletteItems = response.actions.map(e => e as PaletteItem);
-                    this.actionDispatcher.dispatch(new SetUIExtensionVisibilityAction(ToolPalette.ID, !this.editorContext.isReadonly));
+                    this.actionDispatcher.dispatch(
+                        SetUIExtensionVisibilityAction.create({ extensionId: ToolPalette.ID, visible: !this.editorContext.isReadonly })
+                    );
                 }
             });
-        } else if (action instanceof EnableDefaultToolsAction) {
+        } else if (action.kind === EnableDefaultToolsAction.KIND) {
             this.changeActiveButton();
             this.restoreFocus();
         }
     }
 
     editModeChanged(_oldValue: string, _newValue: string): void {
-        this.actionDispatcher.dispatch(new SetUIExtensionVisibilityAction(ToolPalette.ID, !this.editorContext.isReadonly));
+        this.actionDispatcher.dispatch(
+            SetUIExtensionVisibilityAction.create({ extensionId: ToolPalette.ID, visible: !this.editorContext.isReadonly })
+        );
     }
 
     protected clearOnEscape(event: KeyboardEvent): void {
@@ -335,7 +349,7 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
 
     protected clearToolOnEscape(event: KeyboardEvent): void {
         if (matchesKeystroke(event, 'Escape')) {
-            this.actionDispatcher.dispatch(new EnableDefaultToolsAction());
+            this.actionDispatcher.dispatch(EnableDefaultToolsAction.create());
         }
     }
 

package/src/features/tools/base-glsp-tool.ts

@@ -15,18 +15,18 @@
  ********************************************************************************/
 import { Action } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { IActionDispatcher, KeyTool, TYPES } from 'sprotty';
+import { IActionDispatcher, KeyTool } from 'sprotty';
 import { EditorContextService } from '../../base/editor-context-service';
 import { GLSPTool } from '../../base/tool-manager/glsp-tool-manager';
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
 import { IMouseTool } from '../mouse-tool/mouse-tool';
 import { IFeedbackActionDispatcher, IFeedbackEmitter } from '../tool-feedback/feedback-action-dispatcher';
 
 @injectable()
 export abstract class BaseGLSPTool implements GLSPTool {
-    @inject(GLSP_TYPES.IFeedbackActionDispatcher) protected feedbackDispatcher: IFeedbackActionDispatcher;
+    @inject(TYPES.IFeedbackActionDispatcher) protected feedbackDispatcher: IFeedbackActionDispatcher;
     @inject(TYPES.IActionDispatcher) protected actionDispatcher: IActionDispatcher;
-    @inject(GLSP_TYPES.MouseTool) protected mouseTool: IMouseTool;
+    @inject(TYPES.MouseTool) protected mouseTool: IMouseTool;
     @inject(KeyTool) protected keyTool: KeyTool;
     @inject(EditorContextService) protected readonly editorContext: EditorContextService;
 

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

@@ -19,32 +19,30 @@ import {
     ChangeBoundsOperation,
     ChangeRoutingPointsOperation,
     CompoundOperation,
+    Dimension,
+    ElementAndBounds,
     ElementAndRoutingPoints,
     Operation,
-    Point
+    Point,
+    SetBoundsAction
 } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
 import {
     BoundsAware,
-    Dimension,
     EdgeRouterRegistry,
-    ElementAndBounds,
     findParentByFeature,
     ISnapper,
     isSelected,
-    isViewport,
     MouseListener,
     SChildElement,
     SConnectableElement,
-    SetBoundsAction,
     SModelElement,
     SModelRoot,
-    SParentElement,
-    TYPES
+    SParentElement
 } from 'sprotty';
 import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-import { GLSP_TYPES } from '../../base/types';
-import { isValidMove, isValidSize, WriteablePoint } from '../../utils/layout-utils';
+import { TYPES } from '../../base/types';
+import { isValidMove, isValidSize } from '../../utils/layout-utils';
 import {
     forEachElement,
     isNonRoutableSelectedMovableBoundsAware,
@@ -57,6 +55,7 @@ import {
     IMovementRestrictor,
     removeMovementRestrictionFeedback
 } from '../change-bounds/movement-restrictor';
+import { PointPositionUpdater } from '../change-bounds/snap';
 import { SelectionListener, SelectionService } from '../select/selection-service';
 import {
     FeedbackMoveMouseListener,
@@ -83,10 +82,10 @@ import { BaseGLSPTool } from './base-glsp-tool';
 export class ChangeBoundsTool extends BaseGLSPTool {
     static ID = 'glsp.change-bounds-tool';
 
-    @inject(GLSP_TYPES.SelectionService) protected selectionService: SelectionService;
+    @inject(TYPES.SelectionService) protected selectionService: SelectionService;
     @inject(EdgeRouterRegistry) @optional() readonly edgeRouterRegistry?: EdgeRouterRegistry;
     @inject(TYPES.ISnapper) @optional() readonly snapper?: ISnapper;
-    @inject(GLSP_TYPES.IMovementRestrictor) @optional() readonly movementRestrictor?: IMovementRestrictor;
+    @inject(TYPES.IMovementRestrictor) @optional() readonly movementRestrictor?: IMovementRestrictor;
     protected feedbackMoveMouseListener: MouseListener;
     protected changeBoundsListener: MouseListener & SelectionListener;
 
@@ -118,7 +117,7 @@ export class ChangeBoundsTool extends BaseGLSPTool {
         this.selectionService.deregister(this.changeBoundsListener);
         this.mouseTool.deregister(this.feedbackMoveMouseListener);
         this.deregisterFeedback([], this.feedbackMoveMouseListener);
-        this.deregisterFeedback([new HideChangeBoundsToolResizeFeedbackAction()], this.changeBoundsListener);
+        this.deregisterFeedback([HideChangeBoundsToolResizeFeedbackAction.create()], this.changeBoundsListener);
     }
 }
 
@@ -127,8 +126,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
 
     // members for calculating the correct position change
     protected initialBounds: Bounds | undefined;
-    protected lastDragPosition?: Point;
-    protected positionDelta: WriteablePoint = { x: 0, y: 0 };
+    protected pointPositionUpdater: PointPositionUpdater;
 
     // members for resize mode
     protected activeResizeElement?: SModelElement;
@@ -136,11 +134,14 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
 
     constructor(protected tool: ChangeBoundsTool) {
         super();
+        this.pointPositionUpdater = new PointPositionUpdater(tool.snapper);
     }
 
     override mouseDown(target: SModelElement, event: MouseEvent): Action[] {
         super.mouseDown(target, event);
-        if (event.button !== 0) {
+        // If another button than the left mouse button was clicked or we are
+        // still on the root element we don't need to execute the tool behavior
+        if (event.button !== 0 || target instanceof SModelRoot) {
             return [];
         }
         // check if we have a resize handle (only single-selection)
@@ -166,7 +167,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
                 cursorFeedbackAction(this.activeResizeHandle.isNwSeResize() ? CursorCSS.RESIZE_NWSE : CursorCSS.RESIZE_NESW),
                 applyCssClasses(this.activeResizeHandle, ChangeBoundsListener.CSS_CLASS_ACTIVE)
             ];
-            const positionUpdate = this.updatePosition(target, event);
+            const positionUpdate = this.pointPositionUpdater.updatePosition(target, { x: event.pageX, y: event.pageY }, !event.altKey);
             if (positionUpdate) {
                 const resizeActions = this.handleResizeOnClient(positionUpdate);
                 actions.push(...resizeActions);
@@ -177,7 +178,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
     }
 
     override draggingMouseUp(target: SModelElement, event: MouseEvent): Action[] {
-        if (this.lastDragPosition === undefined) {
+        if (this.pointPositionUpdater.isLastDragPositionUndefined()) {
             this.resetPosition();
             return [];
         }
@@ -200,12 +201,12 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
         operations.push(...this.handleMoveElementsOnServer(target));
         operations.push(...this.handleMoveRoutingPointsOnServer(target));
         if (operations.length > 0) {
-            return [new CompoundOperation(operations)];
+            return [CompoundOperation.create(operations)];
         }
         return operations;
     }
 
-    protected handleMoveElementsOnServer(target: SModelElement): Action[] {
+    protected handleMoveElementsOnServer(target: SModelElement): Operation[] {
         const result: Operation[] = [];
         const newBounds: ElementAndBounds[] = [];
         const selectedElements: (SModelElement & BoundsAware)[] = [];
@@ -220,7 +221,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
             .forEach(bounds => newBounds.push(...bounds));
 
         if (newBounds.length > 0) {
-            result.push(new ChangeBoundsOperation(newBounds));
+            result.push(ChangeBoundsOperation.create(newBounds));
         }
         return result;
     }
@@ -235,7 +236,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
         return false;
     }
 
-    protected handleMoveRoutingPointsOnServer(target: SModelElement): Action[] {
+    protected handleMoveRoutingPointsOnServer(target: SModelElement): Operation[] {
         const result: Operation[] = [];
         const newRoutingPoints: ElementAndRoutingPoints[] = [];
         forEachElement(target.index, isNonRoutableSelectedMovableBoundsAware, element => {
@@ -246,7 +247,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
             }
         });
         if (newRoutingPoints.length > 0) {
-            result.push(new ChangeRoutingPointsOperation(newRoutingPoints));
+            result.push(ChangeRoutingPointsOperation.create(newRoutingPoints));
         }
         return result;
     }
@@ -287,7 +288,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
             // only allow one element to have the element resize handles
             this.activeResizeElement = moveableElement;
             if (isResizable(this.activeResizeElement)) {
-                this.tool.dispatchFeedback([new ShowChangeBoundsToolResizeFeedbackAction(this.activeResizeElement.id)], this);
+                this.tool.dispatchFeedback([ShowChangeBoundsToolResizeFeedbackAction.create(this.activeResizeElement.id)], this);
             }
             return true;
         }
@@ -299,7 +300,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
     }
 
     protected initPosition(event: MouseEvent): void {
-        this.lastDragPosition = { x: event.pageX, y: event.pageY };
+        this.pointPositionUpdater.updateLastDragPosition({ x: event.pageX, y: event.pageY });
         if (this.activeResizeHandle) {
             const resizeElement = findParentByFeature(this.activeResizeHandle, isResizable);
             this.initialBounds = {
@@ -311,39 +312,9 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
         }
     }
 
-    protected updatePosition(target: SModelElement, event: MouseEvent): Point | undefined {
-        if (this.lastDragPosition) {
-            const newDragPosition = { x: event.pageX, y: event.pageY };
-
-            const viewport = findParentByFeature(target, 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
-            const positionUpdate = this.snap(this.positionDelta, target, !event.altKey);
-            if (positionUpdate.x === 0 && positionUpdate.y === 0) {
-                return undefined;
-            }
-
-            // 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;
-    }
-
     protected reset(): void {
         if (this.activeResizeElement && isResizable(this.activeResizeElement)) {
-            this.tool.dispatchFeedback([new HideChangeBoundsToolResizeFeedbackAction()], this);
+            this.tool.dispatchFeedback([HideChangeBoundsToolResizeFeedbackAction.create()], this);
         }
         this.tool.dispatchActions([cursorFeedbackAction(CursorCSS.DEFAULT)]);
         this.resetPosition();
@@ -351,8 +322,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
 
     protected resetPosition(): void {
         this.activeResizeHandle = undefined;
-        this.lastDragPosition = undefined;
-        this.positionDelta = { x: 0, y: 0 };
+        this.pointPositionUpdater.resetPosition();
     }
 
     protected handleResizeOnClient(positionUpdate: Point): Action[] {
@@ -418,13 +388,13 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
 
     protected createChangeBoundsAction(element: SModelElement & BoundsAware): Action[] {
         if (this.isValidBoundChange(element, element.bounds, element.bounds)) {
-            return [new ChangeBoundsOperation([toElementAndBounds(element)])];
+            return [ChangeBoundsOperation.create([toElementAndBounds(element)])];
         } else if (this.initialBounds) {
             const actions: Action[] = [];
             if (this.tool.movementRestrictor) {
                 actions.push(removeMovementRestrictionFeedback(element, this.tool.movementRestrictor));
             }
-            actions.push(new SetBoundsAction([{ elementId: element.id, newPosition: this.initialBounds, newSize: this.initialBounds }]));
+            actions.push(SetBoundsAction.create([{ elementId: element.id, newPosition: this.initialBounds, newSize: this.initialBounds }]));
             return actions;
         }
         return [];
@@ -446,12 +416,12 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
             if (this.tool.movementRestrictor) {
                 result.push(removeMovementRestrictionFeedback(element, this.tool.movementRestrictor));
             }
-            result.push(new SetBoundsAction([{ elementId: element.id, newPosition, newSize }]));
+            result.push(SetBoundsAction.create([{ elementId: element.id, newPosition, newSize }]));
         } else if (this.isValidSize(element, newSize)) {
             if (this.tool.movementRestrictor) {
                 result.push(createMovementRestrictionFeedback(element, this.tool.movementRestrictor));
             }
-            result.push(new SetBoundsAction([{ elementId: element.id, newPosition, newSize }]));
+            result.push(SetBoundsAction.create([{ elementId: element.id, newPosition, newSize }]));
         }
 
         return result;

package/src/features/tools/delete-tool.ts

@@ -28,7 +28,7 @@ import {
 } from 'sprotty';
 import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
 import { GLSPTool } from '../../base/tool-manager/glsp-tool-manager';
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
 import { IMouseTool } from '../mouse-tool/mouse-tool';
 import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
 import { IFeedbackActionDispatcher } from '../tool-feedback/feedback-action-dispatcher';
@@ -70,7 +70,7 @@ export class DeleteKeyListener extends KeyListener {
                     .map(e => e.id)
             );
             if (deleteElementIds.length > 0) {
-                return [new DeleteElementOperation(deleteElementIds)];
+                return [DeleteElementOperation.create(deleteElementIds)];
             }
         }
         return [];
@@ -88,8 +88,8 @@ export class MouseDeleteTool implements GLSPTool {
 
     protected deleteToolMouseListener: DeleteToolMouseListener = new DeleteToolMouseListener();
 
-    @inject(GLSP_TYPES.MouseTool) protected mouseTool: IMouseTool;
-    @inject(GLSP_TYPES.IFeedbackActionDispatcher) protected readonly feedbackDispatcher: IFeedbackActionDispatcher;
+    @inject(TYPES.MouseTool) protected mouseTool: IMouseTool;
+    @inject(TYPES.IFeedbackActionDispatcher) protected readonly feedbackDispatcher: IFeedbackActionDispatcher;
 
     get id(): string {
         return MouseDeleteTool.ID;
@@ -114,9 +114,9 @@ export class DeleteToolMouseListener extends MouseListener {
             return [];
         }
         const result: Action[] = [];
-        result.push(new DeleteElementOperation([deletableParent.id]));
+        result.push(DeleteElementOperation.create([deletableParent.id]));
         if (!isCtrlOrCmd(event)) {
-            result.push(new EnableDefaultToolsAction());
+            result.push(EnableDefaultToolsAction.create());
         }
         return result;
     }

package/src/features/tools/di.config.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 EclipseSource and others.
+ * Copyright (c) 2019-2022 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,7 +16,7 @@
 import { TriggerEdgeCreationAction, TriggerNodeCreationAction } from '@eclipse-glsp/protocol';
 import { ContainerModule, interfaces } from 'inversify';
 import { configureActionHandler, configureModelElement } from 'sprotty';
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
 import { MARQUEE } from '../tool-feedback/marquee-tool-feedback';
 import { ChangeBoundsTool } from './change-bounds-tool';
 import { DelKeyDeleteTool, MouseDeleteTool } from './delete-tool';
@@ -30,16 +30,16 @@ import { MarqueeView } from './view';
 
 const toolsModule = new ContainerModule((bind, _unbind, isBound) => {
     // Register default tools
-    bind(GLSP_TYPES.IDefaultTool).to(ChangeBoundsTool);
-    bind(GLSP_TYPES.IDefaultTool).to(EdgeEditTool);
-    bind(GLSP_TYPES.IDefaultTool).to(DelKeyDeleteTool);
+    bind(TYPES.IDefaultTool).to(ChangeBoundsTool);
+    bind(TYPES.IDefaultTool).to(EdgeEditTool);
+    bind(TYPES.IDefaultTool).to(DelKeyDeleteTool);
 
     // Register  tools
-    bind(GLSP_TYPES.ITool).to(MouseDeleteTool);
+    bind(TYPES.ITool).to(MouseDeleteTool);
     bind(NodeCreationTool).toSelf().inSingletonScope();
     bind(EdgeCreationTool).toSelf().inSingletonScope();
-    bind(GLSP_TYPES.ITool).toService(EdgeCreationTool);
-    bind(GLSP_TYPES.ITool).toService(NodeCreationTool);
+    bind(TYPES.ITool).toService(EdgeCreationTool);
+    bind(TYPES.ITool).toService(NodeCreationTool);
 
     configureMarqueeTool({ bind, isBound });
     configureActionHandler({ bind, isBound }, TriggerNodeCreationAction.KIND, NodeCreationTool);
@@ -48,8 +48,8 @@ const toolsModule = new ContainerModule((bind, _unbind, isBound) => {
 
 export function configureMarqueeTool(context: { bind: interfaces.Bind; isBound: interfaces.IsBound }): void {
     configureModelElement(context, MARQUEE, MarqueeNode, MarqueeView);
-    context.bind(GLSP_TYPES.IDefaultTool).to(MarqueeTool);
-    context.bind(GLSP_TYPES.ITool).to(MarqueeMouseTool);
+    context.bind(TYPES.IDefaultTool).to(MarqueeTool);
+    context.bind(TYPES.ITool).to(MarqueeMouseTool);
 }
 
 export default toolsModule;

package/src/features/tools/edge-creation-tool.ts

@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, CreateEdgeOperation, isTriggerElementTypeCreationAction, TriggerEdgeCreationAction } from '@eclipse-glsp/protocol';
+import { Action, CreateEdgeOperation, TriggerEdgeCreationAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import {
     AnchorComputerRegistry,
@@ -66,13 +66,13 @@ export class EdgeCreationTool extends BaseGLSPTool implements IActionHandler {
     disable(): void {
         this.mouseTool.deregister(this.creationToolMouseListener);
         this.mouseTool.deregister(this.feedbackEndMovingMouseListener);
-        this.deregisterFeedback([new RemoveFeedbackEdgeAction(), cursorFeedbackAction()]);
+        this.deregisterFeedback([RemoveFeedbackEdgeAction.create(), cursorFeedbackAction()]);
     }
 
     handle(action: Action): Action | void {
-        if (isTriggerElementTypeCreationAction(action)) {
+        if (TriggerEdgeCreationAction.is(action)) {
             this.triggerAction = action;
-            return new EnableToolsAction([this.id]);
+            return EnableToolsAction.create([this.id]);
         }
     }
 }
@@ -96,7 +96,7 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
         this.target = undefined;
         this.currentTarget = undefined;
         this.allowedTarget = false;
-        this.tool.dispatchFeedback([new RemoveFeedbackEdgeAction()]);
+        this.tool.dispatchFeedback([RemoveFeedbackEdgeAction.create()]);
     }
 
     override nonDraggingMouseUp(_element: SModelElement, event: MouseEvent): Action[] {
@@ -105,7 +105,9 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
             if (!this.isSourceSelected()) {
                 if (this.currentTarget && this.allowedTarget) {
                     this.source = this.currentTarget.id;
-                    this.tool.dispatchFeedback([new DrawFeedbackEdgeAction(this.triggerAction.elementTypeId, this.source)]);
+                    this.tool.dispatchFeedback([
+                        DrawFeedbackEdgeAction.create({ elementTypeId: this.triggerAction.elementTypeId, sourceId: this.source })
+                    ]);
                 }
             } else {
                 if (this.currentTarget && this.allowedTarget) {
@@ -113,15 +115,22 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
                 }
             }
             if (this.source && this.target) {
-                result.push(new CreateEdgeOperation(this.triggerAction.elementTypeId, this.source, this.target, this.triggerAction.args));
+                result.push(
+                    CreateEdgeOperation.create({
+                        elementTypeId: this.triggerAction.elementTypeId,
+                        sourceElementId: this.source,
+                        targetElementId: this.target,
+                        args: this.triggerAction.args
+                    })
+                );
                 if (!isCtrlOrCmd(event)) {
-                    result.push(new EnableDefaultToolsAction());
+                    result.push(EnableDefaultToolsAction.create());
                 } else {
                     this.reinitialize();
                 }
             }
         } else if (event.button === 2) {
-            result.push(new EnableDefaultToolsAction());
+            result.push(EnableDefaultToolsAction.create());
         }
         return result;
     }

package/src/features/tools/edge-edit-tool.ts

@@ -22,6 +22,7 @@ import {
     EdgeRouterRegistry,
     findParentByFeature,
     isConnectable,
+    ISnapper,
     isSelected,
     SModelElement,
     SModelRoot,
@@ -29,7 +30,7 @@ import {
     SRoutingHandle
 } from 'sprotty';
 import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
 import { isRoutable, isRoutingHandle } from '../../utils/smodel-util';
 import { isReconnectable, isReconnectHandle, isSourceRoutingHandle, isTargetRoutingHandle, SReconnectHandle } from '../reconnect/model';
 import { SelectionListener, SelectionService } from '../select/selection-service';
@@ -50,9 +51,10 @@ import { BaseGLSPTool } from './base-glsp-tool';
 export class EdgeEditTool extends BaseGLSPTool {
     static ID = 'glsp.edge-edit-tool';
 
-    @inject(GLSP_TYPES.SelectionService) protected selectionService: SelectionService;
+    @inject(TYPES.SelectionService) protected selectionService: SelectionService;
     @inject(AnchorComputerRegistry) protected anchorRegistry: AnchorComputerRegistry;
     @inject(EdgeRouterRegistry) @optional() protected edgeRouterRegistry?: EdgeRouterRegistry;
+    @inject(TYPES.ISnapper) @optional() readonly snapper?: ISnapper;
 
     protected feedbackEdgeSourceMovingListener: FeedbackEdgeSourceMovingMouseListener;
     protected feedbackEdgeTargetMovingListener: FeedbackEdgeTargetMovingMouseListener;
@@ -71,7 +73,7 @@ export class EdgeEditTool extends BaseGLSPTool {
         // install feedback move mouse listener for client-side move updates
         this.feedbackEdgeSourceMovingListener = new FeedbackEdgeSourceMovingMouseListener(this.anchorRegistry);
         this.feedbackEdgeTargetMovingListener = new FeedbackEdgeTargetMovingMouseListener(this.anchorRegistry);
-        this.feedbackMovingListener = new FeedbackEdgeRouteMovingMouseListener(this.edgeRouterRegistry);
+        this.feedbackMovingListener = new FeedbackEdgeRouteMovingMouseListener(this.edgeRouterRegistry, this.snapper);
     }
 
     registerFeedbackListeners(): void {
@@ -123,10 +125,10 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
         // note: order is important here as we want the reconnect handles to cover the routing handles
         const feedbackActions = [];
         if (canEditRouting(edge)) {
-            feedbackActions.push(new SwitchRoutingModeAction([this.edge.id], []));
+            feedbackActions.push(SwitchRoutingModeAction.create({ elementsToActivate: [this.edge.id] }));
         }
         if (isReconnectable(edge)) {
-            feedbackActions.push(new ShowEdgeReconnectHandlesFeedbackAction(this.edge.id));
+            feedbackActions.push(ShowEdgeReconnectHandlesFeedbackAction.create(this.edge.id));
         }
         this.tool.dispatchFeedback(feedbackActions);
     }
@@ -139,16 +141,16 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
         if (this.edge && this.edge.target && this.edge.source) {
             if (isSourceRoutingHandle(edge, reconnectHandle)) {
                 this.tool.dispatchFeedback([
-                    new HideEdgeReconnectHandlesFeedbackAction(),
+                    HideEdgeReconnectHandlesFeedbackAction.create(),
                     cursorFeedbackAction(CursorCSS.EDGE_RECONNECT),
-                    new DrawFeedbackEdgeSourceAction(this.edge.type, this.edge.targetId)
+                    DrawFeedbackEdgeSourceAction.create({ elementTypeId: this.edge.type, targetId: this.edge.targetId })
                 ]);
                 this.reconnectMode = 'NEW_SOURCE';
             } else if (isTargetRoutingHandle(edge, reconnectHandle)) {
                 this.tool.dispatchFeedback([
-                    new HideEdgeReconnectHandlesFeedbackAction(),
+                    HideEdgeReconnectHandlesFeedbackAction.create(),
                     cursorFeedbackAction(CursorCSS.EDGE_CREATION_TARGET),
-                    new DrawFeedbackEdgeAction(this.edge.type, this.edge.sourceId)
+                    DrawFeedbackEdgeAction.create({ elementTypeId: this.edge.type, sourceId: this.edge.sourceId })
                 ]);
                 this.reconnectMode = 'NEW_TARGET';
             }
@@ -224,10 +226,10 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
         }
 
         if (this.edge && this.newConnectable) {
-            const sourceId = this.isReconnectingNewSource() ? this.newConnectable.id : this.edge.sourceId;
-            const targetId = this.isReconnectingNewSource() ? this.edge.targetId : this.newConnectable.id;
-            if (this.requiresReconnect(sourceId, targetId)) {
-                result.push(new ReconnectEdgeOperation(this.edge.id, sourceId, targetId));
+            const sourceElementId = this.isReconnectingNewSource() ? this.newConnectable.id : this.edge.sourceId;
+            const targetElementId = this.isReconnectingNewSource() ? this.edge.targetId : this.newConnectable.id;
+            if (this.requiresReconnect(sourceElementId, targetElementId)) {
+                result.push(ReconnectEdgeOperation.create({ edgeElementId: this.edge.id, sourceElementId, targetElementId }));
             }
             this.reset();
         } else if (this.edge && this.routingHandle) {
@@ -235,7 +237,9 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
             // reroute actions
             const latestEdge = target.index.getById(this.edge.id);
             if (latestEdge && isRoutable(latestEdge)) {
-                result.push(new ChangeRoutingPointsOperation([{ elementId: latestEdge.id, newRoutingPoints: latestEdge.routingPoints }]));
+                result.push(
+                    ChangeRoutingPointsOperation.create([{ elementId: latestEdge.id, newRoutingPoints: latestEdge.routingPoints }])
+                );
                 this.routingHandle = undefined;
             }
         }
@@ -306,9 +310,9 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
     protected resetFeedback(): void {
         const result: Action[] = [];
         if (this.edge) {
-            result.push(new SwitchRoutingModeAction([], [this.edge.id]));
+            result.push(SwitchRoutingModeAction.create({ elementsToDeactivate: [this.edge.id] }));
         }
-        result.push(...[new HideEdgeReconnectHandlesFeedbackAction(), cursorFeedbackAction(), new RemoveFeedbackEdgeAction()]);
+        result.push(...[HideEdgeReconnectHandlesFeedbackAction.create(), cursorFeedbackAction(), RemoveFeedbackEdgeAction.create()]);
         this.tool.deregisterFeedback(result);
         this.tool.deregisterFeedbackListeners();
     }