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

package/src/features/layout/layout-elements-action.spec.ts

@@ -1,426 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2019-2026 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 {
-    Action,
-    AnimationFrameSyncer,
-    Bounds,
-    ChangeBoundsOperation,
-    CommandExecutionContext,
-    ConsoleLogger,
-    ElementAndBounds,
-    ElementMove,
-    FeatureSet,
-    GChildElement,
-    GModelFactory,
-    GModelRoot,
-    GNode,
-    GNodeSchema,
-    IActionDispatcher,
-    MoveAction,
-    MoveCommand,
-    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 {
-    AlignElementsAction,
-    AlignElementsActionHandler,
-    Alignment,
-    ResizeDimension,
-    ResizeElementsAction,
-    ResizeElementsActionHandler
-} from './layout-elements-action';
-
-class MockActionDispatcher implements IActionDispatcher {
-    constructor(public dispatchedActions: Action[] = []) {}
-    requestUntil<Res extends ResponseAction>(
-        action: RequestAction<Res>,
-        timeoutMs?: number | undefined,
-        rejectOnTimeout?: boolean | undefined
-    ): Promise<Res | undefined> {
-        throw new Error('Method not implemented.');
-    }
-    dispatchOnceModelInitialized(...actions: Action[]): void {}
-    onceModelInitialized(): Promise<void> {
-        return Promise.resolve();
-    }
-    dispatchAfterNextUpdate(...actions: Action[]): void {}
-    dispatch(action: Action): Promise<void> {
-        this.dispatchedActions.push(action);
-        return Promise.resolve();
-    }
-    dispatchAll(actions: Action[]): Promise<void> {
-        actions.forEach(action => this.dispatchedActions.push(action));
-        return Promise.resolve();
-    }
-    request<Res extends ResponseAction>(action: RequestAction<Res>): Promise<Res> {
-        throw new Error('Method not implemented.');
-    }
-}
-
-class MockSelectionService extends SelectionService {
-    constructor(public modelRoot: GModelRoot) {
-        super();
-    }
-    override getModelRoot(): Readonly<GModelRoot> {
-        return this.modelRoot;
-    }
-}
-
-// Generic Test setup
-const container = new Container();
-container.load(defaultModule);
-
-const actionDispatcher = new MockActionDispatcher();
-
-const node1 = {
-    id: 'node1',
-    type: 'node:circle',
-    selected: true
-};
-const node2 = {
-    id: 'node2',
-    type: 'node:circle',
-    selected: true
-};
-const node3 = {
-    id: 'node3',
-    type: 'node:circle',
-    selected: true
-};
-const model = createModel();
-
-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: GChildElement, feature: symbol): void {
-    (element.features as FeatureSet & Set<symbol>).add(feature);
-}
-
-const context: CommandExecutionContext = {
-    root: model,
-    modelFactory: sinon.createStubInstance(GModelFactory),
-    duration: 0,
-    modelChanged: undefined!,
-    logger: new ConsoleLogger(),
-    syncer: new AnimationFrameSyncer()
-};
-
-const defaultSize = { height: 10, width: 10 };
-
-describe('AlignElementsCommand', () => {
-    let handler: AlignElementsActionHandler;
-    const setModel = (newModel: GModelRoot): void => {
-        handler['selectionService'] = new MockSelectionService(newModel);
-    };
-
-    beforeEach(() => {
-        actionDispatcher.dispatchedActions = [];
-
-        handler = new AlignElementsActionHandler();
-        handler['actionDispatcher'] = actionDispatcher;
-    });
-    it('should align all elements left', () => {
-        const newModel = initModel([
-            { elementId: 'node1', newPosition: { x: 111, y: 111 }, newSize: defaultSize },
-            { elementId: 'node2', newPosition: { x: 222, y: 222 }, newSize: defaultSize },
-            { elementId: 'node3', newPosition: { x: 333, y: 333 }, newSize: defaultSize }
-        ]);
-        const action = AlignElementsAction.create({ elementIds: ['node1', 'node2', 'node3'], alignment: Alignment.Left });
-        setModel(newModel);
-        handler.handle(action);
-
-        assertAllBounds(
-            new Map([
-                ['node1', { x: 111, y: 111, width: defaultSize.width, height: defaultSize.height }],
-                ['node2', { x: 111, y: 222, width: defaultSize.width, height: defaultSize.height }],
-                ['node3', { x: 111, y: 333, width: defaultSize.width, height: defaultSize.height }]
-            ])
-        );
-    });
-
-    it('should align all elements right', () => {
-        const newModel = initModel([
-            { elementId: 'node1', newPosition: { x: 111, y: 111 }, newSize: defaultSize },
-            { elementId: 'node2', newPosition: { x: 222, y: 222 }, newSize: defaultSize },
-            { elementId: 'node3', newPosition: { x: 333, y: 333 }, newSize: defaultSize }
-        ]);
-        const action = AlignElementsAction.create({ elementIds: ['node1', 'node2', 'node3'], alignment: Alignment.Right });
-        setModel(newModel);
-        handler.handle(action);
-        assertAllBounds(
-            new Map([
-                ['node1', { x: 333, y: 111, width: defaultSize.width, height: defaultSize.height }],
-                ['node2', { x: 333, y: 222, width: defaultSize.width, height: defaultSize.height }],
-                ['node3', { x: 333, y: 333, width: defaultSize.width, height: defaultSize.height }]
-            ])
-        );
-    });
-
-    it('should align all elements center', () => {
-        actionDispatcher.dispatchedActions = [];
-        const newModel = initModel([
-            { elementId: 'node1', newPosition: { x: 111, y: 111 }, newSize: defaultSize },
-            { elementId: 'node2', newPosition: { x: 222, y: 222 }, newSize: defaultSize },
-            { elementId: 'node3', newPosition: { x: 333, y: 333 }, newSize: defaultSize }
-        ]);
-        const action = AlignElementsAction.create({ elementIds: ['node1', 'node2', 'node3'], alignment: Alignment.Center });
-        setModel(newModel);
-        handler.handle(action);
-
-        assertAllBounds(
-            new Map([
-                ['node1', { x: 222, y: 111, width: defaultSize.width, height: defaultSize.height }],
-                ['node2', { x: 222, y: 222, width: defaultSize.width, height: defaultSize.height }],
-                ['node3', { x: 222, y: 333, width: defaultSize.width, height: defaultSize.height }]
-            ])
-        );
-    });
-
-    it('should align all elements top', () => {
-        const newModel = initModel([
-            { elementId: 'node1', newPosition: { x: 111, y: 111 }, newSize: defaultSize },
-            { elementId: 'node2', newPosition: { x: 222, y: 222 }, newSize: defaultSize },
-            { elementId: 'node3', newPosition: { x: 333, y: 333 }, newSize: defaultSize }
-        ]);
-        const action = AlignElementsAction.create({ elementIds: ['node1', 'node2', 'node3'], alignment: Alignment.Top });
-        setModel(newModel);
-        handler.handle(action);
-
-        assertAllBounds(
-            new Map([
-                ['node1', { x: 111, y: 111, width: defaultSize.width, height: defaultSize.height }],
-                ['node2', { x: 222, y: 111, width: defaultSize.width, height: defaultSize.height }],
-                ['node3', { x: 333, y: 111, width: defaultSize.width, height: defaultSize.height }]
-            ])
-        );
-    });
-
-    it('should align all elements bottom', () => {
-        const newModel = initModel([
-            { elementId: 'node1', newPosition: { x: 111, y: 111 }, newSize: defaultSize },
-            { elementId: 'node2', newPosition: { x: 222, y: 222 }, newSize: defaultSize },
-            { elementId: 'node3', newPosition: { x: 333, y: 333 }, newSize: defaultSize }
-        ]);
-        const action = AlignElementsAction.create({ elementIds: ['node1', 'node2', 'node3'], alignment: Alignment.Bottom });
-        setModel(newModel);
-        handler.handle(action);
-
-        assertAllBounds(
-            new Map([
-                ['node1', { x: 111, y: 333, width: defaultSize.width, height: defaultSize.height }],
-                ['node2', { x: 222, y: 333, width: defaultSize.width, height: defaultSize.height }],
-                ['node3', { x: 333, y: 333, width: defaultSize.width, height: defaultSize.height }]
-            ])
-        );
-    });
-
-    it('should align all elements middle', () => {
-        const newModel = initModel([
-            { elementId: 'node1', newPosition: { x: 111, y: 111 }, newSize: defaultSize },
-            { elementId: 'node2', newPosition: { x: 222, y: 222 }, newSize: defaultSize },
-            { elementId: 'node3', newPosition: { x: 333, y: 333 }, newSize: defaultSize }
-        ]);
-        const action = AlignElementsAction.create({ elementIds: ['node1', 'node2', 'node3'], alignment: Alignment.Middle });
-        setModel(newModel);
-        handler.handle(action);
-
-        assertAllBounds(
-            new Map([
-                ['node1', { x: 111, y: 222, width: defaultSize.width, height: defaultSize.height }],
-                ['node2', { x: 222, y: 222, width: defaultSize.width, height: defaultSize.height }],
-                ['node3', { x: 333, y: 222, width: defaultSize.width, height: defaultSize.height }]
-            ])
-        );
-    });
-});
-
-describe('ResizeElementsCommand', () => {
-    let handler: ResizeElementsActionHandler;
-    const setModel = (newModel: GModelRoot): void => {
-        handler['selectionService'] = new MockSelectionService(newModel);
-    };
-
-    beforeEach(() => {
-        actionDispatcher.dispatchedActions = [];
-
-        handler = new ResizeElementsActionHandler();
-        handler['actionDispatcher'] = actionDispatcher;
-    });
-    it('should make same width as last', () => {
-        const newModel = initModel([
-            { elementId: 'node1', newPosition: { x: 100, y: 100 }, newSize: { height: 10, width: 10 } },
-            { elementId: 'node2', newPosition: { x: 100, y: 200 }, newSize: { height: 20, width: 20 } },
-            { elementId: 'node3', newPosition: { x: 100, y: 300 }, newSize: { height: 30, width: 30 } }
-        ]);
-        const action = ResizeElementsAction.create({
-            elementIds: ['node1', 'node2', 'node3'],
-            dimension: ResizeDimension.Width,
-            reduceFunction: 'last'
-        });
-        setModel(newModel);
-        handler.handle(action);
-
-        // resize is keeping the center, so the X moves by diff / 2
-        assertAllBoundsInChangeBounds(
-            new Map([
-                ['node1', { x: 90, y: 100, height: 10, width: 30 }],
-                ['node2', { x: 95, y: 200, height: 20, width: 30 }],
-                ['node3', { x: 100, y: 300, height: 30, width: 30 }]
-            ])
-        );
-    });
-
-    it('should make same height as last', () => {
-        const newModel = initModel([
-            { elementId: 'node1', newPosition: { x: 100, y: 100 }, newSize: { height: 10, width: 10 } },
-            { elementId: 'node2', newPosition: { x: 100, y: 200 }, newSize: { height: 20, width: 20 } },
-            { elementId: 'node3', newPosition: { x: 100, y: 300 }, newSize: { height: 30, width: 30 } }
-        ]);
-        const action = ResizeElementsAction.create({
-            elementIds: ['node1', 'node2', 'node3'],
-            dimension: ResizeDimension.Height,
-            reduceFunction: 'last'
-        });
-        setModel(newModel);
-        handler.handle(action);
-
-        // resize is keeping the center, so the Y moves by diff / 2
-        assertAllBoundsInChangeBounds(
-            new Map([
-                ['node1', { x: 100, y: 90, height: 30, width: 10 }],
-                ['node2', { x: 100, y: 195, height: 30, width: 20 }],
-                ['node3', { x: 100, y: 300, height: 30, width: 30 }]
-            ])
-        );
-    });
-
-    it('should make same width and height as last', () => {
-        const newModel = initModel([
-            { elementId: 'node1', newPosition: { x: 100, y: 100 }, newSize: { height: 10, width: 10 } },
-            { elementId: 'node2', newPosition: { x: 100, y: 200 }, newSize: { height: 20, width: 20 } },
-            { elementId: 'node3', newPosition: { x: 100, y: 300 }, newSize: { height: 30, width: 30 } }
-        ]);
-        const action = ResizeElementsAction.create({
-            elementIds: ['node1', 'node2', 'node3'],
-            dimension: ResizeDimension.Width_And_Height,
-            reduceFunction: 'last'
-        });
-        setModel(newModel);
-        handler.handle(action);
-
-        // resize is keeping the center, so the Y moves by diff / 2
-        assertAllBoundsInChangeBounds(
-            new Map([
-                ['node1', { x: 90, y: 90, height: 30, width: 30 }],
-                ['node2', { x: 95, y: 195, height: 30, width: 30 }],
-                ['node3', { x: 100, y: 300, height: 30, width: 30 }]
-            ])
-        );
-    });
-});
-
-function initModel(elementAndBounds: ElementAndBounds[]): GModelRoot {
-    const mySetBoundsAction = SetBoundsAction.create(elementAndBounds);
-    const setBoundsCommand = new SetBoundsCommand(mySetBoundsAction);
-    return setBoundsCommand.execute(context) as GModelRoot;
-}
-
-function assertAllBounds(allBounds: Map<string, Bounds>): void {
-    allBounds.forEach((bounds, nodeId) => assertBounds(nodeId, bounds));
-}
-
-function assertAllBoundsInChangeBounds(allBounds: Map<string, Bounds>): void {
-    allBounds.forEach((bounds, nodeId) => assertBoundsInChangeBoundsActions(nodeId, bounds));
-}
-
-function assertBounds(nodeId: string, bounds: Bounds): void {
-    assertBoundsInMoves(nodeId, bounds);
-    assertBoundsInChangeBoundsActions(nodeId, bounds);
-}
-
-function assertBoundsInMoves(nodeId: string, bounds: Bounds): void {
-    const moves = dispatchedElementMoves();
-    const move = getMoveById(nodeId, moves);
-    expect(move.toPosition.x).to.be.equal(bounds.x);
-    expect(move.toPosition.y).to.be.equal(bounds.y);
-}
-
-function assertBoundsInChangeBoundsActions(nodeId: string, bounds: Bounds): void {
-    const allChangeBounds = dispatchedChangeBounds();
-    const changeBounds = getElementAndBoundsById(nodeId, allChangeBounds);
-    expect(changeBounds.newPosition!.x).to.be.equal(bounds.x);
-    expect(changeBounds.newPosition!.y).to.be.equal(bounds.y);
-    expect(changeBounds.newSize!.height).to.be.equal(bounds.height);
-    expect(changeBounds.newSize!.width).to.be.equal(bounds.width);
-}
-
-function getMoveById(id: string, moves: ElementMove[]): ElementMove {
-    return moves.filter(m => m.elementId === id)[0];
-}
-
-function getElementAndBoundsById(id: string, elementAndBounds: ElementAndBounds[]): ElementAndBounds {
-    return elementAndBounds.filter(m => m.elementId === id)[0];
-}
-
-function dispatchedElementMoves(): ElementMove[] {
-    return actionDispatcher.dispatchedActions
-        .filter(isMoveAction)
-        .map(a => a.moves)
-        .reduce((acc, val) => acc.concat(val), []);
-}
-
-function dispatchedChangeBounds(): ElementAndBounds[] {
-    return actionDispatcher.dispatchedActions
-        .filter(isChangeBounds)
-        .map(a => a.newBounds)
-        .reduce((acc, val) => acc.concat(val), []);
-}
-
-function isMoveAction(action: Action): action is MoveAction {
-    return action.kind === MoveCommand.KIND;
-}
-
-function isChangeBounds(action: Action): action is ChangeBoundsOperation {
-    return action.kind === ChangeBoundsOperation.KIND;
-}

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

