@wemap/routers 12.8.5 → 12.8.6

package/index.ts

@@ -33,6 +33,7 @@ export { default as OtpRemoteRouter } from './src/remote/otp/OtpRemoteRouter.js'
 export { default as CitywayRemoteRouter } from './src/remote/cityway/CitywayRemoteRouter.js';
 export { default as DeutscheBahnRemoteRouter } from './src/remote/deutsche-bahn/DeutscheBahnRemoteRouter.js';
 export { default as IdfmRemoteRouter } from './src/remote/idfm/IdfmRemoteRouter.js';
+export { default as GeoveloRemoteRouter } from './src/remote/geovelo/GeoveloRemoteRouter.js';
 export { default as WemapMultiRemoteRouter } from './src/remote/wemap-multi/WemapMultiRemoteRouter.js';
 export { default as RemoteRouterManager, type RemoteRouterName, type RoutingFallbackStrategy } from './src/remote/RemoteRouterManager.js';
 

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/routers"
     },
     "name": "@wemap/routers",
-    "version": "12.8.5",
+    "version": "12.8.6",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -52,5 +52,5 @@
         },
         "./helpers/*": "./helpers/*"
     },
-    "gitHead": "3acfe134ade4d53dcec76009c7c421573c9f211c"
+    "gitHead": "9b7c7370f24c721dc136b32470ff96ef9df99042"
 }

package/src/remote/geovelo/GeoveloRemoteRouter.spec.ts

