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

package/lib/utils/gmodel-util.d.ts

@@ -0,0 +1,173 @@
+/********************************************************************************
+ * Copyright (c) 2019-2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { BoundsAware, EdgeRouterRegistry, ElementAndBounds, ElementAndRoutingPoints, FluentIterable, ModelIndexImpl, RoutedPoint, Selectable, GModelElement, GRoutableElement, GRoutingHandle, TypeGuard, GModelElementSchema } from '@eclipse-glsp/sprotty';
+/**
+ * Helper type to represent a filter predicate for {@link GModelElement}s. This is used to retrieve
+ * elements from the {@link ModelIndexImpl} that also conform to a second type `T`. Its mainly used for
+ * retrieving elements that also implement a certain model features (e.g. selectable)
+ */
+export type ModelFilterPredicate<T> = (modelElement: GModelElement) => modelElement is GModelElement & T;
+/**
+ * Retrieves all elements from the given {@link ModelIndexImpl} that match the given {@link ModelFilterPredicate}
+ * @param index The {@link ModelIndexImpl}.
+ * @param predicate The {@link ModelFilterPredicate} that should be used.
+ * @returns A {@link FluentIterable} of all indexed element that match the predicate
+ * (correctly casted to also include the additional type of the predicate).
+ */
+export declare function filter<T>(index: ModelIndexImpl, predicate: ModelFilterPredicate<T>): FluentIterable<GModelElement & T>;
+/**
+ * Retrieves all elements from the given {@link ModelIndexImpl} that match the given {@link ModelFilterPredicate} and executes
+ * the given runnable for each element of the result set.
+ * @param index The {@link ModelIndexImpl}.
+ * @param predicate The {@link ModelFilterPredicate} that should be used.
+ * @param runnable The runnable that should be executed for each matching element.
+ */
+export declare function forEachElement<T>(index: ModelIndexImpl, predicate: ModelFilterPredicate<T>, runnable: (modelElement: GModelElement & T) => void): void;
+/**
+ * Retrieves an array of all elements that match the given {@link ModelFilterPredicate} from the given {@link ModelIndexImpl}.
+ * @param index The {@link ModelIndexImpl}.
+ * @param predicate The {@link ModelFilterPredicate} that should be used.
+ * @returns An array of all indexed element that match the predicate
+ * (correctly casted to also include the additional type of the predicate).
+ */
+export declare function getMatchingElements<T>(index: ModelIndexImpl, predicate: ModelFilterPredicate<T>): (GModelElement & T)[];
+/**
+ * Invokes the given model index to retrieve the corresponding model elements for the given set of ids. Ids that
+ * have no corresponding element in the index will be ignored.
+ * @param index THe model index.
+ * @param elementsIDs The element ids.
+ * @param guard Optional typeguard. If defined only elements that match the guard will be returned.
+ * @returns An array of the model elements that correspond to the given ids and filter predicate.
+ */
+export declare function getElements<S extends GModelElement>(index: ModelIndexImpl, elementsIDs: string[], guard?: TypeGuard<S>): S[];
+/**
+ * Retrieves the amount of currently selected elements in the given {@link ModelIndexImpl}.
+ * @param index The {@link ModelIndexImpl}.
+ * @returns The amount of selected elements.
+ */
+export declare function getSelectedElementCount(index: ModelIndexImpl): number;
+/**
+ * Helper function to check wether an any element is selected in the given {@link ModelIndexImpl}.
+ * @param index The {@link ModelIndexImpl}.
+ * @returns `true` if at least one element is selected, `false` otherwise.
+ */
+export declare function hasSelectedElements(index: ModelIndexImpl): boolean;
+/**
+ * Helper function to check wether an element is defined. Can be used as {@link ModelFilterPredicate}.
+ * @param element The element that should be checked.
+ * @returns the type predicate for `T`
+ */
+export declare function isNotUndefined<T>(element: T | undefined): element is T;
+/**
+ * Adds a set of css classes to the given {@link GModelElement}.
+ * @param element The element to which the css classes should be added.
+ * @param cssClasses The set of css classes as string array.
+ */
+export declare function addCssClasses(element: GModelElement, cssClasses: string[]): void;
+/**
+ * Removes a set of css classes from the given {@link GModelElement}.
+ * @param element The element from which the css classes should be removed.
+ * @param cssClasses The set of css classes as string array.
+ */
+export declare function removeCssClasses(root: GModelElement, cssClasses: string[]): void;
+export declare function isNonRoutableSelectedMovableBoundsAware(element: GModelElement): element is SelectableBoundsAware;
+/**
+ * A typeguard function to check wether a given {@link GModelElement} implements the {@link BoundsAware} model feature,
+ * the {@link Selectable} model feature and is actually selected. In addition, the element must not be a {@link GRoutableElement}.
+ * @param element The element to check.
+ * @returns A type predicate indicating wether the element is of type {@link SelectableBoundsAware}.
+ */
+export declare function isNonRoutableSelectedBoundsAware(element: GModelElement): element is SelectableBoundsAware;
+/**
+ * A type guard function to check wether a given {@link GModelElement} is a {@link GRoutableElement}.
+ * @param element The element to check.
+ * @returns A type predicate indicating wether the element is a {@link GRoutableElement}.
+ */
+export declare function isRoutable<T extends GModelElement>(element: T): element is T & GRoutableElement;
+/**
+ * A typeguard function to check wether a given {@link GModelElement} is a {@link SRoutingHandle}.
+ * @param element The element to check.
+ * @returns A type predicate indicating wether the element is a {@link SRoutingHandle}
+ */
+export declare function isRoutingHandle(element: GModelElement | undefined): element is GRoutingHandle;
+/**
+ * A typeguard function to check wether a given {@link GModelElement} implements the {@link Selectable} model feature and
+ * the {@link BoundsAware} model feature.
+ * @returns A type predicate indicating wether the element is of type {@link SelectableBoundsAware}.
+ */
+export declare function isSelectableAndBoundsAware(element: GModelElement): element is SelectableBoundsAware;
+/**
+ * Union type to describe {@link GModelElement}s that implement the {@link Selectable} and {@link BoundsAware} feature.
+ */
+export type SelectableBoundsAware = GModelElement & BoundsAware & Selectable;
+/**
+ * Union type to describe {@link GModelElement}s that implement the {@link BoundsAware} feature.
+ */
+export type BoundsAwareModelElement = GModelElement & BoundsAware;
+/**
+ * Helper function to translate a given {@link GModelElement} into its corresponding {@link ElementAndBounds} representation.
+ * @param element The element to translate.
+ * @returns The corresponding {@link ElementAndBounds} for the given element.
+ */
+export declare function toElementAndBounds(element: BoundsAwareModelElement): ElementAndBounds;
+/**
+ * Helper function to translate a given {@link GRoutableElement} into its corresponding
+ * {@link ElementAndRoutingPoints} representation.
+ * @param element The element to translate.
+ * @returns The corresponding {@link ElementAndRoutingPoints} for the given element.
+ */
+export declare function toElementAndRoutingPoints(element: GRoutableElement): ElementAndRoutingPoints;
+/** All routing points. */
+export declare const ALL_ROUTING_POINTS: undefined;
+/** Pure routing point data kinds. */
+export declare const ROUTING_POINT_KINDS: string[];
+/** Pure route data kinds. */
+export declare const ROUTE_KINDS: string[];
+/**
+ * Helper function to calculate the {@link ElementAndRoutingPoints} for a given {@link GRoutableElement}.
+ * If client layout is activated, i.e., the edge routing registry is given and has a router for the element, then the routing
+ * points from the calculated route are used, otherwise we use the already specified routing points of the {@link GRoutableElement}.
+ * @param element The element to translate.
+ * @param routerRegistry the edge router registry.
+ * @returns The corresponding {@link ElementAndRoutingPoints} for the given element.
+ */
+export declare function calcElementAndRoutingPoints(element: GRoutableElement, routerRegistry?: EdgeRouterRegistry): ElementAndRoutingPoints;
+/**
+ * Helper function to calculate the route for a given {@link GRoutableElement}.
+ * If client layout is activated, i.e., the edge routing registry is given and has a router for the element, then the points
+ * from the calculated route are used, otherwise we use the already specified routing points of the {@link GRoutableElement}.
+ * @param element The element to translate.
+ * @param routerRegistry the edge router registry.
+ * @returns The corresponding route for the given element.
+ */
+export declare function calcElementAndRoute(element: GRoutableElement, routerRegistry?: EdgeRouterRegistry): ElementAndRoutingPoints;
+/**
+ * Helper function to calculate the route for a given {@link GRoutableElement} 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 declare function calcRoute(element: GRoutableElement, routerRegistry: EdgeRouterRegistry, pointKinds?: string[] | undefined, tolerance?: number): RoutedPoint[] | undefined;
+/**
+ * Convenience function to retrieve the model element type from a given input. The input
+ * can either be a {@link GModelElement}, {@link GModelElementSchema} or a string.
+ * @param input The type input.
+ * @returns The corresponding model type as string.
+ */
+export declare function getElementTypeId(input: GModelElement | GModelElementSchema | string): string;
+//# sourceMappingURL=gmodel-util.d.ts.map

