@wemap/providers 4.0.15 → 5.0.0

package/debug/src/NavigationConfig.js

@@ -1,9 +1,8 @@
 import React from 'react'; // eslint-disable-line no-unused-vars
 
-import {
-    AbsoluteHeading, UserPosition, Level, Itinerary
-} from '@wemap/geo';
+import { AbsoluteHeading, UserPosition, Level, Coordinates } from '@wemap/geo';
 import { deg2rad } from '@wemap/maths';
+import { Itinerary } from '@wemap/osm';
 import { TimeUtils } from '@wemap/utils';
 
 const datasets = {};
@@ -94,14 +93,17 @@ class NavigationConfig {
         this.dataset = dataset;
     }
 
+    /** @type {Coordinates} */
     static get INITIAL_POSITION() {
         return this.dataset.initialPosition;
     }
 
+    /** @type {AbsoluteHeading} */
     static get INITIAL_HEADING() {
         return this.dataset.initialHeading;
     }
 
+    /** @type {Itinerary} */
     static get ITINERARY() {
         return this.dataset.itinerary;
     }

package/package.json

@@ -8,16 +8,16 @@
     "Guillaume Pannetier <guillaume.pannetier@getwemap.com>"
   ],
   "dependencies": {
-    "@wemap/geo": "^4.0.14",
+    "@wemap/geo": "^5.0.0",
     "@wemap/geomagnetism": "^0.1.1",
-    "@wemap/logger": "^4.0.0",
-    "@wemap/map": "^4.0.14",
-    "@wemap/maths": "^4.0.3",
-    "@wemap/utils": "^4.0.0"
+    "@wemap/logger": "^5.0.0",
+    "@wemap/map": "^5.0.0",
+    "@wemap/maths": "^5.0.0",
+    "@wemap/utils": "^5.0.0"
   },
   "description": "A package using different geoloc systems",
   "devDependencies": {
-    "@wemap/osm": "^4.0.15",
+    "@wemap/osm": "^5.0.0",
     "mapbox-gl": "^1.11.1"
   },
   "homepage": "https://github.com/wemap/wemap-modules-js#readme",
@@ -39,6 +39,6 @@
     "url": "git+https://github.com/wemap/wemap-modules-js.git"
   },
   "type": "module",
-  "version": "4.0.15",
-  "gitHead": "eaaaf8ba0d4ba7e2d1de5a8910f7cf8e0ad8aaf1"
+  "version": "5.0.0",
+  "gitHead": "73607e294f29d3f9a41673bfc25ad9489a1da7f4"
 }

package/src/ProvidersInterface.js

@@ -9,6 +9,7 @@ import {
 } from './Providers.js';
 import ProvidersLoggerOld from './events/ProvidersLoggerOld.js';
 import MapMatchingHandler from './mapmatching/MapMatchingHandler.js';
+import { Itinerary } from '@wemap/osm';
 
 class ProvidersInterface {
 
@@ -51,6 +52,10 @@ class ProvidersInterface {
             MapMatchingHandler.network = data;
             return;
         }
+        if (eventType === EventType.Itinerary) {
+            MapMatchingHandler.itinerary = data;
+            return;
+        }
         this._getProviderFromEventType(eventType).feed(data, eventType);
     }
 
@@ -121,6 +126,11 @@ class ProvidersInterface {
                 throw errorFn('Network');
             }
             break;
+        case EventType.Itinerary:
+            if (!(data instanceof Itinerary || data === null)) {
+                throw errorFn('Itinerary');
+            }
+            break;
         default:
             throw new Error(`Unable to deal with this event type: ${eventType}`);
         }

package/src/mapmatching/MapMatchingHandler.js

@@ -1,8 +1,9 @@
 /* eslint-disable max-statements */
 import {
-    AbsoluteHeading, Edge, Itinerary, MapMatching, Network, Projection, UserPosition
+    AbsoluteHeading, GraphEdge, MapMatching, Network, GraphProjection, UserPosition
 } from '@wemap/geo';
 import { deg2rad, diffAngle, diffAngleLines } from '@wemap/maths';
+import { Itinerary } from '@wemap/osm';
 import { TimeUtils } from '@wemap/utils';
 
 import EventType from '../events/EventType.js';
