@wemap/routers 12.8.9 → 12.9.0

package/src/remote/navitia/NavitiaRemoteRouter.ts

@@ -0,0 +1,445 @@
+import { Coordinates, Utils as GeoUtils } from '@wemap/geo';
+import Logger from '@wemap/logger';
+
+import RemoteRouter from '../RemoteRouter.js';
+import Itinerary from '../../model/Itinerary.js';
+import Leg, { TransportInfo } from '../../model/Leg.js';
+import { dateWithTimeZone } from '../RemoteRouterUtils.js';
+import { TransitMode, areTransitAndTravelModeConsistent } from '../../model/TransitMode.js';
+import StepsBuilder from '../../model/StepsBuilder.js';
+import { type MinStepInfo } from '../../model/Step.js';
+import { type RouterRequest } from '../../model/RouterRequest.js';
+import { RemoteRoutingError } from '../../RoutingError.js';
+import { NavitiaJson, NavitiaCoordinates, NavitiaSection, NavitiaIntermediateStep } from './types';
+
+/**
+ * List of all modes supported by the API
+ * http://doc.navitia.io/#physical-mode
+ */
+
+const transitModeCorrespondance = new Map<string, TransitMode>();
+transitModeCorrespondance.set('Air', 'AIRPLANE');
+transitModeCorrespondance.set('Boat', 'BOAT');
+transitModeCorrespondance.set('Bus', 'BUS');
+transitModeCorrespondance.set('BusRapidTransit', 'BUS');
+transitModeCorrespondance.set('Coach', 'BUS');
+transitModeCorrespondance.set('Ferry', 'FERRY');
+transitModeCorrespondance.set('Funicular', 'FUNICULAR');
+transitModeCorrespondance.set('LocalTrain', 'TRAIN');
+transitModeCorrespondance.set('LongDistanceTrain', 'TRAIN');
+transitModeCorrespondance.set('Metro', 'METRO');
+transitModeCorrespondance.set('Métro', 'METRO');
+transitModeCorrespondance.set('RailShuttle', 'TRAIN');
+transitModeCorrespondance.set('RapidTransit', 'BUS');
+transitModeCorrespondance.set('Shuttle', 'BUS');
+transitModeCorrespondance.set('SuspendedCableCar', 'FUNICULAR');
+transitModeCorrespondance.set('Taxi', 'TAXI');
+transitModeCorrespondance.set('Train', 'TRAIN');
+transitModeCorrespondance.set('RER', 'TRAIN');
+transitModeCorrespondance.set('Tramway', 'TRAM');
+transitModeCorrespondance.set('walking', 'WALK');
+transitModeCorrespondance.set('bike', 'BIKE');
+
+/**
+ * List of transports modes
+ */
+const TRANSPORT_IDS = [
+    'physical_mode:Air',
+    'physical_mode:Boat',
+    'physical_mode:Bus',
+    'physical_mode:BusRapidTransit',
+    'physical_mode:Coach',
+    'physical_mode:Ferry',
+    'physical_mode:Funicular',
+    'physical_mode:LocalTrain',
+    'physical_mode:LongDistanceTrain',
+    'physical_mode:Metro',
+    'physical_mode:RailShuttle',
+    'physical_mode:RapidTransit',
+    'physical_mode:Shuttle',
+    'physical_mode:SuspendedCableCar',
+    'physical_mode:Taxi',
+    'physical_mode:Train',
+    'physical_mode:Tramway'
+];
+
+function jsonToCoordinates(json: NavitiaCoordinates) {
+    return new Coordinates(Number(json.lat), Number(json.lon));
+}
+
+function last<T>(array: T[]) {
+    return array[array.length - 1];
+}
+
+/**
+ * stringDate (e.g. 20211117T104516)
+ */
+function dateStringToTimestamp(stringDate: string, timeZone: string) {
+    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();
+}
+
+// The api key should be defined in the routingurl as api_key=XXXXXXXX
+
+/**
+ * Singleton.
+ */
+class NavitiaRemoteRouter extends RemoteRouter {
+
+    get rname() { return 'navitia' as const; }
+
+    async getItineraries(endpointUrl: string, routerRequest: RouterRequest) {
+        const url = this.getURL(endpointUrl, routerRequest);
+
+        // The api key should be defined in the routingurl as api_key=XXXXXXXX
+        const api_key = url.searchParams.get('api_key');
+        if (!api_key) {
+            throw RemoteRoutingError.missingApiKey(this.rname);
+        }
+
+        const res = await (fetch(url, {
+            method: 'GET',
+            headers: { 
+                'Authorization': api_key,
+             }
+        }).catch(() => {
+            throw RemoteRoutingError.unreachableServer(this.rname, url.toString());
+        }));
+
+
+        const jsonResponse: NavitiaJson = await res.json().catch(() => {
+            throw RemoteRoutingError.responseNotParsing(this.rname, url.toString());
+        });
+
+        // When Navitia failed to calculate an itinerary (ie. start or end
+        // point is far from network), it respond a 404 with an error message
+        // or a 200 with an error message
+        if (jsonResponse && jsonResponse.error) {
+            throw RemoteRoutingError.notFound(this.rname, jsonResponse.error.message);
+        }
+
+        const itineraries = this.parseResponse(jsonResponse);
+
+        const sameModeFound = itineraries.some((itinerary) => areTransitAndTravelModeConsistent(itinerary.transitMode, routerRequest.travelMode));
+
+        if (!sameModeFound) {
+            throw RemoteRoutingError.notFound(
+                this.rname,
+                'Selected mode of transport was not found for this itinerary.'
+            )
+        }
+
+        return itineraries;
+    }
+
+    getURL(endpointUrl: string, routerRequest: RouterRequest) {
+        const { origin, destination, waypoints, travelMode } = routerRequest;
+
+        if ((waypoints || []).length > 0) {
+            Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints?.length})`);
+        }
+
+        const url = new URL(endpointUrl);
+
+        const coreParams = new URLSearchParams();
+        coreParams.set('from', `${origin.longitude};${origin.latitude}`);
+        coreParams.set('to', `${destination.longitude};${destination.latitude}`);
+        coreParams.set('data_freshness', 'realtime');
+
+        if (routerRequest.itineraryModifiers?.avoidStairs) {
+            coreParams.set('wheelchair', 'true')
+        }
+
+        let queryParams: URLSearchParams = new URLSearchParams();
+        switch (travelMode) {
+            case 'WALK':
+                queryParams = this.getWalkingQuery();
+                break;
+            case 'BIKE':
+                queryParams = this.getBikeQuery();
+                break;
+            case 'CAR':
+                queryParams = this.getCarQuery();
+                break;
+            default:
+                break;
+        }
+
+        [coreParams, queryParams].map(params => {
+            for (const pair of params.entries()) {
+                url.searchParams.append(pair[0], pair[1]);
+            }
+        });
+
+        return url;
+    }
+
+    getCarQuery() {
+        const urlSearchParams = new URLSearchParams();
+
+        TRANSPORT_IDS.forEach((id) => {
+            urlSearchParams.append('forbidden_uris[]', id);
+        });
+
+        urlSearchParams.append('first_section_mode[]', 'walking');
+        urlSearchParams.append('first_section_mode[]', 'car');
+        urlSearchParams.append('last_section_mode[]', 'walking');
+        urlSearchParams.append('last_section_mode[]', 'car');
+
+        return urlSearchParams;
+    }
+
+    getWalkingQuery() {
+        const urlSearchParams = new URLSearchParams();
+
+        TRANSPORT_IDS.forEach((id) => {
+            urlSearchParams.append('forbidden_uris[]', id);
+        });
+
+        urlSearchParams.append('first_section_mode[]', 'walking');
+        urlSearchParams.append('last_section_mode[]', 'walking');
+
+        return urlSearchParams;
+    }
+
+    getBikeQuery() {
+        const urlSearchParams = new URLSearchParams();
+
+        TRANSPORT_IDS.forEach((id) => {
+            urlSearchParams.append('forbidden_uris[]', id);
+        });
+
+        urlSearchParams.append('first_section_mode[]', 'bike');
+        urlSearchParams.append('last_section_mode[]', 'bike');
+
+        return urlSearchParams;
+    }
+
+
+    getSectionCoords(section: NavitiaSection) {
+        let from: NavitiaCoordinates | undefined;
+        let to: NavitiaCoordinates | undefined;
+
+        if ('stop_point' in section.from) {
+            from = section.from.stop_point.coord;
+        } else if ('address' in section.from) {
+            from = section.from.address.coord;
+        } else {
+            from = section.from.poi.coord;
+        }
+
+        if ('stop_point' in section.to) {
+            to = section.to.stop_point.coord;
+        } else if ('address' in section.to) {
+            to = section.to.address.coord;
+        } else {
+            to = section.to.poi.coord;
+        }
+
+        return {
+            from: jsonToCoordinates(from),
+            to: jsonToCoordinates(to)
+        };
+    }
+
+    /**
+     * Since the navitia 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
+     */
+    findStepsCoord(legCoords: Coordinates[], steps: NavitiaIntermediateStep[]) {
+        const coords = legCoords;
+
+        const duplicatedCoords = [...coords];
+        let previousStep = steps[0];
+        let accumulatedIndex = 0;
+        const outputSteps = [];
+
+        for (const [idx, step] of steps.entries()) {
+            let newCoords: Coordinates;
+
+            let _idCoordsInLeg;
+
+            if (idx === 0) {
+                _idCoordsInLeg = 0;
+                newCoords = coords[0];
+            } else if (idx === steps.length - 1) {
+                _idCoordsInLeg = coords.length - 1;
+                newCoords = last(coords);
+            } else if (duplicatedCoords.length === 1) {
+                accumulatedIndex++;
+
+                _idCoordsInLeg = accumulatedIndex;
+
+                newCoords = duplicatedCoords[0];
+
+                coords[_idCoordsInLeg] = newCoords;
+            } else {
+                const result = GeoUtils.trimRoute(duplicatedCoords, duplicatedCoords[0], previousStep.distance);
+                accumulatedIndex += result.length - 1;
+
+                duplicatedCoords.splice(0, result.length - 1);
+
+                _idCoordsInLeg = accumulatedIndex;
+
+                newCoords = last(result);
+
+                coords[_idCoordsInLeg] = newCoords;
+            }
+
+            outputSteps.push({
+                ...step,
+                coords: newCoords
+            });
+
+            previousStep = step;
+        }
+
+        return outputSteps;
+    }
+
+    findStepCoords(step: NavitiaSection['path'][number], section: NavitiaSection) {
+        if ('instruction_start_coordinate' in step) {
+            return jsonToCoordinates(step.instruction_start_coordinate);
+        }
+
+        const via = section.vias?.find(via => via.id === step.via_uri);
+        if (via) {
+            return jsonToCoordinates(via.access_point.coord);
+        }
+    }
+
+    parseResponse(json: NavitiaJson) {
+
+        if (!json || !json.journeys) {
+            throw RemoteRoutingError.notFound(this.rname, json.error?.message);
+        }
+
+        const itineraries = [];
+
+        const timeZone = json.context.timezone;
+
+        for (const jsonItinerary of json.journeys) {
+
+            const legs = [];
+
+            for (const jsonSection of jsonItinerary.sections) {
+
+                if (jsonSection.type === 'waiting' || jsonSection.type === 'transfer') {
+                    continue;
+                }
+
+                const { from: startSection, to: endSection } = this.getSectionCoords(jsonSection);
+
+                // A section can have multiple same coordinates, we need to remove them
+                let existingCoords: string[] = [];
+                const legCoords = 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;
+                }, [] as Coordinates[]);
+
+                const stepsBuilder = new StepsBuilder().setStart(startSection).setEnd(endSection).setPathCoords(legCoords);
+                let transportInfo: TransportInfo | undefined;
+                let transitMode = transitModeCorrespondance.get(jsonSection.mode) as TransitMode;
+
+                if (jsonSection.path) {
+                    const useNavitiaSteps = jsonSection.path.every(step => 'instruction_start_coordinate' in step || step.via_uri);
+                    const navitiaIntermediateSteps = [];
+
+                    for (const jsonPathLink of jsonSection.path) {
+                        let coords: Coordinates;
+                        if (useNavitiaSteps) {
+                            coords = this.findStepCoords(jsonPathLink, jsonSection)!;
+
+                            const intermediateStep = {
+                                name: jsonPathLink.name,
+                                distance: jsonPathLink.length,
+                                coords
+                            };
+
+                            stepsBuilder.addStepInfo(intermediateStep);
+                        } else {
+                            navitiaIntermediateSteps.push({
+                                name: jsonPathLink.name,
+                                distance: jsonPathLink.length,
+                            });
+                        }
+                    }
+
+                    if (!useNavitiaSteps) {
+                        stepsBuilder.setStepsInfo(this.findStepsCoord(legCoords, navitiaIntermediateSteps));
+                    }
+                }
+
+                if (jsonSection.type === 'public_transport') {
+                    transportInfo = {
+                        name: jsonSection.display_informations.code,
+                        routeColor: jsonSection.display_informations.color,
+                        routeTextColor: jsonSection.display_informations.text_color,
+                        directionName: jsonSection.display_informations.direction
+                    };
+
+                    transitMode = transitModeCorrespondance.get(jsonSection.display_informations.physical_mode) as TransitMode;
+
+                    const legStep: MinStepInfo = {
+                        coords: legCoords[0],
+                        name: transportInfo.directionName,
+                        distance: jsonSection.geojson.properties[0].length
+                    };
+                    stepsBuilder.setStepsInfo([legStep]);
+                }
+
+                const leg = new Leg({
+                    transitMode,
+                    duration: jsonSection.duration,
+                    startTime: dateStringToTimestamp(jsonSection.departure_date_time, timeZone),
+                    endTime: dateStringToTimestamp(jsonSection.arrival_date_time, timeZone),
+                    start: {
+                        name: jsonSection.from.name,
+                        coords: startSection
+                    },
+                    end: {
+                        name: jsonSection.to.name,
+                        coords: endSection
+                    },
+                    coords: legCoords,
+                    transportInfo,
+                    steps: stepsBuilder.build()
+                });
+                legs.push(leg);
+            }
+
+            const itinerary = new Itinerary({
+                duration: jsonItinerary.duration,
+                startTime: dateStringToTimestamp(jsonItinerary.departure_date_time, timeZone),
+                endTime: dateStringToTimestamp(jsonItinerary.arrival_date_time, timeZone),
+                origin: this.getSectionCoords(jsonItinerary.sections[0]).from,
+                destination: this.getSectionCoords(last(jsonItinerary.sections)).to,
+                legs
+            });
+
+            itineraries.push(itinerary);
+        }
+
+        return itineraries;
+    }
+}
+
+export default new NavitiaRemoteRouter();

package/src/remote/navitia/types.ts

@@ -0,0 +1,73 @@
+
+export type NavitiaCoordinates = { lat: number | string, lon: number | string };
+export type NavitiaPath = {
+    name: string,
+    length: number
+} & ({ instruction_start_coordinate: NavitiaCoordinates } | { via_uri: string });
+
+export type NavitiaWaypoint = { name: string }
+    & (
+        { stop_point: { coord: NavitiaCoordinates } } |
+        { address: { coord: NavitiaCoordinates } } |
+        { poi: { coord: NavitiaCoordinates } }
+    )
+
+export type NavitiaSection = {
+    id: string;
+    type: 'waiting' | 'transfer' | string,
+    mode: string,
+    departure_date_time: string,
+    arrival_date_time: string,
+    duration: number,
+    geojson: {
+        coordinates: [number, number][],
+        properties: { length: number }[]
+    },
+    path: NavitiaPath[],
+    display_informations: {
+        code: string,
+        color: string,
+        text_color: string,
+        direction: string,
+        physical_mode: string
+    },
+    from: NavitiaWaypoint,
+    to: NavitiaWaypoint,
+    vias?: {
+        id: string;
+        name: string;
+        access_point: {
+            id: string;
+            name: string;
+            coord: {
+                lon: string;
+                lat: string;
+            },
+            embedded_type: string;
+        },
+        is_entrance: boolean,
+        is_exit: boolean,
+        length: number,
+        traversal_time: number,
+        pathway_mode: number
+    }[]
+}
+export type NavitiaJson = {
+    journeys: {
+        duration: number,
+        departure_date_time: string,
+        arrival_date_time: string,
+        sections: NavitiaSection[]
+    }[],
+    context: {
+        timezone: string
+    };
+    error: {
+        message?: string;
+    }
+};
+
+export type NavitiaIntermediateStep = {
+    name: string,
+    distance: number
+};

package/src/remote/osrm/OsrmRemoteRouter.spec.ts

@@ -37,7 +37,7 @@ describe('OsrmRemoteRouter - parseResponse', () => {
         const itinerary1 = itineraries[0];
         expect(itinerary1.origin.equals(origin)).true;
         expect(itinerary1.destination.equals(destination)).true;
-        expect(itinerary1.distance).closeTo(400, 1);
+        expect(itinerary1.distance).closeTo(429, 1);
         expect(itinerary1.duration).equal(287.8);
         expect(itinerary1.startTime).is.null;
         expect(itinerary1.endTime).is.null;

package/src/wemap-multi/CustomGraphMap.ts

@@ -196,7 +196,8 @@ export default class CustomGraphMap {
 
     getRouteInsideMap(start: Coordinates, end: Coordinates, options: GraphRouterOptions) {
         // Call the Wemap router to get the shortest path
-        return this.router.calculateShortestPath(start, end, options).route();
+        const route = this.router.calculateShortestPath(start, end, options).route();
+        return route.hasRoute ? route : null;
     }
 
     getTripInsideMap(waypoints: Coordinates[], options: GraphRouterOptions) {