@eclipse-glsp/client 2.8.0-next.8 → 2.9.0-next.1

package/src/features/tools/marquee-selection/marquee-behavior.spec.ts

@@ -1,176 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2021-2024 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 { DOMHelper } from '@eclipse-glsp/sprotty';
-import { expect } from 'chai';
-import { IMarqueeBehavior, MarqueeUtil } from './marquee-behavior';
-
-describe('MarqueeUtil', () => {
-    function initUtil(marqueeBehavior?: IMarqueeBehavior): MarqueeUtil {
-        const util = new MarqueeUtil(marqueeBehavior, new DOMHelper());
-        util.updateStartPoint({ x: 0, y: 0 });
-        util.updateCurrentPoint({ x: 0, y: 0 });
-        return util;
-    }
-
-    describe('Node marquee', () => {
-        const node = { x: 20, y: 20, width: 200, height: 50 };
-
-        it('touch element', () => {
-            const util = initUtil();
-            expect(util.isNodeMarked(node)).is.equals(false);
-            util.updateCurrentPoint({ x: 30, y: 50 });
-            expect(util.isNodeMarked(node)).is.equals(true);
-            util.updateCurrentPoint({ x: 250, y: 85 });
-            expect(util.isNodeMarked(node)).is.equals(true);
-            util.updateStartPoint({ x: 30, y: 25 });
-            expect(util.isNodeMarked(node)).is.equals(true);
-        });
-
-        it('touch element (reverse)', () => {
-            const util = initUtil();
-            expect(util.isNodeMarked(node)).is.equals(false);
-            util.updateStartPoint({ x: 30, y: 50 });
-            expect(util.isNodeMarked(node)).is.equals(true);
-            util.updateStartPoint({ x: 250, y: 85 });
-            expect(util.isNodeMarked(node)).is.equals(true);
-            util.updateCurrentPoint({ x: 30, y: 25 });
-            expect(util.isNodeMarked(node)).is.equals(true);
-        });
-
-        it('mark entire element', () => {
-            const util = initUtil({ entireElement: true, entireEdge: false });
-            expect(util.isNodeMarked(node)).is.equals(false);
-            util.updateCurrentPoint({ x: 30, y: 50 });
-            expect(util.isNodeMarked(node)).is.equals(false);
-            util.updateCurrentPoint({ x: 250, y: 85 });
-            expect(util.isNodeMarked(node)).is.equals(true);
-            util.updateStartPoint({ x: 30, y: 85 });
-            expect(util.isNodeMarked(node)).is.equals(false);
-        });
-
-        it('mark entire element (reverse)', () => {
-            const util = initUtil({ entireElement: true, entireEdge: false });
-            expect(util.isNodeMarked(node)).is.equals(false);
-            util.updateStartPoint({ x: 30, y: 50 });
-            expect(util.isNodeMarked(node)).is.equals(false);
-            util.updateStartPoint({ x: 250, y: 85 });
-            expect(util.isNodeMarked(node)).is.equals(true);
-            util.updateCurrentPoint({ x: 30, y: 85 });
-            expect(util.isNodeMarked(node)).is.equals(false);
-        });
-    });
-
-    describe('Edge marquee', () => {
-        const edge = [
-            { x: 20, y: 40 },
-            { x: 40, y: 20 }
-        ];
-        const edge2 = [
-            { x: 20, y: 20 },
-            { x: 40, y: 40 },
-            { x: 50, y: 10 }
-        ];
-
-        it('touch edge', () => {
-            const util = initUtil();
-            expect(util.isEdgeMarked(edge)).is.equals(false);
-            expect(util.isEdgeMarked(edge2)).is.equals(false);
-            util.updateCurrentPoint({ x: 20, y: 20 });
-            expect(util.isEdgeMarked(edge)).is.equals(false);
-            expect(util.isEdgeMarked(edge2)).is.equals(true);
-            util.updateCurrentPoint({ x: 30, y: 30 });
-            expect(util.isEdgeMarked(edge)).is.equals(true);
-            expect(util.isEdgeMarked(edge2)).is.equals(true);
-            util.updateCurrentPoint({ x: 50, y: 50 });
-            expect(util.isEdgeMarked(edge)).is.equals(true);
-            expect(util.isEdgeMarked(edge2)).is.equals(true);
-            util.updateStartPoint({ x: 25, y: 25 });
-            expect(util.isEdgeMarked(edge)).is.equals(true);
-            expect(util.isEdgeMarked(edge2)).is.equals(true);
-        });
-
-        it('touch edge (reverse)', () => {
-            const util = initUtil();
-            expect(util.isEdgeMarked(edge)).is.equals(false);
-            expect(util.isEdgeMarked(edge2)).is.equals(false);
-            util.updateStartPoint({ x: 20, y: 20 });
-            expect(util.isEdgeMarked(edge)).is.equals(false);
-            expect(util.isEdgeMarked(edge2)).is.equals(true);
-            util.updateStartPoint({ x: 30, y: 30 });
-            expect(util.isEdgeMarked(edge)).is.equals(true);
-            expect(util.isEdgeMarked(edge2)).is.equals(true);
-            util.updateStartPoint({ x: 50, y: 50 });
-            expect(util.isEdgeMarked(edge)).is.equals(true);
-            expect(util.isEdgeMarked(edge2)).is.equals(true);
-            util.updateCurrentPoint({ x: 25, y: 25 });
-            expect(util.isEdgeMarked(edge)).is.equals(true);
-            expect(util.isEdgeMarked(edge2)).is.equals(true);
-        });
-
-        it('mark entire edge', () => {
-            const util = initUtil({ entireElement: false, entireEdge: true });
-            expect(util.isEdgeMarked(edge)).is.equals(false);
-            expect(util.isEdgeMarked(edge2)).is.equals(false);
-            util.updateCurrentPoint({ x: 20, y: 20 });
-            expect(util.isEdgeMarked(edge)).is.equals(false);
-            expect(util.isEdgeMarked(edge2)).is.equals(false);
-            util.updateCurrentPoint({ x: 30, y: 30 });
-            expect(util.isEdgeMarked(edge)).is.equals(false);
-            expect(util.isEdgeMarked(edge2)).is.equals(false);
-            util.updateCurrentPoint({ x: 45, y: 50 });
-            expect(util.isEdgeMarked(edge)).is.equals(true);
-            expect(util.isEdgeMarked(edge2)).is.equals(false);
-            util.updateCurrentPoint({ x: 55, y: 50 });
-            expect(util.isEdgeMarked(edge)).is.equals(true);
-            expect(util.isEdgeMarked(edge2)).is.equals(true);
-            util.updateStartPoint({ x: 25, y: 25 });
-            expect(util.isEdgeMarked(edge)).is.equals(false);
-            expect(util.isEdgeMarked(edge2)).is.equals(false);
-        });
-
-        it('mark entire edge (reverse)', () => {
-            const util = initUtil({ entireElement: false, entireEdge: true });
-            expect(util.isEdgeMarked(edge)).is.equals(false);
-            expect(util.isEdgeMarked(edge2)).is.equals(false);
-            util.updateStartPoint({ x: 20, y: 20 });
-            expect(util.isEdgeMarked(edge)).is.equals(false);
-            expect(util.isEdgeMarked(edge2)).is.equals(false);
-            util.updateStartPoint({ x: 30, y: 30 });
-            expect(util.isEdgeMarked(edge)).is.equals(false);
-            expect(util.isEdgeMarked(edge2)).is.equals(false);
-            util.updateStartPoint({ x: 45, y: 50 });
-            expect(util.isEdgeMarked(edge)).is.equals(true);
-            expect(util.isEdgeMarked(edge2)).is.equals(false);
-            util.updateStartPoint({ x: 55, y: 50 });
-            expect(util.isEdgeMarked(edge)).is.equals(true);
-            expect(util.isEdgeMarked(edge2)).is.equals(true);
-            util.updateCurrentPoint({ x: 25, y: 25 });
-            expect(util.isEdgeMarked(edge)).is.equals(false);
-            expect(util.isEdgeMarked(edge2)).is.equals(false);
-        });
-
-        it('edge path should be marked', () => {
-            const path = 'M 599.968775008469,272.3972942960205 L 677.0904664855072,232';
-            const util = initUtil({ entireElement: false, entireEdge: true });
-            expect(util.isEdgePathMarked(path)).is.equals(false);
-            util.updateCurrentPoint({ x: 600, y: 300 });
-            expect(util.isEdgePathMarked(path)).is.equals(false);
-            util.updateCurrentPoint({ x: 700, y: 300 });
-            expect(util.isEdgePathMarked(path)).is.equals(true);
-        });
-    });
-});

