@wemap/routers 12.10.8 → 12.10.9

package/src/remote/idfm/IdfmRemoteRouter.ts

@@ -1,523 +0,0 @@
-/* eslint-disable max-statements */
-import { Coordinates, Utils as GeoUtils } from '@wemap/geo';
-import Logger from '@wemap/logger';
-
-import Itinerary from '../../model/Itinerary.js';
-import Leg, { TransportInfo } from '../../model/Leg.js';
-import { dateWithTimeZone } from '../RemoteRouterUtils.js';
-import StepsBuilder from '../../model/StepsBuilder.js';
-import RemoteRouter from '../RemoteRouter.js';
-import { areTransitAndTravelModeConsistent, type TransitMode } from '../../model/TransitMode.js';
-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 = {
-    name: string,
-    length: number
-} & ({ instruction_start_coordinate: IdfmCoordinates } | { via_uri: string });
-
-type IdfmWaypoint = { name: string }
-    & (
-        { stop_point: { coord: IdfmCoordinates } } |
-        { address: { coord: IdfmCoordinates } } |
-        { poi: { coord: IdfmCoordinates } }
-    )
-
-type IdfmSection = {
-    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: IdfmPath[],
-    display_informations: {
-        code: string,
-        color: string,
-        text_color: string,
-        direction: string,
-        physical_mode: string
-    },
-    from: IdfmWaypoint,
-    to: IdfmWaypoint,
-    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
-    }[]
-}
-type IdfmJson = {
-    journeys: {
-        duration: number,
-        departure_date_time: string,
-        arrival_date_time: string,
-        sections: IdfmSection[]
-    }[],
-    context: {
-        timezone: string
-    };
-    error: {
-        message?: string;
-    }
-};
-
-type IdfmIntermediateStep = {
-    name: string,
-    distance: number
-};
-
-/**
- * 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'
-];
-
-const apiKey = 'qWHj6ax6DMttG8DX6tH9CQARaiTgQ1Di';
-
-
-function jsonToCoordinates(json: IdfmCoordinates) {
-    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();
-}
-
-
-/**
- * Singleton.
- */
-class IdfmRemoteRouter extends RemoteRouter {
-
-    /**
-     * @override
-     */
-    get rname() { return 'idfm' as const; }
-
-
-    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, {
-            method: 'GET',
-            headers: { apiKey }
-        }).catch(() => {
-            throw RemoteRoutingError.unreachableServer(this.rname, url);
-        }));
-
-
-        const jsonResponse: IdfmJson = await res.json().catch(() => {
-            throw RemoteRoutingError.responseNotParsing(this.rname, url);
-        });
-
-        // When IDFM 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.toString();
-    }
-
-    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: IdfmSection) {
-        let from: IdfmCoordinates | undefined;
-        let to: IdfmCoordinates | 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 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
-     */
-    findStepsCoord(legCoords: Coordinates[], steps: IdfmIntermediateStep[]) {
-        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: IdfmSection['path'][number], section: IdfmSection) {
-        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: IdfmJson) {
-
-        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 useIDFMSteps = jsonSection.path.every(step => 'instruction_start_coordinate' in step || step.via_uri);
-                    const idfmIntermediateSteps = [];
-
-                    for (const jsonPathLink of jsonSection.path) {
-                        let coords: Coordinates;
-                        if (useIDFMSteps) {
-                            coords = this.findStepCoords(jsonPathLink, jsonSection)!;
-
-                            const intermediateStep = {
-                                name: jsonPathLink.name,
-                                distance: jsonPathLink.length,
-                                coords
-                            };
-
-                            stepsBuilder.addStepInfo(intermediateStep);
-                        } else {
-                            idfmIntermediateSteps.push({
-                                name: jsonPathLink.name,
-                                distance: jsonPathLink.length,
-                            });
-                        }
-                    }
-
-                    if (!useIDFMSteps) {
-                        stepsBuilder.setStepsInfo(this.findStepsCoord(legCoords, idfmIntermediateSteps));
-                    }
-                }
-
-                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 IdfmRemoteRouter();

package/src/remote/navitia/NavitiaRemoteRouter.spec.ts

@@ -1,116 +0,0 @@
-/* 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 NavitiaRemoteRouter from './NavitiaRemoteRouter.js';
-import { verifyStepsCoherence } from '../../model/Itinerary.spec.js';
-import { areTransitAndTravelModeConsistent } from '../../model/TransitMode.js';
-
-const { expect } = chai;
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const assetsPath = path.resolve(__dirname, '../../../assets');
-
-describe('NavitiaRouter - parseResponse', () => {
-
-    it('Itineraries - 1', () => {
-
-        const filePath = path.resolve(assetsPath, 'itinerary-lemans-navitia.json');
-        const fileString = fs.readFileSync(filePath, 'utf8');
-        const json = JSON.parse(fileString);
-
-        const itineraries = NavitiaRemoteRouter.parseResponse(json);
-        itineraries.forEach(verifyStepsCoherence);
-
-        expect(itineraries.length).equal(5);
-
-        const itinerary1 = itineraries[0];
-        expect(itinerary1.origin.equals(new Coordinates(48.007274, 0.187574))).true;
-        expect(itinerary1.destination.equals(new Coordinates(48.005228, 0.205664))).true;
-        expect(itinerary1.distance).to.be.closeTo(1710, 1);
-        expect(itinerary1.duration).equal(1140);
-        expect(itinerary1.transitMode).equal('TRAM');
-        // Do not work because of the input time format
-        expect(itinerary1.startTime).equal(1722854691000);
-        expect(itinerary1.endTime).equal(1722855831000);
-        expect(itinerary1.legs.length).equal(3);
-
-        expect(areTransitAndTravelModeConsistent(itinerary1.transitMode, 'TRANSIT')).is.true;
-
-        const itinerary1leg1 = itinerary1.legs[0];
-        // Do not work because of the input time format
-        expect(itinerary1leg1.startTime).equal(1722854691000);
-        expect(itinerary1leg1.endTime).equal(1722854885000);
-        expect(itinerary1leg1.distance).to.be.closeTo(224, 1);
-        expect(itinerary1leg1.transitMode).equal('WALK');
-        expect(itinerary1leg1.transportInfo).is.null;
-        expect(itinerary1leg1.start.name).equal('33 Rue Saint-Pavin des Champs (Le Mans)');
-        expect(itinerary1leg1.start.coords.distanceTo(new Coordinates(48.007274, 0.187574))).to.be.closeTo(0, 1);
-        expect(itinerary1leg1.end.name).equal('Lafayette (Le Mans)');
-        expect(itinerary1leg1.end.coords.distanceTo(new Coordinates(48.006794, 0.190226))).to.be.closeTo(0, 1);
-
-        const itinerary1leg2 = itinerary1.legs[1];
-        expect(itinerary1leg2.transitMode).equal('TRAM');
-        expect(itinerary1leg2.transportInfo).is.not.null;
-        expect(itinerary1leg2.transportInfo?.name).equal('T1');
-        expect(itinerary1leg2.transportInfo?.routeColor).equal('E5261D');
-        expect(itinerary1leg2.transportInfo?.routeTextColor).equal('FFFFFF');
-        expect(itinerary1leg2.transportInfo?.directionName).equal('Antarès - Stade Marie Marvingt (Le Mans)');
-    });
-    
-    it('Itineraries - 2', () => {
-
-        const filePath = path.resolve(assetsPath, 'itinerary-lemans-navitia.json');
-        const fileString = fs.readFileSync(filePath, 'utf8');
-        const json = JSON.parse(fileString);
-
-        const itineraries = NavitiaRemoteRouter.parseResponse(json);
-        itineraries.forEach(verifyStepsCoherence);
-
-
-        const itinerary2 = itineraries[1];
-        expect(itinerary2.origin.equals(new Coordinates(48.007274, 0.187574))).true;
-        expect(itinerary2.destination.equals(new Coordinates(48.005228, 0.205664))).true;
-        expect(itinerary2.distance).to.be.closeTo(1995, 1);
-        expect(itinerary2.duration).equal(1452);
-        expect(itinerary2.transitMode).equal('MULTI');
-        // Do not work because of the input time format
-        expect(itinerary2.startTime).equal(1722854691000);
-        expect(itinerary2.endTime).equal(1722856143000);
-        expect(itinerary2.legs.length).equal(4);
-
-        expect(areTransitAndTravelModeConsistent(itinerary2.transitMode, 'TRANSIT')).is.true;
-
-        const itinerary2leg1 = itinerary2.legs[0];
-        // Do not work because of the input time format
-        expect(itinerary2leg1.startTime).equal(1722854691000);
-        expect(itinerary2leg1.endTime).equal(1722854885000);
-        expect(itinerary2leg1.distance).to.be.closeTo(224, 1);
-        expect(itinerary2leg1.transitMode).equal('WALK');
-        expect(itinerary2leg1.transportInfo).is.null;
-        expect(itinerary2leg1.start.name).equal('33 Rue Saint-Pavin des Champs (Le Mans)');
-        expect(itinerary2leg1.start.coords.distanceTo(new Coordinates(48.007274, 0.187574))).to.be.closeTo(0, 1);
-        expect(itinerary2leg1.end.name).equal('Lafayette (Le Mans)');
-        expect(itinerary2leg1.end.coords.distanceTo(new Coordinates(48.006794, 0.190226))).to.be.closeTo(0, 1);
-
-        const itinerary2leg2 = itinerary2.legs[1];
-        expect(itinerary2leg2.transitMode).equal('TRAM');
-        expect(itinerary2leg2.transportInfo).is.not.null;
-        expect(itinerary2leg2.transportInfo?.name).equal('T1');
-        expect(itinerary2leg2.transportInfo?.routeColor).equal('E5261D');
-        expect(itinerary2leg2.transportInfo?.routeTextColor).equal('FFFFFF');
-        expect(itinerary2leg2.transportInfo?.directionName).equal('Antarès - Stade Marie Marvingt (Le Mans)');
-        
-        const itinerary2leg3 = itinerary2.legs[2];
-        expect(itinerary2leg3.transitMode).equal('BUS');
-        expect(itinerary2leg3.transportInfo).is.not.null;
-        expect(itinerary2leg3.transportInfo?.name).equal('6');
-        expect(itinerary2leg3.transportInfo?.routeColor).equal('C3057F');
-        expect(itinerary2leg3.transportInfo?.routeTextColor).equal('FFFFFF');
-        expect(itinerary2leg3.transportInfo?.directionName).equal('St-Martin (Le Mans)');
-    });
-});