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

package/package.json

@@ -5,7 +5,7 @@
         "Guillaume Pannetier <guillaume.pannetier@getwemap.com>"
     ],
     "description": "Wemap geo utils package",
-    "module": "dist/index.js",
+    "main": "dist/index.js",
     "types": "index.ts",
     "repository": {
         "type": "git",
@@ -13,7 +13,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "11.0.0-alpha.0",
+    "version": "11.0.0-alpha.12",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -31,11 +31,17 @@
     ],
     "license": "ISC",
     "dependencies": {
-        "@wemap/logger": "^11.0.0-alpha.0",
-        "@wemap/maths": "^11.0.0-alpha.0"
+        "@wemap/logger": "^11.0.0-alpha.4",
+        "@wemap/maths": "^11.0.0-alpha.12"
     },
     "devDependencies": {
         "jsdom-global": "^3.0.2"
     },
-    "gitHead": "516aaa5323ac9c469cbc75b484b8cae14d1d8d12"
+    "exports": {
+        ".": {
+            "import": "./dist/index.mjs",
+            "require": "./dist/index.js"
+        }
+    },
+    "gitHead": "42a1aece349e6db3151938ebc9b3d85daf9bb90d"
 }

package/src/Utils.ts

@@ -6,13 +6,13 @@ import { EPS_MM } from './Constants.js';
 import Coordinates from './coordinates/Coordinates.js';
 import UserPosition from './coordinates/UserPosition.js';
 
