@wemap/routers 6.0.2 → 6.2.0

package/index.js

@@ -19,6 +19,7 @@ export * as OsrmUtils from './src/osrm/OsrmUtils.js';
 export * as OtpUtils from './src/otp/OtpUtils.js';
 export * as CitywayUtils from './src/cityway/CitywayUtils.js';
 export * as DeutscheBahnRouterUtils from './src/deutsche-bahn/DeutscheBahnRouterUtils.js';
+export * as IdfmUtils from './src/idfm/IdfmUtils.js';
 
 /* Others */
 export { default as ItineraryInfoManager } from './src/ItineraryInfoManager.js';

package/package.json

@@ -11,7 +11,7 @@
         "directory": "packages/routers"
     },
     "name": "@wemap/routers",
-    "version": "6.0.2",
+    "version": "6.2.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -31,5 +31,5 @@
         "@wemap/maths": "^6.0.0",
         "@wemap/osm": "^6.0.0"
     },
-    "gitHead": "8851e7c4537556e51a3f0c52de9fc80d5e37ad73"
+    "gitHead": "52637f96a68517d6bae4f531ae980ea5eba372ba"
 }

package/src/Constants.js

@@ -0,0 +1,30 @@
+const Constants = {};
+
+Constants.ROUTING_MODE = {
+    AIRPLANE: 'AIRPLANE',
+    BOAT: 'BOAT',
+    BIKE: 'BIKE',
+    BUS: 'BUS',
+    CAR: 'CAR',
+    FERRY: 'FERRY',
+    FUNICULAR: 'FUNICULAR',
+    METRO: 'METRO',
+    TRAIN: 'TRAIN',
+    TAXI: 'TAXI',
+    TRAM: 'TRAM',
+    WALK: 'WALK'
+};
+
+Constants.PUBLIC_TRANSPORT = [
+    Constants.ROUTING_MODE.AIRPLANE,
+    Constants.ROUTING_MODE.BOAT,
+    Constants.ROUTING_MODE.BUS,
+    Constants.ROUTING_MODE.FERRY,
+    Constants.ROUTING_MODE.FUNICULAR,
+    Constants.ROUTING_MODE.METRO,
+    Constants.ROUTING_MODE.TRAIN,
+    Constants.ROUTING_MODE.TAXI,
+    Constants.ROUTING_MODE.TRAM
+];
+
+export default Constants;

package/src/Utils.js

@@ -11,6 +11,27 @@ export function getDurationFromLength(length, speed = 5) {
     return length / (speed * 1000 / 3600);
 }
 