package/src/features/validation/marker-navigator.spec.ts

@@ -1,183 +0,0 @@
-/********************************************************************************
- * 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 { BoundsAware, GChildElement, GIssue, GModelElement, GModelRoot, GNode, GParentElement } from '@eclipse-glsp/sprotty';
-import { expect } from 'chai';
-import { Container } from 'inversify';
-import 'mocha';
-import 'reflect-metadata';
-import { defaultModule } from '../../base/default.module';
-import { GGraph } from '../../model';
-import { decorationModule } from '../decoration/decoration-module';
-import { GIssueMarker } from './issue-marker';
-import { MarkerNavigator } from './marker-navigator';
-import { markerNavigatorModule } from './validation-modules';
-
-describe('MarkerNavigator', () => {
-    const container = new Container();
-    container.load(defaultModule, decorationModule, markerNavigatorModule);
-    const markerNavigator = container.get<MarkerNavigator>(MarkerNavigator);
-    function createRoot(...nodeIds: string[]): GModelRoot {
-        const root = new GGraph();
-        root.features = new Set<symbol>(GGraph.DEFAULT_FEATURES);
-        root.id = 'root';
-        root.type = 'graph';
-        nodeIds.forEach(id => {
-            const node = new GNode();
-            node.id = id;
-            node.type = 'node';
-            node.features = new Set<symbol>(GNode.DEFAULT_FEATURES);
-            root.add(node);
-        });
-        return root;
-    }
-
-    const rootWithoutAnyMarkers = createRoot('1');
-
-    const rootWithMarkers = createRoot('bottom-right', 'top-right', 'top-left', 'bottom-left');
-
-    const elementTopLeft = rootWithMarkers.children[2] as BoundsAware & GChildElement;
-    elementTopLeft.bounds = { width: 10, height: 10, x: 100, y: 100 };
-    const elementTopRight = rootWithMarkers.children[1] as BoundsAware & GChildElement;
-    elementTopRight.bounds = { width: 10, height: 10, x: 200, y: 100 };
-    const elementBottomLeft = rootWithMarkers.children[3] as BoundsAware & GChildElement;
-    elementBottomLeft.bounds = { width: 10, height: 10, x: 100, y: 200 };
-    const elementBottomRight = rootWithMarkers.children[0] as BoundsAware & GChildElement;
-    elementBottomRight.bounds = { width: 10, height: 10, x: 200, y: 200 };
-
-    beforeEach('clear issue marker', () => {
-        [elementTopLeft, elementTopRight, elementBottomLeft, elementBottomRight].forEach(clearMarker);
-    });
-
-    it('next(undefined) without any markers returns undefined', () => {
-        expect(markerNavigator.next(rootWithoutAnyMarkers)).to.be.undefined;
-    });
-
-    it('previous(undefined) without any markers returns undefined', () => {
-        expect(markerNavigator.previous(rootWithoutAnyMarkers)).to.be.undefined;
-    });
-
-    it('next(undefined) with one marker returns the one marker', () => {
-        const marker = setIssues(elementTopLeft, [{ message: 'msg', severity: 'error' }]);
-        const next = markerNavigator.next(rootWithMarkers);
-        expect(next).to.eql(marker);
-    });
-
-    it('next(firstMarker) with only one marker returns again the first marker', () => {
-        const marker = setIssues(elementTopLeft, [{ message: 'msg', severity: 'error' }]);
-        const next = markerNavigator.next(rootWithMarkers, marker);
-        expect(next).to.eql(marker);
-        // and again and again
-        const nextNext = markerNavigator.next(rootWithMarkers, next);
-        expect(nextNext).to.eql(marker);
-    });
-
-    it('previous(firstMarker) with only one marker returns again the first marker', () => {
-        const marker = setIssues(elementTopLeft, [{ message: 'msg', severity: 'error' }]);
-        const previous = markerNavigator.previous(rootWithMarkers, marker);
-        expect(previous).to.eql(marker);
-        // and again and again
-        const previousPrevious = markerNavigator.previous(rootWithMarkers, previous);
-        expect(previousPrevious).to.eql(marker);
-    });
-
-    it('next(firstMarker) with two marker returns second marker then again first marker', () => {
-        const marker1 = setIssues(elementTopLeft, [{ message: 'msg', severity: 'error' }]);
-        const marker2 = setIssues(elementTopRight, [{ message: 'msg', severity: 'error' }]);
-        const next = markerNavigator.next(rootWithMarkers, marker1);
-        expect(next).to.eql(marker2);
-        // and again and again
-        const nextNext = markerNavigator.next(rootWithMarkers, next);
-        expect(nextNext).to.eql(marker1);
-    });
-
-    it('previous(firstMarker) with two marker returns second marker then again first marker', () => {
-        const marker1 = setIssues(elementTopLeft, [{ message: 'msg', severity: 'error' }]);
-        const marker2 = setIssues(elementTopRight, [{ message: 'msg', severity: 'error' }]);
-        const next = markerNavigator.previous(rootWithMarkers, marker1);
-        expect(next).to.eql(marker2);
-        // and again and again
-        const nextNext = markerNavigator.previous(rootWithMarkers, next);
-        expect(nextNext).to.eql(marker1);
-    });
-
-    it('returns markers in the order left-to-right, top-to-bottom with next()', () => {
-        const marker1 = setIssues(elementTopLeft, [{ message: 'msg', severity: 'error' }]);
-        const marker2 = setIssues(elementTopRight, [{ message: 'msg', severity: 'error' }]);
-        const marker3 = setIssues(elementBottomLeft, [{ message: 'msg', severity: 'error' }]);
-        const marker4 = setIssues(elementBottomRight, [{ message: 'msg', severity: 'error' }]);
-        const found1 = markerNavigator.next(rootWithMarkers);
-        const found2 = markerNavigator.next(rootWithMarkers, found1);
-        const found3 = markerNavigator.next(rootWithMarkers, found2);
-        const found4 = markerNavigator.next(rootWithMarkers, found3);
-        const found5 = markerNavigator.next(rootWithMarkers, found4);
-        expect(found1).to.eql(marker1);
-        expect(found2).to.eql(marker2);
-        expect(found3).to.eql(marker3);
-        expect(found4).to.eql(marker4);
-        expect(found5).to.eql(marker1);
-    });
-
-    it('returns markers in the order left-to-right, top-to-bottom with previous()', () => {
-        const marker1 = setIssues(elementTopLeft, [{ message: 'msg', severity: 'error' }]);
-        const marker2 = setIssues(elementTopRight, [{ message: 'msg', severity: 'error' }]);
-        const marker3 = setIssues(elementBottomLeft, [{ message: 'msg', severity: 'error' }]);
-        const marker4 = setIssues(elementBottomRight, [{ message: 'msg', severity: 'error' }]);
-        const found1 = markerNavigator.previous(rootWithMarkers);
-        const found2 = markerNavigator.previous(rootWithMarkers, found1);
-        const found3 = markerNavigator.previous(rootWithMarkers, found2);
-        const found4 = markerNavigator.previous(rootWithMarkers, found3);
-        const found5 = markerNavigator.previous(rootWithMarkers, found4);
-        expect(found1).to.eql(marker1);
-        expect(found2).to.eql(marker4);
-        expect(found3).to.eql(marker3);
-        expect(found4).to.eql(marker2);
-        expect(found5).to.eql(marker1);
-    });
-});
-
-function clearMarker(elem: GParentElement): void {
-    elem.children.filter(isMarker).forEach(marker => elem.remove(marker));
-}
-
-function setIssues(elem: GParentElement, issues: GIssue[]): GIssueMarker {
-    const marker = getOrCreateMarker(elem);
-    marker.issues = issues;
-    return marker;
-}
-
-function getOrCreateMarker(elem: GParentElement): GIssueMarker {
-    const marker = findMarker(elem);
-    if (marker instanceof GIssueMarker) {
-        return marker;
-    }
-    return createMarker(elem as GParentElement);
-}
-
-function findMarker(elem: GParentElement): GIssueMarker | undefined {
-    return elem.children.find(isMarker);
-}
-
-function isMarker(element: GModelElement): element is GIssueMarker {
-    return element instanceof GIssueMarker;
-}
-
-function createMarker(elem: GParentElement): GIssueMarker {
-    const newMarker = new GIssueMarker();
-    newMarker.type = 'marker';
-    newMarker.id = `${elem.id}_marker`;
-    elem.add(newMarker);
-    return newMarker;
-}

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

@@ -1,221 +0,0 @@
-/********************************************************************************
- * 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 {
-    AbstractEdgeRouter,
-    EdgeRouterRegistry,
-    GNode,
-    GRoutableElement,
-    GRoutingHandle,
-    LinearRouteOptions,
-    Point,
-    ResolvedHandleMove,
-    RoutedPoint
-} from '@eclipse-glsp/sprotty';
-import { expect } from 'chai';
-import { Container } from 'inversify';
-import { routingModule } from '../features/routing/routing-module';
-import { ALL_ROUTING_POINTS, ROUTE_KINDS, ROUTING_POINT_KINDS, calcRoute } from './gmodel-util';
-import { GEdge, GGraph } from '../model';
-
-class TestRouter extends AbstractEdgeRouter {
-    kind = 'test-router';
-
-    route(edge: GRoutableElement): 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: GRoutableElement): void {
-        // do nothing
-    }
-
-    protected getOptions(edge: GRoutableElement): LinearRouteOptions {
-        return {
-            minimalPointDistance: 0,
-            selfEdgeOffset: 0,
-            standardDistance: 0
-        };
-    }
-
-    protected getInnerHandlePosition(edge: GRoutableElement, route: RoutedPoint[], handle: GRoutingHandle): Point | undefined {
-        return undefined;
-    }
-
-    protected applyInnerHandleMoves(edge: GRoutableElement, moves: ResolvedHandleMove[]): void {
-        // do nothing
-    }
-}
-
-describe('SModel Util', () => {
-    describe('calcRoute', () => {
-        const graph = new GGraph();
-
-        const source = new GNode();
-        source.id = 'node0';
-        source.position = { x: 0, y: 0 };
-        source.size = { width: 0, height: 0 };
-        graph.add(source);
-
-        const target = new GNode();
-        target.id = 'node1';
-        target.position = { x: 100, y: 100 };
-        target.size = { width: 0, height: 0 };
-        graph.add(target);
-
-        const edge = new GEdge();
-        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 }
-            ]);
-        });
-    });
-});