@eclipse-glsp/client 1.1.0-next.fe0b297.182 → 2.0.0

package/src/features/layout/layout-elements-action.spec.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
@@ -16,36 +16,36 @@
 /* eslint-disable deprecation/deprecation */
 import {
     Action,
+    AnimationFrameSyncer,
     Bounds,
     ChangeBoundsOperation,
-    ElementAndBounds,
-    RequestAction,
-    ResponseAction,
-    SetBoundsAction
-} from '@eclipse-glsp/protocol';
-import { expect } from 'chai';
-import { Container } from 'inversify';
-import 'mocha';
-import 'reflect-metadata';
-import {
-    AnimationFrameSyncer,
     CommandExecutionContext,
     ConsoleLogger,
-    defaultModule,
+    ElementAndBounds,
     ElementMove,
     FeatureSet,
+    GChildElement,
+    GModelFactory,
+    GModelRoot,
+    GNode,
+    GNodeSchema,
     IActionDispatcher,
     MoveAction,
     MoveCommand,
-    SChildElement,
-    SetBoundsCommand,
-    SGraphFactory,
-    SModelRoot
-} from 'sprotty';
-import { TYPES } from '../../base/types';
+    RequestAction,
+    ResponseAction,
+    SetBoundsAction,
+    SetBoundsCommand
+} from '@eclipse-glsp/sprotty';
+import { expect } from 'chai';
+import { Container } from 'inversify';
+import 'mocha';
+import 'reflect-metadata';
+import * as sinon from 'sinon';
+import { defaultModule } from '../../base/default.module';
+import { SelectionService } from '../../base/selection-service';
+import { GGraph } from '../../model';
 import { resizeFeature } from '../change-bounds/model';
