@wemap/routers 12.10.8-alpha.0 → 12.10.8-alpha.1

package/src/model/StepsBuilder.ts

@@ -1,242 +0,0 @@
-import { Coordinates, Level } from '@wemap/geo';
-import Logger from '@wemap/logger';
-import { diffAngle, deg2rad } from '@wemap/maths';
-
-import { type LevelChange, type LevelChangeType } from './LevelChange.js';
-import { type Step, type MinStepInfo } from './Step.js';
-import { getDurationFromLength } from '../Utils.js';
-import GraphRoute from '../graph/GraphRoute.js';
-
-const SKIP_STEP_ANGLE_MAX = deg2rad(20);
-
-export default class StepsBuilder {
-
-    private start: Coordinates | null = null;
-    private end: Coordinates | null = null;
-    private pathCoords: Coordinates[] | null = null;
-    private stepsInfo: MinStepInfo[] = [];
-
-    setStart(start: Coordinates) {
-        this.start = start;
-        return this;
-    }
-
-    setEnd(end: Coordinates) {
-        this.end = end;
-        return this;
-    }
-
-    setPathCoords(pathCoords: Coordinates[]) {
-        this.pathCoords = pathCoords;
-        return this;
-    }
-
-    setStepsInfo(stepsInfo: MinStepInfo[]) {
-        this.stepsInfo = stepsInfo;
-        return this;
-    }
-
-    addStepInfo(stepInfo: MinStepInfo) {
-        this.stepsInfo.push(stepInfo);
-        return this;
-    }
-
-    setGraphRoute(graphRoute: GraphRoute) {
-
-        const stepsInfo: MinStepInfo[] = [];
-
-        const { start, end } = graphRoute;
-
-        if (!graphRoute.hasRoute) { return this; }
-
-        let currentStep: MinStepInfo | null = null;
-        let previousBearing = start.bearingTo(graphRoute.vertices[0].coords);
-
-        for (let i = 0; i < graphRoute.vertices.length - 1; i++) {
-
-            const isFirstStep = i === 0;
-
-            const vertex = graphRoute.vertices[i];
-            const currentCoords = vertex.coords;
-            const nextVertex = graphRoute.vertices[i + 1];
-            const nextCoords = nextVertex.coords;
-
-            const edge = graphRoute.edges[i];
-
-            const nextBearing = vertex.bearingTo(nextVertex);
-            const angle = diffAngle(previousBearing, nextBearing + Math.PI);
-
-            const previousStep = stepsInfo.length ? stepsInfo[stepsInfo.length - 1] : null;
-
-            const { isSubwayEntrance, isGate, subwayEntranceRef } = vertex.properties;
-            const { isElevator, areEscalators, areStairs, isMovingWalkway, incline } = edge.properties;
-
-            let levelChangeType: LevelChangeType | null = null;
-            if (isElevator) {
-                levelChangeType = 'elevator';
-            } else if (areEscalators) {
-                levelChangeType = 'escalator';
-            } else if (areStairs) {
-                levelChangeType = 'stairs';
-            } else if (isMovingWalkway) {
-                levelChangeType = 'moving walkway';
-            } else {
-                levelChangeType = 'incline plane';
-            }
-
-            // Handle stairs/elevators/escalators/moving walkway/incline plane without change in level coordinates
-            let forceLevelChange: 'up' | 'down' | undefined;
-            if (
-                (areStairs || isElevator)
-                && incline
-                && !previousStep?.levelChange
-            ) {
-                forceLevelChange = incline;
-            }
-
-            const previousEdge = i > 0 ? graphRoute.edges[i - 1] : null;
-            const previousEdgeProperties = previousEdge?.properties || {};
-            const forceEndOfLevelChange = Boolean(
-                previousEdgeProperties.incline && previousEdgeProperties.areStairs
-                && (!incline || !areStairs)
-            );
-            const isEntrance = vertex.properties.isSubwayEntrance;
-
-            const stepName = edge.properties.name || null;
-            const duration = graphRoute.edgesWeights[i];
-            const stepExtras = {
-                ...(isSubwayEntrance && { isSubwayEntrance }),
-                ...(subwayEntranceRef && { subwayEntranceRef }),
-                ...(isGate && { isGate })
-            };
-
-            let splitByAngle = Math.abs(diffAngle(Math.PI, angle)) >= SKIP_STEP_ANGLE_MAX;
-
-            const splitByLevel = Level.isRange(edge.level) && !Level.isRange(currentCoords.level) || forceLevelChange;
-            splitByAngle = splitByAngle && !(currentCoords.level && Level.isRange(currentCoords.level));
-
-
-            const splitByEndOfLevelChange = previousStep?.levelChange && !Level.isRange(currentCoords.level)
-                || forceEndOfLevelChange;
-
-            const splitStepCondition = splitByAngle || splitByLevel || splitByEndOfLevelChange || isEntrance;
-
-            // New step creation
-            if (isFirstStep || splitStepCondition) {
-
-                let levelChange: LevelChange | undefined;
-
-                if (splitByLevel) {
-                    const difference = Level.diff(currentCoords.level, nextCoords.level) || 0;
-                    let direction: 'up' | 'down' = difference > 0 ? 'up' : 'down';
-                    if (forceLevelChange) {
-                        direction = forceLevelChange;
-                    }
-                    levelChange = {
-                        difference, direction, ...(levelChangeType && { type: levelChangeType })
-                    };
-                }
-
-                currentStep = {
-                    coords: currentCoords,
-                    ...(stepName && { name: stepName }),
-                    extras: stepExtras,
-                    levelChange,
-                    distance: 0,
-                    duration: 0
-                };
-
-                stepsInfo.push(currentStep);
-            }
-
-            currentStep!.distance! += currentCoords.distanceTo(nextCoords);
-            currentStep!.duration! += duration;
-
-            previousBearing = nextBearing;
-        }
-
-        const lastCoords = graphRoute.vertices[graphRoute.vertices.length - 1].coords;
-
-        // Create a last step if end is not on the graph
-        if (!Coordinates.equals(lastCoords, end)) {
-            stepsInfo.push({ coords: lastCoords });
-        }
-
-        this.setStart(start);
-        this.setEnd(end);
-        this.setPathCoords(graphRoute.vertices.map(v => v.coords));
-        this.setStepsInfo(stepsInfo);
-
-        return this;
-    }
-
-    build(): Step[] {
-
-        const { pathCoords, start, end } = this;
-
-        if (!pathCoords) {
-            Logger.warn(`StepsBuilder: Missing "pathCoords" property to build steps`);
-            return [];
-        }
-
-        if (!start) {
-            Logger.warn(`StepsBuilder: Missing "from" property to build steps`);
-            return [];
-        }
-
-        if (!end) {
-            Logger.warn(`StepsBuilder: Missing "to" property to build steps`);
-            return [];
-        }
-
-        if (this.stepsInfo.length === 0) {
-            // If there is no steps info, steps coordinates are calculated using our steps calculation algorithm above.
-            this.setGraphRoute(GraphRoute.fromCoordinates(start, end, pathCoords));
-        }
-
-        const { stepsInfo } = this;
-
-        return stepsInfo.map((stepInfo, stepId) => {
-            const coordsId = pathCoords.findIndex(coords => coords.equals(stepInfo.coords));
-            if (coordsId === -1) {
-                throw new Error('Cannot find step coordinates in itinerary coordinates.');
-            }
-
-            const coordsBeforeStep = coordsId === 0 ? start : pathCoords[coordsId - 1];
-            const coordsAfterStep = coordsId === pathCoords.length - 1
-                ? end
-                : pathCoords[coordsId + 1];
-
-            const previousBearing = coordsBeforeStep.bearingTo(stepInfo.coords);
-            const nextBearing = stepInfo.coords.bearingTo(coordsAfterStep);
-
-            let distance = 0;
-            const isLastStep = stepId === stepsInfo.length - 1;
-            const coordsToStopCalculation = isLastStep
-                ? pathCoords[pathCoords.length - 1]
-                : stepsInfo[stepId + 1].coords;
-
-            let currentCoordsId = coordsId;
-            while (!pathCoords[currentCoordsId].equals(coordsToStopCalculation)) {
-                distance += pathCoords[currentCoordsId].distanceTo(pathCoords[currentCoordsId + 1]);
-                currentCoordsId++;
-            }
-
-            return {
-                coords: stepInfo.coords,
-                name: stepInfo.name || null,
-                number: stepId + 1,
-                previousBearing,
-                nextBearing,
-                angle: diffAngle(previousBearing, nextBearing + Math.PI),
-                firstStep: stepId === 0,
-                lastStep: isLastStep,
-                distance, // stepInfo.distance is overwritten
-                duration: stepInfo.duration || getDurationFromLength(distance),
-                levelChange: stepInfo.levelChange || null,
-                extras: stepInfo.extras || null
-            }
-        });
-    }
-
-}