@@ -0,0 +1,54 @@
+/* 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 { verifyStepsCoherence } from '../../model/Itinerary.spec.js';
+import { areTransitAndTravelModeConsistent } from '../../model/TransitMode.js';
+import GeoveloRemoteRouter from './GeoveloRemoteRouter.js';
+
+const { expect } = chai;
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const assetsPath = path.resolve(__dirname, '../../../assets');
+
+describe.only('GeoveloRouter - parseResponse', () => {
+
+    it('Itineraries - 1', () => {
+
+        const filePath = path.resolve(assetsPath, 'geovelo-montpellier.json');
+        const fileString = fs.readFileSync(filePath, 'utf8');
+        const json = JSON.parse(fileString);
+
+        const itineraries = GeoveloRemoteRouter.parseResponse(json);
+        itineraries.forEach(verifyStepsCoherence);
+
+        expect(itineraries.length).equal(3);
+
+        const itinerary1 = itineraries[0];
+        expect(itinerary1.origin.equals(new Coordinates(43.596949, 3.877772))).true;
+        expect(itinerary1.destination.equals(new Coordinates(43.609609, 3.914684))).true;
+        expect(itinerary1.distance).to.be.closeTo(4029, 1);
+        expect(itinerary1.duration).equal(1053);
+        expect(itinerary1.transitMode).equal('BIKE');
+        // Do not work because of the input time format
+        expect(itinerary1.startTime).equal(1643623200000);
+        expect(itinerary1.endTime).equal(1643624253000);
+        expect(itinerary1.legs.length).equal(1);
+
+        expect(areTransitAndTravelModeConsistent(itinerary1.transitMode, 'BIKE')).is.true;
+
+        const itinerary1leg1 = itinerary1.legs[0];
+        // Do not work because of the input time format
+        expect(itinerary1leg1.startTime).equal(1643623200000);
+        expect(itinerary1leg1.endTime).equal(1643624253000);
+        expect(itinerary1leg1.distance).to.be.closeTo(4029, 1);
+        expect(itinerary1leg1.transitMode).equal('BIKE');
+        expect(itinerary1leg1.transportInfo).is.null;
+        expect(itinerary1leg1.start.coords.distanceTo(new Coordinates(43.596949, 3.877772))).to.be.closeTo(0, 1);
+        expect(itinerary1leg1.end.coords.distanceTo(new Coordinates(43.609609, 3.914684))).to.be.closeTo(0, 1);
+    });
+});

package/src/remote/geovelo/GeoveloRemoteRouter.ts

@@ -0,0 +1,290 @@
+/* eslint-disable max-statements */
+import polyline from '@mapbox/polyline';
+import { Coordinates } from '@wemap/geo';
+
+import Itinerary from '../../model/Itinerary.js';
+import Leg, { TransportInfo } from '../../model/Leg.js';
+import StepsBuilder from '../../model/StepsBuilder.js';
+import RemoteRouter from '../RemoteRouter.js';
+import type { TransitMode } from '../../model/TransitMode.js';
+import { RouterRequest } from '../../model/RouterRequest.js';
+import { RemoteRoutingError } from '../../RoutingError.js';
+
+type DistanceDetails = {
+    total: number;
+    normalRoads: number;
+    recommendedRoads: number;
+    discouragedRoads: number;
+    cycleway: number;
+    greenway: number;
+    lane: number;
+    livingstreet: number;
+    sharebusway: number;
+    footway: number;
+    pedestrian: number;
+    opposite: number;
+    steps: number;
+    zone30: number;
+    residential: number;
+};
+
+type Waypoint = {
+    longitude: number;
+    latitude: number;
+    title?: string | null;
+};
+
+type Instruction = Array<string | number>;
+
+type SectionWithInstructions = {
+    transportMode: 'BIKE' | 'PEDESTRIAN';
+    duration: number;
+    waypointsIndices: number[] | null;
+    geometry: string;
+    estimatedDatetimeOfDeparture: string;
+    estimatedDatetimeOfArrival: string;
+    details: SectionDetails;
+    waypoints: Waypoint[];
+};
+
+type SectionDetails = {
+    distances: DistanceDetails;
+    instructions: Instruction[];
+    profile: string;
+    direction: string;
+    verticalGain: number;
+    verticalLoss: number;
+    calories: number;
+    elevations: string | null;
+    ridesets: any[];
+    averageSpeed: number;
+    bikeType: string;
+};
+
+type Route = {
+    sections: SectionWithInstructions[];
+    distances: {
+        total: number;
+        normalRoads: number;
+        recommendedRoads: number;
+        discouragedRoads: number;
+    };
+    title: string;
+    waypoints: Waypoint[];
+    estimatedDatetimeOfDeparture: string;
+    estimatedDatetimeOfArrival: string;
+    duration: number;
+    id: string;
+};
+
+type Routes = Route[];
+
+type QueryParams = {
+    instructions: boolean;
+    elevations: boolean;
+    geometry: boolean;
+    single_result: boolean;
+    bike_stations: boolean;
+    objects_as_ids: boolean;
+    merge_instructions: boolean;
+    show_pushing_bike_instructions: boolean;
+}
+
+type RequestBodyParams = {
+    datetimeOfDeparture?: string;
+    datetimeOfArrival?: string;
+    bikeDetails?: {
+        profile: string;
+        bikeType: string;
+        averageSpeed: number;
+        eBike: boolean;
+        bikeStations: Array<{ from: number; to: number }>;
+    };
+    transportModes: Array<'BIKE' | 'PEDESTRIAN'>;
+    waypoints: Waypoint[];
+}
+
+function unpackJSON(data: any[][]) {
+    const headers = data[0];
+
+    return data.slice(1).map(row => {
+        const obj: any = {};
+        headers.forEach((header, index) => {
+            obj[header] = row[index];
+        });
+        return obj;
+    });
+}
+
+const transitModeCorrespondance = new Map<string, TransitMode>();
+transitModeCorrespondance.set('BIKE', 'BIKE');
+transitModeCorrespondance.set('PEDESTRIAN', 'WALK');
+
+const apiKey = 'qWHj6ax6DMttG8DX6tH9CQARaiTgQ1Di';
+
+function waypointToCoordinates(waypoint: Waypoint) {
+    return new Coordinates(waypoint.latitude, waypoint.longitude);
+}
+
+function last<T>(array: T[]) {
+    return array[array.length - 1];
+}
+
+/**
+ * Singleton.
+ */
+class GeoveloRemoteRouter extends RemoteRouter {
+
+    /**
+     * @override
+     */
+    get rname() { return 'geovelo' as const; }
+
+
+    async getItineraries(endpointUrl: string, routerRequest: RouterRequest) {
+        const queryParams = this.getQueryParams();
+        const bodyParams = this.getBodyParams(routerRequest);
+
+        const url = new URL(endpointUrl);
+
+        for (const [key, value] of Object.entries(queryParams)) {
+            url.searchParams.append(key, value.toString());
+        }
+
+        const res = await (fetch(url, {
+            method: 'POST',
+            headers: { apiKey },
+            body: JSON.stringify(bodyParams)
+        }).catch(() => {
+            throw RemoteRoutingError.unreachableServer(this.rname, url.toString());
+        }));
+
+
+        const jsonResponse: Routes = await res.json().catch(() => {
+            throw RemoteRoutingError.responseNotParsing(this.rname, url.toString());
+        });
+
+        // When Geovélo failed to calculate an itinerary (ie. start or end
+        // point is far from network), it respond with empty routes
+        if (!jsonResponse || jsonResponse.length === 0) {
+            throw RemoteRoutingError.notFound(this.rname, 'No itineraries found.');
+        }
+
+        const itineraries = this.parseResponse(jsonResponse);
+
+        return itineraries;
+    }
+
+    getQueryParams(): QueryParams {
+        return {
+            instructions: true,
+            elevations: false,
+            geometry: true,
+            single_result: false,
+            bike_stations: false,
+            objects_as_ids: false,
+            merge_instructions: true,
+            show_pushing_bike_instructions: false
+        };
+    }
+
+    getBodyParams(routerRequest: RouterRequest): RequestBodyParams {
+        const { origin, destination, waypoints } = routerRequest;
+        let computedWaypoints: Waypoint[] = [];
+        if (waypoints && waypoints.length > 1) {
+            computedWaypoints = waypoints.map((waypoint) => ({
+                longitude: waypoint.longitude,
+                latitude: waypoint.latitude
+            }));
+        } else {
+            computedWaypoints = [
+                { latitude: origin.latitude, longitude: origin.longitude },
+                { latitude: destination.latitude, longitude: destination.longitude }
+            ]
+        }
+
+        return {
+            transportModes: ['BIKE'],
+            waypoints: computedWaypoints
+        };
+    }
+
+    parseResponse(json: Routes) {
+        if (!json || !json.length) {
+            throw RemoteRoutingError.notFound(this.rname);
+        }
+
+        const itineraries = [];
+
+        for (const route of json) {
+
+            const legs = [];
+
+            for (const section of route.sections) {
+                const from = waypointToCoordinates(section.waypoints[0]);
+                const to = waypointToCoordinates(last(section.waypoints));
+                const geometry = polyline.toGeoJSON(section.geometry, 6);
+
+                // A section can have multiple same coordinates, we need to remove them
+                let existingCoords: string[] = [];
+                const legCoords = geometry.coordinates.reduce((acc, [lon, lat]) => {
+                    if (!existingCoords.includes(`${lon}-${lat}`)) {
+                        existingCoords = existingCoords.concat(`${lon}-${lat}`);
+                        acc.push(new Coordinates(lat, lon));
+                    }
+                    return acc;
+                }, [] as Coordinates[]);
+
+                const stepsBuilder = new StepsBuilder().setStart(from).setEnd(to).setPathCoords(legCoords);
+                const transitMode = transitModeCorrespondance.get(section.transportMode) as TransitMode;
+
+                const unpackedIntructions = unpackJSON(section.details.instructions);
+
+                for (const instruction of unpackedIntructions) {
+                    const { geometryIndex, roadLength, roadName } = instruction;
+                    const coordinates = geometry.coordinates[geometryIndex];
+
+                    const intermediateStep = {
+                        name: roadName,
+                        distance: roadLength,
+                        coords: new Coordinates(coordinates[1], coordinates[0])
+                    };
+
+                    stepsBuilder.addStepInfo(intermediateStep);
+                }
+
+
+                const leg = new Leg({
+                    transitMode,
+                    duration: section.duration,
+                    startTime: new Date(section.estimatedDatetimeOfDeparture).getTime(),
+                    endTime: new Date(section.estimatedDatetimeOfArrival).getTime(),
+                    start: {
+                        coords: from
+                    },
+                    end: {
+                        coords: to
+                    },
+                    coords: legCoords,
+                    steps: stepsBuilder.build()
+                });
+                legs.push(leg);
+            }
+
+            const itinerary = new Itinerary({
+                duration: route.duration,
+                startTime: new Date(route.estimatedDatetimeOfDeparture).getTime(),
+                endTime: new Date(route.estimatedDatetimeOfArrival).getTime(),
+                origin: waypointToCoordinates(route.waypoints[0]),
+                destination: waypointToCoordinates(last(route.waypoints)),
+                legs
+            });
+
+            itineraries.push(itinerary);
+        }
+
+        return itineraries;
+    }
+}
+
+export default new GeoveloRemoteRouter();

package/src/remote/idfm/IdfmRemoteRouter.ts

@@ -11,6 +11,7 @@ import { areTransitAndTravelModeConsistent, type TransitMode } from '../../model
 import { type MinStepInfo } from '../../model/Step.js';
 import { RouterRequest } from '../../model/RouterRequest.js';
 import { RemoteRoutingError } from '../../RoutingError.js';
+import GeoveloRemoteRouter from '../geovelo/GeoveloRemoteRouter.js';
 
 type IdfmCoordinates = { lat: number | string, lon: number | string };
 type IdfmPath = {
@@ -182,6 +183,12 @@ class IdfmRemoteRouter extends RemoteRouter {
 
 
     async getItineraries(endpointUrl: string, routerRequest: RouterRequest) {
+        const { travelMode } = routerRequest;
+        if (travelMode === 'BIKE') {
+            // IDFM does not support bike routing, we use Geovelo instead
+            return GeoveloRemoteRouter.getItineraries('https://idfm.getwemap.com/marketplace/computedroutes', routerRequest);
+        }
+
         const url = this.getURL(endpointUrl, routerRequest);
 
         const res = await (fetch(url, {