@eclipse-glsp/client 1.1.0-next.c40feb3.207 → 1.1.0-next.c5afbfa.273

package/src/lib/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
@@ -13,15 +13,56 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { SModelElementSchema } from '@eclipse-glsp/protocol';
-import { exportFeature, SGraph, SModelElement, viewportFeature } from 'sprotty';
+import {
+    Bounds,
+    exportFeature,
+    getRouteBounds,
+    isBounds,
+    Point,
+    SEdge,
+    SGraph,
+    SModelElement,
+    SModelElementSchema,
+    viewportFeature
+} from '~glsp-sprotty';
 import { Containable, containerFeature } from '../features/hints/model';
-import { Saveable, saveFeature } from '../features/save/model';
 
-export class GLSPGraph extends SGraph implements Saveable, Containable {
-    static override readonly DEFAULT_FEATURES = [viewportFeature, exportFeature, saveFeature, containerFeature];
+export class GLSPGraph extends SGraph implements Containable {
+    static override readonly DEFAULT_FEATURES = [viewportFeature, exportFeature, containerFeature];
     dirty = false;
     isContainableElement(input: string | SModelElement | SModelElementSchema): boolean {
         return true;
     }
 }
+
+export class GEdge extends SEdge {
+    override localToParent(point: Point | Bounds): Bounds {
+        const bounds = getRouteBounds(this.routingPoints);
+        const result = {
+            x: point.x + bounds.x,
+            y: point.y + bounds.y,
+            width: -1,
+            height: -1
+        };
+        if (isBounds(point)) {
+            result.width = point.width;
+            result.height = point.height;
+        }
+        return result;
+    }
+
+    override parentToLocal(point: Point | Bounds): Bounds {
+        const bounds = getRouteBounds(this.routingPoints);
+        const result = {
+            x: point.x - bounds.x,
+            y: point.y - bounds.y,
+            width: -1,
+            height: -1
+        };
+        if (isBounds(point)) {
+            result.width = point.width;
+            result.height = point.height;
+        }
+        return result;
+    }
+}

package/src/standalone-modules.ts

@@ -0,0 +1,87 @@
+/********************************************************************************
+ * Copyright (c) 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,
+    EndProgressAction,
+    FeatureModule,
+    IActionHandler,
+    ICommand,
+    ILogger,
+    ModuleConfiguration,
+    ServerMessageAction,
+    StartProgressAction,
+    TYPES,
+    UpdateProgressAction,
+    configureActionHandler
+} from '~glsp-sprotty';
+import { standaloneCopyPasteModule } from './features/copy-paste/copy-paste-modules';
+import { standaloneExportModule } from './features/export/export-modules';
+import { saveModule } from './features/save/save-module';
+import { standaloneSelectModule } from './features/select/select-module';
+import { undoRedoModule } from './features/undo-redo/undo-redo-module';
+import { standaloneMarkerNavigatorModule } from './features/validation/validation-modules';
+import { standaloneViewportModule } from './features/viewport/viewport-modules';
+
+export const standaloneFallbackModule = new FeatureModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    bind(FallbackActionHandler).toSelf().inSingletonScope();
+    configureActionHandler(context, ServerMessageAction.KIND, FallbackActionHandler);
+    configureActionHandler(context, StartProgressAction.KIND, FallbackActionHandler);
+    configureActionHandler(context, UpdateProgressAction.KIND, FallbackActionHandler);
+    configureActionHandler(context, EndProgressAction.KIND, FallbackActionHandler);
+});
+
+/**
+ * A fallback action handler for actions sent by features that are currently not supported by
+ * default in the standalone context. Unhandled actions will be simply forwarded to the {@link ILogger}.
+ */
+@injectable()
+export class FallbackActionHandler implements IActionHandler {
+    @inject(TYPES.ILogger)
+    protected logger: ILogger;
+
+    handle(action: Action): void | Action | ICommand {
+        this.logger.log(this, 'Unhandled action received:', action);
+    }
+}
+
+/**
+ * Configuration of all `standalone` modules.
+ *
+ * Standalone modules compose additional features/services that are intended for the standalone deployment of GLSP (i.e. plain webapp)
+ * When integrated into an application frame (e.g Theia/VS Code) this module is typically omitted and/or replaced
+ * with an application native module.
+ *
+ * Typically standalone modules built on top of (i.e require ) a default module and are therefore conditionally loaded if the
+ * required default modules have been loaded beforehand.
+ */
+
+export const STANDALONE_MODULES = [
+    standaloneViewportModule,
+    standaloneCopyPasteModule,
+    standaloneMarkerNavigatorModule,
+    standaloneSelectModule,
+    standaloneExportModule,
+    standaloneFallbackModule,
+    saveModule,
+    undoRedoModule
+] as const;
+
+export const STANDALONE_MODULE_CONFIG: ModuleConfiguration = {
+    add: [...STANDALONE_MODULES]
+};

package/src/utils/argument-utils.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021 EclipseSource and others.
+ * Copyright (c) 2021-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,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { SModelElement } from 'sprotty';
+import { SModelElement } from '~glsp-sprotty';
 import { hasArguments } from '../base/argumentable';
 
 export namespace GArgument {

package/src/utils/html-utils.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2020 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

package/src/utils/layout-utils.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,8 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Dimension, ElementAndBounds, Point, Writable } from '@eclipse-glsp/protocol';
-import { BoundsAware, ElementMove, ModelLayoutOptions, SModelElement } from 'sprotty';
+import { BoundsAware, Dimension, ElementAndBounds, ElementMove, ModelLayoutOptions, Point, SModelElement, Writable } from '~glsp-sprotty';
 import { IMovementRestrictor } from '../features/change-bounds/movement-restrictor';
 
 export function minWidth(element: SModelElement & BoundsAware): number {

package/src/utils/marker.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 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,8 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { MarkerKind } from '@eclipse-glsp/protocol';
-import { SIssueMarker, SParentElement } from 'sprotty';
+import { MarkerKind, SIssueMarker, SParentElement } from '~glsp-sprotty';
 
 export namespace MarkerPredicates {
     export const ALL = (): boolean => true;

package/src/utils/smodel-util.spec.ts

@@ -0,0 +1,222 @@
+/********************************************************************************
+ * Copyright (c) 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 { expect } from 'chai';
+import { Container } from 'inversify';
+import {
+    AbstractEdgeRouter,
+    EdgeRouterRegistry,
+    LinearRouteOptions,
+    Point,
+    ResolvedHandleMove,
+    RoutedPoint,
+    SEdge,
+    SGraph,
+    SNode,
+    SRoutableElement,
+    SRoutingHandle
+} from '~glsp-sprotty';
+import { routingModule } from '../features/routing/routing-module';
+import { ALL_ROUTING_POINTS, ROUTE_KINDS, ROUTING_POINT_KINDS, calcRoute } from './smodel-util';
+
+class TestRouter extends AbstractEdgeRouter {
+    kind = 'test-router';
+
+    route(edge: SRoutableElement): RoutedPoint[] {
+        const pureRoute = edge.routingPoints.map(
+            (point, idx) =>
+                <RoutedPoint>{
+                    kind: 'linear',
+                    ...point,
+                    pointIndex: idx
+                }
+        );
+        return [
+            { kind: 'source', ...edge.source!.position },
+            ...pureRoute,
+            { kind: 'bezier-control-after', x: 999, y: 999, pointIndex: pureRoute.length },
+            { kind: 'target', ...edge.target!.position }
+        ];
+    }
+
+    createRoutingHandles(edge: SRoutableElement): void {
+        // do nothing
+    }
+
+    protected getOptions(edge: SRoutableElement): LinearRouteOptions {
+        return {
+            minimalPointDistance: 0,
+            selfEdgeOffset: 0,
+            standardDistance: 0
+        };
+    }
+
+    protected getInnerHandlePosition(edge: SRoutableElement, route: RoutedPoint[], handle: SRoutingHandle): Point | undefined {
+        return undefined;
+    }
+
+    protected applyInnerHandleMoves(edge: SRoutableElement, moves: ResolvedHandleMove[]): void {
+        // do nothing
+    }
+}
+
+describe('SModel Util', () => {
+    describe('calcRoute', () => {
+        const graph = new SGraph();
+
+        const source = new SNode();
+        source.id = 'node0';
+        source.position = { x: 0, y: 0 };
+        source.size = { width: 0, height: 0 };
+        graph.add(source);
+
+        const target = new SNode();
+        target.id = 'node1';
+        target.position = { x: 100, y: 100 };
+        target.size = { width: 0, height: 0 };
+        graph.add(target);
+
+        const edge = new SEdge();
+        edge.id = 'edge0';
+        edge.sourceId = 'node0';
+        edge.targetId = 'node1';
+        graph.add(edge);
+
+        edge.routerKind = 'test-router';
+
+        const container = new Container();
+        container.load(routingModule);
+
+        const routerRegistry = container.get<EdgeRouterRegistry>(EdgeRouterRegistry);
+        routerRegistry.register('test-router', new TestRouter());
+
+        it('should return complete route', () => {
+            edge.source!.position = { x: 0, y: 0 };
+            edge.target!.position = { x: 100, y: 100 };
+            edge.routingPoints = [
+                { x: 20, y: 20 },
+                { x: 30, y: 30 },
+                { x: 40, y: 40 }
+            ];
+            const route = calcRoute(edge, routerRegistry);
+            expect(route).to.deep.equal(<RoutedPoint[]>[
+                { x: 0, y: 0, kind: 'source' },
+                { x: 20, y: 20, kind: 'linear', pointIndex: 0 },
+                { x: 30, y: 30, kind: 'linear', pointIndex: 1 },
+                { x: 40, y: 40, kind: 'linear', pointIndex: 2 },
+                { x: 999, y: 999, kind: 'bezier-control-after', pointIndex: 3 },
+                { x: 100, y: 100, kind: 'target' }
+            ]);
+        });
+
+        it('should filter duplicates with same coordinates', () => {
+            edge.source!.position = { x: 0, y: 0 };
+            edge.target!.position = { x: 100, y: 100 };
+            edge.routingPoints = [
+                { x: 20, y: 20 },
+                { x: 20, y: 20 },
+                { x: 30, y: 30 },
+                { x: 40, y: 40 }
+            ];
+
+            const route = calcRoute(edge, routerRegistry);
+            expect(route).to.deep.equal(<RoutedPoint[]>[
+                { x: 0, y: 0, kind: 'source' },
+                { x: 20, y: 20, kind: 'linear', pointIndex: 0 },
+                { x: 30, y: 30, kind: 'linear', pointIndex: 2 },
+                { x: 40, y: 40, kind: 'linear', pointIndex: 3 },
+                { x: 999, y: 999, kind: 'bezier-control-after', pointIndex: 4 },
+                { x: 100, y: 100, kind: 'target' }
+            ]);
+        });
+
+        it('should not filter source and target even if duplicate coordinates', () => {
+            edge.source!.position = { x: 0, y: 0 };
+            edge.target!.position = { x: 0, y: 0 };
+            edge.routingPoints = [
+                { x: 20, y: 20 },
+                { x: 30, y: 30 },
+                { x: 40, y: 40 }
+            ];
+
+            const route = calcRoute(edge, routerRegistry);
+            expect(route).to.deep.equal(<RoutedPoint[]>[
+                { x: 0, y: 0, kind: 'source' },
+                { x: 20, y: 20, kind: 'linear', pointIndex: 0 },
+                { x: 30, y: 30, kind: 'linear', pointIndex: 1 },
+                { x: 40, y: 40, kind: 'linear', pointIndex: 2 },
+                { x: 999, y: 999, kind: 'bezier-control-after', pointIndex: 3 },
+                { x: 0, y: 0, kind: 'target' }
+            ]);
+        });
+
+        it('should filter duplicates with same coordinates but allow tolerance', () => {
+            edge.source!.position = { x: 0, y: 0 };
+            edge.target!.position = { x: 100, y: 100 };
+            edge.routingPoints = [
+                { x: 20, y: 20 },
+                { x: 25, y: 25 },
+                { x: 30, y: 30 },
+                { x: 40, y: 40 }
+            ];
+
+            const route = calcRoute(edge, routerRegistry, ALL_ROUTING_POINTS, 10);
+            expect(route).to.deep.equal(<RoutedPoint[]>[
+                { x: 0, y: 0, kind: 'source' },
+                { x: 20, y: 20, kind: 'linear', pointIndex: 0 },
+                { x: 30, y: 30, kind: 'linear', pointIndex: 2 },
+                { x: 40, y: 40, kind: 'linear', pointIndex: 3 },
+                { x: 999, y: 999, kind: 'bezier-control-after', pointIndex: 4 },
+                { x: 100, y: 100, kind: 'target' }
+            ]);
+        });
+
+        it('should allow filtering based on point type: ROUTE_KINDS', () => {
+            edge.source!.position = { x: 0, y: 0 };
+            edge.target!.position = { x: 100, y: 100 };
+            edge.routingPoints = [
+                { x: 20, y: 20 },
+                { x: 30, y: 30 },
+                { x: 40, y: 40 }
+            ];
+
+            const route = calcRoute(edge, routerRegistry, ROUTE_KINDS);
+            expect(route).to.deep.equal(<RoutedPoint[]>[
+                { x: 0, y: 0, kind: 'source' },
+                { x: 20, y: 20, kind: 'linear', pointIndex: 0 },
+                { x: 30, y: 30, kind: 'linear', pointIndex: 1 },
+                { x: 40, y: 40, kind: 'linear', pointIndex: 2 },
+                { x: 100, y: 100, kind: 'target' }
+            ]);
+        });
+
+        it('should allow filtering based on point type: ROUTING_POINT_KINDS', () => {
+            edge.source!.position = { x: 0, y: 0 };
+            edge.target!.position = { x: 100, y: 100 };
+            edge.routingPoints = [
+                { x: 20, y: 20 },
+                { x: 30, y: 30 },
+                { x: 40, y: 40 }
+            ];
+
+            const route = calcRoute(edge, routerRegistry, ROUTING_POINT_KINDS);
+            expect(route).to.deep.equal(<RoutedPoint[]>[
+                { x: 20, y: 20, kind: 'linear', pointIndex: 0 },
+                { x: 30, y: 30, kind: 'linear', pointIndex: 1 },
+                { x: 40, y: 40, kind: 'linear', pointIndex: 2 }
+            ]);
+        });
+    });
+});

package/src/utils/smodel-util.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,24 +13,28 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import {
-    distinctAdd, ElementAndBounds, ElementAndRoutingPoints, Point, remove, SModelElementSchema,
-    TypeGuard
-} from '@eclipse-glsp/protocol';
 import {
     BoundsAware,
+    distinctAdd,
     EdgeRouterRegistry,
+    ElementAndBounds,
+    ElementAndRoutingPoints,
+    FluentIterable,
     isBoundsAware,
     isMoveable,
     isSelectable,
-    isSelected, ModelIndexImpl,
+    isSelected,
+    ModelIndexImpl,
+    Point,
+    remove,
     RoutedPoint,
     Selectable,
     SModelElement,
+    SModelElementSchema,
     SRoutableElement,
-    SRoutingHandle
-} from 'sprotty';
-import { FluentIterable } from 'sprotty/lib/utils/iterable';
+    SRoutingHandle,
+    TypeGuard
+} from '~glsp-sprotty';
 
 /**
  * Helper type to represent a filter predicate for {@link SModelElement}s. This is used to retrieve
@@ -228,6 +232,8 @@ export function toElementAndRoutingPoints(element: SRoutableElement): ElementAnd
         newRoutingPoints: element.routingPoints
     };
 }
+/** All routing points. */
+export const ALL_ROUTING_POINTS = undefined;
 
 /** Pure routing point data kinds. */
 export const ROUTING_POINT_KINDS = ['linear', 'bezier-junction'];
@@ -268,16 +274,36 @@ export function calcElementAndRoute(element: SRoutableElement, routerRegistry?:
 }
 
 /**
- * Helper function to calculate the route for a given {@link SRoutableElement}.
+ * Helper function to calculate the route for a given {@link SRoutableElement} by filtering duplicate points.
  * @param element The element to translate.
  * @param routerRegistry the edge router registry.
  * @param pointKinds the routing point kinds that should be considered.
+ * @param tolerance the tolerance applied to a point's coordinates to determine duplicates.
  * @returns The corresponding route for the given element.
  */
-export function calcRoute(element: SRoutableElement, routerRegistry: EdgeRouterRegistry, pointKinds?: string[]): RoutedPoint[] | undefined {
-    return routerRegistry?.get(element.routerKind).route(element)
-        .filter((point, idx, fullRoute) => idx === fullRoute.findIndex(otherPoint => otherPoint.x === point.x && otherPoint.y === point.y))
-        .filter(point => !pointKinds || pointKinds.includes(point.kind));
+export function calcRoute(
+    element: SRoutableElement,
+    routerRegistry: EdgeRouterRegistry,
+    pointKinds: string[] | undefined = ALL_ROUTING_POINTS,
+    tolerance = Number.EPSILON
+): RoutedPoint[] | undefined {
+    const route = routerRegistry.get(element.routerKind).route(element);
+    const calculatedRoute: RoutedPoint[] = [];
+    for (const point of route) {
+        // only include points we are actually interested in
+        if (pointKinds && !pointKinds.includes(point.kind)) {
+            continue;
+        }
+        // check if we are a duplicate based on coordinates in the already calculated route
+        if (
+            ROUTING_POINT_KINDS.includes(point.kind) &&
+            calculatedRoute.find(calculatedPoint => Point.maxDistance(point, calculatedPoint) < tolerance)
+        ) {
+            continue;
+        }
+        calculatedRoute.push(point);
+    }
+    return calculatedRoute;
 }
 
 /**
@@ -302,4 +328,3 @@ export function getElementTypeId(input: SModelElement | SModelElementSchema | st
         return (input as any)['type'] as string;
     }
 }
-

package/src/utils/viewpoint-util.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,8 +14,21 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { Bounds, Dimension, Point, Viewport } from '@eclipse-glsp/protocol';
-import { BoundsAware, findParentByFeature, isAlignable, isViewport, SModelElement, translateBounds } from 'sprotty';
+import {
+    Bounds,
+    BoundsAware,
+    Dimension,
+    Point,
+    SChildElement,
+    SModelElement,
+    Viewport,
+    findParentByFeature,
+    isAlignable,
+    isBoundsAware,
+    isViewport,
+    translateBounds
+} from '~glsp-sprotty';
+import { BoundsAwareModelElement } from './smodel-util';
 
 /**
  * Return the position corresponding to this mouse event (Browser coordinates)
@@ -88,3 +101,32 @@ export function toAbsolutePosition(target: SModelElement & BoundsAware): Point {
 export function toAbsoluteSize(target: SModelElement & BoundsAware): Dimension {
     return toAbsoluteBounds(target);
 }
+
+/**
+ * Convert a point, specified in absolute coordinates, to a point relative
+ * to the parent of the specified child element.
+ *
+ * @param element the child element
+ * @param absolutePoint a point in absolute coordinates
+ * @returns the equivalent point, relative to the element's parent coordinates
+ */
+export function absoluteToParent(element: BoundsAwareModelElement & SChildElement, absolutePoint: Point): Point {
+    if (isBoundsAware(element.parent)) {
+        return absoluteToLocal(element.parent, absolutePoint);
+    }
+    // If the parent is not bounds-aware, assume it's at 0; 0 and proceed
+    return absoluteToLocal(element, absolutePoint);
+}
+
+/**
+ * Convert a point, specified in absolute coordinates, to a point relative
+ * to the specified element.
+ *
+ * @param element the element
+ * @param absolutePoint a point in absolute coordinates
+ * @returns the equivalent point, relative to the element's coordinates
+ */
+export function absoluteToLocal(element: BoundsAwareModelElement, absolutePoint: Point): Point {
+    const absoluteElementBounds = toAbsoluteBounds(element);
+    return { x: absolutePoint.x - absoluteElementBounds.x, y: absolutePoint.y - absoluteElementBounds.y };
+}

package/src/views/base-view-module.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021 EclipseSource and others.
+ * Copyright (c) 2021-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,19 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { DefaultTypes } from '@eclipse-glsp/protocol';
-import { ContainerModule, interfaces } from 'inversify';
 import {
+    BindingContext,
     CircularNode,
     CircularNodeView,
-    configureModelElement,
+    DefaultTypes,
     DiamondNode,
     DiamondNodeView,
     ExpandButtonView,
+    FeatureModule,
     ForeignObjectElement,
     ForeignObjectView,
     HtmlRoot,
     HtmlRootView,
-    moveFeature,
     PreRenderedElement,
     PreRenderedView,
     RectangularNode,
@@ -35,9 +34,7 @@ import {
     SCompartment,
     SCompartmentView,
     SEdge,
-    selectFeature,
     SGraphView,
-    ShapedPreRenderedElement,
     SIssueMarker,
     SLabel,
     SLabelView,
@@ -45,25 +42,24 @@ import {
     SPort,
     SRoutingHandle,
     SRoutingHandleView,
+    ShapedPreRenderedElement,
     SvgViewportView,
-    ViewportRootElement
-} from 'sprotty';
+    ViewportRootElement,
+    configureModelElement,
+    moveFeature,
+    selectFeature
+} from '~glsp-sprotty';
 import { GLSPGraph } from '../lib/model';
 import { GEdgeView } from './glsp-edge-view';
 import { GIssueMarkerView } from './issue-marker-view';
 import { RoundedCornerNodeView } from './rounded-corner-view';
 
-interface ContainerContext {
-    bind: interfaces.Bind;
-    isBound: interfaces.IsBound;
-}
-
-const baseViewModule = new ContainerModule((bind, unbind, isBound, rebind) => {
+export const baseViewModule = new FeatureModule((bind, unbind, isBound, rebind) => {
     const context = { bind, unbind, isBound, rebind };
     configureDefaultModelElements(context);
 });
 
-export function configureDefaultModelElements(context: ContainerContext): void {
+export function configureDefaultModelElements(context: Pick<BindingContext, 'bind' | 'isBound'>): void {
     // HTML elements
     configureModelElement(context, DefaultTypes.HTML, HtmlRoot, HtmlRootView);
 
@@ -97,5 +93,3 @@ export function configureDefaultModelElements(context: ContainerContext): void {
     configureModelElement(context, DefaultTypes.NODE_DIAMOND, DiamondNode, DiamondNodeView);
     configureModelElement(context, DefaultTypes.NODE_RECTANGLE, RectangularNode, RectangularNodeView);
 }
-
-export default baseViewModule;