@eclipse-glsp/client 1.1.0-next.6ec1da0.211 → 1.1.0-next.7be33cd.257

package/src/model-source/glsp-diagram-server.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,17 +13,22 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { injectable } from 'inversify';
 import {
     Action,
+    ActionHandlerRegistry,
     ActionMessage,
     ComputedBoundsAction,
+    DiagramServerProxy,
+    ExportSvgAction,
     GLSPClient,
+    ICommand,
     RequestModelAction,
     ServerMessageAction,
-    SetEditModeAction
-} from '@eclipse-glsp/protocol';
-import { injectable } from 'inversify';
-import { ActionHandlerRegistry, DiagramServerProxy, ExportSvgAction, ICommand, ServerStatusAction, SwitchEditModeCommand } from 'sprotty';
+    ServerStatusAction,
+    SetEditModeAction,
+    SwitchEditModeCommand
+} from '~glsp-sprotty';
 import { SourceUriAware } from '../base/source-uri-aware';
 
 const receivedFromServerProperty = '__receivedFromServer';

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,
+    routingModule
+} from '~glsp-sprotty';
+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,18 @@
  * 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,
+    SModelElement,
+    Viewport,
+    findParentByFeature,
+    isAlignable,
+    isViewport,
+    translateBounds
+} from '~glsp-sprotty';
 
 /**
  * Return the position corresponding to this mouse event (Browser coordinates)

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,12 +13,12 @@
  *
  * 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 { ContainerModule } from 'inversify';
 import {
+    BindingContext,
     CircularNode,
     CircularNodeView,
-    configureModelElement,
+    DefaultTypes,
     DiamondNode,
     DiamondNodeView,
     ExpandButtonView,
@@ -26,7 +26,6 @@ import {
     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) => {
     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);
 

package/src/views/compartments.tsx

@@ -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
@@ -15,7 +15,7 @@
  ********************************************************************************/
 import { injectable } from 'inversify';
 import { VNode } from 'snabbdom';
-import { BoundsAware, RenderingContext, SChildElement, SCompartment, ShapeView, svg } from 'sprotty/lib';
+import { BoundsAware, RenderingContext, SChildElement, SCompartment, ShapeView, svg } from '~glsp-sprotty';
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const JSX = { createElement: svg };

package/src/views/glsp-edge-view.tsx

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021-2022 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,10 +13,9 @@
  *
  * 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 { Classes, VNode } from 'snabbdom';
-import { PolylineEdgeView, RenderingContext, SEdge, svg } from 'sprotty';
+import { Point, PolylineEdgeView, RenderingContext, SEdge, svg } from '~glsp-sprotty';
 import { EdgePadding } from '../utils/argument-utils';
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -32,7 +31,7 @@ export class GEdgeView extends PolylineEdgeView {
         }
 
         return (
-            <g class-sprotty-edge={true} class-mouseover={edge.hoverFeedback} {...this.addtionalClasses(edge, context)}>
+            <g class-sprotty-edge={true} class-mouseover={edge.hoverFeedback} {...this.additionalClasses(edge, context)}>
                 {this.renderLine(edge, route, context)}
                 {this.renderAdditionals(edge, route, context)}
                 {context.renderChildren(edge, { route })}
@@ -40,7 +39,7 @@ export class GEdgeView extends PolylineEdgeView {
         );
     }
 
-    protected addtionalClasses(_edge: Readonly<SEdge>, _context: RenderingContext): Classes {
+    protected additionalClasses(_edge: Readonly<SEdge>, _context: RenderingContext): Classes {
         return {};
     }
 

package/src/views/glsp-projection-view.tsx

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2017-2018 TypeFox and others.
+ * Copyright (c) 2017-2023 TypeFox 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,12 +14,10 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-/** @jsx html */
-import { Bounds } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
 import { h, VNode, VNodeStyle } from 'snabbdom';
 import {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    Bounds,
     html,
     IViewArgs,
     ProjectedViewportView,
@@ -29,7 +27,10 @@ import {
     setClass,
     ViewportRootElement,
     ViewProjection
-} from 'sprotty';
+} from '~glsp-sprotty';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const JSX = { createElement: html };
 
 /**
  * Special viewport root view that renders horizontal and vertical projection bars for quick navigation.

package/src/views/index.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 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
@@ -20,4 +20,3 @@ export * from './glsp-projection-view';
 export * from './issue-marker-view';
 export * from './rounded-corner';
 export * from './rounded-corner-view';
-

package/src/views/issue-marker-view.tsx

@@ -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
@@ -16,7 +16,7 @@
 /* eslint-disable max-len */
 import { injectable } from 'inversify';
 import { VNode } from 'snabbdom';
-import { IssueMarkerView, RenderingContext, setClass, SIssueMarker, SIssueSeverity, svg } from 'sprotty';
+import { IssueMarkerView, RenderingContext, setClass, SIssueMarker, SIssueSeverity, svg } from '~glsp-sprotty';
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const JSX = { createElement: svg };

package/src/views/rounded-corner-view.tsx

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021-2022 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
@@ -15,7 +15,7 @@
  ********************************************************************************/
 import { injectable } from 'inversify';
 import { Classes, VNode } from 'snabbdom';
-import { Hoverable, RectangularNodeView, RenderingContext, Selectable, SNode, SPort, SShapeElement, svg } from 'sprotty';
+import { Hoverable, RectangularNodeView, RenderingContext, SNode, SPort, SShapeElement, Selectable, svg } from '~glsp-sprotty';
 import { CornerRadius } from '../utils/argument-utils';
 import { RoundedCornerWrapper } from './rounded-corner';
 
@@ -70,7 +70,7 @@ export class RoundedCornerNodeView extends RectangularNodeView {
     }
 
     protected renderPath(wrapper: Readonly<RoundedCornerWrapper>, _context: RenderingContext, inset: number): string {
-        // Calcualte length of straight line segments
+        // Calculate length of straight line segments
         const topLineLength = Math.max(0, wrapper.size.width - wrapper.cornerRadius.topLeft - wrapper.cornerRadius.topRight);
         const rightLineLength = Math.max(0, wrapper.size.height - wrapper.cornerRadius.topRight - wrapper.cornerRadius.bottomRight);
         const bottomLineLength = Math.max(0, wrapper.size.width - wrapper.cornerRadius.bottomLeft - wrapper.cornerRadius.bottomRight);