@wemap/routers 12.10.8 → 12.10.9

package/src/remote/navitia/NavitiaRemoteRouter.ts

@@ -1,445 +0,0 @@
-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

@@ -1,73 +0,0 @@
-
-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

@@ -1,127 +0,0 @@
-/* eslint-disable max-statements */
-import chai from 'chai';
-import chaiAlmost from 'chai-almost';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-import { Coordinates } from '@wemap/geo';
-
-import OsrmRemoteRouter from './OsrmRemoteRouter.js';
-import { verifyStepsCoherence } from '../../model/Itinerary.spec.js';
-import { areTransitAndTravelModeConsistent } from '../../model/TransitMode.js';
-
-
-const { expect } = chai;
-chai.use(chaiAlmost(0.1));
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const assetsPath = path.resolve(__dirname, '../../../assets');
-
-
-describe('OsrmRemoteRouter - parseResponse', () => {
-
-    it('Itineraries - 1', () => {
-
-        const filePath = path.resolve(assetsPath, 'itinerary-montpellier-outdoor.json');
-        const fileString = fs.readFileSync(filePath, 'utf8');
-        const json = JSON.parse(fileString);
-
-        const origin = new Coordinates(43.6007871, 3.8757218000000004);
-        const destination = new Coordinates(43.598877, 3.873866);
-        const itineraries = OsrmRemoteRouter.parseResponse(json, origin, destination, 'WALK');
-        itineraries.forEach(verifyStepsCoherence);
-
-        expect(itineraries.length).equal(1);
-        
-        const itinerary1 = itineraries[0];
-        expect(itinerary1.origin.equals(origin)).true;
-        expect(itinerary1.destination.equals(destination)).true;
-        expect(itinerary1.distance).closeTo(400, 1);
-        expect(itinerary1.duration).equal(287.8);
-        expect(itinerary1.startTime).is.null;
-        expect(itinerary1.endTime).is.null;
-        expect(itinerary1.legs.length).equal(1);
-        expect(itinerary1.coords.length).equal(19);
-        expect(itinerary1.transitMode).equal('WALK');
-        expect(areTransitAndTravelModeConsistent(itinerary1.transitMode, 'WALK')).is.true;
-
-        const itinerary1leg1 = itinerary1.legs[0];
-        expect(itinerary1leg1.startTime).is.null;
-        expect(itinerary1leg1.endTime).is.null;
-        expect(itinerary1leg1.distance).closeTo(400, 1);
-        expect(itinerary1leg1.duration).equal(287.8);
-        expect(itinerary1leg1.transitMode).equal('WALK');
-        expect(itinerary1leg1.transportInfo).is.null;
-        expect(itinerary1leg1.start.name).is.null;
-        expect(itinerary1leg1.start.coords.equals(new Coordinates(43.600777, 3.875607))).true;
-        expect(itinerary1leg1.end.name).is.null;
-        expect(itinerary1leg1.end.coords.equals(new Coordinates(43.59906, 3.873865))).true;
-        expect(itinerary1leg1.coords.length).equal(19);
-        expect(itinerary1leg1.coords).deep.equal(itinerary1.coords);
-
-    });
-
-
-    it('Itineraries - 2', () => {
-
-        const filePath = path.resolve(assetsPath, 'itinerary-montpellier-osrm-3.json');
-        const fileString = fs.readFileSync(filePath, 'utf8');
-        const json = JSON.parse(fileString);
-
-        const origin = new Coordinates(43.605663, 3.887244);
-        const destination = new Coordinates(43.6054106, 3.8878106);
-        const itineraries = OsrmRemoteRouter.parseResponse(json, origin, destination, 'WALK');
-        itineraries.forEach(verifyStepsCoherence);
-
-        expect(itineraries.length).equal(1);
-        expect(itineraries[0].transitMode).equal('WALK');
-        expect(itineraries[0].origin.equals(origin)).true;
-        expect(itineraries[0].destination.equals(destination)).true;
-        expect(areTransitAndTravelModeConsistent(itineraries[0].transitMode, 'WALK')).is.true;
-
-        const steps = itineraries[0].steps;
-        expect(steps.length).equal(2);
-        expect(steps[1].angle).almost.equal(1.575);
-
-    });
-
-
-    it('Itineraries - 2 - should return CAR itinerary', () => {
-
-        const filePath = path.resolve(assetsPath, 'itinerary-montpellier-osrm-3.json');
-        const fileString = fs.readFileSync(filePath, 'utf8');
-        const json = JSON.parse(fileString);
-
-        const origin = new Coordinates(43.605663, 3.887244);
-        const destination = new Coordinates(43.6054106, 3.8878106);
-        const itineraries = OsrmRemoteRouter.parseResponse(json, origin, destination, 'CAR');
-        itineraries.forEach(verifyStepsCoherence);
-
-        expect(itineraries.length).equal(1);
-        expect(itineraries[0].transitMode).equal('CAR');
-        expect(itineraries[0].origin.equals(origin)).true;
-        expect(itineraries[0].destination.equals(destination)).true;
-        expect(areTransitAndTravelModeConsistent(itineraries[0].transitMode, 'CAR')).is.true;
-
-        const steps = itineraries[0].steps;
-        expect(steps.length).equal(2);
-        expect(steps[1].angle).almost.equal(1.575);
-
-    });
-
-
-    it('Itineraries - 3', () => {
-
-        const filePath = path.resolve(assetsPath, 'itinerary-step-not-on-path-osrm.json');
-        const fileString = fs.readFileSync(filePath, 'utf8');
-        const json = JSON.parse(fileString);
-
-        const from = new Coordinates(48.880506, 2.353747);
-        const to = new Coordinates(48.879921, 2.354741);
-        const itineraries = OsrmRemoteRouter.parseResponse(json, from, to, 'WALK');
-        itineraries.forEach(verifyStepsCoherence);
-
-    });
-
-});