package/src/model/TransitMode.spec.ts

@@ -1,31 +0,0 @@
-import chai from 'chai';
-
-import { isTransitModePublicTransport, areTransitAndTravelModeConsistent } from './TransitMode.js';
-
-const { expect } = chai;
-
-describe('TransitMode', () => {
-
-    it('transit and travel mode consistent', () => {
-        expect(areTransitAndTravelModeConsistent('AIRPLANE', 'TRANSIT')).is.true;
-        expect(areTransitAndTravelModeConsistent('BOAT', 'TRANSIT' )).is.true;
-        expect(areTransitAndTravelModeConsistent('BUS', 'TRANSIT' )).is.true;
-        expect(areTransitAndTravelModeConsistent('FERRY', 'TRANSIT' )).is.true;
-        expect(areTransitAndTravelModeConsistent('FUNICULAR', 'TRANSIT' )).is.true;
-        expect(areTransitAndTravelModeConsistent('METRO', 'TRANSIT' )).is.true;
-        expect(areTransitAndTravelModeConsistent('TRAIN', 'TRANSIT' )).is.true;
-        expect(areTransitAndTravelModeConsistent('TRAM', 'TRANSIT' )).is.true;
-        expect(areTransitAndTravelModeConsistent('MULTI', 'TRANSIT' )).is.true;
-
-        expect(areTransitAndTravelModeConsistent('BIKE', 'TRANSIT')).is.false;
-        expect(areTransitAndTravelModeConsistent('CAR', 'TRANSIT')).is.false;
-        expect(areTransitAndTravelModeConsistent('MOTO', 'TRANSIT')).is.false;
-        expect(areTransitAndTravelModeConsistent('TAXI', 'TRANSIT')).is.false;
-
-        expect(areTransitAndTravelModeConsistent('WALK', 'TRANSIT')).is.true;
-        expect(areTransitAndTravelModeConsistent('WALK', 'WALK')).is.true;
-        expect(areTransitAndTravelModeConsistent('BIKE', 'BIKE')).is.true;
-        expect(areTransitAndTravelModeConsistent('CAR', 'CAR')).is.true;
-    });
-
-});