@@ -69,13 +70,13 @@ class MapMatchingHandler extends Provider {
     /** @type {number?} */
     _stepDetectorProviderId;
 
-    /** @type {Projection[]} */
+    /** @type {GraphProjection[]} */
     _projectionsWithAbsAndWithoutRelAttitudeInARow = [];
 
     /** @type {number} */
     _countStepsFromLastMatching = 0;
 
-    /** @type {Projection[]} */
+    /** @type {GraphProjection[]} */
     _lastProjections = [];
 
 
@@ -142,12 +143,12 @@ class MapMatchingHandler extends Provider {
         return ProvidersOptions.useMapMatching;
     }
 
-    /** @type {Network} */
+    /** @type {?Network} */
     get network() {
         return this._mapMatching.network;
     }
 
-    /** @type {Network} */
+    /** @type {?Network} */
     set network(network) {
 
         this._mapMatching.network = network;
@@ -156,7 +157,21 @@ class MapMatchingHandler extends Provider {
         this._manageStartStop();
 
         if (this.canUseMapMatching()) {
-            this._notifyPositionFromNetworkInput(network);
+            // TODO if necessary
+            // this._notifyPositionFromNetworkInput(network);
+        }
+    }
+
+    /** @type {?Itinerary} */
+    set itinerary(itinerary) {
+
+        this._mapMatching.network = itinerary ? itinerary.toNetwork() : null;
+        this.notify(this.createEvent(EventType.Itinerary, itinerary));
+
+        this._manageStartStop();
+
+        if (this.canUseMapMatching()) {
+            this._notifyPositionFromItineraryInput(itinerary);
         }
     }
 
@@ -168,9 +183,13 @@ class MapMatchingHandler extends Provider {
     }
 
     /**
-     * @param {Network} network
+     * @param {Itinerary} itinerary
      */
-    _notifyPositionFromNetworkInput(network) {
+    _notifyPositionFromItineraryInput(itinerary) {
+
+        if (!MapMatchingHandler.USE_ITINERARY_START_AS_POSITION || itinerary.start) {
+            return;
+        }
 
         const lastEvent = AbsolutePosition.lastEvent;
         const lastPosition = lastEvent ? lastEvent.data : null;
@@ -183,46 +202,36 @@ class MapMatchingHandler extends Provider {
             AbsolutePosition.notify(newEvent);
         };
 
-        let newPosition;
-        if (MapMatchingHandler.USE_ITINERARY_START_AS_POSITION
-            && network instanceof Itinerary && network.start) {
-
-            // In case of an itinerary, use itinerary start as new position,
-            // but add the distance between lastPosition and itinerary start for the accuracy
-            newPosition = UserPosition.fromCoordinates(network.start);
-
-            if (lastPosition) {
-                newPosition.alt = lastPosition.alt;
-                newPosition.time = lastPosition.time;
-                newPosition.accuracy = lastPosition.accuracy + newPosition.distanceTo(lastPosition);
-                newPosition.bearing = lastPosition.bearing;
-            } else {
-                newPosition.alt = Constants.DEFAULT_ALTITUDE;
-                newPosition.time = TimeUtils.preciseTime();
-                newPosition.accuracy = 0;
-                newPosition.bearing = network.edges[0].bearing;
-            }
-
-            // if the distance between itinerary.start and itinerary.nodes[0] is less than MM_MAX_DIST,
-            //  projection.projection is itinerary.nodes[0]
-            const projection = this.getProjection(newPosition, true);
-            if (projection) {
-                notify(projection.projection);
-                // Do not notify for attitude projection because bearing has not been used.
-            } else {
-                // This means the first position is far from the network and the user has
-                //  to reach itinerary.nodes[0] before to continue
-                notify(newPosition);
-            }
+        // In case of an itinerary, use itinerary start as new position,
+        // but add the distance between lastPosition and itinerary start for the accuracy
+        const newPosition = UserPosition.fromCoordinates(itinerary.from);
+
+        if (lastPosition) {
+            newPosition.alt = lastPosition.alt;
+            newPosition.time = lastPosition.time;
+            newPosition.accuracy = lastPosition.accuracy + newPosition.distanceTo(lastPosition);
+            newPosition.bearing = lastPosition.bearing;
+        } else if (itinerary.coords >= 2) {
+            newPosition.alt = Constants.DEFAULT_ALTITUDE;
+            newPosition.time = TimeUtils.preciseTime();
+            newPosition.accuracy = 0;
+            newPosition.bearing = itinerary.coords[0].bearingTo(itinerary.coords[1]);
+        } else {
             return;
         }
 
-        if (!lastPosition) {
-            return;
+        // if the distance between itinerary.start and itinerary.nodes[0] is less than MM_MAX_DIST,
+        //  projection.projection is itinerary.nodes[0]
+        const projection = this.getProjection(newPosition, true);
+        if (projection) {
+            notify(projection.projection);
+            // Do not notify for attitude projection because bearing has not been used.
+        } else {
+            // This means the first position is far from the network and the user has
+            //  to reach itinerary.nodes[0] before to continue
+            notify(newPosition);
         }
-
-        newPosition = lastPosition.clone();
-        // TODO in function of the lastEvent, if it is from relative or absolute
+        return;
     }
 
     /**
@@ -422,7 +431,7 @@ class MapMatchingHandler extends Provider {
 
         const firstProjection = this._lastProjections[0];
         return !this._lastProjections.some(projection =>
-            !(projection.nearestElement instanceof Edge)
+            !(projection.nearestElement instanceof GraphEdge)
             || (diffAngleLines(projection.nearestElement.bearing, firstProjection.nearestElement.bearing)
                 > MapMatchingHandler.LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD)
         );
@@ -444,7 +453,7 @@ class MapMatchingHandler extends Provider {
         }
 
         const { nearestElement, origin } = projection;
-        if (!(nearestElement instanceof Edge)) {
+        if (!(nearestElement instanceof GraphEdge)) {
             return;
         }