@wemap/routers 12.10.8 → 12.10.9

package/src/remote/osrm/OsrmRemoteRouter.ts

@@ -1,303 +0,0 @@
-/* eslint-disable max-statements */
-
-import { Coordinates, Level } from '@wemap/geo';
-import { rad2deg, positiveMod } from '@wemap/maths';
-import { LineString, Position } from 'geojson';
-
-import Itinerary from '../../model/Itinerary.js';
-import Leg from '../../model/Leg.js';
-import StepsBuilder from '../../model/StepsBuilder.js';
-import RemoteRouter from '../RemoteRouter.js';
-import { type TravelMode } from '../../model/TravelMode.js';
-import { type TransitMode } from '../../model/TransitMode.js';
-import { type RouterRequest } from '../../model/RouterRequest.js';
-import { RemoteRoutingError } from '../../RoutingError.js';
-
-type OsrmCoordinates = Position;
-type OsrmModifier = 'sharp right' | 'sharp left' | 'slight right'
-    | 'slight left' | 'right' | 'left' | 'u turn' | 'straight';
-type OsrmManeuverType = 'depart' | 'turn' | 'arrive';
-type OsrmStep = {
-    geometry: LineString,
-    distance: number,
-    duration: number,
-    name?: string,
-    maneuver: {
-        bearing_before: number,
-        bearing_after: number,
-        location: OsrmCoordinates,
-        modifier: OsrmModifier,
-        type: OsrmManeuverType
-    }
-};
-type OsrmJson = {
-    code?: string,
-    message?: string,
-    routes?: {
-        geometry: LineString,
-        legs: {
-            distance: number,
-            duration: number,
-            steps: OsrmStep[]
-        }[],
-        distance: number,
-        duration: number,
-        weight_name: string,
-        weight: number
-    }[],
-    waypoints?: []
-};
-
-type OsrmMode = 'driving' | 'walking' | 'bike' | 'pmr' | 'bike-safest' | 'bike-fastest';
-
-const outputModeCorrespondance = new Map<TravelMode, TransitMode>();
-outputModeCorrespondance.set('CAR', 'CAR');
-outputModeCorrespondance.set('WALK', 'WALK');
-outputModeCorrespondance.set('BIKE', 'BIKE');
-
-/**
- * Singleton.
- */
-class OsrmRemoteRouter extends RemoteRouter {
-
-    get rname() { return 'osrm' as const; }
-
-    async getItineraries(endpointUrl: string, routerRequest: RouterRequest) {
-        const url = this.getURL(endpointUrl, routerRequest);
-
-        const res = await (fetch(url).catch(() => {
-            throw RemoteRoutingError.unreachableServer(this.rname, url);
-        }));
-
-        const jsonResponse = await res.json().catch(() => {
-            throw RemoteRoutingError.responseNotParsing(this.rname, url);
-        });
-
-        return this.parseResponse(jsonResponse, routerRequest.origin, routerRequest.destination, routerRequest.travelMode);
-    }
-
-    /**
-     * @throws {TravelModeCorrespondanceNotFound}
-     */
-    getURL(endpointUrl: string, routerRequest: RouterRequest) {
-        const { origin, destination } = routerRequest;
-
-        const osrmMode = this.inputModeCorrespondance(routerRequest);
-        const waypoints = [origin, ...routerRequest.waypoints || [], destination];
-
-        let url = endpointUrl + '/route/v1/' + osrmMode + '/';
-        url += waypoints.map(waypoint => [waypoint.longitude + ',' + waypoint.latitude]).join(';');
-        url += '?geometries=geojson&overview=full&steps=true';
-        routerRequest.provideItineraryAlternatives && (url += '&alternatives=true')
-        return url;
-    }
-
-    inputModeCorrespondance = (routerRequest: RouterRequest): OsrmMode => {
-        const { travelMode, travelModePreference: preference } = routerRequest;
-        if (travelMode === 'WALK' && routerRequest.itineraryModifiers?.avoidStairs) return 'pmr';
-        if (travelMode === 'WALK') return 'walking';
-        if (travelMode === 'BIKE') {
-            if (preference === 'FASTEST') return 'bike-fastest';
-            if (preference === 'SAFEST') return 'bike-safest';
-            if (preference === 'TOURISM') return 'bike-safest';
-            return 'bike-safest';
-        }
-        if (travelMode === 'CAR') return 'driving';
-        throw RemoteRoutingError.travelModeUnimplemented(this.rname, travelMode);
-    }
-
-    coordinatesToJson({ lat, lng, level }: Coordinates): OsrmCoordinates {
-        if (level === null) {
-            return [lng, lat];
-        }
-        if (Level.isRange(level)) {
-            return [lng, lat, level[0]];
-        }
-        return [lng, lat, level];
-    }
-
-    /**
-     * @param {object} json
-     * @returns {Coordinates}
-     */
-    jsonToCoordinates(json: OsrmCoordinates): Coordinates {
-        const coords = new Coordinates(json[1], json[0]);
-        if (json.length > 2) {
-            coords.level = json[2] as number;
-        }
-        return coords;
-    }
-
-    getModifierFromAngle(_angle: number): OsrmModifier {
-
-        const angle = positiveMod(rad2deg(_angle), 360);
-
-        if (angle > 0 && angle < 60) {
-            return 'sharp right';
-        }
-        if (angle >= 60 && angle < 140) {
-            return 'right';
-        }
-        if (angle >= 140 && angle < 160) {
-            return 'slight right';
-        }
-        if (angle >= 160 && angle <= 200) {
-            return 'straight';
-        }
-        if (angle > 200 && angle <= 220) {
-            return 'slight left';
-        }
-        if (angle > 220 && angle <= 300) {
-            return 'left';
-        }
-        if (angle > 300 && angle < 360) {
-            return 'sharp left';
-        }
-        return 'u turn';
-    }
-
-    noRouteFoundJson(message: object) {
-        return {
-            'code': 'NoRoute',
-            message
-        };
-    }
-
-    /**
-     * @deprecated
-     */
-    itineraryToOsrmJson(itinerary: Itinerary): OsrmJson {
-
-        const lastLegId = itinerary.legs.length - 1;
-        const itinerarySteps = itinerary.steps;
-
-        const jsonLegs = itinerary.legs.map(({ distance, duration, coords }, idLeg) => {
-
-            // Filter steps which are in leg
-            const legSteps = itinerarySteps.filter(step =>
-                coords.find(_coords => _coords.equals(step.coords))
-            );
-
-            const lastStepId = legSteps.length - 1;
-
-            return {
-                distance,
-                duration: duration || 0,
-                steps: legSteps.map((step, idStep, arr) => {
-
-                    let type: OsrmManeuverType = idStep === 0 && idLeg === 0 ? 'depart' : 'turn';
-                    type = idStep === lastStepId && idLeg === lastLegId ? 'arrive' : type;
-
-                    const stepCoordsIdx = coords.findIndex(p => p.equals(step.coords));
-                    const nextStepCoordsIdx = idStep === lastStepId
-                        ? stepCoordsIdx
-                        : coords.findIndex(p => p.equals(arr[idStep + 1].coords));
-
-                    const osrmStep: OsrmStep = {
-                        geometry: {
-                            type: 'LineString',
-                            coordinates: coords.slice(stepCoordsIdx, nextStepCoordsIdx + 1).map(this.coordinatesToJson)
-                        },
-                        distance: step.distance,
-                        duration: step.duration || 0,
-                        ...(step.name && { name: step.name }),
-                        maneuver: {
-                            bearing_before: rad2deg(step.previousBearing),
-                            bearing_after: rad2deg(step.nextBearing),
-                            location: this.coordinatesToJson(step.coords),
-                            modifier: this.getModifierFromAngle(step.angle),
-                            type
-                        },
-                    };
-                    return osrmStep;
-                })
-            };
-        });
-
-        return {
-            'code': 'Ok',
-            'routes': [
-                {
-                    'geometry': {
-                        'type': 'LineString',
-                        'coordinates': itinerary.coords.map(this.coordinatesToJson)
-                    },
-                    'legs': jsonLegs,
-                    'distance': itinerary.distance,
-                    'duration': itinerary.duration,
-                    'weight_name': 'routability',
-                    'weight': 0
-                }
-            ],
-            'waypoints': []
-        };
-    }
-
-    parseResponse(json: OsrmJson, origin: Coordinates, destination: Coordinates, travelMode: TravelMode) {
-
-        const transitMode = outputModeCorrespondance.get(travelMode)!;
-
-        const { routes: jsonRoutes } = json;
-        if (!jsonRoutes) {
-            throw RemoteRoutingError.notFound(this.rname, json.message);
-        }
-
-        return jsonRoutes.map(jsonItinerary => {
-
-            const legs = jsonItinerary.legs.map((jsonLeg) => {
-                const legCoords = jsonLeg.steps
-                    .map(step => step.geometry.coordinates.map(this.jsonToCoordinates))
-                    .flat()
-                    // Remove duplicates
-                    .filter((coords, idx, arr) => idx === 0 || !arr[idx - 1].equals(coords));
-
-                const startCoords = legCoords[0];
-                const endCoords = legCoords[legCoords.length - 1];
-
-                const stepsBuilder = new StepsBuilder().setPathCoords(legCoords).setStart(startCoords).setEnd(endCoords);
-                jsonLeg.steps?.forEach(({ maneuver, name, distance, duration }) => {
-
-                    const stepCoords = this.jsonToCoordinates(maneuver.location);
-
-                    // Sometimes, OSRM step does not have the same coordinates than a point in legCoords.
-                    // ex: first step of https://routing-orsm.getwemap.com/route/v1/walking/2.33222164147,48.87084765712;2.3320734,48.8730212?geometries=geojson&overview=full&steps=true
-                    // That is why we look for the closest point.
-                    const distances = legCoords.map(coords => coords.distanceTo(stepCoords));
-                    const idStepCoordsInLeg = distances.indexOf(Math.min(...distances));
-                    if (idStepCoordsInLeg < 0) {
-                        throw new Error('Osrm Parser: Cannot find step coords in leg coordinates');
-                    }
-
-                    stepsBuilder.addStepInfo({
-                        coords: legCoords[idStepCoordsInLeg],
-                        name,
-                        distance,
-                        duration
-                    });
-                })
-
-                return new Leg({
-                    transitMode,
-                    duration: jsonLeg.duration,
-                    coords: legCoords,
-                    start: {
-                        coords: startCoords
-                    },
-                    end: {
-                        coords: endCoords
-                    },
-                    steps: stepsBuilder.build()
-                });
-            });
-
-            return new Itinerary({
-                duration: jsonItinerary.duration,
-                origin,
-                destination,
-                legs
-            });
-        });
-    }
-}
-
-export default new OsrmRemoteRouter();