package/lib/utils/gmodel-util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gmodel-util.d.ts","sourceRoot":"","sources":["../../src/utils/gmodel-util.ts"],"names":[],"mappings":"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"}

package/lib/utils/gmodel-util.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getElementTypeId = exports.calcRoute = exports.calcElementAndRoute = exports.calcElementAndRoutingPoints = exports.ROUTE_KINDS = exports.ROUTING_POINT_KINDS = exports.ALL_ROUTING_POINTS = exports.toElementAndRoutingPoints = exports.toElementAndBounds = exports.isSelectableAndBoundsAware = exports.isRoutingHandle = exports.isRoutable = exports.isNonRoutableSelectedBoundsAware = exports.isNonRoutableSelectedMovableBoundsAware = exports.removeCssClasses = exports.addCssClasses = exports.isNotUndefined = exports.hasSelectedElements = exports.getSelectedElementCount = exports.getElements = exports.getMatchingElements = exports.forEachElement = exports.filter = void 0;
+/********************************************************************************
+ * Copyright (c) 2019-2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+const sprotty_1 = require("@eclipse-glsp/sprotty");
+/**
+ * Retrieves all elements from the given {@link ModelIndexImpl} that match the given {@link ModelFilterPredicate}
+ * @param index The {@link ModelIndexImpl}.
+ * @param predicate The {@link ModelFilterPredicate} that should be used.
+ * @returns A {@link FluentIterable} of all indexed element that match the predicate
+ * (correctly casted to also include the additional type of the predicate).
+ */
+function filter(index, predicate) {
+    return index.all().filter(predicate);
+}
+exports.filter = filter;
+/**
+ * Retrieves all elements from the given {@link ModelIndexImpl} that match the given {@link ModelFilterPredicate} and executes
+ * the given runnable for each element of the result set.
+ * @param index The {@link ModelIndexImpl}.
+ * @param predicate The {@link ModelFilterPredicate} that should be used.
+ * @param runnable The runnable that should be executed for each matching element.
+ */
+function forEachElement(index, predicate, runnable) {
+    filter(index, predicate).forEach(runnable);
+}
+exports.forEachElement = forEachElement;
+/**
+ * Retrieves an array of all elements that match the given {@link ModelFilterPredicate} from the given {@link ModelIndexImpl}.
+ * @param index The {@link ModelIndexImpl}.
+ * @param predicate The {@link ModelFilterPredicate} that should be used.
+ * @returns An array of all indexed element that match the predicate
+ * (correctly casted to also include the additional type of the predicate).
+ */
+function getMatchingElements(index, predicate) {
+    return Array.from(filter(index, predicate));
+}
+exports.getMatchingElements = getMatchingElements;
+/**
+ * Invokes the given model index to retrieve the corresponding model elements for the given set of ids. Ids that
+ * have no corresponding element in the index will be ignored.
+ * @param index THe model index.
+ * @param elementsIDs The element ids.
+ * @param guard Optional typeguard. If defined only elements that match the guard will be returned.
+ * @returns An array of the model elements that correspond to the given ids and filter predicate.
+ */
+function getElements(index, elementsIDs, guard) {
+    // Internal filter function that filters out undefined model elements and runs an optional typeguard check.
+    const filterFn = (element) => {
+        if (element !== undefined) {
+            return guard ? guard(element) : true;
+        }
+        return false;
+    };
+    return elementsIDs.map(id => index.getById(id)).filter(filterFn);
+}
+exports.getElements = getElements;
+/**
+ * Retrieves the amount of currently selected elements in the given {@link ModelIndexImpl}.
+ * @param index The {@link ModelIndexImpl}.
+ * @returns The amount of selected elements.
+ */
+function getSelectedElementCount(index) {
+    let selected = 0;
+    forEachElement(index, sprotty_1.isSelected, element => selected++);
+    return selected;
+}
+exports.getSelectedElementCount = getSelectedElementCount;
+/**
+ * Helper function to check wether an any element is selected in the given {@link ModelIndexImpl}.
+ * @param index The {@link ModelIndexImpl}.
+ * @returns `true` if at least one element is selected, `false` otherwise.
+ */
+function hasSelectedElements(index) {
+    return getSelectedElementCount(index) > 0;
+}
+exports.hasSelectedElements = hasSelectedElements;
+/**
+ * Helper function to check wether an element is defined. Can be used as {@link ModelFilterPredicate}.
+ * @param element The element that should be checked.
+ * @returns the type predicate for `T`
+ */
+function isNotUndefined(element) {
+    return element !== undefined;
+}
+exports.isNotUndefined = isNotUndefined;
+/**
+ * Adds a set of css classes to the given {@link GModelElement}.
+ * @param element The element to which the css classes should be added.
+ * @param cssClasses The set of css classes as string array.
+ */
+function addCssClasses(element, cssClasses) {
+    var _a;
+    const elementCssClasses = (_a = element.cssClasses) !== null && _a !== void 0 ? _a : [];
+    (0, sprotty_1.distinctAdd)(elementCssClasses, ...cssClasses);
+    element.cssClasses = elementCssClasses;
+}
+exports.addCssClasses = addCssClasses;
+/**
+ * Removes a set of css classes from the given {@link GModelElement}.
+ * @param element The element from which the css classes should be removed.
+ * @param cssClasses The set of css classes as string array.
+ */
+function removeCssClasses(root, cssClasses) {
+    if (!root.cssClasses || root.cssClasses.length === 0) {
+        return;
+    }
+    (0, sprotty_1.remove)(root.cssClasses, ...cssClasses);
+}
+exports.removeCssClasses = removeCssClasses;
+function isNonRoutableSelectedMovableBoundsAware(element) {
+    return isNonRoutableSelectedBoundsAware(element) && (0, sprotty_1.isMoveable)(element);
+}
+exports.isNonRoutableSelectedMovableBoundsAware = isNonRoutableSelectedMovableBoundsAware;
+/**
+ * A typeguard function to check wether a given {@link GModelElement} implements the {@link BoundsAware} model feature,
+ * the {@link Selectable} model feature and is actually selected. In addition, the element must not be a {@link GRoutableElement}.
+ * @param element The element to check.
+ * @returns A type predicate indicating wether the element is of type {@link SelectableBoundsAware}.
+ */
+function isNonRoutableSelectedBoundsAware(element) {
+    return (0, sprotty_1.isBoundsAware)(element) && (0, sprotty_1.isSelected)(element) && !isRoutable(element);
+}
+exports.isNonRoutableSelectedBoundsAware = isNonRoutableSelectedBoundsAware;
+/**
+ * A type guard function to check wether a given {@link GModelElement} is a {@link GRoutableElement}.
+ * @param element The element to check.
+ * @returns A type predicate indicating wether the element is a {@link GRoutableElement}.
+ */
+function isRoutable(element) {
+    return element instanceof sprotty_1.GRoutableElement && element.routingPoints !== undefined;
+}
+exports.isRoutable = isRoutable;
+/**
+ * A typeguard function to check wether a given {@link GModelElement} is a {@link SRoutingHandle}.
+ * @param element The element to check.
+ * @returns A type predicate indicating wether the element is a {@link SRoutingHandle}
+ */
+function isRoutingHandle(element) {
+    return element !== undefined && element instanceof sprotty_1.GRoutingHandle;
+}
+exports.isRoutingHandle = isRoutingHandle;
+/**
+ * A typeguard function to check wether a given {@link GModelElement} implements the {@link Selectable} model feature and
+ * the {@link BoundsAware} model feature.
+ * @returns A type predicate indicating wether the element is of type {@link SelectableBoundsAware}.
+ */
+function isSelectableAndBoundsAware(element) {
+    return (0, sprotty_1.isSelectable)(element) && (0, sprotty_1.isBoundsAware)(element);
+}
+exports.isSelectableAndBoundsAware = isSelectableAndBoundsAware;
+/**
+ * Helper function to translate a given {@link GModelElement} into its corresponding {@link ElementAndBounds} representation.
+ * @param element The element to translate.
+ * @returns The corresponding {@link ElementAndBounds} for the given element.
+ */
+function toElementAndBounds(element) {
+    return {
+        elementId: element.id,
+        newPosition: {
+            x: element.bounds.x,
+            y: element.bounds.y
+        },
+        newSize: {
+            width: element.bounds.width,
+            height: element.bounds.height
+        }
+    };
+}
+exports.toElementAndBounds = toElementAndBounds;
+/**
+ * Helper function to translate a given {@link GRoutableElement} into its corresponding
+ * {@link ElementAndRoutingPoints} representation.
+ * @param element The element to translate.
+ * @returns The corresponding {@link ElementAndRoutingPoints} for the given element.
+ */
+function toElementAndRoutingPoints(element) {
+    return {
+        elementId: element.id,
+        newRoutingPoints: element.routingPoints
+    };
+}
+exports.toElementAndRoutingPoints = toElementAndRoutingPoints;
+/** All routing points. */
+exports.ALL_ROUTING_POINTS = undefined;
+/** Pure routing point data kinds. */
+exports.ROUTING_POINT_KINDS = ['linear', 'bezier-junction'];
+/** Pure route data kinds. */
+exports.ROUTE_KINDS = [...exports.ROUTING_POINT_KINDS, 'source', 'target'];
+/**
+ * Helper function to calculate the {@link ElementAndRoutingPoints} for a given {@link GRoutableElement}.
+ * If client layout is activated, i.e., the edge routing registry is given and has a router for the element, then the routing
+ * points from the calculated route are used, otherwise we use the already specified routing points of the {@link GRoutableElement}.
+ * @param element The element to translate.
+ * @param routerRegistry the edge router registry.
+ * @returns The corresponding {@link ElementAndRoutingPoints} for the given element.
+ */
+function calcElementAndRoutingPoints(element, routerRegistry) {
+    const newRoutingPoints = routerRegistry ? calcRoute(element, routerRegistry, exports.ROUTING_POINT_KINDS) : element.routingPoints;
+    return { elementId: element.id, newRoutingPoints };
+}
+exports.calcElementAndRoutingPoints = calcElementAndRoutingPoints;
+/**
+ * Helper function to calculate the route for a given {@link GRoutableElement}.
+ * If client layout is activated, i.e., the edge routing registry is given and has a router for the element, then the points
+ * from the calculated route are used, otherwise we use the already specified routing points of the {@link GRoutableElement}.
+ * @param element The element to translate.
+ * @param routerRegistry the edge router registry.
+ * @returns The corresponding route for the given element.
+ */
+function calcElementAndRoute(element, routerRegistry) {
+    var _a, _b;
+    let route = routerRegistry ? calcRoute(element, routerRegistry, exports.ROUTE_KINDS) : undefined;
+    if (!route) {
+        // add source and target to the routing points
+        route = [...element.routingPoints];
+        route.splice(0, 0, ((_a = element.source) === null || _a === void 0 ? void 0 : _a.position) || sprotty_1.Point.ORIGIN);
+        route.push(((_b = element.target) === null || _b === void 0 ? void 0 : _b.position) || sprotty_1.Point.ORIGIN);
+    }
+    return { elementId: element.id, newRoutingPoints: route };
+}
+exports.calcElementAndRoute = calcElementAndRoute;
+/**
+ * Helper function to calculate the route for a given {@link GRoutableElement} 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.
+ */
+function calcRoute(element, routerRegistry, pointKinds = exports.ALL_ROUTING_POINTS, tolerance = Number.EPSILON) {
+    const route = routerRegistry.get(element.routerKind).route(element);
+    const calculatedRoute = [];
+    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 (exports.ROUTING_POINT_KINDS.includes(point.kind) &&
+            calculatedRoute.find(calculatedPoint => sprotty_1.Point.maxDistance(point, calculatedPoint) < tolerance)) {
+            continue;
+        }
+        calculatedRoute.push(point);
+    }
+    return calculatedRoute;
+}
+exports.calcRoute = calcRoute;
+/**
+ * Convenience function to retrieve the model element type from a given input. The input
+ * can either be a {@link GModelElement}, {@link GModelElementSchema} or a string.
+ * @param input The type input.
+ * @returns The corresponding model type as string.
+ */
+function getElementTypeId(input) {
+    if (typeof input === 'string') {
+        return input;
+    }
+    else {
+        return input.type;
+    }
+}
+exports.getElementTypeId = getElementTypeId;
+//# sourceMappingURL=gmodel-util.js.map