+/**
+ * Create and return a date with a given timezone
+ * @param {number} year
+ * @param {number} month
+ * @param {number} day
+ * @param {number} hours
+ * @param {number} minutes
+ * @param {number} seconds
+ * @param {string} timeZone - timezone name (e.g. 'Europe/Paris')
+ */
+export function dateWithTimeZone(year, month, day, hour, minute, second, timeZone = 'Europe/Paris') {
+    const date = new Date(Date.UTC(year, month, day, hour, minute, second));
+
+    const utcDate = new Date(date.toLocaleString('en-US', { timeZone: 'UTC' }));
+    const tzDate = new Date(date.toLocaleString('en-US', { timeZone: timeZone }));
+    const offset = utcDate.getTime() - tzDate.getTime();
+
+    date.setTime(date.getTime() + offset);
+
+    return date;
+}
 
 /**
  * @param {Itinerary} itinerary

package/src/cityway/CitywayUtils.js

@@ -7,7 +7,16 @@ import Itinerary from '../model/Itinerary.js';
 import Leg from '../model/Leg.js';
 import RouterResponse from '../model/RouterResponse.js';
 import Step from '../model/Step.js';
-import { generateStepsMetadata } from '../Utils.js';
+import { generateStepsMetadata, dateWithTimeZone } from '../Utils.js';
+import Constants from '../Constants.js';
+
+const routingModeCorrespondance = new Map();
+routingModeCorrespondance.set('WALK', Constants.ROUTING_MODE.WALK);
+routingModeCorrespondance.set('BICYCLE', Constants.ROUTING_MODE.BIKE);
+routingModeCorrespondance.set('BUS', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('TRAMWAY', Constants.ROUTING_MODE.TRAM);
+routingModeCorrespondance.set('FUNICULAR', Constants.ROUTING_MODE.FUNICULAR);
+routingModeCorrespondance.set('TRAIN', Constants.ROUTING_MODE.TRAIN);
 
 /**
  * @param {object} json
@@ -25,11 +34,15 @@ function jsonDateToTimestamp(jsonDate) {
     const [dateStr, timeStr] = jsonDate.split(' ');
     const [dayStr, monthStr, yearStr] = dateStr.split('/');
     const [hoursStr, minutesStr, secondsStr] = timeStr.split(':');
-    const date = new Date(
-        Number(yearStr), Number(monthStr) - 1, Number(dayStr),
-        Number(hoursStr), Number(minutesStr), Number(secondsStr)
-    );
-    return date.getTime();
+
+    return dateWithTimeZone(
+        Number(yearStr),
+        Number(monthStr) - 1,
+        Number(dayStr),
+        Number(hoursStr),
+        Number(minutesStr),
+        Number(secondsStr)
+    ).getTime();
 }
 
 /**
@@ -113,13 +126,13 @@ export function createRouterResponseFromJson(json) {
 
             const leg = new Leg();
 
-            leg.mode = jsonLeg.TransportMode;
+            leg.mode = routingModeCorrespondance.get(jsonLeg.TransportMode);
             leg.duration = parseDuration(jsonLeg.Duration);
             leg.startTime = jsonDateToTimestamp(jsonLeg.Departure.Time);
             leg.endTime = jsonDateToTimestamp(jsonLeg.Arrival.Time);
             leg.coords = [];
 
-            if (leg.mode === 'WALK' || leg.mode === 'BICYCLE') {
+            if (leg.mode === Constants.ROUTING_MODE.WALK || leg.mode === Constants.ROUTING_MODE.BIKE) {
 
                 leg.from = {
                     name: jsonLeg.Departure.Site.Name,
@@ -160,7 +173,7 @@ export function createRouterResponseFromJson(json) {
                     leg.steps.push(step);
                 }
 
-            } else if (leg.mode === 'BUS' || leg.mode === 'TRAMWAY' || leg.mode === 'FUNICULAR' || leg.mode === 'TRAIN') {
+            } else if (Constants.PUBLIC_TRANSPORT.includes(leg.mode)) {
 
                 leg.from = {
                     name: jsonLeg.Departure.StopPlace.Name,
@@ -172,8 +185,7 @@ export function createRouterResponseFromJson(json) {
                 };
 
                 let transportName = jsonLeg.Line.Number;
-                if (leg.mode === 'TRAMWAY') {
-                    leg.mode = 'TRAM';
+                if (leg.mode === Constants.ROUTING_MODE.TRAM) {
                     // In order to remove the "TRAM " prefix.
                     transportName = transportName.substr(5);
                 }

package/src/cityway/CitywayUtils.spec.js

@@ -36,14 +36,14 @@ describe('CitywayUtils - createRouterResponseFromJson', () => {
         expect(itinerary1.duration).equal(2379);
         expect(itinerary1.mode).equal('PT');
         // Do not work because of the input time format
-        // expect(itinerary1.startTime).equal(1620659156000);
-        // expect(itinerary1.endTime).equal(1620661535000);
+        expect(itinerary1.startTime).equal(1620659156000);
+        expect(itinerary1.endTime).equal(1620661535000);
         expect(itinerary1.legs.length).equal(5);
 
         const itinerary1leg1 = itinerary1.legs[0];
         // Do not work because of the input time format
-        // expect(itinerary1leg1.startTime).equal(1620659156000);
-        // expect(itinerary1leg1.endTime).equal(1620659340000);
+        expect(itinerary1leg1.startTime).equal(1620659156000);
+        expect(itinerary1leg1.endTime).equal(1620659340000);
         expect(itinerary1leg1.distance).to.be.closeTo(200.14, 0.1);
         expect(itinerary1leg1.mode).equal('WALK');
         expect(itinerary1leg1.transportInfo).is.null;
@@ -94,7 +94,7 @@ describe('CitywayUtils - createRouterResponseFromJson', () => {
         verifyRouterResponseData(routerResponse);
 
         expect(routerResponse.itineraries[0].mode).equal('BIKE');
-        expect(routerResponse.itineraries[0].legs[0].mode).equal('BICYCLE');
+        expect(routerResponse.itineraries[0].legs[0].mode).equal('BIKE');
     });
 
     it('RouterResponse - 5', () => {

package/src/idfm/IdfmUtils.js

@@ -0,0 +1,247 @@
+/* eslint-disable max-statements */
+import { Coordinates, Utils as GeoUtils } from '@wemap/geo';
+
+import Itinerary from '../model/Itinerary.js';
+import Leg from '../model/Leg.js';
+import RouterResponse from '../model/RouterResponse.js';
+import Step from '../model/Step.js';
+import { generateStepsMetadata, dateWithTimeZone } from '../Utils.js';
+import Constants from '../Constants.js';
+
+/**
+ * List of all modes supported by the API
+ * http://doc.navitia.io/#physical-mode
+ */
+
+const routingModeCorrespondance = new Map();
+routingModeCorrespondance.set('Air', Constants.ROUTING_MODE.AIRPLANE);
+routingModeCorrespondance.set('Boat', Constants.ROUTING_MODE.BOAT);
+routingModeCorrespondance.set('Bus', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('BusRapidTransit', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('Coach', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('Ferry', Constants.ROUTING_MODE.FERRY);
+routingModeCorrespondance.set('Funicular', Constants.ROUTING_MODE.FUNICULAR);
+routingModeCorrespondance.set('LocalTrain', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('LongDistanceTrain', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('Metro', Constants.ROUTING_MODE.METRO);
+routingModeCorrespondance.set('Métro', Constants.ROUTING_MODE.METRO);
+routingModeCorrespondance.set('RailShuttle', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('RapidTransit', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('Shuttle', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('SuspendedCableCar', Constants.ROUTING_MODE.FUNICULAR);
+routingModeCorrespondance.set('Taxi', Constants.ROUTING_MODE.TAXI);
+routingModeCorrespondance.set('Train', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('Tramway', Constants.ROUTING_MODE.TRAM);
+routingModeCorrespondance.set('walking', Constants.ROUTING_MODE.WALK);
+routingModeCorrespondance.set('bike', Constants.ROUTING_MODE.BIKE);
+
+/**
+ * @param {object} json
+ * @returns {Coordinates}
+ */
+export function jsonToCoordinates(json) {
+    return new Coordinates(Number(json.lat), Number(json.lon));
+}
+
+function getSectionCoords(section) {
+    const from = section.from.stop_point ? jsonToCoordinates(section.from.stop_point.coord) : jsonToCoordinates(section.from.address.coord);
+    const to = section.to.stop_point ? jsonToCoordinates(section.to.stop_point.coord) : jsonToCoordinates(section.to.address.coord);
+
+    return {
+        from,
+        to
+    };
+}
+
+/**
+ * Get last item of a given array
+ * @param {Array} array
+ * @returns {any}
+ */
+function last(array) {
+    return array[array.length - 1];
+}
+
+/**
+ * Since the IDFM API does not provide coords for each step, we need to compute them
+ * We trim the coordinates of the leg with the distance of each step and keep the last result as the coords of the step
+ * @param {Leg} leg
+ */
+function findStepsCoord(leg) {
+    const { steps, coords } = leg;
+
+    const duplicatedCoords = [...coords];
+    let previousStep = steps[0];
+    let accumulatedIndex = 0;
+
+    for (const [idx, step] of steps.entries()) {
+        let newCoords;
+
+        if (idx === 0) {
+            step._idCoordsInLeg = 0;
+            newCoords = coords[0];
+        } else if (idx === steps.length - 1) {
+            step._idCoordsInLeg = coords.length - 1;
+            newCoords = last(coords);
+        } else {
+            const result = GeoUtils.trimRoute(duplicatedCoords, duplicatedCoords[0], previousStep.distance);
+            accumulatedIndex += result.length - 1;
+
+            duplicatedCoords.splice(0, result.length - 1);
+
+            step._idCoordsInLeg = accumulatedIndex;
+
+            newCoords = last(result);
+
+            coords[step._idCoordsInLeg] = newCoords;
+        }
+
+        step.coords = newCoords;
+
+        previousStep = step;
+    }
+}
+
+/**
+ * @param {string} stringDate (e.g. 20211117T104516)
+ * @returns {number}
+ */
+function dateStringToTimestamp(stringDate, timeZone) {
+    const yearStr = stringDate.substr(0, 4);
+    const monthStr = stringDate.substr(4, 2);
+    const dayStr = stringDate.substr(6, 2);
+    const hoursStr = stringDate.substr(9, 2);
+    const minutesStr = stringDate.substr(11, 2);
+    const secondsStr = stringDate.substr(13, 2);
+
+    return dateWithTimeZone(
+        Number(yearStr),
+        Number(monthStr) - 1,
+        Number(dayStr),
+        Number(hoursStr),
+        Number(minutesStr),
+        Number(secondsStr),
+        timeZone
+    ).getTime();
+}
+
+/**
+ * Generate multi itineraries from OTP JSON
+ * @param {object} json JSON file provided by OTP.
+ * @returns {?RouterResponse}
+ */
+export function createRouterResponseFromJson(json) {
+
+    if (!json || !json.journeys) {
+        return null;
+    }
+
+    const routerResponse = new RouterResponse();
+    routerResponse.routerName = 'idfm';
+
+    routerResponse.from = getSectionCoords(json.journeys[0].sections[0]).from;
+    routerResponse.to = getSectionCoords(last(json.journeys[0].sections)).to;
+
+    const timeZone = json.context.timezone;
+
+    for (const jsonItinerary of json.journeys) {
+
+        const itinerary = new Itinerary();
+
+        itinerary.duration = jsonItinerary.duration;
+        itinerary.startTime = dateStringToTimestamp(jsonItinerary.departure_date_time, timeZone);
+        itinerary.endTime = dateStringToTimestamp(jsonItinerary.arrival_date_time, timeZone);
+        itinerary.from = routerResponse.from;
+        itinerary.to = routerResponse.to;
+        itinerary.distance = 0;
+
+        routerResponse.itineraries.push(itinerary);
+
+        for (const jsonSection of jsonItinerary.sections) {
+
+            if (jsonSection.type === 'waiting' || jsonSection.type === 'transfer') {
+                continue;
+            }
+
+            const leg = new Leg();
+            let existingCoords = [];
+            const { from, to } = getSectionCoords(jsonSection);
+
+            leg.distance = 0;
+            leg.mode = routingModeCorrespondance.get(jsonSection.mode);
+            leg.duration = jsonSection.duration;
+            leg.startTime = dateStringToTimestamp(jsonSection.departure_date_time, timeZone);
+            leg.endTime = dateStringToTimestamp(jsonSection.arrival_date_time, timeZone);
+
+            leg.from = {
+                name: jsonSection.from.name,
+                coords: from
+            };
+
+            leg.to = {
+                name: jsonSection.to.name,
+                coords: to
+            };
+
+            // A section can have multiple same coordinates, we need to remove them
+            leg.coords = jsonSection.geojson.coordinates.reduce((acc, [lon, lat]) => {
+                if (!existingCoords.includes(`${lon}-${lat}`)) {
+                    existingCoords = existingCoords.concat(`${lon}-${lat}`);
+                    acc.push(new Coordinates(lat, lon));
+                }
+
+                return acc;
+            }, []);
+
+            leg.steps = [];
+
+            if (jsonSection.path) {
+                for (const jsonPathLink of jsonSection.path) {
+                    const step = new Step();
+
+                    step.levelChange = null;
+
+                    step.name = jsonPathLink.name;
+                    step.distance = jsonPathLink.length;
+
+                    leg.distance += step.distance;
+                    leg.steps.push(step);
+                }
+
+                findStepsCoord(leg);
+            }
+
+            if (jsonSection.type === 'public_transport') {
+                leg.transportInfo = {
+                    name: jsonSection.display_informations.code,
+                    routeColor: jsonSection.display_informations.color,
+                    routeTextColor: jsonSection.display_informations.text_color,
+                    directionName: jsonSection.display_informations.direction
+                };
+
+                leg.mode = routingModeCorrespondance.get(jsonSection.display_informations.physical_mode);
+
+                const legStep = new Step();
+                legStep.coords = leg.coords[0];
+                legStep._idCoordsInLeg = 0;
+                legStep.name = leg.transportInfo.directionName;
+                legStep.levelChange = null;
+                legStep.distance = jsonSection.geojson.properties[0].length;
+
+                leg.steps = [legStep];
+            }
+
+            itinerary.distance += leg.distance;
+
+            itinerary.legs.push(leg);
+
+        }
+
+        // All legs have to be parsed before computing steps metadata
+        generateStepsMetadata(itinerary);
+    }
+
+    return routerResponse;
+}
+
+

package/src/idfm/IdfmUtils.spec.js

@@ -0,0 +1,64 @@
+/* eslint-disable max-statements */
+import chai from 'chai';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { Coordinates } from '@wemap/geo';
+
+import { createRouterResponseFromJson } from './IdfmUtils.js';
+
+import { verifyRouterResponseData } from '../model/RouterResponse.type.spec.js';
+
+
+const { expect } = chai;
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+describe('IdfmUtils - createRouterResponseFromJson', () => {
+
+    it('RouterResponse - 1', () => {
+
+        const filePath = path.resolve(__dirname, '../../assets/itinerary-paris-idfm.json');
+        const fileString = fs.readFileSync(filePath, 'utf8');
+        const json = JSON.parse(fileString);
+
+        const routerResponse = createRouterResponseFromJson(json);
+        verifyRouterResponseData(routerResponse);
+
+        expect(routerResponse.routerName).equal('idfm');
+        expect(routerResponse.itineraries.length).equal(5);
+        expect(routerResponse.from.equalsTo(new Coordinates(48.875877, 2.301357))).true;
+        expect(routerResponse.to.equalsTo(new Coordinates(48.877877, 2.351929))).true;
+
+        const itinerary1 = routerResponse.itineraries[0];
+        expect(itinerary1.distance).to.be.closeTo(1242, 1);
+        expect(itinerary1.duration).equal(1842);
+        expect(itinerary1.mode).equal('PT');
+        // Do not work because of the input time format
+        expect(itinerary1.startTime).equal(1637596640000);
+        expect(itinerary1.endTime).equal(1637598482000);
+        expect(itinerary1.legs.length).equal(3);
+
+        const itinerary1leg1 = itinerary1.legs[0];
+        // Do not work because of the input time format
+        expect(itinerary1leg1.startTime).equal(1637596640000);
+        expect(itinerary1leg1.endTime).equal(1637597040000);
+        expect(itinerary1leg1.distance).to.be.closeTo(468, 1);
+        expect(itinerary1leg1.mode).equal('WALK');
+        expect(itinerary1leg1.transportInfo).is.null;
+        expect(itinerary1leg1.from.name).equal('8 Avenue Bertie Albrecht (Paris)');
+        expect(itinerary1leg1.from.coords.equalsTo(new Coordinates(48.875877, 2.301357))).true;
+        expect(itinerary1leg1.to.name).equal('Ternes (Paris)');
+        expect(itinerary1leg1.to.coords.equalsTo(new Coordinates(48.878228, 2.298113))).true;
+
+        const itinerary1leg2 = itinerary1.legs[1];
+        expect(itinerary1leg2.mode).equal('METRO');
+        expect(itinerary1leg2.transportInfo).is.not.null;
+        expect(itinerary1leg2.transportInfo.name).equal('2');
+        expect(itinerary1leg2.transportInfo.routeColor).equal('003CA6');
+        expect(itinerary1leg2.transportInfo.routeTextColor).equal('FFFFFF');
+        expect(itinerary1leg2.transportInfo.directionName).equal('Nation (Paris)');
+    });
+});
+

package/src/model/Itinerary.js

@@ -2,6 +2,7 @@
 import { Coordinates, Network } from '@wemap/geo';
 import Leg from './Leg.js';
 import Step from './Step.js';
+import Constants from '../Constants.js';
 import { getDurationFromLength } from '../Utils.js';
 
 /**
@@ -78,9 +79,9 @@ class Itinerary {
             let isDriving;
 
             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.PUBLIC_TRANSPORT.includes(leg.mode);
+                isBicycle = isBicycle || leg.mode === Constants.ROUTING_MODE.BIKE;
+                isDriving = isDriving || leg.mode === Constants.ROUTING_MODE.CAR;
             });
 
             if (isPublicTransport) {

package/src/model/Leg.js

@@ -1,10 +1,11 @@
 import { Coordinates, Network } from '@wemap/geo';
 
 import Step from './Step.js';
+import Constants from '../Constants.js';
 
 class Leg {
 
-    /** @type {!string} can be WALK, BIKE, BUS, TRAM, CAR, FUNICULAR */
+    /** @type {!string} can be values in Constants.ROUTING_MODE */
     mode;
 
     /** @type {!number} */
@@ -34,6 +35,10 @@ class Leg {
     /** @type {?(Step[])} */
     steps = null;
 
+    isPublicTransport() {
+        return Constants.PUBLIC_TRANSPORT.includes(this.mode);
+    }
+
     /**
      * @returns {Network}
      */