@eclipse-glsp/client 1.1.0-next.0d35bd0.205 → 1.1.0-next.0e4a7fc.263

package/src/features/tools/{change-bounds-tool.ts → change-bounds/change-bounds-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,57 +13,57 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
- import {
+import { inject, injectable, optional } from 'inversify';
+
+import {
     Action,
     Bounds,
+    BoundsAware,
     ChangeBoundsOperation,
     ChangeRoutingPointsOperation,
     CompoundOperation,
     Dimension,
+    Disposable,
+    EdgeRouterRegistry,
     ElementAndBounds,
     ElementAndRoutingPoints,
-    Operation,
-    Point,
-    SetBoundsAction
-} from '@eclipse-glsp/protocol';
-import { inject, injectable, optional } from 'inversify';
-import {
-    BoundsAware,
-    EdgeRouterRegistry,
-    findParentByFeature,
     ISnapper,
-    isSelected,
     MouseListener,
+    Operation,
+    Point,
     SChildElement,
     SConnectableElement,
     SModelElement,
     SModelRoot,
-    SParentElement
-} from 'sprotty';
-import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-import { TYPES } from '../../base/types';
-import { isValidMove, isValidSize } from '../../utils/layout-utils';
+    SParentElement,
+    SetBoundsAction,
+    TYPES,
+    findParentByFeature,
+    isSelected
+} from '~glsp-sprotty';
+import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
+import { CursorCSS, applyCssClasses, cursorFeedbackAction, deleteCssClasses } from '../../../base/feedback/css-feedback';
+import { ISelectionListener, SelectionService } from '../../../base/selection-service';
+import { PointPositionUpdater } from '../../../features/change-bounds/snap';
+import { isValidMove, isValidSize } from '../../../utils/layout-utils';
 import {
     calcElementAndRoutingPoints,
     forEachElement,
     isNonRoutableSelectedMovableBoundsAware,
     toElementAndBounds
-} from '../../utils/smodel-util';
-import { isBoundsAwareMoveable, isResizable, Resizable, ResizeHandleLocation, SResizeHandle } from '../change-bounds/model';
+} from '../../../utils/smodel-util';
+import { Resizable, ResizeHandleLocation, SResizeHandle, isBoundsAwareMoveable, isResizable } from '../../change-bounds/model';
 import {
-    createMovementRestrictionFeedback,
     IMovementRestrictor,
+    createMovementRestrictionFeedback,
     removeMovementRestrictionFeedback
-} from '../change-bounds/movement-restrictor';
-import { PointPositionUpdater } from '../change-bounds/snap';
-import { SelectionListener, SelectionService } from '../select/selection-service';
+} from '../../change-bounds/movement-restrictor';
+import { BaseGLSPTool } from '../base-glsp-tool';
 import {
     FeedbackMoveMouseListener,
     HideChangeBoundsToolResizeFeedbackAction,
     ShowChangeBoundsToolResizeFeedbackAction
-} from '../tool-feedback/change-bounds-tool-feedback';
-import { applyCssClasses, CursorCSS, cursorFeedbackAction, deleteCssClasses } from '../tool-feedback/css-feedback';
-import { BaseGLSPTool } from './base-glsp-tool';
+} from './change-bounds-tool-feedback';
 
 /**
  * The change bounds tool has the license to move multiple elements or resize a single element by implementing the ChangeBounds operation.
@@ -82,12 +82,10 @@ import { BaseGLSPTool } from './base-glsp-tool';
 export class ChangeBoundsTool extends BaseGLSPTool {
     static ID = 'glsp.change-bounds-tool';
 
-    @inject(TYPES.SelectionService) protected selectionService: SelectionService;
+    @inject(SelectionService) protected selectionService: SelectionService;
     @inject(EdgeRouterRegistry) @optional() readonly edgeRouterRegistry?: EdgeRouterRegistry;
     @inject(TYPES.ISnapper) @optional() readonly snapper?: ISnapper;
     @inject(TYPES.IMovementRestrictor) @optional() readonly movementRestrictor?: IMovementRestrictor;
-    protected feedbackMoveMouseListener: MouseListener;
-    protected changeBoundsListener: MouseListener & SelectionListener;
 
     get id(): string {
         return ChangeBoundsTool.ID;
@@ -95,33 +93,36 @@ export class ChangeBoundsTool extends BaseGLSPTool {
 
     enable(): void {
         // install feedback move mouse listener for client-side move updates
-        this.feedbackMoveMouseListener = this.createMoveMouseListener();
-        this.mouseTool.register(this.feedbackMoveMouseListener);
+        const feedbackMoveMouseListener = this.createMoveMouseListener();
+        if (Disposable.is(feedbackMoveMouseListener)) {
+            this.toDisposeOnDisable.push(feedbackMoveMouseListener);
+        }
 
         // install change bounds listener for client-side resize updates and server-side updates
-        this.changeBoundsListener = this.createChangeBoundsListener();
-        this.mouseTool.register(this.changeBoundsListener);
-        this.selectionService.register(this.changeBoundsListener);
+        const changeBoundsListener = this.createChangeBoundsListener();
+        if (Disposable.is(changeBoundsListener)) {
+            this.toDisposeOnDisable.push(changeBoundsListener);
+        }
+
+        this.toDisposeOnDisable.push(
+            this.mouseTool.registerListener(feedbackMoveMouseListener),
+            this.mouseTool.registerListener(changeBoundsListener),
+            Disposable.create(() => this.deregisterFeedback(feedbackMoveMouseListener)),
+            Disposable.create(() => this.deregisterFeedback(changeBoundsListener, [HideChangeBoundsToolResizeFeedbackAction.create()])),
+            this.selectionService.onSelectionChanged(change => changeBoundsListener.selectionChanged(change.root, change.selectedElements))
+        );
     }
 
     protected createMoveMouseListener(): MouseListener {
         return new FeedbackMoveMouseListener(this);
     }
 
-    protected createChangeBoundsListener(): MouseListener & SelectionListener {
+    protected createChangeBoundsListener(): MouseListener & ISelectionListener {
         return new ChangeBoundsListener(this);
     }
-
-    disable(): void {
-        this.mouseTool.deregister(this.changeBoundsListener);
-        this.selectionService.deregister(this.changeBoundsListener);
-        this.mouseTool.deregister(this.feedbackMoveMouseListener);
-        this.deregisterFeedback([], this.feedbackMoveMouseListener);
-        this.deregisterFeedback([HideChangeBoundsToolResizeFeedbackAction.create()], this.changeBoundsListener);
-    }
 }
 
-export class ChangeBoundsListener extends DragAwareMouseListener implements SelectionListener {
+export class ChangeBoundsListener extends DragAwareMouseListener implements ISelectionListener, Disposable {
     static readonly CSS_CLASS_ACTIVE = 'active';
 
     // members for calculating the correct position change
@@ -172,12 +173,12 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
                 const resizeActions = this.handleResizeOnClient(positionUpdate);
                 actions.push(...resizeActions);
             }
-            return actions;
+            this.tool.registerFeedback(actions, this);
         }
         return [];
     }
 
-    override draggingMouseUp(target: SModelElement, event: MouseEvent): Action[] {
+    override draggingMouseUp(target: SModelElement, _event: MouseEvent): Action[] {
         if (this.pointPositionUpdater.isLastDragPositionUndefined()) {
             this.resetPosition();
             return [];
@@ -192,6 +193,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
             actions.push(...this.handleMoveOnServer(target));
         }
         this.resetPosition();
+        this.tool.deregisterFeedback(this, [cursorFeedbackAction(CursorCSS.DEFAULT)]);
         return actions;
     }
 
@@ -243,16 +245,16 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
             //  If client routing is enabled -> delegate routingpoints of connected edges to server
             forEachElement(target.index, isNonRoutableSelectedMovableBoundsAware, element => {
                 if (element instanceof SConnectableElement) {
-                    element.incomingEdges.map(connectable => calcElementAndRoutingPoints(connectable, routerRegistry))
+                    element.incomingEdges
+                        .map(connectable => calcElementAndRoutingPoints(connectable, routerRegistry))
                         .forEach(ear => newRoutingPoints.push(ear));
-                    element.outgoingEdges.map(connectable => calcElementAndRoutingPoints(connectable, routerRegistry))
+                    element.outgoingEdges
+                        .map(connectable => calcElementAndRoutingPoints(connectable, routerRegistry))
                         .forEach(ear => newRoutingPoints.push(ear));
                 }
             });
         }
-        return newRoutingPoints.length > 0
-         ? [ChangeRoutingPointsOperation.create(newRoutingPoints)]
-         : [];
+        return newRoutingPoints.length > 0 ? [ChangeRoutingPointsOperation.create(newRoutingPoints)] : [];
     }
 
     protected handleResize(activeResizeHandle: SResizeHandle): Action[] {
@@ -291,7 +293,10 @@ 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([ShowChangeBoundsToolResizeFeedbackAction.create(this.activeResizeElement.id)], this);
+                this.tool.registerFeedback(
+                    [ShowChangeBoundsToolResizeFeedbackAction.create(this.activeResizeElement.id)],
+                    this.activeResizeElement
+                );
             }
             return true;
         }
@@ -315,12 +320,34 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
         }
     }
 
-    protected reset(): void {
+    dispose(): void {
+        this.reset(true);
+    }
+
+    protected reset(resetBounds = false): void {
+        this.resetFeedback(resetBounds);
+        this.resetPosition();
+    }
+
+    protected resetFeedback(resetBounds = false): void {
+        const resetFeedback: Action[] = [];
         if (this.activeResizeElement && isResizable(this.activeResizeElement)) {
-            this.tool.dispatchFeedback([HideChangeBoundsToolResizeFeedbackAction.create()], this);
+            if (this.initialBounds && this.activeResizeHandle && resetBounds) {
+                // we only reset the bounds if an active resize operation was cancelled due to the tool being disabled
+                resetFeedback.push(
+                    SetBoundsAction.create([
+                        {
+                            elementId: this.activeResizeElement.id,
+                            newPosition: this.initialBounds,
+                            newSize: this.initialBounds
+                        }
+                    ])
+                );
+            }
+            this.tool.deregisterFeedback(this.activeResizeElement, [HideChangeBoundsToolResizeFeedbackAction.create()]);
         }
-        this.tool.dispatchActions([cursorFeedbackAction(CursorCSS.DEFAULT)]);
-        this.resetPosition();
+        resetFeedback.push(cursorFeedbackAction(CursorCSS.DEFAULT));
+        this.tool.deregisterFeedback(this, resetFeedback);
     }
 
     protected resetPosition(): void {

package/src/features/{tool-feedback → tools/change-bounds}/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,27 +13,14 @@
  *
  * 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, setAttr, SModelElement, svg } from 'sprotty';
-import { isResizable, ResizeHandleLocation, SResizeHandle } from '../change-bounds/model';
+import { IView, Point, RenderingContext, setAttr, svg } from '~glsp-sprotty';
+import { ResizeHandleLocation, SResizeHandle, isResizable } from '../../change-bounds/model';
 
 // 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.
- */
-@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} />;
-    }
-}
-
 @injectable()
 export class SResizeHandleView implements IView {
     render(handle: SResizeHandle, context: RenderingContext): VNode {

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/{save/model.ts → tools/deletion/deletion-tool-module.ts}

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 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,14 +13,11 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { SModelElement, SModelExtension, SModelRoot } from 'sprotty';
+import { FeatureModule, TYPES, bindAsService } from '~glsp-sprotty';
+import { DelKeyDeleteTool, MouseDeleteTool } from './delete-tool';
 
-export const saveFeature = Symbol.for('saveFeature');
-
-export interface Saveable extends SModelExtension {
-    dirty: boolean;
-}
-
-export function isSaveable(element: SModelElement): element is SModelRoot & Saveable {
-    return element.hasFeature(saveFeature);
-}
+export const deletionToolModule = new FeatureModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    bindAsService(context, TYPES.IDefaultTool, DelKeyDeleteTool);
+    bindAsService(context, TYPES.ITool, MouseDeleteTool);
+});

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/edege-creation-module.ts

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