-type RouteSample = Coordinates & { bearing: number };
+export type RouteSample = Coordinates & { bearing: number };
 
 /**
  * Sample a route of Coordinates
- * @param {Array.<Coordinates>} route ordered points
- * @param {*} stepSize step size to sample
- * @param {*} maxLength max route length to sample
+ * @param route ordered points
+ * @param stepSize step size to sample
+ * @param maxLength max route length to sample
  */
 export function sampleRoute(
     route: Coordinates[],

package/src/coordinates/BoundingBox.ts

@@ -16,8 +16,6 @@ class BoundingBox {
 
     /**
      * Returns the geographical coordinate equidistant from the bounding box's corners.
-     *
-     * @returns {Coordinates} The bounding box's center.
      */
     get center(): Coordinates {
         const latCenter = (this.southWest.lat + this.northEast.lat) / 2;
@@ -27,8 +25,6 @@ class BoundingBox {
 
     /**
      * Check if a point is contained in the bounding box.
-     *
-     * @returns {Coordinates} The point to analyze.
      */
     contains(point: Coordinates): boolean {
         return point.lat <= this.northEast.lat
@@ -39,9 +35,6 @@ class BoundingBox {
 
     /**
      * Extend the bounds to include a given LngLat or LngLatBounds.
-     *
-     * @param {Coordinates|BoundingBox} obj object to extend to
-     * @returns {BoundingBox} `this`
      */
     extend(obj: Coordinates | BoundingBox): BoundingBox {
         const sw = this.southWest,
@@ -74,7 +67,6 @@ class BoundingBox {
     /**
      * This method extends the bounding box with a value in meters
      * /*\ This method is not precise as distance differs in function of latitude
-     * @param {!number} measure in meters
      */
     extendsWithMeasure(measure: number): BoundingBox {
 
@@ -97,8 +89,6 @@ class BoundingBox {
      * Returns bounds created by extending or retracting the current bounds by a given ratio in each direction.
      * For example, a ratio of 0.5 extends the bounds by 50% in each direction.
      * Negative values will retract the bounds.
-     * @param {Number} bufferRatio
-     * @returns {BoundingBox} `this`
      */
     pad(bufferRatio: number): BoundingBox {
         const sw = this.southWest;
@@ -115,8 +105,6 @@ class BoundingBox {
 
     /**
      * Returns the southwest corner of the bounding box.
-     *
-     * @returns {Coordinates} The southwest corner of the bounding box.
      */
     getSouthWest() {
         return this.southWest;
@@ -124,63 +112,49 @@ class BoundingBox {
 
     /**
     * Returns the northeast corner of the bounding box.
-    *
-    * @returns {Coordinates} The northeast corner of the bounding box.
-     */
+    */
     getNorthEast() {
         return this.northEast;
     }
 
     /**
     * Returns the northwest corner of the bounding box.
-    *
-    * @returns {Coordinates} The northwest corner of the bounding box.
-     */
+    */
     getNorthWest() {
         return new Coordinates(this.getNorth(), this.getWest());
     }
 
     /**
     * Returns the southeast corner of the bounding box.
-    *
-    * @returns {LngLat} The southeast corner of the bounding box.
-     */
+    */
     getSouthEast() {
         return new Coordinates(this.getSouth(), this.getEast());
     }
 
     /**
     * Returns the west edge of the bounding box.
-    *
-    * @returns {number} The west edge of the bounding box.
-     */
+    */
     getWest() {
         return this.southWest.lng;
     }
 
     /**
     * Returns the south edge of the bounding box.
-    *
-    * @returns {number} The south edge of the bounding box.
-     */
+    */
     getSouth() {
         return this.southWest.lat;
     }
 
     /**
     * Returns the east edge of the bounding box.
-    *
-    * @returns {number} The east edge of the bounding box.
-     */
+    */
     getEast() {
         return this.northEast.lng;
     }
 
     /**
     * Returns the north edge of the bounding box.
-    *
-    * @returns {number} The north edge of the bounding box.
-     */
+    */
     getNorth() {
         return this.northEast.lat;
     }
@@ -204,6 +178,16 @@ class BoundingBox {
         );
     }
 
+    static fromCoordinates(coords: Coordinates[]) {
+        if (coords.length === 0) {
+            return null;
+        }
+        return coords.reduce(
+            (acc, _coords) => acc.extend(_coords),
+            new BoundingBox(coords[0], coords[0])
+        );
+    }
+
     /**
      * Returns the WSEN array
      */

package/src/graph/GraphEdge.ts

@@ -7,10 +7,10 @@ import { Level_t } from '../types.js';
  * An edge is mostly issued from an OsmWay, but this is not always the case.
  * For example, edges created by mapmatching.
  */
-class GraphEdge<T = unknown> {
+class GraphEdge<E = unknown, N = unknown> {
 
-    private _node1!: GraphNode<T>;
-    private _node2!: GraphNode<T>;
+    private _node1!: GraphNode<N, E>;
+    private _node2!: GraphNode<N, E>;
     private _level: Level_t = null;
 
     private _bearing: number | null = null;
@@ -18,12 +18,12 @@ class GraphEdge<T = unknown> {
 
     private _computedSizeAndBearing = false;
 
-    builtFrom: T | null;
+    builtFrom: E | null;
 
     isOneway = false;
 
-    constructor(node1: GraphNode<T>, node2: GraphNode<T>,
-        level: Level_t = null, builtFrom: T | null = null,
+    constructor(node1: GraphNode<N, E>, node2: GraphNode<N, E>,
+        level: Level_t = null, builtFrom: E | null = null,
     ) {
         this.node1 = node1;
         this.node2 = node2;
@@ -106,7 +106,7 @@ class GraphEdge<T = unknown> {
         this._computedSizeAndBearing = true;
     }
 
-    equals(other: GraphEdge<T>) {
+    equals(other: GraphEdge<E, N>) {
 
         if (this === other) {
             return true;
@@ -124,7 +124,7 @@ class GraphEdge<T = unknown> {
     }
 
     clone() {
-        const edge = new GraphEdge<T>(this.node1, this.node2, this.level, this.builtFrom);
+        const edge = new GraphEdge<E, N>(this.node1, this.node2, this.level, this.builtFrom);
         edge.isOneway = this.isOneway;
         return edge;
     }

package/src/graph/GraphNode.spec.ts

@@ -16,6 +16,8 @@ const { expect } = chai;
 
 describe('GraphNode', () => {
 
+    type N = string;
+    type E = string;
 
     it('creation', () => {
 
@@ -69,14 +71,14 @@ describe('GraphNode', () => {
     // eslint-disable-next-line max-statements
     it('generateNodesLevels', () => {
 
-        const cleanNodes = (count: number) => [...Array(count)].map((_ignore, idx) => new GraphNode<string>(new Coordinates(0, 0), `n${idx}`));
+        const cleanNodes = (count: number) => [...Array(count)].map((_ignore, idx) => new GraphNode<N, E>(new Coordinates(0, 0), `n${idx}`));
         const cleanNodesWithAdjEdges = (...levelEdges: Level_t[]) => {
             const _nodes = cleanNodes(levelEdges.length + 1);
-            levelEdges.forEach((level, idx) => new GraphEdge<string | null>(_nodes[0], _nodes[idx + 1], level));
+            levelEdges.forEach((level, idx) => new GraphEdge<E | null>(_nodes[0], _nodes[idx + 1], level));
             return _nodes;
         };
 
-        let nodes: GraphNode<string>[];
+        let nodes: GraphNode<N>[];
 
         /**
          * Simple case with only adjacent nodes

package/src/graph/GraphNode.ts

@@ -5,35 +5,35 @@ import { GraphNodeJson, Level_t } from '../types.js';
 import GraphEdge from './GraphEdge.js';
 
 
-class GraphNode<T = unknown> {
+class GraphNode<N = unknown, E = unknown> {
 
     coords: Coordinates;
 
-    edges: GraphEdge<T>[] = [];
-    builtFrom: T | null;
+    edges: GraphEdge<E, N>[] = [];
+    builtFrom: N | null;
     io = false;
 
-    constructor(coords: Coordinates, builtFrom: T | null = null) {
+    constructor(coords: Coordinates, builtFrom: N | null = null) {
         this.coords = coords;
         this.builtFrom = builtFrom;
     }
 
-    distanceTo(other: GraphNode<T>) {
+    distanceTo(other: GraphNode<N, E>) {
         return this.coords.distanceTo(other.coords);
     }
 
-    bearingTo(other: GraphNode<T>) {
+    bearingTo(other: GraphNode<N, E>) {
         return this.coords.bearingTo(other.coords);
     }
 
-    equals(other: GraphNode<T>) {
+    equals(other: GraphNode<N, E>) {
         return this.coords.equals(other.coords)
             && this.builtFrom === other.builtFrom;
     }
 
 
     clone() {
-        const node = new GraphNode<T>(this.coords, this.builtFrom);
+        const node = new GraphNode<N, E>(this.coords, this.builtFrom);
         node.edges = this.edges.slice(0);
         node.io = this.io;
         return node;
@@ -46,8 +46,8 @@ class GraphNode<T = unknown> {
         return this.coords.toCompressedJson();
     }
 
-    static fromJson<T2>(json: GraphNodeJson, builtFrom: T2 | null = null) {
-        return new GraphNode<T2>(Coordinates.fromCompressedJson(json), builtFrom);
+    static fromJson<N2, E2>(json: GraphNodeJson, builtFrom: N2 | null = null) {
+        return new GraphNode<N2, E2>(Coordinates.fromCompressedJson(json), builtFrom);
     }
 
     _generateLevelFromEdges() {
@@ -89,7 +89,7 @@ class GraphNode<T = unknown> {
          * This method looks for single level nodes recursively from a multi-level node
          * The result of this method is an union of all single level nodes found.
          */
-        const lookForLevel = (node: GraphNode<T>, visitedNodes: GraphNode<T>[]): Level_t => {
+        const lookForLevel = (node: GraphNode<N, E>, visitedNodes: GraphNode<N, E>[]): Level_t => {
 
             visitedNodes.push(node);
 
@@ -156,7 +156,7 @@ class GraphNode<T = unknown> {
         return true;
     }
 
-    static generateNodesLevels<T2>(nodes: GraphNode<T2>[]) {
+    static generateNodesLevels<N2, E2>(nodes: GraphNode<N2, E2>[]) {
 
         nodes.forEach(node => node._generateLevelFromEdges());
 

package/src/graph/GraphProjection.ts

@@ -2,15 +2,15 @@ import Coordinates from '../coordinates/Coordinates.js';
 import GraphEdge from './GraphEdge.js';
 import GraphNode from './GraphNode.js';
 
-class GraphProjection<T = unknown, U extends Coordinates = Coordinates> {
+class GraphProjection<N = unknown, E = unknown, U extends Coordinates = Coordinates> {
 
     origin: U;
     distanceFromNearestElement: number;
     coords: U;
-    nearestElement: GraphNode<T> | GraphEdge<T>;
+    nearestElement: GraphNode<N, E> | GraphEdge<E, N>;
 
     constructor(origin: U, distanceFromNearestElement: number,
-        coords: U, nearestElement: GraphNode<T> | GraphEdge<T>
+        coords: U, nearestElement: GraphNode<N, E> | GraphEdge<E, N>
     ) {
         this.origin = origin;
         this.distanceFromNearestElement = distanceFromNearestElement;

package/src/graph/GraphUtils.ts

@@ -3,9 +3,9 @@ import Coordinates from '../coordinates/Coordinates.js';
 import GraphEdge from './GraphEdge.js';
 import GraphNode from './GraphNode.js';
 
-export function getEdgeByNodes<T>(
-    edges: GraphEdge<T>[],
-    node1: GraphNode<T>, node2: GraphNode<T>
+export function getEdgeByNodes<E, N>(
+    edges: GraphEdge<E, N>[],
+    node1: GraphNode<N, E>, node2: GraphNode<N, E>
 ) {
     return edges.find(edge => node1 === edge.node1 && node2 === edge.node2
         || node2 === edge.node1 && node1 === edge.node2
@@ -13,8 +13,8 @@ export function getEdgeByNodes<T>(
 }
 
 
-export function getNodeByCoords<T>(
-    nodes: GraphNode<T>[],
+export function getNodeByCoords<N, E>(
+    nodes: GraphNode<N, E>[],
     coords: Coordinates
 ) {
     return nodes.find(node => node.coords.equals(coords));

package/src/graph/MapMatching.ts

@@ -12,14 +12,14 @@ import GraphEdge from './GraphEdge.js';
 import GraphNode from './GraphNode.js';
 import { EPS_MM } from '../Constants.js';
 
-class MapMatching<T = unknown> {
+class MapMatching<N = unknown, E = unknown> {
 
-    network: Network<T> | null = null;
+    network: Network<N, E> | null = null;
 
     private _maxDistance = Number.MAX_VALUE;
     private _maxAngleBearing = Math.PI;
 
-    constructor(network: Network<T> | null = null) {
+    constructor(network: Network<N, E> | null = null) {
         this.network = network;
     }
 
@@ -47,11 +47,11 @@ class MapMatching<T = unknown> {
      *  Second is true if projection will be used on the nodes of the specified edge, false otherwise.
      */
     _shouldProjectOnEdgeAndNodes(
-        edge: GraphEdge<T>,
+        edge: GraphEdge<E, N>,
         location: Coordinates | UserPosition,
         useBearing: boolean,
         useMultiLevelSegments: boolean,
-        acceptEdgeFn: (edge: GraphEdge<T>) => boolean) {
+        acceptEdgeFn: (edge: GraphEdge<E, N>) => boolean) {
 
         // ignore projections if edge is not accepted
         if (!acceptEdgeFn(edge)) {
@@ -124,7 +124,7 @@ class MapMatching<T = unknown> {
         useDistance = false,
         useBearing = false,
         useMultiLevelSegments = true,
-        acceptEdgeFn: (edge: GraphEdge<T>) => boolean = () => true) {
+        acceptEdgeFn: (edge: GraphEdge<E, N>) => boolean = () => true) {
 
         if (this.network === null) {
             throw new Error('Network has not been set yet');
@@ -212,7 +212,7 @@ class MapMatching<T = unknown> {
             projection.accuracy += distanceFromNearestElement;
         }
 
-        return new GraphProjection<T, U>(
+        return new GraphProjection<N, E, U>(
             location,
             distanceFromNearestElement,
             projection,

package/src/graph/Network.spec.ts

@@ -15,6 +15,9 @@ const { expect } = chai;
 
 describe('Network', () => {
 
+    type N = string;
+    type E = string;
+
     it('creation', () => {
 
         expect(() => new Network()).not.throw(Error);
@@ -65,8 +68,8 @@ describe('Network', () => {
 
     it('toDetailedString', () => {
 
-        const nodeFn = (node: GraphNode<string>) => node.builtFrom || '';
-        const edgeFn = (edge: GraphEdge<string>) => edge.builtFrom || '';
+        const nodeFn = (node: GraphNode<N, E>) => node.builtFrom || '';
+        const edgeFn = (edge: GraphEdge<E, N>) => edge.builtFrom || '';
         expect(() => network.toDetailedString(nodeFn, edgeFn)).not.throw(Error);
 
     });

package/src/graph/Network.ts

@@ -11,17 +11,12 @@ import { getEdgeByNodes } from './GraphUtils.js';
  * TODO: rename to GraphNetwork
  * A typical network with nodes (Node) and edges (Edge)
  */
-class Network<T = unknown> {
+class Network<N = unknown, E = unknown> {
 
-    nodes: GraphNode<T>[];
-    edges: GraphEdge<T>[];
+    nodes: GraphNode<N, E>[];
+    edges: GraphEdge<E, N>[];
 
-    /**
-     * @template T
-     * @param {GraphNode<T>[]} nodes
-     * @param {GraphEdge<T>[]} edges
-     */
-    constructor(nodes?: GraphNode<T>[], edges?: GraphEdge<T>[]) {
+    constructor(nodes?: GraphNode<N, E>[], edges?: GraphEdge<E, N>[]) {
         this.nodes = Array.isArray(nodes) ? nodes : [];
         this.edges = Array.isArray(edges) ? edges : [];
     }
@@ -31,7 +26,7 @@ class Network<T = unknown> {
         return this.nodes.find(node => node.coords.equals(coords));
     }
 
-    getEdgeByNodes(node1: GraphNode<T>, node2: GraphNode<T>) {
+    getEdgeByNodes(node1: GraphNode<N>, node2: GraphNode<N>) {
         return getEdgeByNodes(this.edges, node1, node2);
     }
 
@@ -39,10 +34,7 @@ class Network<T = unknown> {
         if (!this.nodes.length) {
             return null;
         }
-        const boundingBox = this.nodes.reduce(
-            (acc, node) => acc.extend(node.coords),
-            new BoundingBox(this.nodes[0].coords, this.nodes[0].coords)
-        );
+        const boundingBox = BoundingBox.fromCoordinates(this.nodes.map(node => node.coords)) as BoundingBox;
         if (extendedMeasure) {
             boundingBox.extendsWithMeasure(extendedMeasure);
         }
@@ -50,8 +42,8 @@ class Network<T = unknown> {
     }
 
     toDetailedString(
-        _nodeToStringFn: (node: GraphNode<T>) => string,
-        _edgeToStringFn: (node: GraphEdge<T>) => string
+        _nodeToStringFn: (node: GraphNode<N, E>) => string,
+        _edgeToStringFn: (edge: GraphEdge<E, N>) => string
     ) {
 
         let nodeToStringFn = _nodeToStringFn;
@@ -102,14 +94,14 @@ class Network<T = unknown> {
     }
 
 
-    static fromCompressedJson<T2>(json: NetworkJson) {
+    static fromCompressedJson<N2, E2>(json: NetworkJson) {
 
-        const network = new Network<T2 | null>();
+        const network = new Network<N2 | null, E2 | null>();
 
-        network.nodes = json.nodes.map(node => GraphNode.fromJson(node, null));
+        network.nodes = json.nodes.map(node => GraphNode.fromJson<N2, E2>(node, null));
 
         network.edges = json.edges.map(jsonEdge => {
-            const edge = new GraphEdge(
+            const edge = new GraphEdge<E2 | null, N2 | null>(
                 network.nodes[jsonEdge[0]],
                 network.nodes[jsonEdge[1]],
                 jsonEdge[2],
@@ -125,23 +117,30 @@ class Network<T = unknown> {
     }
 
 
-    static fromCoordinates<T2>(segments: Coordinates[][]) {
+    static fromCoordinates<N2, E2>(segments: Coordinates[][]) {
 
-        const network = new Network<T2 | null>();
+        const network = new Network<N2 | null, E2 | null>();
 
         const getOrCreateNode = (coords: Coordinates) => {
             const node = network.nodes.find(otherNode => otherNode.coords.equals(coords));
             if (node) {
                 return node;
             }
-            const newNode = new GraphNode<T2 | null>(coords, null);
+            const newNode = new GraphNode<N2 | null, E2 | null>(coords, null);
             network.nodes.push(newNode);
             return newNode;
         };
 
 
-        const createEdgeFromNodes = (node1: GraphNode<T2 | null>, node2: GraphNode<T2 | null>) =>
-            new GraphEdge(node1, node2, Level.union(node1.coords.level, node2.coords.level), null);
+        const createEdgeFromNodes = (
+            node1: GraphNode<N2 | null, E2 | null>,
+            node2: GraphNode<N2 | null, E2 | null>
+        ) => new GraphEdge<E2 | null, N2 | null>(
+            node1,
+            node2,
+            Level.union(node1.coords.level, node2.coords.level),
+            null
+        );
 
         for (const segment of segments) {
 

package/src/router/GraphItinerary.spec.ts

@@ -3,7 +3,7 @@ import GraphItinerary from './GraphItinerary';
 
 const { expect } = chai;
 
-export function isReadable<T>(itinerary: GraphItinerary<T>) {
+export function isReadable(itinerary: GraphItinerary) {
     for (let i = 0; i < itinerary.nodes.length; i++) {
         const node = itinerary.nodes[i];
         if (i !== itinerary.nodes.length - 1) {

package/src/router/GraphItinerary.ts

@@ -5,19 +5,19 @@ import GraphEdge from '../graph/GraphEdge.js';
 import { getEdgeByNodes } from '../graph/GraphUtils.js';
 
 
-class GraphItinerary<T> {
+class GraphItinerary<N = unknown, E = unknown> {
 
     start: Coordinates;
     end: Coordinates;
 
-    nodes: GraphNode<T>[];
-    edges: GraphEdge<T>[];
+    nodes: GraphNode<N, E>[];
+    edges: GraphEdge<E, N>[];
 
     edgesWeights: number[];
 
-    private constructor(
+    protected constructor(
         start: Coordinates, end: Coordinates,
-        nodes: GraphNode<T>[], edges: GraphEdge<T>[],
+        nodes: GraphNode<N, E>[], edges: GraphEdge<E, N>[],
         edgesWeights: number[]
     ) {
         this.start = start;
@@ -27,9 +27,9 @@ class GraphItinerary<T> {
         this.edgesWeights = edgesWeights;
     }
 
-    static fromNetworkNodes<T2>(
+    static fromNetworkNodes<N2, E2>(
         start: Coordinates, end: Coordinates,
-        networkNodes: GraphNode<T2>[], edgesWeights: number[]
+        networkNodes: GraphNode<N2, E2>[], edgesWeights: number[]
     ) {
 
         const nodes = networkNodes.map(node => {
@@ -47,7 +47,7 @@ class GraphItinerary<T> {
             return newNode;
         });
 
-        const edges: GraphEdge<T2>[] = [];
+        const edges: GraphEdge<E2, N2>[] = [];
         networkNodes.forEach((node, idx, arr) => {
             if (idx === 0) {
                 return;
@@ -55,7 +55,7 @@ class GraphItinerary<T> {
 
             // Retrieve network edge
             const prevNode = arr[idx - 1];
-            const edge = getEdgeByNodes<T2>(prevNode.edges, prevNode, node);
+            const edge = getEdgeByNodes(prevNode.edges, prevNode, node);
 
             if (!edge) {
                 Logger.error('Cannot retrieve edge to create itinerary');
@@ -63,7 +63,7 @@ class GraphItinerary<T> {
             }
 
             // Create itinerary edge
-            const newEdge = new GraphEdge<T2>(
+            const newEdge = new GraphEdge(
                 nodes[idx - 1],
                 nodes[idx],
                 edge.level,
@@ -73,7 +73,7 @@ class GraphItinerary<T> {
             edges.push(newEdge);
         });
 
-        return new GraphItinerary<T2>(start, end, nodes, edges, edgesWeights);
+        return new GraphItinerary(start, end, nodes, edges, edgesWeights);
     }
 }