@wemap/routers 12.10.8 → 12.10.9

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

@@ -1,54 +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 { 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('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

@@ -1,293 +0,0 @@
-/* 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,
-                'Content-Type': 'application/json'
-            },
-            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.spec.ts

@@ -1,102 +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 IdfmRemoteRouter from './IdfmRemoteRouter.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('IdfmRouter - parseResponse', () => {
-
-    it('Itineraries - 1', () => {
-
-        const filePath = path.resolve(assetsPath, 'itinerary-paris-idfm.json');
-        const fileString = fs.readFileSync(filePath, 'utf8');
-        const json = JSON.parse(fileString);
-
-        const itineraries = IdfmRemoteRouter.parseResponse(json);
-        itineraries.forEach(verifyStepsCoherence);
-
-        expect(itineraries.length).equal(9);
-
-        const itinerary1 = itineraries[0];
-        expect(itinerary1.origin.equals(new Coordinates(48.836123, 2.341896))).true;
-        expect(itinerary1.destination.equals(new Coordinates(48.867999, 2.32563))).true;
-        expect(itinerary1.distance).to.be.closeTo(5769, 1);
-        expect(itinerary1.duration).equal(1977);
-        expect(itinerary1.transitMode).equal('MULTI');
-        // Do not work because of the input time format
-        expect(itinerary1.startTime).equal(1712073372000);
-        expect(itinerary1.endTime).equal(1712075349000);
-        expect(itinerary1.legs.length).equal(4);
-
-        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(1712073372000);
-        expect(itinerary1leg1.endTime).equal(1712074079000);
-        expect(itinerary1leg1.distance).to.be.closeTo(702, 1);
-        expect(itinerary1leg1.transitMode).equal('WALK');
-        expect(itinerary1leg1.transportInfo).is.null;
-        expect(itinerary1leg1.start.name).equal('29 Rue de la Santé (Paris)');
-        expect(itinerary1leg1.start.coords.distanceTo(new Coordinates(48.836123, 2.341896))).to.be.closeTo(0, 1);
-        expect(itinerary1leg1.end.name).equal('Port Royal (Paris)');
-        expect(itinerary1leg1.end.coords.distanceTo(new Coordinates(48.8400644, 2.3371384))).to.be.closeTo(0, 1);
-
-        const itinerary1leg2 = itinerary1.legs[1];
-        expect(itinerary1leg2.transitMode).equal('TRAIN');
-        expect(itinerary1leg2.transportInfo).is.not.null;
-        expect(itinerary1leg2.transportInfo?.name).equal('B');
-        expect(itinerary1leg2.transportInfo?.routeColor).equal('5091CB');
-        expect(itinerary1leg2.transportInfo?.routeTextColor).equal('FFFFFF');
-        expect(itinerary1leg2.transportInfo?.directionName).equal('Aéroport Charles de Gaulle 2 (Terminal 2) (Tremblay-en-France)');
-    });
-    
-    it('Itineraries - 2 - steps', () => {
-
-        const filePath = path.resolve(assetsPath, 'itinerary-paris-idfm-2.json');
-        const fileString = fs.readFileSync(filePath, 'utf8');
-        const json = JSON.parse(fileString);
-
-        const itineraries = IdfmRemoteRouter.parseResponse(json);
-        itineraries.forEach(verifyStepsCoherence);
-
-        expect(itineraries.length).equal(2);
-
-        // Get WALK itinerary
-        const itinerary1 = itineraries[1];
-        expect(itinerary1.origin.equals(new Coordinates(48.856222, 2.334505))).true;
-        expect(itinerary1.destination.equals(new Coordinates(48.85784, 2.332184))).true;
-        expect(itinerary1.distance).to.be.closeTo(457, 1);
-        expect(itinerary1.duration).equal(434);
-        expect(itinerary1.transitMode).equal('WALK');
-        // Do not work because of the input time format
-        expect(itinerary1.startTime).equal(1712237614000);
-        expect(itinerary1.endTime).equal(1712238048000);
-        expect(itinerary1.legs.length).equal(1);
-
-        expect(areTransitAndTravelModeConsistent(itinerary1.transitMode, 'WALK')).is.true;
-
-        const steps = itinerary1.steps;
-
-        expect(steps.length).equal(9);
-        expect(steps[0].firstStep).equal(true);
-        expect(steps[0].number).equal(1);
-
-        expect(steps[1].firstStep).equal(false);
-        expect(steps[1].number).equal(2);
-
-        expect(steps[8].lastStep).equal(true);
-        expect(steps[8].number).equal(9);
-    });
-});