package/lib/utils/gmodel-util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gmodel-util.js","sourceRoot":"","sources":["../../src/utils/gmodel-util.ts"],"names":[],"mappings":"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"}

package/lib/utils/gmodel-util.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gmodel-util.spec.d.ts.map

package/lib/utils/gmodel-util.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gmodel-util.spec.d.ts","sourceRoot":"","sources":["../../src/utils/gmodel-util.spec.ts"],"names":[],"mappings":""}

package/lib/utils/gmodel-util.spec.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+const sprotty_1 = require("@eclipse-glsp/sprotty");
+const chai_1 = require("chai");
+const inversify_1 = require("inversify");
+const routing_module_1 = require("../features/routing/routing-module");
+const gmodel_util_1 = require("./gmodel-util");
+const model_1 = require("../model");
+class TestRouter extends sprotty_1.AbstractEdgeRouter {
+    constructor() {
+        super(...arguments);
+        this.kind = 'test-router';
+    }
+    route(edge) {
+        const pureRoute = edge.routingPoints.map((point, idx) => (Object.assign(Object.assign({ kind: 'linear' }, point), { pointIndex: idx })));
+        return [
+            Object.assign({ kind: 'source' }, edge.source.position),
+            ...pureRoute,
+            { kind: 'bezier-control-after', x: 999, y: 999, pointIndex: pureRoute.length },
+            Object.assign({ kind: 'target' }, edge.target.position)
+        ];
+    }
+    createRoutingHandles(edge) {
+        // do nothing
+    }
+    getOptions(edge) {
+        return {
+            minimalPointDistance: 0,
+            selfEdgeOffset: 0,
+            standardDistance: 0
+        };
+    }
+    getInnerHandlePosition(edge, route, handle) {
+        return undefined;
+    }
+    applyInnerHandleMoves(edge, moves) {
+        // do nothing
+    }
+}
+describe('SModel Util', () => {
+    describe('calcRoute', () => {
+        const graph = new model_1.GGraph();
+        const source = new sprotty_1.GNode();
+        source.id = 'node0';
+        source.position = { x: 0, y: 0 };
+        source.size = { width: 0, height: 0 };
+        graph.add(source);
+        const target = new sprotty_1.GNode();
+        target.id = 'node1';
+        target.position = { x: 100, y: 100 };
+        target.size = { width: 0, height: 0 };
+        graph.add(target);
+        const edge = new model_1.GEdge();
+        edge.id = 'edge0';
+        edge.sourceId = 'node0';
+        edge.targetId = 'node1';
+        graph.add(edge);
+        edge.routerKind = 'test-router';
+        const container = new inversify_1.Container();
+        container.load(routing_module_1.routingModule);
+        const routerRegistry = container.get(sprotty_1.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 = (0, gmodel_util_1.calcRoute)(edge, routerRegistry);
+            (0, chai_1.expect)(route).to.deep.equal([
+                { 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 = (0, gmodel_util_1.calcRoute)(edge, routerRegistry);
+            (0, chai_1.expect)(route).to.deep.equal([
+                { 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 = (0, gmodel_util_1.calcRoute)(edge, routerRegistry);
+            (0, chai_1.expect)(route).to.deep.equal([
+                { 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 = (0, gmodel_util_1.calcRoute)(edge, routerRegistry, gmodel_util_1.ALL_ROUTING_POINTS, 10);
+            (0, chai_1.expect)(route).to.deep.equal([
+                { 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 = (0, gmodel_util_1.calcRoute)(edge, routerRegistry, gmodel_util_1.ROUTE_KINDS);
+            (0, chai_1.expect)(route).to.deep.equal([
+                { 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 = (0, gmodel_util_1.calcRoute)(edge, routerRegistry, gmodel_util_1.ROUTING_POINT_KINDS);
+            (0, chai_1.expect)(route).to.deep.equal([
+                { x: 20, y: 20, kind: 'linear', pointIndex: 0 },
+                { x: 30, y: 30, kind: 'linear', pointIndex: 1 },
+                { x: 40, y: 40, kind: 'linear', pointIndex: 2 }
+            ]);
+        });
+    });
+});
+//# sourceMappingURL=gmodel-util.spec.js.map