@wemap/routers 12.0.0-alpha.5 → 12.0.0-alpha.7

package/dist/index.js

@@ -944,31 +944,31 @@ class RouterResponse {
 }
 const _GraphRouterOptionsBuilder = class _GraphRouterOptionsBuilder {
   constructor() {
-    __publicField(this, "useStairs", true);
-    __publicField(this, "useEscalators", true);
-    __publicField(this, "useElevators", true);
-    __publicField(this, "useMovingWalkway", true);
-    __publicField(this, "useTicketRestrictedAreas", true);
+    __publicField(this, "avoidStairs", false);
+    __publicField(this, "avoidEscalators", false);
+    __publicField(this, "avoidElevators", false);
+    __publicField(this, "avoidMovingWalkway", false);
+    __publicField(this, "avoidTicketRestrictedAreas", false);
     __publicField(this, "projectionMaxDistance");
   }
-  setUseStairs(useStairs) {
-    this.useStairs = useStairs;
+  setAvoidStairs(avoidStairs) {
+    this.avoidStairs = avoidStairs;
     return this;
   }
-  setUseEscalators(useEscalators) {
-    this.useEscalators = useEscalators;
+  setAvoidEscalators(avoidEscalators) {
+    this.avoidEscalators = avoidEscalators;
     return this;
   }
-  setUseElevators(useElevators) {
-    this.useElevators = useElevators;
+  setAvoidElevators(avoidElevators) {
+    this.avoidElevators = avoidElevators;
     return this;
   }
-  setUseMovingWalkway(useMovingWalkway) {
-    this.useMovingWalkway = useMovingWalkway;
+  setAvoidMovingWalkway(avoidMovingWalkway) {
+    this.avoidMovingWalkway = avoidMovingWalkway;
     return this;
   }
-  setUseTicketRestrictedAreas(useTicketRestrictedAreas) {
-    this.useTicketRestrictedAreas = useTicketRestrictedAreas;
+  setAvoidTicketRestrictedAreas(avoidTicketRestrictedAreas) {
+    this.avoidTicketRestrictedAreas = avoidTicketRestrictedAreas;
     return this;
   }
   static fromJson(options) {
@@ -988,25 +988,25 @@ const _GraphRouterOptionsBuilder = class _GraphRouterOptionsBuilder {
       return duration;
     };
     const acceptEdgeFn = (edge) => {
-      if (!this.useStairs && edge.properties.areStairs)
+      if (this.avoidStairs && edge.properties.areStairs)
         return false;
-      if (!this.useEscalators && edge.properties.areEscalators)
+      if (this.avoidEscalators && edge.properties.areEscalators)
         return false;
-      if (!this.useElevators && edge.properties.isElevator)
+      if (this.avoidElevators && edge.properties.isElevator)
         return false;
-      if (!this.useMovingWalkway && edge.properties.isMovingWalkway)
+      if (this.avoidMovingWalkway && edge.properties.isMovingWalkway)
         return false;
-      if (!this.useTicketRestrictedAreas && edge.properties.needTicket)
+      if (this.avoidTicketRestrictedAreas && edge.properties.needTicket)
         return false;
       return true;
     };
     return {
       input: {
-        useStairs: this.useStairs,
-        useEscalators: this.useEscalators,
-        useElevators: this.useElevators,
-        useMovingWalkway: this.useMovingWalkway,
-        useTicketRestrictedAreas: this.useTicketRestrictedAreas,
+        avoidStairs: this.avoidStairs,
+        avoidEscalators: this.avoidEscalators,
+        avoidElevators: this.avoidElevators,
+        avoidMovingWalkway: this.avoidMovingWalkway,
+        avoidTicketRestrictedAreas: this.avoidTicketRestrictedAreas,
         projectionMaxDistance: this.projectionMaxDistance
       },
       weightEdgeFn,
@@ -1016,7 +1016,7 @@ const _GraphRouterOptionsBuilder = class _GraphRouterOptionsBuilder {
   }
 };
 __publicField(_GraphRouterOptionsBuilder, "DEFAULT", new _GraphRouterOptionsBuilder().build());
-__publicField(_GraphRouterOptionsBuilder, "WITHOUT_STAIRS", new _GraphRouterOptionsBuilder().setUseStairs(false).build());
+__publicField(_GraphRouterOptionsBuilder, "WITHOUT_STAIRS", new _GraphRouterOptionsBuilder().setAvoidStairs(true).build());
 let GraphRouterOptionsBuilder = _GraphRouterOptionsBuilder;
 class GraphRouterEngineResults {
   constructor(prev, dist, source, targets, edges) {
@@ -1528,29 +1528,30 @@ class CitywayRemoteRouter extends RemoteRouter {
    * @throws {transitModeCorrespondanceNotFound}
    * @throws {RemoteRouterServerUnreachable}
    */
-  async getItineraries(endpointUrl, travelMode, travelModePreference, waypoints) {
-    const url = this.getURL(endpointUrl, travelMode, waypoints);
+  async getItineraries(endpointUrl, routerRequest) {
+    const url = this.getURL(endpointUrl, routerRequest);
     const res = await fetch(url).catch(() => {
       throw new RemoteRouterServerUnreachable(this.rname, url);
     });
     const jsonResponse = await res.json().catch(() => {
       throw new RemoteRouterServerUnreachable(this.rname, url);
     });
-    return this.createRouterResponseFromJson(jsonResponse, waypoints[0], waypoints[1]);
+    return this.createRouterResponseFromJson(jsonResponse, routerRequest.origin, routerRequest.destination);
   }
   /**
    * @throws {transitModeCorrespondanceNotFound}
    */
-  getURL(endpointUrl, mode, waypoints) {
-    const citywayMode = inputModeCorrespondance$2.get(mode);
+  getURL(endpointUrl, routerRequest) {
+    const { origin, destination, travelMode, waypoints } = routerRequest;
+    const citywayMode = inputModeCorrespondance$2.get(travelMode);
     if (!citywayMode) {
-      throw new TransitModeCorrespondanceNotFound(this.rname, mode);
+      throw new TransitModeCorrespondanceNotFound(this.rname, travelMode);
     }
-    if (waypoints.length > 2) {
-      Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
+    if ((waypoints || []).length > 0) {
+      Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints == null ? void 0 : waypoints.length})`);
     }
-    const fromPlace = `DepartureLatitude=${waypoints[0].latitude}&DepartureLongitude=${waypoints[0].longitude}`;
-    const toPlace = `ArrivalLatitude=${waypoints[1].latitude}&ArrivalLongitude=${waypoints[1].longitude}`;
+    const fromPlace = `DepartureLatitude=${origin.latitude}&DepartureLongitude=${origin.longitude}`;
+    const toPlace = `ArrivalLatitude=${destination.latitude}&ArrivalLongitude=${destination.longitude}`;
     const queryMode = `TripModes=${citywayMode}`;
     const url = new URL(endpointUrl);
     let { search } = url;
@@ -1714,18 +1715,19 @@ class DeutscheBahnRemoteRouter extends RemoteRouter {
    * @override
    * @throws {RemoteRouterServerUnreachable}
    */
-  async getItineraries(endpointUrl, travelMode, travelModePreference, waypoints) {
-    const url = this.getURL(endpointUrl, travelMode, waypoints);
+  async getItineraries(endpointUrl, routerRequest) {
+    const url = this.getURL(endpointUrl, routerRequest);
     const res = await fetch(url).catch(() => {
       throw new RemoteRouterServerUnreachable(this.rname, url);
     });
     const jsonResponse = await res.json().catch(() => {
       throw new RemoteRouterServerUnreachable(this.rname, url);
     });
-    return this.createRouterResponseFromJson(jsonResponse, waypoints[0], waypoints[1]);
+    return this.createRouterResponseFromJson(jsonResponse, routerRequest.origin, routerRequest.destination);
   }
-  getURL(endpointUrl, mode, waypoints) {
+  getURL(endpointUrl, routerRequest) {
     let url = endpointUrl + "/route/v1/walking/";
+    const waypoints = [routerRequest.origin, ...routerRequest.waypoints || [], routerRequest.destination];
     url += waypoints.map((waypoint) => {
       if (waypoint.level !== null) {
         const altitude = geo.Level.isRange(waypoint.level) ? waypoint.level[0] : waypoint.level;
@@ -1834,8 +1836,8 @@ class IdfmRemoteRouter extends RemoteRouter {
    * @throws {IdfmRemoteRouterTokenError}
    * @throws {RemoteRouterServerUnreachable}
    */
-  async getItineraries(endpointUrl, travelMode, travelModePreference, waypoints, options = {}) {
-    const url = this.getURL(endpointUrl, travelMode, waypoints, options);
+  async getItineraries(endpointUrl, routerRequest) {
+    const url = this.getURL(endpointUrl, routerRequest);
     const res = await fetch(url, {
       method: "GET",
       headers: { apiKey }
@@ -1848,36 +1850,38 @@ class IdfmRemoteRouter extends RemoteRouter {
     if (jsonResponse && jsonResponse.error) {
       return new RouterResponse({
         routerName: this.rname,
-        from: waypoints[0],
-        to: waypoints[1],
+        from: routerRequest.origin,
+        to: routerRequest.destination,
         error: jsonResponse.error.message || "no details."
       });
     }
-    const routerResponse = this.createRouterResponseFromJson(jsonResponse, waypoints[0], waypoints[1]);
-    const sameModeFound = routerResponse.itineraries.some((itinerary) => itinerary.mode === travelMode);
+    const routerResponse = this.createRouterResponseFromJson(jsonResponse, routerRequest.origin, routerRequest.destination);
+    const sameModeFound = routerResponse.itineraries.some((itinerary) => itinerary.mode === routerRequest.travelMode);
     if (!sameModeFound) {
       return new RouterResponse({
         routerName: this.rname,
-        from: waypoints[0],
-        to: waypoints[1],
+        from: routerRequest.origin,
+        to: routerRequest.destination,
         error: "Selected mode of transport was not found for this itinerary."
       });
     }
     return routerResponse;
   }
-  getURL(endpointUrl, mode, waypoints, options) {
-    if (waypoints.length > 2) {
-      Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
+  getURL(endpointUrl, routerRequest) {
+    var _a;
+    const { origin, destination, waypoints, travelMode } = routerRequest;
+    if ((waypoints || []).length > 0) {
+      Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints == null ? void 0 : waypoints.length})`);
     }
     const url = new URL(endpointUrl);
     const coreParams = new URLSearchParams();
-    coreParams.set("from", `${waypoints[0].longitude};${waypoints[0].latitude}`);
-    coreParams.set("to", `${waypoints[1].longitude};${waypoints[1].latitude}`);
-    if ("useStairs" in options && !options.useStairs) {
+    coreParams.set("from", `${origin.longitude};${origin.latitude}`);
+    coreParams.set("to", `${destination.longitude};${destination.latitude}`);
+    if ((_a = routerRequest.itineraryModifiers) == null ? void 0 : _a.avoidStairs) {
       coreParams.set("wheelchair", "true");
     }
     let queryParams = new URLSearchParams();
-    switch (mode) {
+    switch (travelMode) {
       case "WALK":
         queryParams = this.getWalkingQuery();
         break;
@@ -2062,7 +2066,11 @@ class TravelModeCorrespondanceNotFound extends Error {
     this.transitMode = transitMode;
   }
 }
-const inputModeCorrespondance$1 = (travelMode, preference) => {
+const inputModeCorrespondance$1 = (routerRequest) => {
+  var _a;
+  const { travelMode, travelModePreference: preference } = routerRequest;
+  if (travelMode === "WALK" && ((_a = routerRequest.itineraryModifiers) == null ? void 0 : _a.avoidStairs))
+    return "pmr";
   if (travelMode === "WALK")
     return "walking";
   if (travelMode === "BIKE") {
@@ -2093,27 +2101,23 @@ class OsrmRemoteRouter extends RemoteRouter {
    * @throws {RemoteRouterServerUnreachable}
    * @throws {TravelModeCorrespondanceNotFound}
    */
-  async getItineraries(endpointUrl, travelMode, travelModePreference, waypoints, options = {}) {
-    const url = this.getURL(endpointUrl, travelMode, travelModePreference, waypoints, options);
+  async getItineraries(endpointUrl, routerRequest) {
+    const url = this.getURL(endpointUrl, routerRequest);
     const res = await fetch(url).catch(() => {
       throw new RemoteRouterServerUnreachable(this.rname, url);
     });
     const jsonResponse = await res.json().catch(() => {
       throw new RemoteRouterServerUnreachable(this.rname, url);
     });
-    const from = waypoints[0];
-    const to = waypoints[waypoints.length - 1];
-    inputModeCorrespondance$1(travelMode, travelModePreference);
-    return this.createRouterResponseFromJson(jsonResponse, from, to, outputModeCorrespondance.get(travelMode));
+    return this.createRouterResponseFromJson(jsonResponse, routerRequest.origin, routerRequest.destination, routerRequest.travelMode);
   }
   /**
    * @throws {TravelModeCorrespondanceNotFound}
    */
-  getURL(endpointUrl, travelMode, travelModePreference, waypoints, options = {}) {
-    let osrmMode = inputModeCorrespondance$1(travelMode, travelModePreference);
-    if ("useStairs" in options && !options.useStairs) {
-      osrmMode = "pmr";
-    }
+  getURL(endpointUrl, routerRequest) {
+    const { origin, destination } = routerRequest;
+    const osrmMode = inputModeCorrespondance$1(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";
@@ -2227,7 +2231,8 @@ class OsrmRemoteRouter extends RemoteRouter {
       "waypoints": []
     };
   }
-  createRouterResponseFromJson(json, from, to, transitMode) {
+  createRouterResponseFromJson(json, from, to, travelMode) {
+    const transitMode = outputModeCorrespondance.get(travelMode);
     const routerResponse = new RouterResponse({ routerName: this.rname, from, to });
     const { routes: jsonRoutes } = json;
     if (!jsonRoutes) {
@@ -2297,29 +2302,30 @@ class OtpRemoteRouter extends RemoteRouter {
    * @throws {RemoteRouterServerUnreachable}
    * @throws {TravelModeCorrespondanceNotFound}
    */
-  async getItineraries(endpointUrl, travelMode, travelModePreference, waypoints) {
-    const url = this.getURL(endpointUrl, travelMode, waypoints);
+  async getItineraries(endpointUrl, routerRequest) {
+    const url = this.getURL(endpointUrl, routerRequest);
     const res = await fetch(url).catch(() => {
       throw new RemoteRouterServerUnreachable(this.rname, url);
     });
     const jsonResponse = await res.json().catch(() => {
       throw new RemoteRouterServerUnreachable(this.rname, url);
     });
-    return this.createRouterResponseFromJson(jsonResponse, waypoints[0], waypoints[1]);
+    return this.createRouterResponseFromJson(jsonResponse, routerRequest.origin, routerRequest.destination);
   }
   /**
    * @throws {TravelModeCorrespondanceNotFound}
    */
-  getURL(endpointUrl, mode, waypoints) {
-    const otpMode = inputModeCorrespondance.get(mode);
+  getURL(endpointUrl, routerRequest) {
+    const { origin, destination, waypoints, travelMode } = routerRequest;
+    const otpMode = inputModeCorrespondance.get(travelMode);
     if (!otpMode) {
-      throw new TravelModeCorrespondanceNotFound(this.rname, mode);
+      throw new TravelModeCorrespondanceNotFound(this.rname, travelMode);
     }
-    if (waypoints.length > 2) {
-      Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
+    if ((waypoints || []).length > 0) {
+      Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints == null ? void 0 : waypoints.length})`);
     }
-    const fromPlace = `fromPlace=${waypoints[0].latitude},${waypoints[0].longitude}`;
-    const toPlace = `toPlace=${waypoints[1].latitude},${waypoints[1].longitude}`;
+    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;
@@ -2402,44 +2408,25 @@ class OtpRemoteRouter extends RemoteRouter {
   }
 }
 const OtpRemoteRouter$1 = new OtpRemoteRouter();
-class WemapMultiRemoteRouterPayload {
-  constructor(waypoints, mode, options = null) {
-    this.waypoints = waypoints;
-    this.mode = mode;
-    this.options = options;
-  }
-  toJson() {
-    return {
-      waypoints: this.waypoints.map((coords) => coords.toCompressedJson()),
-      mode: this.mode,
-      ...this.options && { options: this.options }
-    };
-  }
-  static fromJson(json) {
-    return new WemapMultiRemoteRouterPayload(
-      json.waypoints.map(geo.Coordinates.fromCompressedJson),
-      json.mode,
-      json.options
-    );
-  }
-}
 class WemapMultiRemoteRouter extends RemoteRouter {
   get rname() {
     return "wemap-multi";
   }
-  async getItineraries(endpointUrl, travelMode, travelModePreference, waypoints, options) {
-    const payload = new WemapMultiRemoteRouterPayload(
-      waypoints,
-      travelMode,
-      options
-    );
+  async getItineraries(endpointUrl, routerRequest) {
+    const { origin, destination, waypoints } = routerRequest;
+    const payload = {
+      ...routerRequest,
+      origin: origin instanceof geo.Coordinates ? origin.toJson() : origin,
+      destination: destination instanceof geo.Coordinates ? destination.toJson() : destination,
+      ...waypoints && { waypoints: waypoints.map((w) => w instanceof geo.Coordinates ? w.toJson() : w) }
+    };
     const res = await fetch(endpointUrl, {
       method: "POST",
       headers: {
         "Accept": "application/json",
         "Content-Type": "application/json"
       },
-      body: JSON.stringify(payload.toJson())
+      body: JSON.stringify(payload)
     }).catch(() => {
       throw new RemoteRouterServerUnreachable(this.rname, endpointUrl);
     });
@@ -2467,31 +2454,31 @@ class RemoteRouterManager {
    * @throws {TravelModeCorrespondanceNotFound}
    * @throws {IdfmRemoteRouterTokenError}
    */
-  async getItineraries(name, endpointUrl, travelMode, travelModePreference, waypoints, options) {
+  async getItineraries(name, endpointUrl, routerRequest) {
     const router = this.getRouterByName(name);
     if (!router) {
       throw new Error(`Unknown "${name}" remote router`);
     }
-    return router.getItineraries(endpointUrl, travelMode, travelModePreference, waypoints, options);
+    return router.getItineraries(endpointUrl, routerRequest);
   }
   /**
    * @throws {RemoteRouterServerUnreachable}
    * @throws {TravelModeCorrespondanceNotFound}
    * @throws {IdfmRemoteRouterTokenError}
    */
-  async getItinerariesWithFallback(remoteRouters2, travelMode, travelModePreference, waypoints, options) {
+  async getItinerariesWithFallback(routerRequest, fallbackStrategy) {
     let routerResponse;
-    for (const { name, endpointUrl } of remoteRouters2) {
-      routerResponse = await this.getItineraries(name, endpointUrl, travelMode, travelModePreference, waypoints, options);
+    for (const { name, endpointUrl } of fallbackStrategy) {
+      routerResponse = await this.getItineraries(name, endpointUrl, routerRequest);
       if (routerResponse.itineraries.length) {
         return routerResponse;
       }
     }
     if (!routerResponse) {
       routerResponse = new RouterResponse({
-        routerName: remoteRouters2.map((rr) => rr.name),
-        from: waypoints[0],
-        to: waypoints[waypoints.length]
+        routerName: fallbackStrategy.map((rr) => rr.name),
+        from: routerRequest.origin,
+        to: routerRequest.destination
       });
     }
     return routerResponse;
@@ -2518,86 +2505,51 @@ class WemapMultiRouter {
   getMapByName(mapId) {
     return this.maps.find((map) => map.name === mapId);
   }
-  getIoMapsFromOptions(options) {
-    let ioMapsToTest = this.maps;
-    const targetMaps = options == null ? void 0 : options.targetMaps;
-    if (targetMaps) {
-      ioMapsToTest = this.maps.filter((map) => map.name && targetMaps.includes(map.name));
-      if (ioMapsToTest.length !== targetMaps.length) {
-        ioMapsToTest.forEach((map) => {
-          if (map.name && !targetMaps.includes(map.name)) {
-            Logger.warn(`CustomNetworkMap "${map.name}" not found in WemapMultiRouter`);
-          }
-        });
-      }
-    }
-    return ioMapsToTest;
-  }
   // TODO: Move it away
-  async getTrip(mode, waypoints, options = null) {
-    const ioMapsToTest = this.getIoMapsFromOptions(options);
-    if (waypoints.length < 2) {
-      throw Error(`Cannot retrieve a trip itinerary. Two points or more are necessary`);
-    }
-    if (mode !== "WALK") {
-      throw Error(`Cannot calculate trip itinerary for mode "${mode}". Only "WALK" is implemented.`);
-    }
-    const mapOfWaypoints = waypoints.reduce((map, waypoint) => {
-      const mapOfThisWaypoint = ioMapsToTest.find((map2) => map2.isPointInside(waypoint));
-      if (!mapOfThisWaypoint) {
-        throw Error(`Cannot find a network for this trip waypoint (${waypoint.toString()}). Outdoor trips are not implemented.`);
-      }
-      if (map && mapOfThisWaypoint !== map) {
-        throw Error(`Cannot handle this trip, because two waypoints are on different maps (${mapOfThisWaypoint} and ${mapOfWaypoints}). Multi-map trips are not implemented.`);
-      }
-      return mapOfThisWaypoint;
-    }, null);
-    const routerOptions = GraphRouterOptionsBuilder.fromJson(options || {});
-    const tripRoutes = mapOfWaypoints.getTripInsideMap(waypoints, routerOptions);
-    const tripItineraries = tripRoutes.map((tripRoute) => Itinerary.fromGraphRoute(tripRoute));
-    return new RouterResponse({
-      routerName: this.rname,
-      from: tripItineraries[0].from,
-      to: tripItineraries[tripItineraries.length - 1].to,
-      itineraries: tripItineraries
-    });
-  }
-  async getRoutesMultipleDestinations(start, ends, options = null) {
-    const ioMapsToTest = this.getIoMapsFromOptions(options);
-    const mapOfWaypoints = [start, ...ends].reduce((map, waypoint) => {
-      const mapOfThisWaypoint = ioMapsToTest.find((map2) => map2.isPointInside(waypoint)) || null;
-      if (mapOfThisWaypoint && map && mapOfThisWaypoint !== map) {
-        throw Error(`Cannot handle this itineraries, because two points are on different maps (${mapOfThisWaypoint} and ${mapOfWaypoints}). Multi-map multiple destinations are not implemented.`);
-      }
-      return mapOfThisWaypoint || map;
-    }, null);
-    if (mapOfWaypoints === null) {
-      throw Error(`No map found for this itineraries.`);
-    }
-    const routerOptions = GraphRouterOptionsBuilder.fromJson(options || {});
-    const routes = mapOfWaypoints.getRoutesMultipleDestinationsInsideMap(start, ends, routerOptions);
-    return {
-      routerName: this.rname,
-      itineraries: ends.map((end) => Itinerary.fromGraphRoute(routes.route(end)))
-    };
-  }
-  async getItineraries(travelMode, travelModePreference, waypoints, options = null) {
-    var _a;
-    if (waypoints.length > 2) {
-      Logger.warn(`WemapMultiRouter uses only the first 2 waypoints (asked ${waypoints.length})`);
-    }
-    const start = waypoints[0];
-    const end = waypoints[1];
+  // async getTrip(mode: TravelMode, waypoints: Coordinates[], options: WemapMultiRouterOptions | null = null) {
+  //     const ioMapsToTest = this.getIoMapsFromOptions(options);
+  //     if (waypoints.length < 2) {
+  //         throw Error(`Cannot retrieve a trip itinerary. Two points or more are necessary`);
+  //     }
+  //     if (mode !== 'WALK') {
+  //         throw Error(`Cannot calculate trip itinerary for mode "${mode}". Only "WALK" is implemented.`);
+  //     }
+  //     // Retrieve the map which embed all the waypoints
+  //     const mapOfWaypoints = waypoints.reduce((map, waypoint) => {
+  //         const mapOfThisWaypoint = ioMapsToTest.find(map => map.isPointInside(waypoint));
+  //         if (!mapOfThisWaypoint) {
+  //             throw Error(`Cannot find a network for this trip waypoint (${waypoint.toString()}). Outdoor trips are not implemented.`)
+  //         }
+  //         if (map && mapOfThisWaypoint !== map) {
+  //             throw Error(`Cannot handle this trip, because two waypoints are on different maps (${mapOfThisWaypoint} and ${mapOfWaypoints}). ` +
+  //                 `Multi-map trips are not implemented.`)
+  //         }
+  //         return mapOfThisWaypoint
+  //     }, null as CustomNetworkMap | null);
+  //     // Create GraphRouterOptions from WemapMultiRouterOptions
+  //     const routerOptions = GraphRouterOptionsBuilder.fromJson(options || {});
+  //     const tripRoutes = mapOfWaypoints!.getTripInsideMap(waypoints, routerOptions);
+  //     const tripItineraries = tripRoutes.map(tripRoute => Itinerary.fromGraphRoute(tripRoute));
+  //     return new RouterResponse({
+  //         routerName: this.rname,
+  //         from: tripItineraries[0].from,
+  //         to: tripItineraries[tripItineraries.length - 1].to,
+  //         itineraries: tripItineraries
+  //     });
+  // }
+  async getItineraries(routerRequest, fallbackStrategy = [], targetMaps = this.maps) {
+    const start = routerRequest.origin;
+    const end = routerRequest.destination;
     const routerResponse = new RouterResponse({
       routerName: this.rname,
       from: start,
       to: end
     });
-    const remoteRouters2 = ((_a = options == null ? void 0 : options.remoteRouters) == null ? void 0 : _a.filter(({ name }) => name !== WemapMultiRemoteRouter$1.rname)) || [];
-    const ioMapsToTest = this.getIoMapsFromOptions(options);
+    fallbackStrategy = fallbackStrategy.filter(({ name }) => name !== WemapMultiRemoteRouter$1.rname) || [];
+    const ioMapsToTest = targetMaps;
     if (!ioMapsToTest.length) {
       try {
-        return await RemoteRouterManager$1.getItinerariesWithFallback(remoteRouters2, travelMode, travelModePreference, waypoints, options || void 0);
+        return await RemoteRouterManager$1.getItinerariesWithFallback(routerRequest, fallbackStrategy);
       } catch (e) {
         if (!isRoutingError(e)) {
           throw e;
@@ -2609,7 +2561,7 @@ class WemapMultiRouter {
     let ioMapRoute;
     let ioMapItinerary;
     const mapWithStart = ioMapsToTest.find((map) => map.isPointInside(start));
-    const routerOptions = GraphRouterOptionsBuilder.fromJson(options || {});
+    const routerOptions = GraphRouterOptionsBuilder.fromJson(routerRequest.itineraryModifiers || {});
     if (mapWithStart && mapWithStart.isPointInside(end)) {
       try {
         ioMapRoute = mapWithStart.getRouteInsideMap(start, end, routerOptions);
@@ -2628,7 +2580,7 @@ class WemapMultiRouter {
     let remoteRouterResponse;
     if (!mapWithStart && !mapWithEnd) {
       try {
-        return await RemoteRouterManager$1.getItinerariesWithFallback(remoteRouters2, travelMode, travelModePreference, waypoints, options || void 0);
+        return await RemoteRouterManager$1.getItinerariesWithFallback(routerRequest, fallbackStrategy);
       } catch (e) {
         if (!isRoutingError(e)) {
           throw e;
@@ -2645,13 +2597,13 @@ class WemapMultiRouter {
       }
       try {
         ioMapRoute = mapWithStart.getBestRouteFromStartToEntryPoints(start, end, routerOptions);
-        remoteRouterResponse = await RemoteRouterManager$1.getItinerariesWithFallback(
-          remoteRouters2,
-          travelMode,
-          travelModePreference,
-          [ioMapRoute.end, end],
-          options || void 0
-        );
+        const newRouterRequest = {
+          ...routerRequest,
+          origin: ioMapRoute.end,
+          destination: end,
+          waypoints: []
+        };
+        remoteRouterResponse = await RemoteRouterManager$1.getItinerariesWithFallback(newRouterRequest, fallbackStrategy);
         if (!remoteRouterResponse.itineraries.length) {
           throw new NoRouteFoundError(ioMapRoute.end, end, remoteRouterResponse.error);
         }
@@ -2659,7 +2611,7 @@ class WemapMultiRouter {
         if (!isRoutingError(e)) {
           throw e;
         }
-        routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints" using wemap router on local map "${mapWithStart.name}" and an itinerary from  "entrypoints" to "end" using remote routers (${remoteRouters2.map((r) => r.name).join(", ")}), but failed. Details: ${e.message}.`;
+        routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints" using wemap router on local map "${mapWithStart.name}" and an itinerary from  "entrypoints" to "end" using remote routers (${fallbackStrategy.map((r) => r.name).join(", ")}), but failed. Details: ${e.message}.`;
         return routerResponse;
       }
       ioMapItinerary = Itinerary.fromGraphRoute(ioMapRoute);
@@ -2677,13 +2629,13 @@ class WemapMultiRouter {
       }
       try {
         ioMapRoute = mapWithEnd.getBestRouteFromEntryPointsToEnd(start, end, routerOptions);
-        remoteRouterResponse = await RemoteRouterManager$1.getItinerariesWithFallback(
-          remoteRouters2,
-          travelMode,
-          travelModePreference,
-          [start, ioMapRoute.start],
-          options || void 0
-        );
+        const newRouterRequest = {
+          ...routerRequest,
+          origin: start,
+          destination: ioMapRoute.start,
+          waypoints: []
+        };
+        remoteRouterResponse = await RemoteRouterManager$1.getItinerariesWithFallback(newRouterRequest, fallbackStrategy);
         if (!remoteRouterResponse.itineraries.length) {
           throw new NoRouteFoundError(start, ioMapRoute.start, remoteRouterResponse.error);
         }
@@ -2691,7 +2643,7 @@ class WemapMultiRouter {
         if (!isRoutingError(e)) {
           throw e;
         }
-        routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints" using remote routers (${remoteRouters2.map((r) => r.name).join(", ")}) and an itinerary from "entrypoints" to "end" using wemap router on local map "${mapWithEnd.name}", but failed. Details: ${e.message}.`;
+        routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints" using remote routers (${fallbackStrategy.map((r) => r.name).join(", ")}) and an itinerary from "entrypoints" to "end" using wemap router on local map "${mapWithEnd.name}", but failed. Details: ${e.message}.`;
         return routerResponse;
       }
       ioMapItinerary = Itinerary.fromGraphRoute(ioMapRoute);
@@ -2718,12 +2670,15 @@ class WemapMultiRouter {
       try {
         ioMapRoute1 = mapWithStart.getBestRouteFromStartToEntryPoints(start, end, routerOptions);
         ioMapRoute2 = mapWithEnd.getBestRouteFromEntryPointsToEnd(start, end, routerOptions);
+        const newRouterRequest = {
+          ...routerRequest,
+          origin: ioMapRoute1.end,
+          destination: ioMapRoute2.start,
+          waypoints: []
+        };
         remoteRouterResponse = await RemoteRouterManager$1.getItinerariesWithFallback(
-          remoteRouters2,
-          travelMode,
-          travelModePreference,
-          [ioMapRoute1.end, ioMapRoute2.start],
-          options || void 0
+          newRouterRequest,
+          fallbackStrategy
         );
         if (!remoteRouterResponse.itineraries.length) {
           throw new NoRouteFoundError(ioMapRoute1.end, ioMapRoute2.start, remoteRouterResponse.error);
@@ -2732,7 +2687,7 @@ class WemapMultiRouter {
         if (!isRoutingError(e)) {
           throw e;
         }
-        routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints1" using wemap router on local map  "${mapWithStart.name}", an itinerary from "entrypoints1" to "entrypoints2" using remote routers (${remoteRouters2.map((r) => r.name).join(", ")}) and an itinerary from "entrypoints2" to "end" using wemap router on local map "${mapWithEnd.name}", but failed. Details: ${e.message}.`;
+        routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints1" using wemap router on local map  "${mapWithStart.name}", an itinerary from "entrypoints1" to "entrypoints2" using remote routers (${fallbackStrategy.map((r) => r.name).join(", ")}) and an itinerary from "entrypoints2" to "end" using wemap router on local map "${mapWithEnd.name}", but failed. Details: ${e.message}.`;
         return routerResponse;
       }
       routerResponse.itineraries = remoteRouterResponse.itineraries.map(
@@ -3013,6 +2968,7 @@ exports.Graph = Graph;
 exports.GraphProjection = GraphProjection;
 exports.GraphRoute = GraphRoute;
 exports.GraphRouter = GraphRouter;
+exports.GraphRouterOptionsBuilder = GraphRouterOptionsBuilder;
 exports.IdfmRemoteRouter = IdfmRemoteRouter$1;
 exports.Itinerary = Itinerary;
 exports.ItineraryInfoManager = ItineraryInfoManager;
@@ -3026,7 +2982,6 @@ exports.RemoteRouterServerUnreachable = RemoteRouterServerUnreachable;
 exports.RouterResponse = RouterResponse;
 exports.Vertex = Vertex;
 exports.WemapMultiRemoteRouter = WemapMultiRemoteRouter$1;
-exports.WemapMultiRemoteRouterPayload = WemapMultiRemoteRouterPayload;
 exports.WemapMultiRouter = WemapMultiRouter;
 exports.getDurationFromLength = getDurationFromLength;
 //# sourceMappingURL=index.js.map