package/src/model/TransitMode.ts

@@ -1,28 +0,0 @@
-import { TravelMode } from "./TravelMode";
-
-export type TransitMode = 'AIRPLANE' | 'BOAT' | 'BIKE' | 'BUS' | 'CAR' |
-    'FERRY' | 'FUNICULAR' | 'METRO' | 'MOTO' | 'TRAIN' | 'TAXI' |
-    'TRAM' | 'WALK' | 'MULTI' | 'UNKNOWN';
-
-export type PublicTransport = 'AIRPLANE' | 'BOAT' | 'BUS' |
-    'FERRY' | 'FUNICULAR' | 'METRO' | 'MULTI' | 'TRAIN' | 'TRAM';
-
-export function isTransitModePublicTransport(transitMode: TransitMode): transitMode is PublicTransport {
-    return [
-        'AIRPLANE', 'BOAT', 'BUS', 'FERRY',
-        'FUNICULAR', 'METRO', 'MULTI', 'TRAIN', 'TRAM'
-    ].includes(transitMode);
-}
-
-// Check if the transit mode and the travel mode are consistent
-// If they are strictly equal
-// Edge cases:
-// If the transit mode is public transport and the travel mode is 'TRANSIT'
-// If the transit mode is 'WALK' and the travel mode is 'TRANSIT'
-export function areTransitAndTravelModeConsistent(transitMode: TransitMode, travelMode: TravelMode): boolean {
-    return (
-        transitMode === travelMode
-        || (isTransitModePublicTransport(transitMode) && travelMode === 'TRANSIT')
-        || (transitMode === 'WALK' && travelMode === 'TRANSIT')
-    );
-}