package/src/remote/otp/OtpRemoteRouter.spec.ts

@@ -1,103 +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 OtpRemoteRouter from './OtpRemoteRouter.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('OtpRouter - createRouterResponseFromJson', () => {
-
-    it('Itineraries - 1', () => {
-
-        const filePath = path.resolve(assetsPath, 'itinerary-grenoble-otp-1.json');
-        const fileString = fs.readFileSync(filePath, 'utf8');
-        const json = JSON.parse(fileString);
-
-        const itineraries = OtpRemoteRouter.parseResponse(json);
-        itineraries.forEach(verifyStepsCoherence);
-
-        expect(itineraries.length).equal(2);
-
-        const itinerary1 = itineraries[0];
-        expect(itinerary1.origin.equals(new Coordinates(45.187291, 5.723455))).true;
-        expect(itinerary1.destination.equals(new Coordinates(45.163729, 5.74085))).true;
-        expect(itinerary1.coords.length).equal(162);
-        expect(itinerary1.duration).equal(1206);
-        expect(itinerary1.startTime).equal(1614607210000);
-        expect(itinerary1.endTime).equal(1614608416000);
-        expect(itinerary1.legs.length).equal(3);
-        expect(itinerary1.transitMode).equal('BUS');
-        expect(areTransitAndTravelModeConsistent(itinerary1.transitMode, 'TRANSIT')).is.true;
-
-        const itinerary1leg1 = itinerary1.legs[0];
-        expect(itinerary1leg1.startTime).equal(1614607210000);
-        expect(itinerary1leg1.endTime).equal(1614607499000);
-        expect(itinerary1leg1.distance).almost.equal(260.14);
-        expect(itinerary1leg1.transitMode).equal('WALK');
-        expect(itinerary1leg1.transportInfo).is.null;
-        expect(itinerary1leg1.start.name).equal('Origin');
-        expect(itinerary1leg1.start.coords.equals(new Coordinates(45.187291, 5.723455))).true;
-        expect(itinerary1leg1.end.name).equal('Grenoble, Victor Hugo');
-        expect(itinerary1leg1.end.coords.equals(new Coordinates(45.1887, 5.72533))).true;
-
-        const itinerary1leg2 = itinerary1.legs[1];
-        expect(itinerary1leg2.transitMode).equal('BUS');
-        expect(itinerary1leg2.transportInfo).is.not.null;
-        expect(itinerary1leg2.transportInfo?.name).equal('C4');
-        expect(itinerary1leg2.transportInfo?.routeColor).equal('F3D000');
-        expect(itinerary1leg2.transportInfo?.routeTextColor).equal('000000');
-        expect(itinerary1leg2.transportInfo?.directionName).equal('Eybens, Le Verderet');
-
-    });
-
-
-    it('Itineraries - 2', () => {
-
-        const filePath = path.resolve(assetsPath, 'itinerary-grenoble-otp-2.json');
-        const fileString = fs.readFileSync(filePath, 'utf8');
-        const json = JSON.parse(fileString);
-
-        const itineraries = OtpRemoteRouter.parseResponse(json);
-        itineraries.forEach(verifyStepsCoherence);
-
-        expect(itineraries.length).equal(2);
-
-        const itinerary1 = itineraries[0];
-        expect(itinerary1.origin.equals(new Coordinates(45.192514856662456, 5.731452541397871))).true;
-        expect(itinerary1.destination.equals(new Coordinates(45.18544, 5.73123))).true;
-        expect(itinerary1.legs.length).equal(5);
-
-        expect(itinerary1.transitMode).equal('TRAM');
-        expect(areTransitAndTravelModeConsistent(itinerary1.transitMode, 'TRANSIT')).is.true;
-
-        expect(itinerary1.legs[0].transitMode).equal('WALK');
-
-        expect(itinerary1.legs[1].transitMode).equal('TRAM');
-        expect(itinerary1.legs[1].transportInfo).is.not.null;
-
-        expect(itinerary1.legs[2].transitMode).equal('WALK');
-
-        expect(itinerary1.legs[3].transitMode).equal('TRAM');
-        expect(itinerary1.legs[3].transportInfo).is.not.null;
-
-        expect(itinerary1.legs[4].transitMode).equal('WALK');
-
-        expect(itinerary1.steps[0].firstStep).is.true;
-        expect(itinerary1.steps[itinerary1.steps.length - 1].lastStep).is.true;
-    });
-
-
-});

