@eclipse-glsp/client 1.1.0-next.9fabd84.216 → 1.1.0-next.a6b28e7.258

package/src/features/tools/{delete-tool.ts → deletion/delete-tool.ts}

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2022 EclipseSource and others.
+ * Copyright (c) 2019-2023 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,25 +13,24 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, DeleteElementOperation } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import {
+    Action,
+    DeleteElementOperation,
     EnableDefaultToolsAction,
+    KeyListener,
+    KeyTool,
+    MouseListener,
+    SModelElement,
     findParentByFeature,
     isCtrlOrCmd,
     isDeletable,
     isSelectable,
-    KeyListener,
-    KeyTool,
-    MouseListener,
-    SModelElement
-} from 'sprotty';
-import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
-import { GLSPTool } from '../../base/tool-manager/glsp-tool-manager';
-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';
+    matchesKeystroke
+} from '~glsp-sprotty';
+import { CursorCSS, cursorFeedbackAction } from '../../../base/feedback/css-feedback';
+import { GLSPTool } from '../../../base/tool-manager/glsp-tool-manager';
+import { BaseGLSPTool } from '../base-glsp-tool';
 
 /**
  * Deletes selected elements when hitting the `Del` key.
@@ -81,28 +80,20 @@ export class DeleteKeyListener extends KeyListener {
  * Deletes selected elements when clicking on them.
  */
 @injectable()
