@wemap/providers 6.2.2 → 7.0.0

package/dist/wemap-providers.es.js

@@ -1,7 +1,7 @@
 import { deg2rad, Vector3, Matrix, Quaternion, Matrix3, Matrix4, Vector, Rotations, std, diffAngleLines, diffAngle, rad2deg } from '@wemap/maths';
 import { BrowserUtils, Browser, PromiseUtils, TimeUtils } from '@wemap/utils';
 import Logger from '@wemap/logger';
-import { GraphUtils, Level, Coordinates, Network, GraphRouterOptions, Attitude, RelativePosition, Constants as Constants$1, MapMatching, UserPosition, GraphEdge, AbsoluteHeading, GeoRelativePosition as GeoRelativePosition$1 } from '@wemap/geo';
+import { Coordinates, Network, GraphRouterOptions, Attitude, RelativePosition, Constants as Constants$2, MapMatching, UserPosition, GraphEdge, AbsoluteHeading, GeoRelativePosition as GeoRelativePosition$1, Level } from '@wemap/geo';
 import geomagnetism from '@wemap/geomagnetism';
 import '@wemap/osm';
 import { SharedCameras, Camera, CameraUtils } from '@wemap/camera';
@@ -917,28 +917,22 @@ class LevelChange {
     type = null;
 
     /**
-     * @param {GraphNode<OsmElement>} firstNode
-     * @param {GraphNode<OsmElement>} secondNode
-     * @returns {LevelChange}
+     * @param {LevelChange} obj1
+     * @param {LevelChange} obj2
+     * @returns {Boolean}
      */
-    static fromTwoNodes(firstNode, secondNode) {
-
-        const levelChange = new LevelChange();
-
-        const edge = GraphUtils.getEdgeByNodes(firstNode.edges, firstNode, secondNode);
-
-        if (edge.builtFrom.isElevator) {
-            levelChange.type = 'elevator';
-        } else if (edge.builtFrom.isConveying) {
-            levelChange.type = 'conveyor';
-        } else if (edge.builtFrom.areStairs) {
-            levelChange.type = 'stairs';
-        }
-
-        levelChange.difference = Level.diff(firstNode.coords.level, secondNode.coords.level);
-        levelChange.direction = levelChange.difference > 0 ? 'up' : 'down';
+    static equalsTo(obj1, obj2) {
+        return obj1.difference === obj2.difference
+            && obj1.direction === obj2.direction
+            && obj1.type === obj2.type;
+    }
 
-        return levelChange;
+    /**
+     * @param {LevelChange} obj
+     * @returns {Boolean}
+     */
+    equalsTo(obj) {
+        return LevelChange.equalsTo(this, obj);
     }
 
     /**
@@ -1009,6 +1003,45 @@ class Step {
     /** @type {!number} */
     _idCoordsInLeg = null;
 
+    /**
+     * @param {Step} obj1
+     * @param {Step} obj2
+     * @returns {Boolean}
+     */
+    static equalsTo(obj1, obj2) {
+        return obj1.firstStep === obj2.firstStep
+            && obj1.lastStep === obj2.lastStep
+            && obj1.number === obj2.number
+            && obj1.coords.equalsTo(obj2.coords)
+            && obj1.angle === obj2.angle
+            && obj1.previousBearing === obj2.previousBearing
+            && obj1.nextBearing === obj2.nextBearing
+            && obj1.distance === obj2.distance
+            && obj1.duration === obj2.duration
+            && obj1.name === obj2.name
+            && (
+                obj1.levelChange === obj2.levelChange
+                || obj1.levelChange !== null && obj1.levelChange.equalsTo(obj2.levelChange)
+            )
+            && (
+                obj1.extras === obj2.extras
+                || (
+                    obj1.extras !== null
+                    && obj1.extras.subwayEntrance === obj2.extras.subwayEntrance
+                    && obj1.extras.subwayEntranceRef === obj2.extras.subwayEntranceRef
+                )
+            )
+            && obj1._idCoordsInLeg === obj2._idCoordsInLeg;
+    }
+
+    /**
+     * @param {Step} obj
+     * @returns {Boolean}
+     */
+    equalsTo(obj) {
+        return Step.equalsTo(this, obj);
+    }
+
     /**
      * @returns {object}
      */
@@ -1056,31 +1089,62 @@ class Step {
         step.nextBearing = json.nextBearing;
         step.distance = json.distance;
         step._idCoordsInLeg = json._idCoordsInLeg;
-        if (json.firstStep) {
+        if (typeof json.firstStep === 'boolean') {
             step.firstStep = json.firstStep;
         }
-        if (json.lastStep) {
+        if (typeof json.lastStep === 'boolean') {
             step.lastStep = json.lastStep;
         }
-        if (json.duration) {
+        if (typeof json.duration === 'number') {
             step.duration = json.duration;
         }
-        if (json.name) {
+        if (typeof json.name === 'string') {
             step.name = json.name;
         }
-        if (json.levelChange) {
+        if (typeof json.levelChange === 'object') {
             step.levelChange = LevelChange.fromJson(json.levelChange);
         }
-        if (json.extras) {
+        if (typeof json.extras === 'object') {
             step.extras = json.extras;
         }
         return step;
     }
 }
 
+const Constants$1 = {};
+
+Constants$1.ROUTING_MODE = {
+    AIRPLANE: 'AIRPLANE',
+    BOAT: 'BOAT',
+    BIKE: 'BIKE',
+    BUS: 'BUS',
+    CAR: 'CAR',
+    FERRY: 'FERRY',
+    FUNICULAR: 'FUNICULAR',
+    METRO: 'METRO',
+    MOTO: 'MOTO',
+    TRAIN: 'TRAIN',
+    TAXI: 'TAXI',
+    TRAM: 'TRAM',
+    WALK: 'WALK',
+    MULTI: 'MULTI',
+    UNKNOWN: 'UNKNOWN'
+};
+
+Constants$1.PUBLIC_TRANSPORT = [
+    Constants$1.ROUTING_MODE.AIRPLANE,
+    Constants$1.ROUTING_MODE.BOAT,
+    Constants$1.ROUTING_MODE.BUS,
+    Constants$1.ROUTING_MODE.FERRY,
+    Constants$1.ROUTING_MODE.FUNICULAR,
+    Constants$1.ROUTING_MODE.METRO,
+    Constants$1.ROUTING_MODE.TRAIN,
+    Constants$1.ROUTING_MODE.TRAM
+];
+
 class Leg {
 
-    /** @type {!string} can be WALK, BIKE, BUS, TRAM, CAR, FUNICULAR */
+    /** @type {!string} can be values in Constants.ROUTING_MODE */
     mode;
 
     /** @type {!number} */
@@ -1110,6 +1174,10 @@ class Leg {
     /** @type {?(Step[])} */
     steps = null;
 
+    isPublicTransport() {
+        return Constants$1.PUBLIC_TRANSPORT.includes(this.mode);
+    }
+
     /**
      * @returns {Network}
      */
@@ -1117,6 +1185,72 @@ class Leg {
         return Network.fromCoordinates([this.coords]);
     }
 
+
+    /**
+     * @param {Leg} obj1
+     * @param {Leg} obj2
+     * @returns {Boolean}
+     */
+    // eslint-disable-next-line complexity
+    static equalsTo(obj1, obj2) {
+        const intermediate = obj1.mode === obj2.mode
+            && obj1.distance === obj2.distance
+            && obj1.duration === obj2.duration
+            && obj1.startTime === obj2.startTime
+            && obj1.endTime === obj2.endTime
+            && obj1.from.name === obj2.from.name
+            && obj1.from.coords.equalsTo(obj2.from.coords)
+            && obj1.to.name === obj2.to.name
+            && obj1.to.coords.equalsTo(obj2.to.coords)
+            && obj1.coords.length === obj2.coords.length
+            && (
+                obj1.steps === obj2.steps
+                || obj1.steps.length === obj2.steps.length
+            );
+
+        if (!intermediate) {
+            return false;
+        }
+
+        let i;
+        for (i = 0; i < obj1.coords.length; i++) {
+            if (!obj1.coords[i].equalsTo(obj2.coords[i])) {
+                return false;
+            }
+        }
+        if (obj1.steps) {
+            for (i = 0; i < obj1.steps.length; i++) {
+                if (!obj1.steps[i].equalsTo(obj2.steps[i])) {
+                    return false;
+                }
+            }
+        }
+
+        if (obj1.transportInfo !== obj2.transportInfo) {
+            if (obj1.transportInfo === null) {
+                return false;
+            }
+            if (
+                obj1.transportInfo.name !== obj2.transportInfo.name
+                || obj1.transportInfo.routeColor !== obj2.transportInfo.routeColor
+                || obj1.transportInfo.routeTextColor !== obj2.transportInfo.routeTextColor
+                || obj1.transportInfo.directionName !== obj2.transportInfo.directionName
+            ) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * @param {Leg} obj
+     * @returns {Boolean}
+     */
+    equalsTo(obj) {
+        return Leg.equalsTo(this, obj);
+    }
+
     /**
      * @returns {object}
      */
@@ -1129,18 +1263,18 @@ class Leg {
             duration: this.duration,
             coords: this.coords.map(coords => coords.toCompressedJson())
         };
-        if (this.from.name) {
-            output.from.name = this.from.name;
-        }
-        if (this.to.name) {
-            output.to.name = this.to.name;
-        }
         if (this.startTime !== null) {
             output.startTime = this.startTime;
         }
         if (this.endTime !== null) {
             output.endTime = this.endTime;
         }
+        if (this.from.name !== null) {
+            output.from.name = this.from.name;
+        }
+        if (this.to.name !== null) {
+            output.to.name = this.to.name;
+        }
         if (this.transportInfo !== null) {
             output.transportInfo = this.transportInfo;
         }
@@ -1158,27 +1292,31 @@ class Leg {
     static fromJson(json) {
         const leg = new Leg();
         leg.mode = json.mode;
-        leg.from = { coords: Coordinates.fromCompressedJson(json.from.coords) };
-        leg.to = { coords: Coordinates.fromCompressedJson(json.to.coords) };
         leg.distance = json.distance;
         leg.duration = json.duration;
-        leg.coords = json.coords.map(Coordinates.fromCompressedJson);
-        if (json.from.name) {
-            leg.from.name = json.from.name;
-        }
-        if (json.to.name) {
-            leg.to.name = json.to.name;
-        }
-        if (json.startTime) {
+
+        if (typeof json.startTime === 'number') {
             leg.startTime = json.startTime;
         }
-        if (json.endTime) {
+        if (typeof json.endTime === 'number') {
             leg.endTime = json.endTime;
         }
-        if (json.transportInfo) {
+
+        leg.from = {
+            coords: Coordinates.fromCompressedJson(json.from.coords),
+            name: typeof json.from.name === 'string' ? json.from.name : null
+        };
+        leg.to = {
+            coords: Coordinates.fromCompressedJson(json.to.coords),
+            name: typeof json.to.name === 'string' ? json.to.name : null
+        };
+
+        leg.coords = json.coords.map(Coordinates.fromCompressedJson);
+
+        if (typeof json.transportInfo === 'object') {
             leg.transportInfo = json.transportInfo;
         }
-        if (json.steps) {
+        if (typeof json.steps === 'object') {
             leg.steps = json.steps.map(Step.fromJson);
         }
         return leg;
@@ -1266,14 +1404,14 @@ class Itinerary {
 
     get mode() {
         if (!this._mode) {
-            let isPublicTransport;
-            let isBicycle;
-            let isDriving;
+            let isPublicTransport = false;
+            let isBicycle = false;
+            let isDriving = false;
 
             this.legs.forEach((leg) => {
-                isPublicTransport = isPublicTransport || ['BUS', 'FUNICULAR', 'TRAM', 'TRAIN'].includes(leg.mode);
-                isBicycle = isBicycle || ['BIKE', 'BICYCLE'].includes(leg.mode);
-                isDriving = isDriving || leg.mode === 'CAR';
+                isPublicTransport = isPublicTransport || Constants$1.PUBLIC_TRANSPORT.includes(leg.mode);
+                isBicycle = isBicycle || leg.mode === Constants$1.ROUTING_MODE.BIKE;
+                isDriving = isDriving || leg.mode === Constants$1.ROUTING_MODE.CAR;
             });
 
             if (isPublicTransport) {
@@ -1381,6 +1519,42 @@ class Itinerary {
         return itinerary;
     }
 
+
+    /**
+     * @param {Itinerary} obj1
+     * @param {Itinerary} obj2
+     * @returns {Boolean}
+     */
+    static equalsTo(obj1, obj2) {
+        const intermediate = obj1.from.equalsTo(obj2.from)
+            && obj1.to.equalsTo(obj2.to)
+            && obj1.distance === obj2.distance
+            && obj1.duration === obj2.duration
+            && obj1.startTime === obj2.startTime
+            && obj1.endTime === obj2.endTime
+            && obj1.legs.length === obj2.legs.length;
+
+        if (!intermediate) {
+            return false;
+        }
+
+        for (let i = 0; i < obj1.legs.length; i++) {
+            if (!obj1.legs[i].equalsTo(obj2.legs[i])) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * @param {Itinerary} obj
+     * @returns {Boolean}
+     */
+    equalsTo(obj) {
+        return Itinerary.equalsTo(this, obj);
+    }
+
     /**
      * @returns {object}
      */
@@ -1413,10 +1587,10 @@ class Itinerary {
         itinerary.distance = json.distance;
         itinerary.duration = json.duration;
         itinerary.legs = json.legs.map(Leg.fromJson);
-        if (json.startTime) {
+        if (typeof json.startTime === 'number') {
             itinerary.startTime = json.startTime;
         }
-        if (json.endTime) {
+        if (typeof json.endTime === 'number') {
             itinerary.endTime = json.endTime;
         }
         return itinerary;
@@ -1455,6 +1629,18 @@ class WemapRouterOptions extends GraphRouterOptions {
 
 deg2rad(20);
 
+/* eslint-disable max-statements */
+
+/**
+ * Input mode correspondance
+ */
+const inputModeCorrespondance$2 = new Map();
+inputModeCorrespondance$2.set(Constants$1.ROUTING_MODE.CAR, 'driving');
+inputModeCorrespondance$2.set(Constants$1.ROUTING_MODE.WALK, 'walking');
+inputModeCorrespondance$2.set(Constants$1.ROUTING_MODE.BIKE, 'bike');
+inputModeCorrespondance$2.set(Constants$1.ROUTING_MODE.BUS, 'bus');
+inputModeCorrespondance$2.set(Constants$1.ROUTING_MODE.MULTI, 'walking');
+
 function createCommonjsModule(fn) {
   var module = { exports: {} };
 	return fn(module, module.exports), module.exports;
@@ -1623,6 +1809,109 @@ if (module.exports) {
 }
 });
 
+/* eslint-disable max-statements */
+
+/**
+ * Input mode correspondance
+ */
+const inputModeCorrespondance$1 = new Map();
+inputModeCorrespondance$1.set(Constants$1.ROUTING_MODE.CAR, 'CAR');
+inputModeCorrespondance$1.set(Constants$1.ROUTING_MODE.WALK, 'WALK');
+inputModeCorrespondance$1.set(Constants$1.ROUTING_MODE.BIKE, 'BICYCLE');
+inputModeCorrespondance$1.set(Constants$1.ROUTING_MODE.BUS, 'WALK,TRANSIT');
+inputModeCorrespondance$1.set(Constants$1.ROUTING_MODE.MULTI, 'WALK,TRANSIT');
+
+/* eslint-disable max-depth */
+
+/**
+ * Input mode correspondance
+ */
+const inputModeCorrespondance = new Map();
+inputModeCorrespondance.set(Constants$1.ROUTING_MODE.CAR, 'Car');
+inputModeCorrespondance.set(Constants$1.ROUTING_MODE.WALK, 'Walk');
+inputModeCorrespondance.set(Constants$1.ROUTING_MODE.BIKE, 'Bike');
+inputModeCorrespondance.set(Constants$1.ROUTING_MODE.BUS, 'PT');
+inputModeCorrespondance.set(Constants$1.ROUTING_MODE.MULTI, 'PT');
+
+
+/**
+ * List of all routing modes supported by the API
+ */
+const routingModeCorrespondance$1 = new Map();
+routingModeCorrespondance$1.set('WALK', Constants$1.ROUTING_MODE.WALK);
+routingModeCorrespondance$1.set('BICYCLE', Constants$1.ROUTING_MODE.BIKE);
+routingModeCorrespondance$1.set('TRAMWAY', Constants$1.ROUTING_MODE.TRAM);
+routingModeCorrespondance$1.set('METRO', Constants$1.ROUTING_MODE.METRO);
+routingModeCorrespondance$1.set('FUNICULAR', Constants$1.ROUTING_MODE.FUNICULAR);
+routingModeCorrespondance$1.set('BUS', Constants$1.ROUTING_MODE.BUS);
+routingModeCorrespondance$1.set('COACH', Constants$1.ROUTING_MODE.BUS);
+routingModeCorrespondance$1.set('SCHOOL', Constants$1.ROUTING_MODE.BUS);
+routingModeCorrespondance$1.set('BUS_PMR', Constants$1.ROUTING_MODE.BUS);
+routingModeCorrespondance$1.set('MINIBUS', Constants$1.ROUTING_MODE.BUS);
+routingModeCorrespondance$1.set('TROLLEY_BUS', Constants$1.ROUTING_MODE.BUS);
+routingModeCorrespondance$1.set('TAXIBUS', Constants$1.ROUTING_MODE.BUS);
+routingModeCorrespondance$1.set('SHUTTLE', Constants$1.ROUTING_MODE.BUS);
+routingModeCorrespondance$1.set('TRAIN', Constants$1.ROUTING_MODE.TRAIN);
+routingModeCorrespondance$1.set('HST', Constants$1.ROUTING_MODE.TRAIN);
+routingModeCorrespondance$1.set('LOCAL_TRAIN', Constants$1.ROUTING_MODE.TRAIN);
+routingModeCorrespondance$1.set('AIR', Constants$1.ROUTING_MODE.AIRPLANE);
+routingModeCorrespondance$1.set('FERRY', Constants$1.ROUTING_MODE.BOAT);
+routingModeCorrespondance$1.set('TAXI', Constants$1.ROUTING_MODE.UNKNOWN);
+routingModeCorrespondance$1.set('CAR_POOL', Constants$1.ROUTING_MODE.UNKNOWN);
+routingModeCorrespondance$1.set('PRIVATE_VEHICLE', Constants$1.ROUTING_MODE.CAR);
+routingModeCorrespondance$1.set('SCOOTER', Constants$1.ROUTING_MODE.MOTO);
+
+/**
+ * List of all plan trip supported by the API
+ * Routing mode UNKNOWN means that the itinerary will not be parsed by the router
+ */
+const planTripType = new Map();
+planTripType.set(0, Constants$1.ROUTING_MODE.BUS);
+planTripType.set(1, Constants$1.ROUTING_MODE.WALK);
+planTripType.set(2, Constants$1.ROUTING_MODE.BIKE);
+planTripType.set(3, Constants$1.ROUTING_MODE.CAR);
+planTripType.set(4, Constants$1.ROUTING_MODE.UNKNOWN);
+planTripType.set(5, Constants$1.ROUTING_MODE.UNKNOWN);
+planTripType.set(6, Constants$1.ROUTING_MODE.UNKNOWN);
+planTripType.set(7, Constants$1.ROUTING_MODE.UNKNOWN);
+planTripType.set(8, Constants$1.ROUTING_MODE.UNKNOWN);
+planTripType.set(9, Constants$1.ROUTING_MODE.UNKNOWN);
+planTripType.set(10, Constants$1.ROUTING_MODE.UNKNOWN);
+planTripType.set(11, Constants$1.ROUTING_MODE.UNKNOWN);
+planTripType.set(12, Constants$1.ROUTING_MODE.UNKNOWN);
+planTripType.set(13, Constants$1.ROUTING_MODE.UNKNOWN);
+planTripType.set(14, Constants$1.ROUTING_MODE.UNKNOWN);
+
+/* eslint-disable max-statements */
+
+/**
+ * List of all modes supported by the API
+ * http://doc.navitia.io/#physical-mode
+ */
+
+const routingModeCorrespondance = new Map();
+routingModeCorrespondance.set('Air', Constants$1.ROUTING_MODE.AIRPLANE);
+routingModeCorrespondance.set('Boat', Constants$1.ROUTING_MODE.BOAT);
+routingModeCorrespondance.set('Bus', Constants$1.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('BusRapidTransit', Constants$1.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('Coach', Constants$1.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('Ferry', Constants$1.ROUTING_MODE.FERRY);
+routingModeCorrespondance.set('Funicular', Constants$1.ROUTING_MODE.FUNICULAR);
+routingModeCorrespondance.set('LocalTrain', Constants$1.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('LongDistanceTrain', Constants$1.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('Metro', Constants$1.ROUTING_MODE.METRO);
+routingModeCorrespondance.set('Métro', Constants$1.ROUTING_MODE.METRO);
+routingModeCorrespondance.set('RailShuttle', Constants$1.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('RapidTransit', Constants$1.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('Shuttle', Constants$1.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('SuspendedCableCar', Constants$1.ROUTING_MODE.FUNICULAR);
+routingModeCorrespondance.set('Taxi', Constants$1.ROUTING_MODE.TAXI);
+routingModeCorrespondance.set('Train', Constants$1.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('RER', Constants$1.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('Tramway', Constants$1.ROUTING_MODE.TRAM);
+routingModeCorrespondance.set('walking', Constants$1.ROUTING_MODE.WALK);
+routingModeCorrespondance.set('bike', Constants$1.ROUTING_MODE.BIKE);
+
 const DEFAULT_RELATIVE_NOISES = {
     acc: 0.5,
     gyr: 0.3
@@ -2685,7 +2974,7 @@ class StepDetector extends Provider {
     // Linear acceleration in ENU
     static computeLinearAcceleration(quaternion, acc) {
         const linearAcc = Quaternion.rotate(Quaternion.inverse(quaternion), acc);
-        linearAcc[2] -= Constants$1.EARTH_GRAVITY;
+        linearAcc[2] -= Constants$2.EARTH_GRAVITY;
         return linearAcc;
     }
 }