@wemap/geo 11.0.0-alpha.0 → 11.0.0-alpha.10

package/src/router/GraphRouter.spec.ts

@@ -15,18 +15,18 @@ import GraphRouterOptions from './GraphRouterOptions.js';
 const { expect } = chai;
 chai.use(chaiAlmost(1e-3));
 
-const networkDidNotChange = <T>(
-    networkAfter: Network<T>,
-    nodesBefore: GraphNode<T>[],
-    edgesBefore: GraphEdge<T>[]
+const networkDidNotChange = <N, E>(
+    networkAfter: Network<N, E>,
+    nodesBefore: GraphNode<N, E>[],
+    edgesBefore: GraphEdge<E, N>[]
 ) => {
 
-    const isEdgeInArray = (edgeArray: GraphEdge<T>[], edge: GraphEdge<T>) => edgeArray.find(_edge =>
+    const isEdgeInArray = (edgeArray: GraphEdge<E, N>[], edge: GraphEdge<E, N>) => edgeArray.find(_edge =>
         edge.node1 === _edge.node1
         && edge.node2 === _edge.node2
         && edge.level === _edge.level
     );
-    const areEdgeArrayEquals = (edgeArray1: GraphEdge<T>[], edgeArray2: GraphEdge<T>[]) => {
+    const areEdgeArrayEquals = (edgeArray1: GraphEdge<E, N>[], edgeArray2: GraphEdge<E, N>[]) => {
         if (edgeArray1.length !== edgeArray2.length) {
             return false;
         }
@@ -54,11 +54,11 @@ const networkDidNotChange = <T>(
     expect(areEdgeArrayEquals(networkAfter.edges, edgesBefore)).true;
 };
 
-const getShortestPath = <T>(
-    _router: GraphRouter<T>,
-    _start: GraphNode<T> | Coordinates,
-    _end: GraphNode<T> | Coordinates,
-    _options?: GraphRouterOptions<T>
+const getShortestPath = <N, E>(
+    _router: GraphRouter<N, E>,
+    _start: GraphNode<N, E> | Coordinates,
+    _end: GraphNode<N, E> | Coordinates,
+    _options?: GraphRouterOptions<N, E>
 ) => {
     const { _network: network } = _router;
     const nodesBefore = network.nodes.slice(0);
@@ -74,7 +74,7 @@ const createModel = () => {
 
     const b = (name: string): BuiltFrom_t => ({ name });
 
-    const nodes = [
+    const nodes: GraphNode<BuiltFrom_t, BuiltFrom_t>[] = [
         new GraphNode(new Coordinates(43.6091194, 3.884099), b('p0')),
         new GraphNode(new Coordinates(43.6093629, 3.8842777), b('p1')),
         new GraphNode(new Coordinates(43.6092785, 3.8845052), b('p2')),
@@ -105,9 +105,9 @@ const createModel = () => {
 
 const getNodesNames = (_itinerary: GraphItinerary<BuiltFrom_t>) => _itinerary.nodes.map(node => node.builtFrom?.name || null);
 
-let itinerary: GraphItinerary<BuiltFrom_t>,
-    router: GraphRouter<BuiltFrom_t>,
-    options: GraphRouterOptions<BuiltFrom_t>;
+let itinerary: GraphItinerary<BuiltFrom_t, BuiltFrom_t>,
+    router: GraphRouter<BuiltFrom_t, BuiltFrom_t>,
+    options: GraphRouterOptions<BuiltFrom_t, BuiltFrom_t>;
 
 describe('GraphRouter', () => {
 
@@ -193,7 +193,7 @@ describe('GraphRouter - Itinerary without stairs', () => {
     it('no stairs found', () => {
 
         router = new GraphRouter(network);
-        options = new GraphRouterOptions();
+        options = new GraphRouterOptions<BuiltFrom_t, BuiltFrom_t>();
         options.acceptEdgeFn = edge => !edge.builtFrom?.stairs;
 
         itinerary = getShortestPath(router, start, end, options);

package/src/router/GraphRouter.ts

@@ -10,23 +10,23 @@ import NoRouteFoundError from './NoRouteFoundError.js';
 import GraphRouterOptions from './GraphRouterOptions.js';
 import GraphItinerary from './GraphItinerary.js';
 
-type Vertex<T> = GraphNode<T> & { uniqueRouterId: number };
+type Vertex<N, E> = GraphNode<N, E> & { uniqueRouterId: number };
 
-class GraphRouter<T> {
+class GraphRouter<N, E> {
 
-    _mapMatching: MapMatching<T>;
-    _network: Network<T>;
-    disabledEdges: Set<GraphEdge<T>> = new Set();
+    _mapMatching: MapMatching<N, E>;
+    _network: Network<N, E>;
+    disabledEdges: Set<GraphEdge<E, N>> = new Set();
 
-    constructor(network: Network<T>) {
+    constructor(network: Network<N, E>) {
         this._network = network;
         this._mapMatching = new MapMatching(network);
     }
 
     getShortestPath(
-        start: GraphNode<T> | Coordinates,
-        end: GraphNode<T> | Coordinates,
-        options = new GraphRouterOptions<T>()
+        start: GraphNode<N, E> | Coordinates,
+        end: GraphNode<N, E> | Coordinates,
+        options = new GraphRouterOptions<N, E>()
     ) {
 
         if (!(start instanceof GraphNode) && !(start instanceof Coordinates)) {
@@ -40,10 +40,10 @@ class GraphRouter<T> {
         const { acceptEdgeFn, weightEdgeFn, projectionMaxDistance } = options;
         this._mapMatching.maxDistance = projectionMaxDistance;
 
-        const createdNodes: GraphNode<T>[] = [];
+        const createdNodes: GraphNode<N, E>[] = [];
 
 
-        const retrieveOrCreateNearestNode = (point: GraphNode<T> | Coordinates) => {
+        const retrieveOrCreateNearestNode = (point: GraphNode<N, E> | Coordinates) => {
             if (point instanceof GraphNode) {
                 return point;
             }
@@ -77,7 +77,7 @@ class GraphRouter<T> {
 
         const removeCreatedNodes = () => {
             while (createdNodes.length) {
-                this.removeNodeFromPreviouslyCreatedEdge(createdNodes.pop() as GraphNode<T>);
+                this.removeNodeFromPreviouslyCreatedEdge(createdNodes.pop() as GraphNode<N, E>);
             }
         };
 
@@ -90,7 +90,7 @@ class GraphRouter<T> {
 
         let graphItinerary;
         if (startNode === endNode) {
-            graphItinerary = GraphItinerary.fromNetworkNodes<T>(
+            graphItinerary = GraphItinerary.fromNetworkNodes<N, E>(
                 startCoords, endCoords, [startNode], []
             );
         } else {
@@ -117,11 +117,11 @@ class GraphRouter<T> {
 
     }
 
-    createNodeInsideEdge(edge: GraphEdge<T>, point: Coordinates) {
+    createNodeInsideEdge(edge: GraphEdge<E, N>, point: Coordinates) {
         const a = edge.node1;
         const b = edge.node2;
 
-        const m = new GraphNode<T>(point, edge.builtFrom);
+        const m = new GraphNode<N, E>(point, null); // cannot use edge.builtFrom because of typing
         m.coords.level = edge.level;
 
         const u = edge.clone();
@@ -145,7 +145,7 @@ class GraphRouter<T> {
         return m;
     }
 
-    removeNodeFromPreviouslyCreatedEdge(_node: GraphNode<T>) {
+    removeNodeFromPreviouslyCreatedEdge(_node: GraphNode<N, E>) {
         const u = _node.edges[0];
         const v = _node.edges[1];
 
@@ -164,16 +164,16 @@ class GraphRouter<T> {
     }
 
     getShortestPathBetweenGraphNodes(
-        start: GraphNode<T>,
-        end: GraphNode<T>,
-        acceptEdgeFn: (edge: GraphEdge<T>) => boolean,
-        weightFn: (edge: GraphEdge<T>) => number
+        start: GraphNode<N, E>,
+        end: GraphNode<N, E>,
+        acceptEdgeFn: (edge: GraphEdge<E, N>) => boolean,
+        weightFn: (edge: GraphEdge<E, N>) => number
     ) {
 
         const distanceMap: { [key: number]: number } = {},
             checking: { [key: number]: null | number } = {},
             vertexList: { [key: number]: boolean } = {},
-            vertexNodes: { [key: number]: Vertex<T> } = {},
+            vertexNodes: { [key: number]: Vertex<N, E> } = {},
             parentVertices: { [key: number]: number } = {},
             path = [];
         let vertexId = 1;
@@ -183,8 +183,8 @@ class GraphRouter<T> {
         this._network.nodes.forEach(vertex => {
 
             // Generate Unique Router Id
-            (vertex as Vertex<T>).uniqueRouterId = vertexId;
-            vertexNodes[vertexId] = vertex as Vertex<T>;
+            (vertex as Vertex<N, E>).uniqueRouterId = vertexId;
+            vertexNodes[vertexId] = vertex as Vertex<N, E>;
             distanceMap[vertexId] = Infinity;
             checking[vertexId] = null;
             vertexList[vertexId] = true;
@@ -192,8 +192,8 @@ class GraphRouter<T> {
             vertexId++;
         });
 
-        const startVertex = Object.values(vertexNodes).find(vertex => start.equals(vertex)) as Vertex<T>;
-        const endVertex = Object.values(vertexNodes).find(vertex => end.equals(vertex)) as Vertex<T>;
+        const startVertex = Object.values(vertexNodes).find(vertex => start.equals(vertex)) as Vertex<N, E>;
+        const endVertex = Object.values(vertexNodes).find(vertex => end.equals(vertex)) as Vertex<N, E>;
 
         // The cost from the starting vertex to the starting vertex is 0
         distanceMap[startVertex.uniqueRouterId] = 0;
@@ -217,8 +217,8 @@ class GraphRouter<T> {
                         return false;
                     }
 
-                    const from = (edge.node1 as Vertex<T>).uniqueRouterId,
-                        to = (edge.node2 as Vertex<T>).uniqueRouterId;
+                    const from = (edge.node1 as Vertex<N, E>).uniqueRouterId,
+                        to = (edge.node2 as Vertex<N, E>).uniqueRouterId;
                     // are these vertices joined?
                     return from === current || to === current;
                 })
@@ -226,12 +226,12 @@ class GraphRouter<T> {
                 .forEach(edge => {
                     let to, from, reversed = false;
                     // determine the direction of travel
-                    if ((edge.node1 as Vertex<T>).uniqueRouterId === current) {
-                        to = (edge.node2 as Vertex<T>).uniqueRouterId;
-                        from = (edge.node1 as Vertex<T>).uniqueRouterId;
+                    if ((edge.node1 as Vertex<N, E>).uniqueRouterId === current) {
+                        to = (edge.node2 as Vertex<N, E>).uniqueRouterId;
+                        from = (edge.node1 as Vertex<N, E>).uniqueRouterId;
                     } else {
-                        to = (edge.node1 as Vertex<T>).uniqueRouterId;
-                        from = (edge.node2 as Vertex<T>).uniqueRouterId;
+                        to = (edge.node1 as Vertex<N, E>).uniqueRouterId;
+                        from = (edge.node2 as Vertex<N, E>).uniqueRouterId;
                         reversed = true;
                     }
 
@@ -273,11 +273,11 @@ class GraphRouter<T> {
 
         // Remove Unique Router Id
         this._network.nodes.forEach(vertex => {
-            delete (vertex as GraphNode<T> & { uniqueRouterId?: number }).uniqueRouterId;
+            delete (vertex as GraphNode<N, E> & { uniqueRouterId?: number }).uniqueRouterId;
         });
 
         // This clone the itinerary and temporary nodes
-        return GraphItinerary.fromNetworkNodes<T>(start.coords, end.coords, path, edgesWeights);
+        return GraphItinerary.fromNetworkNodes<N, E>(start.coords, end.coords, path, edgesWeights);
     }
 }
 export default GraphRouter;

package/src/router/GraphRouterOptions.ts

@@ -1,13 +1,13 @@
 import GraphEdge from '../graph/GraphEdge.js';
 
 
-class GraphRouterOptions<T> {
+class GraphRouterOptions<N, E> {
 
     /** in meters */
     projectionMaxDistance = 50;
 
-    weightEdgeFn = (edge: GraphEdge<T>) => edge.length;
-    acceptEdgeFn: (edge: GraphEdge<T>) => boolean = () => true;
+    weightEdgeFn = (edge: GraphEdge<E, N>) => edge.length;
+    acceptEdgeFn: (edge: GraphEdge<E, N>) => boolean = () => true;
 
 }
 

package/tests/CommonTest.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-inline-comments */
 import chai from 'chai';
 
 import Coordinates from '../src/coordinates/Coordinates.js';
@@ -11,7 +10,10 @@ import Network from '../src/graph/Network.js';
 
 const { expect } = chai;
 
-const nodes = [
+type N = string;
+type E = string;
+
+const nodes: Node<N, E>[] = [
     new Node(new Coordinates(43.6092404, 3.884099), 'p0'), // 0
     new Node(new Coordinates(43.6091965, 3.8841285), 'p1'),
     new Node(new Coordinates(43.6091888, 3.8841263), 'p2'),
@@ -39,7 +41,7 @@ const nodes = [
     new Node(new Coordinates(43.6095624, 3.8845134), 'p23')
 ];
 
-const n = (name: string) => (nodes.find(node => node.builtFrom === name) as GraphNode<string>);
+const n = (name: string) => (nodes.find(node => node.builtFrom === name) as GraphNode<N, E>);
 
 const edges = [
     new Edge(n('p1'), n('p2'), 2, 'e0'),
@@ -69,12 +71,12 @@ const edges = [
     new Edge(n('p22'), n('p23'), null, 'e24')
 ];
 
-const network = new Network<string>();
+const network = new Network<E, N>();
 network.edges = edges;
 network.nodes = nodes;
 Node.generateNodesLevels(nodes);
 
-function verifyCoherence<T>(_network: Network<T>) {
+function verifyCoherence(_network: Network) {
 
     _network.edges.forEach(edge => {
         expect(edge.node1).not.equal(edge.node2);
@@ -82,7 +84,7 @@ function verifyCoherence<T>(_network: Network<T>) {
 
     _network.nodes.forEach(node => {
         node.edges.forEach(edge => {
-            expect(edge).satisfy((_edge: GraphEdge<T>) => {
+            expect(edge).satisfy((_edge: GraphEdge) => {
                 return _edge.node1 === node || _edge.node2 === node;
             });
         });