@@ -1,56 +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 { 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', () => {
-        const navigationTarget: NavigationTarget = { uri: 'uri' };
-        NavigationTarget.setElementIds(navigationTarget, 'id1', 'id2');
-        expect(NavigationTarget.getElementIds(navigationTarget)).to.be.eql(['id1', 'id2']);
-    });
-
-    it('should be able to set and get textual positions', () => {
-        const navigationTarget: NavigationTarget = { uri: 'uri' };
-        NavigationTarget.setTextPosition(navigationTarget, { line: 1, character: 2 });
-        expect(NavigationTarget.getTextPosition(navigationTarget)).to.be.eql({ line: 1, character: 2 });
-    });
-
-    it('should be able to set and get custom query arguments', () => {
-        const navigationTarget: NavigationTarget = { uri: 'uri' };
-        NavigationTarget.addArgument(navigationTarget, 'name', 'test');
-        expect(navigationTarget.args!.name).to.be.eql('test');
-    });
-
-    it('should specify whether it has arguments', () => {
-        let navigationTarget: NavigationTarget = { uri: 'uri' };
-        expect(NavigationTarget.hasArguments(navigationTarget)).to.be.false;
-        NavigationTarget.addArgument(navigationTarget, 'name', 'test');
-        expect(NavigationTarget.hasArguments(navigationTarget)).to.be.true;
-
-        navigationTarget = { uri: 'uri' };
-        expect(NavigationTarget.hasArguments(navigationTarget)).to.be.false;
-        NavigationTarget.setElementIds(navigationTarget, 'id1', 'id2');
-        expect(NavigationTarget.hasArguments(navigationTarget)).to.be.true;
-
-        navigationTarget = { uri: 'uri' };
-        expect(NavigationTarget.hasArguments(navigationTarget)).to.be.false;
-        NavigationTarget.setTextPosition(navigationTarget, { line: 1, character: 2 });
-        expect(NavigationTarget.hasArguments(navigationTarget)).to.be.true;
-    });
-});