-export class MouseDeleteTool implements GLSPTool {
+export class MouseDeleteTool extends BaseGLSPTool {
     static ID = 'glsp.delete-mouse';
 
-    isEditTool = true;
-
     protected deleteToolMouseListener: DeleteToolMouseListener = new DeleteToolMouseListener();
 
-    @inject(TYPES.MouseTool) protected mouseTool: IMouseTool;
-    @inject(TYPES.IFeedbackActionDispatcher) protected readonly feedbackDispatcher: IFeedbackActionDispatcher;
-
     get id(): string {
         return MouseDeleteTool.ID;
     }
 
     enable(): void {
-        this.mouseTool.register(this.deleteToolMouseListener);
-        this.feedbackDispatcher.registerFeedback(this, [cursorFeedbackAction(CursorCSS.ELEMENT_DELETION)]);
-    }
-
-    disable(): void {
-        this.mouseTool.deregister(this.deleteToolMouseListener);
-        this.feedbackDispatcher.registerFeedback(this, [cursorFeedbackAction()]);
+        this.toDisposeOnDisable.push(
+            this.mouseTool.registerListener(this.deleteToolMouseListener),
+            this.registerFeedback([cursorFeedbackAction(CursorCSS.ELEMENT_DELETION)], this, [cursorFeedbackAction()])
+        );
     }
 }
 

package/src/features/{mouse-tool → tools/deletion}/di.config.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2022 EclipseSource and others.
+ * Copyright (c) 2019-2023 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,14 +14,13 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { ContainerModule } from 'inversify';
-import { MouseTool } from 'sprotty';
-import { TYPES } from '../../base/types';
-import { RankingMouseTool } from './mouse-tool';
+import { TYPES, bindAsService } from '~glsp-sprotty';
+import { DelKeyDeleteTool, MouseDeleteTool } from './delete-tool';
 
-const glspMouseToolModule = new ContainerModule((bind, _unbind, _isBound, rebind) => {
-    bind(RankingMouseTool).toSelf().inSingletonScope();
-    bind(TYPES.MouseTool).toService(RankingMouseTool);
-    rebind(MouseTool).toService(RankingMouseTool);
+const deletionToolModule = new ContainerModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    bindAsService(context, TYPES.IDefaultTool, DelKeyDeleteTool);
+    bindAsService(context, TYPES.ITool, MouseDeleteTool);
 });
 
-export default glspMouseToolModule;
+export default deletionToolModule;

package/src/features/tools/edge-creation/dangling-edge-feedback.ts

@@ -0,0 +1,185 @@
+/********************************************************************************
+ * Copyright (c) 2019-2023 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
+ * 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 { inject, injectable } from 'inversify';
+import {
+    Action,
+    BindingContext,
+    CommandExecutionContext,
+    CommandReturn,
+    SChildElement,
+    SDanglingAnchor,
+    SEdgeSchema,
+    SModelRoot,
+    SRoutableElement,
+    TYPES,
+    configureCommand,
+    configureView,
+    findParentByFeature,
+    isBoundsAware,
+    isConnectable
+} from '~glsp-sprotty';
+import { FeedbackCommand } from '../../../base/feedback/feedback-command';
+import { isRoutable } from '../../../utils/smodel-util';
+import { toAbsolutePosition } from '../../../utils/viewpoint-util';
+import { FeedbackEdgeEndView } from './view';
+
+export interface DrawFeedbackEdgeAction extends Action {
+    kind: typeof DrawFeedbackEdgeAction.KIND;
+    elementTypeId: string;
+    sourceId: string;
+    edgeSchema?: Partial<SEdgeSchema>;
+}
+
+export namespace DrawFeedbackEdgeAction {
+    export const KIND = 'drawFeedbackEdge';
+
+    export function is(object: any): object is DrawFeedbackEdgeAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(options: {
+        elementTypeId: string;
+        sourceId: string;
+        edgeSchema?: Partial<SEdgeSchema>;
+    }): DrawFeedbackEdgeAction {
+        return {
+            kind: KIND,
+            ...options
+        };
+    }
+}
+
+@injectable()
+export class DrawFeedbackEdgeCommand extends FeedbackCommand {
+    static readonly KIND = DrawFeedbackEdgeAction.KIND;
+
+    constructor(@inject(TYPES.Action) protected action: DrawFeedbackEdgeAction) {
+        super();
+    }
+
+    execute(context: CommandExecutionContext): CommandReturn {
+        drawFeedbackEdge(context, this.action.sourceId, this.action.elementTypeId, this.action.edgeSchema);
+        return context.root;
+    }
+}
+
+export interface RemoveFeedbackEdgeAction extends Action {
+    kind: typeof RemoveFeedbackEdgeAction.KIND;
+}
+
+export namespace RemoveFeedbackEdgeAction {
+    export const KIND = 'removeFeedbackEdgeCommand';
+
+    export function is(object: any): object is RemoveFeedbackEdgeAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(): RemoveFeedbackEdgeAction {
+        return { kind: KIND };
+    }
+}
+
+@injectable()
+export class RemoveFeedbackEdgeCommand extends FeedbackCommand {
+    static readonly KIND = RemoveFeedbackEdgeAction.KIND;
+
+    execute(context: CommandExecutionContext): CommandReturn {
+        removeDanglingFeedbackEdge(context.root);
+        return context.root;
+    }
+}
+
+export class FeedbackEdgeEnd extends SDanglingAnchor {
+    static readonly TYPE = 'feedback-edge-end';
+    constructor(
+        readonly sourceId: string,
+        readonly elementTypeId: string,
+        public feedbackEdge: SRoutableElement | undefined = undefined,
+        override readonly type: string = FeedbackEdgeEnd.TYPE
+    ) {
+        super();
+    }
+}
+
+export function feedbackEdgeId(root: SModelRoot): string {
+    return root.id + '_feedback_edge';
+}
+
+export function feedbackEdgeEndId(root: SModelRoot): string {
+    return root.id + '_feedback_anchor';
+}
+
+export const defaultFeedbackEdgeSchema: Partial<SEdgeSchema> = {
+    cssClasses: ['feedback-edge'],
+    opacity: 0.3
+};
+
+export function drawFeedbackEdge(
+    context: CommandExecutionContext,
+    sourceId: string,
+    elementTypeId: string,
+    edgeTemplate?: Partial<SEdgeSchema>
+): void {
+    const root = context.root;
+    const sourceChild = root.index.getById(sourceId);
+    if (!sourceChild) {
+        return;
+    }
+
+    const source = findParentByFeature(sourceChild, isConnectable);
+    if (!source || !isBoundsAware(source)) {
+        return;
+    }
+
+    const edgeEnd = new FeedbackEdgeEnd(source.id, elementTypeId);
+    edgeEnd.id = feedbackEdgeEndId(root);
+    edgeEnd.position = toAbsolutePosition(source);
+
+    const edgeSchema: SEdgeSchema = {
+        id: feedbackEdgeId(root),
+        type: elementTypeId,
+        sourceId: source.id,
+        targetId: edgeEnd.id,
+        ...defaultFeedbackEdgeSchema,
+        ...edgeTemplate
+    };
+
+    const feedbackEdge = context.modelFactory.createElement(edgeSchema);
+    if (isRoutable(feedbackEdge)) {
+        edgeEnd.feedbackEdge = feedbackEdge;
+        root.add(edgeEnd);
+        root.add(feedbackEdge);
+    }
+}
+
+export function removeDanglingFeedbackEdge(root: SModelRoot): void {
+    const feedbackEdge = root.index.getById(feedbackEdgeId(root));
+    const feedbackEdgeEnd = root.index.getById(feedbackEdgeEndId(root));
+    if (feedbackEdge instanceof SChildElement) {
+        root.remove(feedbackEdge);
+    }
+    if (feedbackEdgeEnd instanceof SChildElement) {
+        root.remove(feedbackEdgeEnd);
+    }
+}
+
+export function configureDanglingFeedbackEdge(context: BindingContext): void {
+    if (!context.isBound(DrawFeedbackEdgeCommand) && !context.isBound(RemoveFeedbackEdgeCommand) && !context.isBound(FeedbackEdgeEndView)) {
+        configureCommand(context, DrawFeedbackEdgeCommand);
+        configureCommand(context, RemoveFeedbackEdgeCommand);
+        configureView(context, FeedbackEdgeEnd.TYPE, FeedbackEdgeEndView);
+    }
+}

package/src/features/tools/edge-creation/di.config.ts

@@ -0,0 +1,28 @@
+/********************************************************************************
+ * Copyright (c) 2019-2023 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
+ * 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 { ContainerModule } from 'inversify';
+import { TYPES, TriggerEdgeCreationAction, bindAsService, configureActionHandler } from '~glsp-sprotty';
+import { configureDanglingFeedbackEdge } from './dangling-edge-feedback';
+import { EdgeCreationTool } from './edge-creation-tool';
+
+const edgeCreationToolModule = new ContainerModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    bindAsService(context, TYPES.ITool, EdgeCreationTool);
+    configureActionHandler(context, TriggerEdgeCreationAction.KIND, EdgeCreationTool);
+    configureDanglingFeedbackEdge(context);
+});
+
+export default edgeCreationToolModule;

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

@@ -0,0 +1,89 @@
+/********************************************************************************
+ * Copyright (c) 2019-2023 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
+ * 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 {
+    Action,
+    AnchorComputerRegistry,
+    Bounds,
+    Disposable,
+    MouseListener,
+    MoveAction,
+    Point,
+    PolylineEdgeRouter,
+    SConnectableElement,
+    SModelElement,
+    findChildrenAtPosition,
+    findParentByFeature,
+    isBoundsAware,
+    isConnectable
+} from '~glsp-sprotty';
+import { IFeedbackActionDispatcher } from '../../../base/feedback/feedback-action-dispatcher';
+import { absoluteToParent, getAbsolutePosition, toAbsoluteBounds } from '../../../utils/viewpoint-util';
+import { FeedbackEdgeEnd, feedbackEdgeEndId } from './dangling-edge-feedback';
+
+export class FeedbackEdgeEndMovingMouseListener extends MouseListener implements Disposable {
+    constructor(protected anchorRegistry: AnchorComputerRegistry, protected feedbackDispatcher: IFeedbackActionDispatcher) {
+        super();
+    }
+
+    override mouseMove(target: SModelElement, event: MouseEvent): Action[] {
+        const root = target.root;
+        const edgeEnd = root.index.getById(feedbackEdgeEndId(root));
+        if (!(edgeEnd instanceof FeedbackEdgeEnd) || !edgeEnd.feedbackEdge) {
+            return [];
+        }
+
+        const edge = edgeEnd.feedbackEdge;
+        const position = getAbsolutePosition(edgeEnd, event);
+        const endAtMousePosition = findChildrenAtPosition(target.root, position)
+            .reverse()
+            .find(element => isConnectable(element) && element.canConnect(edge, 'target'));
+
+        if (endAtMousePosition instanceof SConnectableElement && edge.source && isBoundsAware(edge.source)) {
+            const anchor = this.computeAbsoluteAnchor(endAtMousePosition, Bounds.center(toAbsoluteBounds(edge.source)));
+            if (Point.euclideanDistance(anchor, edgeEnd.position) > 1) {
+                this.feedbackDispatcher.registerFeedback(this, [
+                    MoveAction.create([{ elementId: edgeEnd.id, toPosition: anchor }], { animate: false })
+                ]);
+            }
+        } else {
+            this.feedbackDispatcher.registerFeedback(this, [
+                MoveAction.create([{ elementId: edgeEnd.id, toPosition: position }], { animate: false })
+            ]);
+        }
+
+        return [];
+    }
+
+    protected computeAbsoluteAnchor(element: SConnectableElement, absoluteReferencePoint: Point, offset?: number): Point {
+        const referencePointInParent = absoluteToParent(element, absoluteReferencePoint);
+        const anchorComputer = this.anchorRegistry.get(PolylineEdgeRouter.KIND, element.anchorKind);
+        let anchor = anchorComputer.getAnchor(element, referencePointInParent, offset);
+        // The anchor is computed in the local coordinate system of the element.
+        // If the element is a nested child element we have to add the absolute position of its parent to the anchor.
+        if (element.parent !== element.root) {
+            const parent = findParentByFeature(element.parent, isBoundsAware);
+            if (parent) {
+                const absoluteParentPosition = toAbsoluteBounds(parent);
+                anchor = Point.add(absoluteParentPosition, anchor);
+            }
+        }
+        return anchor;
+    }
+
+    dispose(): void {
+        this.feedbackDispatcher.deregisterFeedback(this);
+    }
+}

package/src/features/tools/{edge-creation-tool.ts → edge-creation/edge-creation-tool.ts}

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2022 EclipseSource and others.
+ * Copyright (c) 2019-2023 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,67 +13,52 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, CreateEdgeOperation, TriggerEdgeCreationAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import {
+    Action,
     AnchorComputerRegistry,
+    CreateEdgeOperation,
     EnableDefaultToolsAction,
-    EnableToolsAction,
+    SEdge,
+    SModelElement,
+    TriggerEdgeCreationAction,
     findParentByFeature,
-    IActionHandler,
     isConnectable,
-    isCtrlOrCmd,
-    SEdge,
-    SModelElement
-} from 'sprotty';
-import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-import {
-    DrawFeedbackEdgeAction,
-    FeedbackEdgeEndMovingMouseListener,
-    RemoveFeedbackEdgeAction
-} from '../tool-feedback/creation-tool-feedback';
-import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
-import { BaseGLSPTool } from './base-glsp-tool';
+    isCtrlOrCmd
+} from '~glsp-sprotty';
+import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
+
+import { CursorCSS, cursorFeedbackAction } from '../../../base/feedback/css-feedback';
+import { BaseGLSPCreationTool } from '../base-glsp-creation-tool';
+import { DrawFeedbackEdgeAction, RemoveFeedbackEdgeAction } from './dangling-edge-feedback';
+import { FeedbackEdgeEndMovingMouseListener } from './edge-creation-tool-feedback';
 
 /**
  * Tool to create connections in a Diagram, by selecting a source and target node.
  */
 @injectable()
-export class EdgeCreationTool extends BaseGLSPTool implements IActionHandler {
+export class EdgeCreationTool extends BaseGLSPCreationTool<TriggerEdgeCreationAction> {
     static ID = 'tool_create_edge';
 
     @inject(AnchorComputerRegistry) protected anchorRegistry: AnchorComputerRegistry;
 
-    protected triggerAction: TriggerEdgeCreationAction;
-    protected creationToolMouseListener: EdgeCreationToolMouseListener;
-    protected feedbackEndMovingMouseListener: FeedbackEdgeEndMovingMouseListener;
+    protected isTriggerAction = TriggerEdgeCreationAction.is;
 
     get id(): string {
         return EdgeCreationTool.ID;
     }
 
-    enable(): void {
-        if (this.triggerAction === undefined) {
-            throw new TypeError(`Could not enable tool ${this.id}.The triggerAction cannot be undefined.`);
-        }
-        this.creationToolMouseListener = new EdgeCreationToolMouseListener(this.triggerAction, this);
-        this.mouseTool.register(this.creationToolMouseListener);
-        this.feedbackEndMovingMouseListener = new FeedbackEdgeEndMovingMouseListener(this.anchorRegistry);
-        this.mouseTool.register(this.feedbackEndMovingMouseListener);
-        this.dispatchFeedback([cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED)]);
-    }
-
-    disable(): void {
-        this.mouseTool.deregister(this.creationToolMouseListener);
-        this.mouseTool.deregister(this.feedbackEndMovingMouseListener);
-        this.deregisterFeedback([RemoveFeedbackEdgeAction.create(), cursorFeedbackAction()]);
-    }
-
-    handle(action: Action): Action | void {
-        if (TriggerEdgeCreationAction.is(action)) {
-            this.triggerAction = action;
-            return EnableToolsAction.create([this.id]);
-        }
+    doEnable(): void {
+        const mouseMovingFeedback = new FeedbackEdgeEndMovingMouseListener(this.anchorRegistry, this.feedbackDispatcher);
+        this.toDisposeOnDisable.push(
+            mouseMovingFeedback,
+            this.mouseTool.registerListener(new EdgeCreationToolMouseListener(this.triggerAction, this)),
+            this.mouseTool.registerListener(mouseMovingFeedback),
+            this.registerFeedback([cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED)], this, [
+                RemoveFeedbackEdgeAction.create(),
+                cursorFeedbackAction()
+            ])
+        );
     }
 }
 
@@ -96,7 +81,7 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
         this.target = undefined;
         this.currentTarget = undefined;
         this.allowedTarget = false;
-        this.tool.dispatchFeedback([RemoveFeedbackEdgeAction.create()]);
+        this.tool.registerFeedback([RemoveFeedbackEdgeAction.create()]);
     }
 
     override nonDraggingMouseUp(_element: SModelElement, event: MouseEvent): Action[] {
@@ -105,7 +90,7 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
             if (!this.isSourceSelected()) {
                 if (this.currentTarget && this.allowedTarget) {
                     this.source = this.currentTarget.id;
-                    this.tool.dispatchFeedback([
+                    this.tool.registerFeedback([
                         DrawFeedbackEdgeAction.create({ elementTypeId: this.triggerAction.elementTypeId, sourceId: this.source })
                     ]);
                 }
@@ -115,6 +100,11 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
                 }
             }
             if (this.source && this.target) {
+                if (!isCtrlOrCmd(event)) {
+                    result.push(EnableDefaultToolsAction.create());
+                } else {
+                    this.reinitialize();
+                }
                 result.push(
                     CreateEdgeOperation.create({
                         elementTypeId: this.triggerAction.elementTypeId,
@@ -123,11 +113,6 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
                         args: this.triggerAction.args
                     })
                 );
-                if (!isCtrlOrCmd(event)) {
-                    result.push(EnableDefaultToolsAction.create());
-                } else {
-                    this.reinitialize();
-                }
             }
         } else if (event.button === 2) {
             result.push(EnableDefaultToolsAction.create());

package/{lib/features/tool-feedback/view.d.ts → src/features/tools/edge-creation/view.tsx}

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2022 EclipseSource and others.
+ * Copyright (c) 2019-2023 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,21 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Point } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
 import { VNode } from 'snabbdom';
-import { IView, RenderingContext, SModelElement } from 'sprotty';
-import { SResizeHandle } from '../change-bounds/model';
+import { IView, Point, RenderingContext, SModelElement, svg } from '~glsp-sprotty';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const JSX = { createElement: svg };
+
 /**
  * This view is used for the invisible end of the feedback edge.
  * A feedback edge is shown as a visual feedback when creating edges.
  */
-export declare class FeedbackEdgeEndView implements IView {
-    render(model: Readonly<SModelElement>, context: RenderingContext): VNode;
+@injectable()
+export class FeedbackEdgeEndView implements IView {
+    render(model: Readonly<SModelElement>, context: RenderingContext): VNode {
+        const position: Point = (model as any).position ?? Point.ORIGIN;
+        return <g x={position.x} y={position.y} />;
+    }
 }
-export declare class SResizeHandleView implements IView {
-    render(handle: SResizeHandle, context: RenderingContext): VNode;
-    protected getPosition(handle: SResizeHandle): Point | undefined;
-    getRadius(): number;
-}
-//# sourceMappingURL=view.d.ts.map

package/src/features/tools/edge-edit/di.config.ts

@@ -0,0 +1,41 @@
+/********************************************************************************
+ * Copyright (c) 2019-2023 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
+ * 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 { ContainerModule } from 'inversify';
+import { TYPES, bindAsService, configureCommand } from '~glsp-sprotty';
+import { EdgeEditTool } from './edge-edit-tool';
+import {
+    DrawFeedbackEdgeSourceCommand,
+    HideEdgeReconnectHandlesFeedbackCommand,
+    ShowEdgeReconnectHandlesFeedbackCommand,
+    SwitchRoutingModeCommand
+} from './edge-edit-tool-feedback';
+import { configureDanglingFeedbackEdge } from '../edge-creation/dangling-edge-feedback';
+
+const edgeEditToolModule = new ContainerModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    bindAsService(context, TYPES.IDefaultTool, EdgeEditTool);
+
+    // reconnect edge tool feedback
+    configureCommand(context, ShowEdgeReconnectHandlesFeedbackCommand);
+    configureCommand(context, HideEdgeReconnectHandlesFeedbackCommand);
+    configureCommand(context, DrawFeedbackEdgeSourceCommand);
+    configureCommand(context, SwitchRoutingModeCommand);
+
+    // dangling edge feedback
+    configureDanglingFeedbackEdge(context);
+});
+
+export default edgeEditToolModule;