package/src/model/generateSteps.ts

@@ -1,102 +0,0 @@
-// import { Coordinates, Level } from '@wemap/geo';
-// import { diffAngle, deg2rad } from '@wemap/maths';
-// import Leg from './Leg.js';
-
-// import { LevelChange, LevelChangeType } from './LevelChange.js';
-// import { MinStepInfo } from './Step.js';
-// import { StepExtra } from './StepExtra.js';
-
-// const SKIP_STEP_ANGLE_MAX = deg2rad(20);
-
-// export type StepsGenerationRules =
-//     (currentCoords: Coordinates, nextCoords: Coordinates, previousStep: MinStepInfo | null) => {
-//         createNewStep?: boolean;
-//         duration?: number;
-//         stepName?: string;
-//         stepExtras?: StepExtra;
-//         levelChangeType?: LevelChangeType;
-//         forceLevelChange?: 'up' | 'down';
-//         forceEndOfLevelChange?: boolean;
-//     };
-
-// export default function generateSteps(leg: Leg, rules?: StepsGenerationRules) {
-
-//     const steps: MinStepInfo[] = [];
-
-//     const { from, to, coords: coordsArray } = leg;
-
-//     let currentStep: MinStepInfo | null = null;
-//     let previousBearing = from.coords.bearingTo(coordsArray[0]);
-
-//     for (let i = 0; i < coordsArray.length - 1; i++) {
-
-//         const isFirstStep = i === 0;
-
-//         const currentCoords = coordsArray[i];
-//         const nextCoords = coordsArray[i + 1];
-//         const edgeLevel = Level.union(currentCoords.level, nextCoords.level);
-
-//         const nextBearing = currentCoords.bearingTo(nextCoords);
-//         const angle = diffAngle(previousBearing, nextBearing + Math.PI);
-
-//         const previousStep = steps.length ? steps[steps.length - 1] : null;
-//         const customRules = rules?.(currentCoords, nextCoords, previousStep);
-
-//         let splitByAngle = Math.abs(diffAngle(Math.PI, angle)) >= SKIP_STEP_ANGLE_MAX;
-
-//         const splitByLevel = Level.isRange(edgeLevel) && !Level.isRange(currentCoords.level) || customRules?.forceLevelChange;
-//         splitByAngle = splitByAngle && !(currentCoords.level && Level.isRange(currentCoords.level));
-
-
-//         const splitByEndOfLevelChange = previousStep?.levelChange && !Level.isRange(currentCoords.level)
-//             || customRules?.forceEndOfLevelChange;
-
-//         const splitStepCondition = splitByAngle || splitByLevel || splitByEndOfLevelChange || customRules?.createNewStep;
-
-//         // New step creation
-//         if (isFirstStep || splitStepCondition) {
-
-//             let levelChange: LevelChange | undefined;
-
-//             if (splitByLevel) {
-//                 const difference = Level.diff(currentCoords.level, nextCoords.level) || 0;
-//                 let direction: 'up' | 'down' = difference > 0 ? 'up' : 'down';
-//                 if (customRules?.forceLevelChange) {
-//                     direction = customRules?.forceLevelChange;
-//                 }
-//                 levelChange = { difference, direction, type: customRules?.levelChangeType };
-//             }
-
-//             // Remove duration in the case of rules do not provide duration.
-//             if (currentStep && currentStep.duration === 0) {
-//                 delete currentStep.duration;
-//             }
-
-//             currentStep = {
-//                 coords: currentCoords,
-//                 name: customRules?.stepName,
-//                 extras: customRules?.stepExtras,
-//                 levelChange,
-//                 distance: 0,
-//                 duration: 0
-//             };
-
-//             steps.push(currentStep);
-//         }
-
-//         currentStep!.distance! += currentCoords.distanceTo(nextCoords);
-//         if (customRules?.duration) {
-//             currentStep!.duration! += customRules?.duration;
-//         }
-//         previousBearing = nextBearing;
-//     }
-
-//     const lastCoords = coordsArray[coordsArray.length - 1];
-
-//     // Create a last step if end is not on the network
-//     if (!Coordinates.equals(lastCoords, to.coords)) {
-//         steps.push({ coords: lastCoords });
-//     }
-
-//     return steps;
-// }