-import { SelectionService } from '../select/selection-service';
-import { FeedbackActionDispatcher } from '../tool-feedback/feedback-action-dispatcher';
 import {
     AlignElementsAction,
     AlignElementsActionHandler,
@@ -71,10 +71,10 @@ class MockActionDispatcher implements IActionDispatcher {
 }
 
 class MockSelectionService extends SelectionService {
-    constructor(public modelRoot: SModelRoot) {
+    constructor(public modelRoot: GModelRoot) {
         super();
     }
-    override getModelRoot(): Readonly<SModelRoot> {
+    override getModelRoot(): Readonly<GModelRoot> {
         return this.modelRoot;
     }
 }
@@ -82,9 +82,6 @@ class MockSelectionService extends SelectionService {
 // Generic Test setup
 const container = new Container();
 container.load(defaultModule);
-container.bind(TYPES.IFeedbackActionDispatcher).to(FeedbackActionDispatcher).inSingletonScope();
-container.rebind(TYPES.IModelFactory).to(SGraphFactory).inSingletonScope();
-const graphFactory = container.get<SGraphFactory>(TYPES.IModelFactory);
 
 const actionDispatcher = new MockActionDispatcher();
 
@@ -105,23 +102,32 @@ const node3 = {
 };
 const model = createModel();
 
-function createModel(): SModelRoot {
-    const root = graphFactory.createRoot({
-        id: 'model1',
-        type: 'graph',
-        children: [node1, node2, node3]
-    });
+function createNode(schema: GNodeSchema): GNode {
+    const node = new GNode();
+    const features = new Set<symbol>(GNode.DEFAULT_FEATURES);
+    node.features = features;
+    Object.assign(node, schema);
+    return node;
+}
+
+function createModel(): GModelRoot {
+    const root = new GGraph();
+    root.features = new Set<symbol>(GGraph.DEFAULT_FEATURES);
+    root.add(createNode(node1));
+    root.add(createNode(node2));
+    root.add(createNode(node3));
+
     root.children.forEach(child => applyFeature(child, resizeFeature));
     return root;
 }
 
-function applyFeature(element: SChildElement, feature: symbol): void {
+function applyFeature(element: GChildElement, feature: symbol): void {
     (element.features as FeatureSet & Set<symbol>).add(feature);
 }
 
 const context: CommandExecutionContext = {
     root: model,
-    modelFactory: graphFactory,
+    modelFactory: sinon.createStubInstance(GModelFactory),
     duration: 0,
     modelChanged: undefined!,
     logger: new ConsoleLogger(),
@@ -132,7 +138,7 @@ const defaultSize = { height: 10, width: 10 };
 
 describe('AlignElementsCommand', () => {
     let handler: AlignElementsActionHandler;
-    const setModel = (newModel: SModelRoot): void => {
+    const setModel = (newModel: GModelRoot): void => {
         handler['selectionService'] = new MockSelectionService(newModel);
     };
 
@@ -259,7 +265,7 @@ describe('AlignElementsCommand', () => {
 
 describe('ResizeElementsCommand', () => {
     let handler: ResizeElementsActionHandler;
-    const setModel = (newModel: SModelRoot): void => {
+    const setModel = (newModel: GModelRoot): void => {
         handler['selectionService'] = new MockSelectionService(newModel);
     };
 
@@ -342,10 +348,10 @@ describe('ResizeElementsCommand', () => {
     });
 });
 
-function initModel(elementAndBounds: ElementAndBounds[]): SModelRoot {
+function initModel(elementAndBounds: ElementAndBounds[]): GModelRoot {
     const mySetBoundsAction = SetBoundsAction.create(elementAndBounds);
     const setBoundsCommand = new SetBoundsCommand(mySetBoundsAction);
-    return setBoundsCommand.execute(context) as SModelRoot;
+    return setBoundsCommand.execute(context) as GModelRoot;
 }
 
 function assertAllBounds(allBounds: Map<string, Bounds>): void {

package/src/features/layout/layout-elements-action.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,29 +13,33 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { inject, injectable, optional } from 'inversify';
 import {
     Action,
     ChangeBoundsOperation,
     ElementAndBounds,
+    ElementMove,
+    IActionDispatcher,
+    IActionHandler,
+    ICommand,
+    MoveAction,
+    GModelElement,
+    SetBoundsAction,
+    TYPES,
+    Writable,
     hasArrayProp,
     hasNumberProp,
-    hasStringProp,
-    SetBoundsAction,
-    Writable
-} from '@eclipse-glsp/protocol';
-import { inject, injectable, optional } from 'inversify';
-import { ElementMove, IActionDispatcher, IActionHandler, ICommand, MoveAction, SModelElement } from 'sprotty';
-import { TYPES } from '../../base/types';
+    hasStringProp
+} from '@eclipse-glsp/sprotty';
+import { SelectionService } from '../../base/selection-service';
 import { toValidElementAndBounds, toValidElementMove } from '../../utils/layout-utils';
-import { BoundsAwareModelElement, getElements } from '../../utils/smodel-util';
+import { BoundsAwareModelElement, getElements } from '../../utils/gmodel-util';
 import { isBoundsAwareMoveable, isResizable } from '../change-bounds/model';
 import { IMovementRestrictor } from '../change-bounds/movement-restrictor';
-import { SelectionService } from '../select/selection-service';
 
 /**
  * Used to specify the desired resize dimension for a {@link ResizeElementsCommand}.
  */
-// eslint-disable-next-line no-shadow
 export enum ResizeDimension {
     Width,
     Height,
@@ -157,7 +161,7 @@ export abstract class LayoutElementsActionHandler implements IActionHandler {
     @inject(TYPES.IActionDispatcher)
     protected actionDispatcher: IActionDispatcher;
 
-    @inject(TYPES.SelectionService)
+    @inject(SelectionService)
     protected selectionService: SelectionService;
 
     @inject(TYPES.IMovementRestrictor)
@@ -172,7 +176,7 @@ export abstract class LayoutElementsActionHandler implements IActionHandler {
         return getElements(index, selectedElements, this.isActionElement);
     }
 
-    protected abstract isActionElement(element: SModelElement): element is BoundsAwareModelElement;
+    protected abstract isActionElement(element: GModelElement): element is BoundsAwareModelElement;
 
     dispatchAction(action: Action): void {
         this.actionDispatcher.dispatch(action);
@@ -266,12 +270,11 @@ export class ResizeElementsActionHandler extends LayoutElementsActionHandler {
         change(element, bounds);
         return toValidElementAndBounds(element, bounds, this.movementRestrictor);
     }
-    protected isActionElement(element: SModelElement): element is BoundsAwareModelElement {
+    protected isActionElement(element: GModelElement): element is BoundsAwareModelElement {
         return isResizable(element);
     }
 }
 
-// eslint-disable-next-line no-shadow
 export enum Alignment {
     Left,
     Center,
@@ -480,7 +483,7 @@ export class AlignElementsActionHandler extends LayoutElementsActionHandler {
             }
         };
     }
-    protected isActionElement(element: SModelElement): element is BoundsAwareModelElement {
+    protected isActionElement(element: GModelElement): element is BoundsAwareModelElement {
         return isBoundsAwareMoveable(element);
     }
 }

package/src/features/layout/layout-module.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 { FeatureModule, configureActionHandler } from '@eclipse-glsp/sprotty';
+import {
+    AlignElementsAction,
+    AlignElementsActionHandler,
+    ResizeElementsAction,
+    ResizeElementsActionHandler
+} from './layout-elements-action';
+
+export const layoutModule = new FeatureModule((bind, _unbind, isBound) => {
+    const context = { bind, isBound };
+    configureActionHandler(context, ResizeElementsAction.KIND, ResizeElementsActionHandler);
+    configureActionHandler(context, AlignElementsAction.KIND, AlignElementsActionHandler);
+});

package/src/features/navigation/navigation-action-handler.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2022 EclipseSource and others.
+ * Copyright (c) 2020-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,28 +13,32 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { inject, injectable } from 'inversify';
 import {
     Action,
+    ActionHandlerRegistry,
     Args,
     CenterAction,
-    hasObjectProp,
-    hasStringProp,
+    IActionDispatcher,
+    IActionHandler,
+    ICommand,
+    ILogger,
+    MessageAction,
     NavigateToExternalTargetAction,
     NavigateToTargetAction,
     NavigationTarget,
     RequestNavigationTargetsAction,
     SelectAction,
     SelectAllAction,
-    ServerMessageAction,
-    ServerSeverity,
-    ServerStatusAction,
     SetNavigationTargetsAction,
-    SetResolvedNavigationTargetAction
-} from '@eclipse-glsp/protocol';
-import { inject, injectable } from 'inversify';
-import { ActionHandlerRegistry, IActionDispatcher, IActionHandler, ICommand, ILogger } from 'sprotty';
+    SetResolvedNavigationTargetAction,
+    SeverityLevel,
+    StatusAction,
+    TYPES,
+    hasObjectProp,
+    hasStringProp
+} from '@eclipse-glsp/sprotty';
 import { EditorContextServiceProvider } from '../../base/editor-context-service';
-import { TYPES } from '../../base/types';
 import { NavigationTargetResolver } from './navigation-target-resolver';
 
 /**
@@ -123,7 +127,7 @@ export namespace ProcessNavigationArgumentsAction {
  *   *(a)* the navigation target already specifies element IDs, in which case this action handler navigates
  *         to the specified elements directly, by the selecting them and centering them in the viewport.
  *   *(b)* the arguments of the navigation targets don't contain element IDs, but other arguments, the
- *         navigation target needs to be resolved into actual elment IDs by the `NavigationTargetResolver`.
+ *         navigation target needs to be resolved into actual element IDs by the `NavigationTargetResolver`.
  *         This can for instance be useful, if the navigation deals with queries or some other more complex
  *         logic that can't be dealt with on the client.
  *  *(c)* the target isn't resolved by the `NavigationTargetResolver`, e.g. because the `uri` doesn't match
@@ -260,11 +264,8 @@ export class NavigationActionHandler implements IActionHandler {
         this.notify('WARNING', message);
     }
 
-    private notify(severity: ServerSeverity, message: string): void {
+    private notify(severity: SeverityLevel, message: string): void {
         const timeout = this.notificationTimeout;
-        this.dispatcher.dispatchAll([
-            ServerStatusAction.create(message, { severity, timeout }),
-            ServerMessageAction.create(message, { severity, timeout })
-        ]);
+        this.dispatcher.dispatchAll([StatusAction.create(message, { severity, timeout }), MessageAction.create(message, { severity })]);
     }
 }

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

@@ -0,0 +1,27 @@
+/********************************************************************************
+ * Copyright (c) 2020-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, NavigateToExternalTargetAction, NavigateToTargetAction, configureActionHandler } from '@eclipse-glsp/sprotty';
+import { NavigateAction, NavigationActionHandler, ProcessNavigationArgumentsAction } from './navigation-action-handler';
+import { NavigationTargetResolver } from './navigation-target-resolver';
+
+export const navigationModule = new FeatureModule((bind, _unbind, isBound) => {
+    bind(NavigationTargetResolver).toSelf().inSingletonScope();
+    bind(NavigationActionHandler).toSelf().inSingletonScope();
+    configureActionHandler({ bind, isBound }, NavigateAction.KIND, NavigationActionHandler);
+    configureActionHandler({ bind, isBound }, NavigateToTargetAction.KIND, NavigationActionHandler);
+    configureActionHandler({ bind, isBound }, ProcessNavigationArgumentsAction.KIND, NavigationActionHandler);
+    configureActionHandler({ bind, isBound }, NavigateToExternalTargetAction.KIND, NavigationActionHandler);
+});

package/src/features/navigation/navigation-target-resolver.spec.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2022 EclipseSource and others.
+ * Copyright (c) 2020-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,11 +13,10 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-/* eslint-disable no-unused-expressions */
-import { NavigationTarget } from '@eclipse-glsp/protocol';
 import { expect } from 'chai';
 import 'mocha';
 import 'reflect-metadata';
+import { NavigationTarget } from '@eclipse-glsp/sprotty';
 
 describe('NavigationTarget', () => {
     it('should be able to set and get element IDs', () => {

package/src/features/navigation/navigation-target-resolver.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2022 EclipseSource and others.
+ * Copyright (c) 2020-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,11 +13,17 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { NavigationTarget, ResolveNavigationTargetAction, ResponseAction, SetResolvedNavigationTargetAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { IActionDispatcher, ILogger } from 'sprotty';
-import { EditorContextServiceProvider } from '../../base/editor-context-service';
-import { TYPES } from '../../base/types';
+import {
+    IActionDispatcher,
+    ILogger,
+    NavigationTarget,
+    ResolveNavigationTargetAction,
+    ResponseAction,
+    SetResolvedNavigationTargetAction,
+    TYPES
+} from '@eclipse-glsp/sprotty';
+import { IDiagramOptions } from '../../base/model/diagram-loader';
 
 /**
  * Resolves `NavigationTargets` to element ids.
@@ -27,14 +33,17 @@ import { TYPES } from '../../base/types';
  */
 @injectable()
 export class NavigationTargetResolver {
-    @inject(TYPES.IEditorContextServiceProvider) protected editorContextService: EditorContextServiceProvider;
-    @inject(TYPES.IActionDispatcher) protected dispatcher: IActionDispatcher;
-    @inject(TYPES.ILogger) protected readonly logger: ILogger;
+    @inject(TYPES.IActionDispatcher)
+    protected dispatcher: IActionDispatcher;
+
+    @inject(TYPES.ILogger)
+    protected logger: ILogger;
+
+    @inject(TYPES.IDiagramOptions)
+    protected diagramOptions: IDiagramOptions;
 
     async resolve(navigationTarget: NavigationTarget): Promise<SetResolvedNavigationTargetAction | undefined> {
-        const contextService = await this.editorContextService();
-        const sourceUri = await contextService.getSourceUri();
-        return this.resolveWithSourceUri(sourceUri, navigationTarget);
+        return this.resolveWithSourceUri(this.diagramOptions.sourceUri, navigationTarget);
     }
 
     async resolveWithSourceUri(

package/src/features/reconnect/model.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,50 +14,52 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import {
+    GModelElement,
+    GRoutableElement,
+    GRoutingHandle,
+    RoutingHandleKind,
     edgeInProgressID,
     edgeInProgressTargetHandleID,
-    RoutingHandleKind,
-    selectFeature,
-    SModelElement,
-    SModelExtension,
-    SRoutableElement,
-    SRoutingHandle
-} from 'sprotty';
+    selectFeature
+} from '@eclipse-glsp/sprotty';
 
 export const reconnectFeature = Symbol('reconnectFeature');
 
-export interface Reconnectable extends SModelExtension {}
+/**
+ * Feature extension interface for {@link reconnectFeature}.
+ */
+export interface Reconnectable {}
 
-export function isReconnectable(element: SModelElement): element is SRoutableElement & Reconnectable {
-    return element instanceof SRoutableElement && element.hasFeature(reconnectFeature);
+export function isReconnectable(element: GModelElement): element is GRoutableElement & Reconnectable {
+    return element instanceof GRoutableElement && element.hasFeature(reconnectFeature);
 }
 
 const ROUTING_HANDLE_SOURCE_INDEX = -2;
 
-export function isReconnectHandle(element: SModelElement | undefined): element is SReconnectHandle {
-    return element !== undefined && element instanceof SReconnectHandle;
+export function isReconnectHandle(element: GModelElement | undefined): element is GReconnectHandle {
+    return element !== undefined && element instanceof GReconnectHandle;
 }
 
-export function addReconnectHandles(element: SRoutableElement): void {
+export function addReconnectHandles(element: GRoutableElement): void {
     removeReconnectHandles(element);
     createReconnectHandle(element, 'source', ROUTING_HANDLE_SOURCE_INDEX);
     createReconnectHandle(element, 'target', element.routingPoints.length);
 }
 
-export function removeReconnectHandles(element: SRoutableElement): void {
-    element.removeAll(child => child instanceof SReconnectHandle);
+export function removeReconnectHandles(element: GRoutableElement): void {
+    element.removeAll(child => child instanceof GReconnectHandle);
 }
 
-export function isSourceRoutingHandle(edge: SRoutableElement, routingHandle: SReconnectHandle): boolean {
+export function isSourceRoutingHandle(edge: GRoutableElement, routingHandle: GReconnectHandle): boolean {
     return routingHandle.pointIndex === ROUTING_HANDLE_SOURCE_INDEX;
 }
 
-export function isTargetRoutingHandle(edge: SRoutableElement, routingHandle: SReconnectHandle): boolean {
+export function isTargetRoutingHandle(edge: GRoutableElement, routingHandle: GReconnectHandle): boolean {
     return routingHandle.pointIndex === edge.routingPoints.length;
 }
 
-export function createReconnectHandle(edge: SRoutableElement, kind: RoutingHandleKind, routingPointIndex: number): SReconnectHandle {
-    const handle = new SReconnectHandle();
+export function createReconnectHandle(edge: GRoutableElement, kind: RoutingHandleKind, routingPointIndex: number): GReconnectHandle {
+    const handle = new GReconnectHandle();
     handle.kind = kind;
     handle.pointIndex = routingPointIndex;
     handle.type = 'routing-point';
@@ -68,7 +70,7 @@ export function createReconnectHandle(edge: SRoutableElement, kind: RoutingHandl
     return handle;
 }
 
-export class SReconnectHandle extends SRoutingHandle {
+export class GReconnectHandle extends GRoutingHandle {
     override hasFeature(feature: symbol): boolean {
         return feature !== selectFeature && super.hasFeature(feature);
     }

package/src/features/routing/glsp-manhattan-edge-router.ts

@@ -0,0 +1,59 @@
+/********************************************************************************
+ * Copyright (c) 2022-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 { ManhattanEdgeRouter, ResolvedHandleMove, GRoutableElement, almostEquals } from '@eclipse-glsp/sprotty';
+
+export class GLSPManhattanEdgeRouter extends ManhattanEdgeRouter {
+    protected override applyInnerHandleMoves(edge: GRoutableElement, moves: ResolvedHandleMove[]): void {
+        const route = this.route(edge);
+        const routingPoints = edge.routingPoints;
+        const minimalPointDistance = this.getOptions(edge).minimalPointDistance;
+        moves.forEach(move => {
+            const handle = move.handle;
+            const index = handle.pointIndex;
+            const correctedX = this.correctX(routingPoints, index, move.toPosition.x, minimalPointDistance);
+            const correctedY = this.correctY(routingPoints, index, move.toPosition.y, minimalPointDistance);
+            switch (handle.kind) {
+                case 'manhattan-50%':
+                    if (index < 0) {
+                        if (routingPoints.length === 0) {
+                            routingPoints.push({ x: correctedX, y: correctedY });
+                            move.handle.pointIndex = 0;
+                        } else if (almostEquals(route[0].x, route[1].x)) {
+                            this.alignX(routingPoints, 0, correctedX);
+                        } else {
+                            this.alignY(routingPoints, 0, correctedY);
+                        }
+                    } else if (index < routingPoints.length - 1) {
+                        if (almostEquals(routingPoints[index].x, routingPoints[index + 1].x)) {
+                            this.alignX(routingPoints, index, correctedX);
+                            this.alignX(routingPoints, index + 1, correctedX);
+                        } else {
+                            this.alignY(routingPoints, index, correctedY);
+                            this.alignY(routingPoints, index + 1, correctedY);
+                        }
+                    } else {
+                        if (almostEquals(route[route.length - 2].x, route[route.length - 1].x)) {
+                            this.alignX(routingPoints, routingPoints.length - 1, correctedX);
+                        } else {
+                            this.alignY(routingPoints, routingPoints.length - 1, correctedY);
+                        }
+                    }
+                    break;
+            }
+        });
+    }
+}

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

@@ -0,0 +1,59 @@
+/********************************************************************************
+ * 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 {
+    AddRemoveBezierSegmentCommand,
+    AnchorComputerRegistry,
+    BezierDiamondAnchor,
+    BezierEdgeRouter,
+    BezierEllipseAnchor,
+    BezierRectangleAnchor,
+    DiamondAnchor,
+    EdgeRouterRegistry,
+    EllipseAnchor,
+    FeatureModule,
+    ManhattanDiamondAnchor,
+    ManhattanEllipticAnchor,
+    ManhattanRectangularAnchor,
+    PolylineEdgeRouter,
+    RectangleAnchor,
+    TYPES,
+    bindAsService,
+    configureCommand
+} from '@eclipse-glsp/sprotty';
+import { GLSPManhattanEdgeRouter } from './glsp-manhattan-edge-router';
+
+export const routingModule = new FeatureModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    bind(EdgeRouterRegistry).toSelf().inSingletonScope();
+    bind(AnchorComputerRegistry).toSelf().inSingletonScope();
+
+    bindAsService(context, TYPES.IEdgeRouter, GLSPManhattanEdgeRouter);
+    bindAsService(context, TYPES.IAnchorComputer, ManhattanEllipticAnchor);
+    bindAsService(context, TYPES.IAnchorComputer, ManhattanRectangularAnchor);
+    bindAsService(context, TYPES.IAnchorComputer, ManhattanDiamondAnchor);
+
+    bindAsService(context, TYPES.IEdgeRouter, PolylineEdgeRouter);
+    bindAsService(context, TYPES.IAnchorComputer, EllipseAnchor);
+    bindAsService(context, TYPES.IAnchorComputer, RectangleAnchor);
+    bindAsService(context, TYPES.IAnchorComputer, DiamondAnchor);
+
+    bindAsService(context, TYPES.IEdgeRouter, BezierEdgeRouter);
+    bindAsService(context, TYPES.IAnchorComputer, BezierEllipseAnchor);
+    bindAsService(context, TYPES.IAnchorComputer, BezierRectangleAnchor);
+    bindAsService(context, TYPES.IAnchorComputer, BezierDiamondAnchor);
+
+    configureCommand({ bind, isBound }, AddRemoveBezierSegmentCommand);
+});