package/src/features/routing/sticky-manhattan-edge-router.spec.ts

@@ -1,212 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2026 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 { DefaultAnchors, EdgeRouterRegistry, GNode, GRoutableElement, Point, Side } from '@eclipse-glsp/sprotty';
-import { expect } from 'chai';
-import { Container } from 'inversify';
-import { GEdge, GGraph } from '../../model';
-import { routingModule } from './routing-module';
-import { GLSPStickyManhattanEdgeRouter, StickyManhattanRouterOptions } from './sticky-manhattan-edge-router';
-
-/** Exposes the protected helpers as public so the spec can exercise them directly. */
-class TestableStickyManhattanEdgeRouter extends GLSPStickyManhattanEdgeRouter {
-    public override manhattanify(points: Point[], edge: GRoutableElement): void {
-        super.manhattanify(points, edge);
-    }
-    public override getOptions(edge: GRoutableElement): StickyManhattanRouterOptions {
-        return super.getOptions(edge);
-    }
-    public override getBestConnectionAnchors(
-        sourceAnchors: DefaultAnchors,
-        targetAnchors: DefaultAnchors,
-        options: StickyManhattanRouterOptions
-    ): { source: Side; target: Side } {
-        return super.getBestConnectionAnchors(sourceAnchors, targetAnchors, options);
-    }
-}
-
-function newNode(id: string, x: number, y: number, width = 40, height = 30): GNode {
-    const node = new GNode();
-    node.id = id;
-    node.position = { x, y };
-    node.size = { width, height };
-    return node;
-}
-
-function setupEdge(opts: { sourcePos?: Point; targetPos?: Point; routingPoints?: Point[] }): {
-    graph: GGraph;
-    edge: GEdge;
-    router: GLSPStickyManhattanEdgeRouter;
-} {
-    const graph = new GGraph();
-    const source = newNode('source', opts.sourcePos?.x ?? 0, opts.sourcePos?.y ?? 0);
-    const target = newNode('target', opts.targetPos?.x ?? 200, opts.targetPos?.y ?? 100);
-    graph.add(source);
-    graph.add(target);
-
-    const edge = new GEdge();
-    edge.id = 'edge';
-    edge.sourceId = 'source';
-    edge.targetId = 'target';
-    edge.routerKind = GLSPStickyManhattanEdgeRouter.KIND;
-    if (opts.routingPoints) {
-        edge.routingPoints = opts.routingPoints.slice();
-    }
-    graph.add(edge);
-
-    const container = new Container();
-    container.load(routingModule);
-    const registry = container.get<EdgeRouterRegistry>(EdgeRouterRegistry);
-    const router = registry.get(GLSPStickyManhattanEdgeRouter.KIND) as GLSPStickyManhattanEdgeRouter;
-    return { graph, edge, router };
-}
-
-describe('GLSPStickyManhattanEdgeRouter', () => {
-    describe('route()', () => {
-        it('returns an empty route when the source node cannot be resolved', () => {
-            const graph = new GGraph();
-            const target = newNode('target', 200, 100);
-            graph.add(target);
-            const edge = new GEdge();
-            edge.id = 'edge';
-            edge.sourceId = 'missing';
-            edge.targetId = 'target';
-            edge.routerKind = GLSPStickyManhattanEdgeRouter.KIND;
-            graph.add(edge);
-
-            const container = new Container();
-            container.load(routingModule);
-            const router = container
-                .get<EdgeRouterRegistry>(EdgeRouterRegistry)
-                .get(GLSPStickyManhattanEdgeRouter.KIND) as GLSPStickyManhattanEdgeRouter;
-            expect(router.route(edge)).to.deep.equal([]);
-        });
-
-        it('produces a source-first, target-last sequence with intermediate linear points', () => {
-            const { edge, router } = setupEdge({});
-            const route = router.route(edge);
-            expect(route[0].kind).to.equal('source');
-            expect(route[route.length - 1].kind).to.equal('target');
-            expect(route.slice(1, -1).every(p => p.kind === 'linear')).to.equal(true);
-        });
-
-        it('computes a two-corner default route for horizontally separated nodes', () => {
-            const { edge, router } = setupEdge({ sourcePos: { x: 0, y: 0 }, targetPos: { x: 200, y: 100 } });
-            const route = router.route(edge);
-            // source RIGHT -> target LEFT with different Y: two corners at midX.
-            const interior = route.slice(1, -1);
-            expect(interior).to.have.lengthOf(2);
-            expect(interior[0].x).to.equal(interior[1].x);
-            expect(interior[0].y).to.not.equal(interior[1].y);
-        });
-    });
-
-    describe('sticky behavior', () => {
-        it('preserves interior bend points when the source node moves vertically', () => {
-            const { edge, router } = setupEdge({
-                sourcePos: { x: 0, y: 0 },
-                targetPos: { x: 300, y: 200 },
-                routingPoints: [
-                    { x: 150, y: 15 },
-                    { x: 150, y: 215 }
-                ]
-            });
-
-            // Prime the position snapshot.
-            router.route(edge);
-
-            // Move the source node down by 50px.
-            edge.source!.position = { x: 0, y: 50 };
-            const route = router.route(edge);
-            const interior = route.slice(1, -1);
-
-            // The shared x=150 spine must stay put — no recomputed midX.
-            expect(interior.every(p => p.x === 150)).to.equal(true);
-            // The target-side bend must not have moved.
-            expect(interior[interior.length - 1].y).to.equal(215);
-        });
-    });
-
-    describe('cleanupRoutingPoints()', () => {
-        it('removes leading routing points that fall inside the source bounds', () => {
-            const { edge, router } = setupEdge({
-                sourcePos: { x: 0, y: 0 },
-                targetPos: { x: 300, y: 100 },
-                routingPoints: [
-                    { x: 10, y: 10 }, // inside source bounds (40x30 at origin)
-                    { x: 150, y: 20 },
-                    { x: 150, y: 110 }
-                ]
-            });
-            const points = edge.routingPoints.slice();
-            router.cleanupRoutingPoints(edge, points, false, false);
-            expect(points).to.not.deep.include({ x: 10, y: 10 });
-            expect(points[0]).to.deep.equal({ x: 150, y: 20 });
-        });
-
-        it('collapses degenerate segments shorter than minimalPointDistance', () => {
-            const { edge, router } = setupEdge({ sourcePos: { x: 0, y: 0 }, targetPos: { x: 300, y: 100 } });
-            const points: Point[] = [
-                { x: 100, y: 20 },
-                { x: 101, y: 21 }, // manhattan distance 2 < default minimal of 3
-                { x: 250, y: 20 }
-            ];
-            router.cleanupRoutingPoints(edge, points, false, false);
-            expect(points).to.have.lengthOf(1);
-            expect(points[0]).to.deep.equal({ x: 250, y: 20 });
-        });
-    });
-
-    describe('manhattanify()', () => {
-        it('inserts an intermediate corner so every segment is strictly orthogonal', () => {
-            const { edge, router } = setupEdge({});
-            const testable = router as TestableStickyManhattanEdgeRouter;
-            const points: Point[] = [
-                { x: 0, y: 0 },
-                { x: 50, y: 50 } // diagonal
-            ];
-            testable.manhattanify(points, edge);
-            expect(points).to.deep.equal([
-                { x: 0, y: 0 },
-                { x: 0, y: 50 },
-                { x: 50, y: 50 }
-            ]);
-        });
-
-        it('leaves strictly orthogonal routes untouched', () => {
-            const { edge, router } = setupEdge({});
-            const testable = router as TestableStickyManhattanEdgeRouter;
-            const points: Point[] = [
-                { x: 0, y: 0 },
-                { x: 50, y: 0 },
-                { x: 50, y: 40 }
-            ];
-            const before = points.map(p => ({ ...p }));
-            testable.manhattanify(points, edge);
-            expect(points).to.deep.equal(before);
-        });
-    });
-
-    describe('getBestConnectionAnchors()', () => {
-        it('picks RIGHT/LEFT when source is clearly to the left of target', () => {
-            const { edge } = setupEdge({ sourcePos: { x: 0, y: 0 }, targetPos: { x: 400, y: 0 } });
-            const router = new TestableStickyManhattanEdgeRouter();
-            const sourceAnchors = new DefaultAnchors(edge.source!, edge.parent, 'source');
-            const targetAnchors = new DefaultAnchors(edge.target!, edge.parent, 'target');
-            const result = router.getBestConnectionAnchors(sourceAnchors, targetAnchors, router.getOptions(edge));
-            expect(result).to.deep.equal({ source: Side.RIGHT, target: Side.LEFT });
-        });
-    });
-});