package/src/remote/RemoteRouterManager.spec.ts

@@ -1,178 +0,0 @@
-import chai from 'chai';
-import chaiAlmost from 'chai-almost';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import fetchMock from 'fetch-mock';
-
-import { Coordinates } from '@wemap/geo';
-
-import RemoteRouterManager, { RoutingFallbackStrategy } from './RemoteRouterManager.js';
-import { RemoteRoutingError } from '../RoutingError.js';
-
-type MockAny = any;
-
-const { expect } = chai;
-chai.use(chaiAlmost(0.1));
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const assetsPath = path.resolve(__dirname, '../../assets');
-const osrmPath = path.resolve(assetsPath, 'itinerary-montpellier-outdoor.json');
-const osrmJson = JSON.parse(fs.readFileSync(osrmPath, 'utf8'));
-
-describe('RemoteRouterManager', () => {
-    afterEach(() => {
-        fetchMock.restore();
-    });
-
-    describe('getRouterByName', () => {
-        it('should return the router', () => {
-            const router = RemoteRouterManager.getRouterByName('osrm');
-            expect(router).not.null;
-        });
-
-        it('should return undefined if router is unknown', () => {
-            const router = RemoteRouterManager.getRouterByName('unknown' as MockAny);
-
-            expect(router).to.be.undefined;
-        });
-    });
-
-    describe('getItineraries', () => {
-        it('should return itineraries', async () => {
-            fetchMock.mock('*', (() => {
-                return osrmJson;
-            })())
-
-            const routerRequest = {
-                origin: new Coordinates(48.8725992, 2.343431),
-                destination: new Coordinates(48.8725694, 2.3433),
-                travelMode: 'WALK'
-            } as const;
-
-            const itineraries = await RemoteRouterManager.getItineraries('osrm', 'http://localhost:3001', routerRequest);
-            expect(itineraries).not.empty;
-        });
-
-        it('should throw an error if router is unknown', (done) => {
-            const routerRequest = {
-                origin: new Coordinates(48.8725992, 2.343431),
-                destination: new Coordinates(48.8725694, 2.3433),
-                travelMode: 'WALK'
-            } as const;
-
-            RemoteRouterManager.getItineraries('unknown' as MockAny, 'http://localhost:3001', routerRequest)
-                .then(() => done('should throw an error'))
-                .catch(() => done());
-        });
-
-        it('should throw an error on server error', (done) => {
-            fetchMock.mock('*', (() => {
-                return new Response(null, { status: 404 });
-            })())
-
-            const routerRequest = {
-                origin: new Coordinates(48.8725992, 2.343431),
-                destination: new Coordinates(48.8725694, 2.3433),
-                travelMode: 'WALK'
-            } as const;
-
-            RemoteRouterManager.getItineraries('unknown' as MockAny, 'http://localhost:3001', routerRequest)
-                .then(() => done('should throw an error'))
-                .catch(() => done());
-        });
-    });
-
-    describe('getItinerariesWithFallback', () => {
-        it('should return itineraries', async () => {
-            fetchMock.mock('*', (() => {
-                return osrmJson;
-            })())
-
-            const routerRequest = {
-                origin: new Coordinates(48.8725992, 2.343431),
-                destination: new Coordinates(48.8725694, 2.3433),
-                travelMode: 'WALK'
-            } as const;
-
-            const fallbackStrategy: RoutingFallbackStrategy = [
-                { name: 'osrm', endpointUrl: 'http://localhost:3001' }
-            ];
-
-            const itineraries = await RemoteRouterManager.getItinerariesWithFallback(routerRequest, fallbackStrategy);
-            expect(itineraries).not.empty;
-        });
-
-        it('should throw an error if all routers are unknown', (done) => {
-            const routerRequest = {
-                origin: new Coordinates(48.8725992, 2.343431),
-                destination: new Coordinates(48.8725694, 2.3433),
-                travelMode: 'WALK'
-            } as const;
-
-            const fallbackStrategy = [
-                { name: 'unknown' as MockAny, endpointUrl: 'http://localhost:3001/unknown' }
-            ];
-
-            RemoteRouterManager.getItinerariesWithFallback(routerRequest, fallbackStrategy)
-                .then(() => done('should throw an error'))
-                .catch((error) => {
-                    expect(error instanceof RemoteRoutingError).to.be.true;
-                    expect((error as RemoteRoutingError).routerName).equal('unknown');
-                    expect((error as RemoteRoutingError).message).to.contains('http://localhost:3001/unknown');
-
-                    done();
-                });
-        });
-
-        it('should throw an error if all routers are unreachable and return all errors', (done) => {
-            fetchMock.mock('*', (() => {
-                return new Response(null, { status: 404 });
-            })())
-
-            const routerRequest = {
-                origin: new Coordinates(48.8725992, 2.343431),
-                destination: new Coordinates(48.8725694, 2.3433),
-                travelMode: 'WALK'
-            } as const;
-
-            const fallbackStrategy = [
-                { name: 'osrm', endpointUrl: 'http://localhost:3001/osrm' },
-                { name: 'unknown' as MockAny, endpointUrl: 'http://localhost:3001/unknown' }
-            ];
-
-            RemoteRouterManager.getItinerariesWithFallback(routerRequest, fallbackStrategy)
-                .then(() => done('should throw an error'))
-                .catch((error) => {
-                    expect(error instanceof RemoteRoutingError).to.be.true;
-                    expect((error as RemoteRoutingError).routerName).equal('osrm, unknown');
-                    expect((error as RemoteRoutingError).message).to.contains('http://localhost:3001/osrm');
-                    expect((error as RemoteRoutingError).message).to.contains('http://localhost:3001/unknown');
-
-                    done();
-                });
-        });
-
-        it('should return itineraries and use fallback router if previous one fails', async () => {
-            fetchMock.mock('*', (() => {
-                return osrmJson;
-            })())
-
-            const routerRequest = {
-                origin: new Coordinates(48.8725992, 2.343431),
-                destination: new Coordinates(48.8725694, 2.3433),
-                travelMode: 'WALK'
-            } as const;
-
-            const fallbackStrategy = [
-                { name: 'unknown' as MockAny, endpointUrl: 'http://localhost:3001/unknown' },
-                { name: 'osrm', endpointUrl: 'http://localhost:3001/osrm' }
-            ];
-
-            const itineraries = await RemoteRouterManager.getItinerariesWithFallback(routerRequest, fallbackStrategy);
-            expect(itineraries).not.empty;
-        });
-
-    });
-
-});