package/src/remote/otp/OtpRemoteRouter.ts

@@ -1,223 +0,0 @@
-import Polyline from '@mapbox/polyline';
-
-import { Coordinates } from '@wemap/geo';
-import Logger from '@wemap/logger';
-
-import Itinerary from '../../model/Itinerary.js';
-import Leg, { type TransportInfo } from '../../model/Leg.js';
-import StepsBuilder from '../../model/StepsBuilder.js';
-import RemoteRouter from '../RemoteRouter.js';
-import { type TravelMode } from '../../model/TravelMode.js';
-import { type RouterRequest } from '../../model/RouterRequest.js';
-import { RemoteRoutingError } from '../../RoutingError.js';
-
-type OtpCoordinates = { lat: number, lon: number };
-type FromTo = OtpCoordinates & { name: string };
-type FromToPT = FromTo & { stopId: string, stopCode: string };
-
-type CommonLeg = {
-    startTime: number,
-    endTime: number,
-    legGeometry: {
-        points: string,
-        length: number
-    },
-    duration: number,
-};
-
-type LegWalk = CommonLeg & {
-    mode: 'WALK',
-    from: FromTo,
-    to: FromTo,
-    steps: (OtpCoordinates & {
-        distance: number,
-        streetName: string
-    })[]
-}
-
-type LegPT = CommonLeg & {
-    mode: 'BUS' | 'TRAM',
-    from: FromToPT,
-    to: FromToPT,
-    intermediateStops: FromToPT,
-    routeShortName: 'string',
-    routeColor?: 'string',
-    routeTextColor?: 'string',
-    headsign: 'string'
-}
-
-type OtpJson = {
-    plan: {
-        from: FromTo,
-        to: FromTo,
-        itineraries: {
-            duration: number,
-            startTime: number,
-            endTime: number,
-            walkDistance: number,
-            legs: (LegWalk | LegPT)[]
-        }[]
-    }
-}
-
-function isLegPT(leg: LegPT | LegWalk): leg is LegPT {
-    return leg.mode === 'BUS' || leg.mode === 'TRAM';
-}
-
-function jsonToCoordinates(json: OtpCoordinates) {
-    return new Coordinates(json.lat, json.lon);
-}
-
-
-/**
- * Input mode correspondance
- */
-const inputModeCorrespondance = new Map<TravelMode, string>();
-inputModeCorrespondance.set('CAR', 'CAR');
-inputModeCorrespondance.set('WALK', 'WALK');
-inputModeCorrespondance.set('BIKE', 'BICYCLE');
-inputModeCorrespondance.set('TRANSIT', 'WALK,TRANSIT');
-
-/**
- * Singleton.
- */
-class OtpRemoteRouter extends RemoteRouter {
-
-    get rname() { return 'otp' as const; }
-
-    async getItineraries(endpointUrl: string, routerRequest: RouterRequest) {
-        const url = this.getURL(endpointUrl, routerRequest);
-        const res = await (fetch(url).catch(() => {
-            throw RemoteRoutingError.unreachableServer(this.rname, url);
-        }));
-
-        const jsonResponse = await res.json().catch(() => {
-            throw RemoteRoutingError.responseNotParsing(this.rname, url);
-        });
-        return this.parseResponse(jsonResponse);
-    }
-
-    getURL(endpointUrl: string, routerRequest: RouterRequest) {
-        const { origin, destination, waypoints, travelMode } = routerRequest;
-
-        const otpMode = inputModeCorrespondance.get(travelMode);
-        if (!otpMode) {
-            throw RemoteRoutingError.travelModeUnimplemented(this.rname, travelMode);
-        }
-
-        if ((waypoints || []).length > 0) {
-            Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints?.length})`);
-        }
-
-        const fromPlace = `fromPlace=${origin.latitude},${origin.longitude}`;
-        const toPlace = `toPlace=${destination.latitude},${destination.longitude}`;
-        const queryMode = `mode=${otpMode}`;
-
-        const url = new URL(endpointUrl);
-        let { search } = url;
-        search = (search ? `${search}&` : '?') + `${fromPlace}&${toPlace}&${queryMode}`;
-
-        return `${url.origin}${url.pathname}${search}`;
-    }
-
-
-    /**
-     * Generate multi itineraries from OTP JSON
-     */
-    parseResponse(json: OtpJson) {
-
-        const { plan: jsonPlan } = json;
-        if (!jsonPlan) {
-            throw RemoteRoutingError.notFound(this.rname);
-        }
-
-        const itineraries = [];
-
-        const itinerariesOrigin = jsonToCoordinates(jsonPlan.from);
-        const itinerariesDestination = jsonToCoordinates(jsonPlan.to);
-
-        for (const jsonItinerary of jsonPlan.itineraries) {
-
-            const legs: Leg[] = [];
-
-            for (const jsonLeg of jsonItinerary.legs) {
-
-                const startCoordinates = jsonToCoordinates(jsonLeg.from);
-                const endCoordinates = jsonToCoordinates(jsonLeg.to);
-
-                const legCoords = Polyline.decode(jsonLeg.legGeometry.points)
-                    .map(([lat, lon]) => new Coordinates(lat, lon));
-
-                let transportInfo: TransportInfo | undefined;
-                const stepsBuilder = new StepsBuilder().setStart(startCoordinates).setEnd(endCoordinates).setPathCoords(legCoords);
-
-                if (isLegPT(jsonLeg)) {
-
-                    transportInfo = {
-                        name: jsonLeg.routeShortName,
-                        routeColor: jsonLeg.routeColor,
-                        routeTextColor: jsonLeg.routeTextColor,
-                        directionName: jsonLeg.headsign
-                    };
-
-                    stepsBuilder.addStepInfo({
-                        coords: legCoords[0],
-                        name: jsonLeg.headsign
-                    });
-
-                } else {
-
-                    jsonLeg.steps.forEach(jsonStep => {
-                        // OTP step does not have the same coordinates than a point in legCoords.
-                        // That is why we look for the closest point.
-                        const distances = legCoords.map(coords => coords.distanceTo(jsonToCoordinates(jsonStep)));
-                        const idStepCoordsInLeg = distances.indexOf(Math.min(...distances));
-                        if (idStepCoordsInLeg < 0) {
-                            throw new Error('OTP Parser: Cannot find closest step');
-                        }
-
-                        stepsBuilder.addStepInfo({
-                            coords: legCoords[idStepCoordsInLeg],
-                            name: jsonStep.streetName
-                        });
-                    })
-                }
-
-
-                const leg = new Leg({
-                    transitMode: jsonLeg.mode,
-                    duration: jsonLeg.duration,
-                    startTime: jsonLeg.startTime,
-                    endTime: jsonLeg.endTime,
-                    start: {
-                        name: jsonLeg.from.name,
-                        coords: jsonToCoordinates(jsonLeg.from)
-                    },
-                    end: {
-                        name: jsonLeg.to.name,
-                        coords: jsonToCoordinates(jsonLeg.to)
-                    },
-                    coords: legCoords,
-                    transportInfo,
-                    steps: stepsBuilder.build()
-                });
-
-                legs.push(leg);
-
-            }
-            const itinerary = new Itinerary({
-                duration: jsonItinerary.duration,
-                startTime: jsonItinerary.startTime,
-                endTime: jsonItinerary.endTime,
-                origin: itinerariesOrigin,
-                destination: itinerariesDestination,
-                legs
-            });
-            itineraries.push(itinerary);
-        }
-
-        return itineraries;
-    }
-}
-
-export default new OtpRemoteRouter();