package/src/remote/RemoteRouterManager.ts

@@ -1,72 +0,0 @@
-import RemoteRouter from './RemoteRouter.js';
-import CitywayRemoteRouter from './cityway/CitywayRemoteRouter.js';
-import NavitiaRemoteRouter from './navitia/NavitiaRemoteRouter.js';
-import DeutscheBahnRemoteRouter from './deutsche-bahn/DeutscheBahnRemoteRouter.js';
-import IdfmRemoteRouter from './idfm/IdfmRemoteRouter.js';
-import OsrmRemoteRouter from './osrm/OsrmRemoteRouter.js';
-import OtpRemoteRouter from './otp/OtpRemoteRouter.js';
-import WemapMultiRemoteRouter from './wemap-multi/WemapMultiRemoteRouter.js';
-import { RouterRequest } from '../model/RouterRequest.js';
-import { RemoteRoutingError } from '../RoutingError.js';
-
-const remoteRouters = [
-    CitywayRemoteRouter,
-    NavitiaRemoteRouter,
-    DeutscheBahnRemoteRouter,
-    IdfmRemoteRouter,
-    OsrmRemoteRouter,
-    OtpRemoteRouter,
-    WemapMultiRemoteRouter
-] as const;
-
-export type RemoteRouterName = typeof remoteRouters[number]['rname'];
-
-export type RoutingFallbackStrategy = { name: RemoteRouterName, endpointUrl: string }[];
-
-/**
- * Singleton
- */
-class RemoteRouterManager {
-
-    getRouterByName(name: RemoteRouterName): RemoteRouter {
-        return remoteRouters.find(remoteRouter => remoteRouter.rname === name) as RemoteRouter;
-    }
-
-    async getItineraries(name: RemoteRouterName, endpointUrl: string, routerRequest: RouterRequest) {
-        const router = this.getRouterByName(name);
-        if (!router) {
-            throw RemoteRoutingError.notFound(name, `Unknown "${name}" remote router`);
-        }
-        return router.getItineraries(endpointUrl, routerRequest);
-    }
-
-    async getItinerariesWithFallback(routerRequest: RouterRequest, fallbackStrategy: RoutingFallbackStrategy) {
-        let itineraries;
-        const errors = [];
-        for (const { name, endpointUrl } of fallbackStrategy) {
-            try {
-                itineraries = await this.getItineraries(name, endpointUrl, routerRequest);
-                if (itineraries.length) {
-                    return itineraries;
-                }
-            } catch (error) {
-                if (error instanceof RemoteRoutingError) {
-                    errors.push({
-                        name,
-                        endpointUrl,
-                        error
-                    });
-                } else {
-                    throw error;
-                }
-            }
-        }
-
-        const routersNames = fallbackStrategy.map(({ name }) => name).join(', ');
-        const errorsMessages = errors.map(routerError => `(${routerError.name}) Could not find an itinerary on endpoint: ${routerError.endpointUrl}. Details: ${routerError.error.message}`).join('\n');
-
-        throw RemoteRoutingError.notFound(routersNames, errorsMessages)
-    }
-}
-
-export default new RemoteRouterManager();

package/src/remote/RemoteRouterUtils.ts

@@ -1,25 +0,0 @@
-import { RoutingError } from "../RoutingError";
-
-/**
- * Create and return a date with a given timezone
- * timeZone - timezone name (e.g. 'Europe/Paris')
- */
-export function dateWithTimeZone(
-    year: number, month: number, day: number,
-    hour: number, minute: number, second: number,
-    timeZone = 'Europe/Paris'
-) {
-    const date = new Date(Date.UTC(year, month, day, hour, minute, second));
-
-    const utcDate = new Date(date.toLocaleString('en-US', { timeZone: 'UTC' }));
-    const tzDate = new Date(date.toLocaleString('en-US', { timeZone: timeZone }));
-    const offset = utcDate.getTime() - tzDate.getTime();
-
-    date.setTime(date.getTime() + offset);
-
-    return date;
-}
-
-export function isRoutingError(e: unknown): e is Error {
-    return e instanceof RoutingError;
-}