@wemap/routers 11.5.0 → 11.8.0

package/dist/index.js

@@ -5,7 +5,7 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const geo = require("@wemap/geo");
 const maths = require("@wemap/maths");
 const salesman = require("@wemap/salesman.js");
@@ -14,12 +14,6 @@ const Logger = require("@wemap/logger");
 const Polyline = require("@mapbox/polyline");
 const pointInPolygon = require("@turf/boolean-point-in-polygon");
 const convexHullFn = require("@turf/convex");
-const _interopDefaultLegacy = (e) => e && typeof e === "object" && "default" in e ? e : { default: e };
-const salesman__default = /* @__PURE__ */ _interopDefaultLegacy(salesman);
-const Logger__default = /* @__PURE__ */ _interopDefaultLegacy(Logger);
-const Polyline__default = /* @__PURE__ */ _interopDefaultLegacy(Polyline);
-const pointInPolygon__default = /* @__PURE__ */ _interopDefaultLegacy(pointInPolygon);
-const convexHullFn__default = /* @__PURE__ */ _interopDefaultLegacy(convexHullFn);
 function getDurationFromLength(length, speed = 5) {
   return length / (speed * 1e3 / 3600);
 }
@@ -245,6 +239,8 @@ class Leg {
       stepsGenerationRules
     });
   }
+  // TODO: Remove when possible...
+  // Livemap specific
   multiplyLevel(levelFactor) {
     this.from.coords.level = geo.Level.multiplyBy(this.from.coords.level, levelFactor);
     this.to.coords.level = geo.Level.multiplyBy(this.to.coords.level, levelFactor);
@@ -285,6 +281,7 @@ class Leg {
         firstStep: stepId === 0,
         lastStep: stepId === stepsInfo.length - 1,
         distance,
+        // stepInfo.distance is overwritten
         duration: stepInfo.duration || getDurationFromLength(distance),
         levelChange: stepInfo.levelChange || null,
         extras: stepInfo.extras || null
@@ -384,6 +381,9 @@ class Itinerary {
       legs
     });
   }
+  /**
+   * Convert lat/lng/level? points to Itinerary
+   */
   static fromOrderedPointsArray(points, start, end) {
     const pointToCoordinates = (point) => new geo.Coordinates(point[0], point[1], null, point[2]);
     return this.fromOrderedCoordinates(
@@ -392,6 +392,9 @@ class Itinerary {
       pointToCoordinates(end)
     );
   }
+  /**
+   * Convert ordered Coordinates to Itinerary
+   */
   static fromOrderedCoordinates(coords, from, to, mode = "WALK") {
     const leg = new Leg({
       from: { coords: from },
@@ -446,11 +449,15 @@ class Itinerary {
       legs: [leg]
     });
   }
+  // TODO: Remove when possible...
+  // Livemap specific
   multiplyLevel(levelFactor) {
     this.from.level = geo.Level.multiplyBy(this.from.level, levelFactor);
     this.to.level = geo.Level.multiplyBy(this.to.level, levelFactor);
     this.legs.forEach((leg) => leg.multiplyLevel(levelFactor));
   }
+  // TODO: Remove when possible...
+  // Livemap specific
   forceUnknownLevelTo0() {
     this.from.level = this.from.level || 0;
     this.to.level = this.to.level || 0;
@@ -482,6 +489,14 @@ class Itinerary {
       }
     };
   }
+  /**
+   * Update steps info thanks to the coordinates of the whole itinerary.
+   * This method will update:
+   * - all steps number
+   * - first/last steps
+   * - previousBearing/nextBearing/angle of first and last step of each leg
+   * - distance/duration of first and last step of each leg
+   */
   updateStepsFromLegs() {
     const itineraryCoords = this.coords.filter((coords, idx, arr) => idx === 0 || !arr[idx - 1].equals(coords));
     const steps = this.legs.map((leg) => leg.steps).flat();
@@ -566,6 +581,8 @@ class RouterResponse {
       error: json.error
     });
   }
+  // TODO: Remove when possible...
+  // Livemap specific
   multiplyLevel(levelFactor) {
     this.from.level = geo.Level.multiplyBy(this.from.level, levelFactor);
     this.to.level = geo.Level.multiplyBy(this.to.level, levelFactor);
@@ -579,7 +596,7 @@ const DEFAULT_WAY_SELECTOR = (way) => {
   const isElevatorArea = way.tags.highway === "elevator" && way.isArea;
   return HIGHWAYS_PEDESTRIANS.includes(way.tags.highway) && !isElevatorArea && !["no", "private"].includes(way.tags.access) || way.tags.footway === "sidewalk" || way.tags.public_transport === "platform" || way.tags.railway === "platform";
 };
-const _OsmGraph = class extends geo.GeoGraph {
+const _OsmGraph = class _OsmGraph extends geo.GeoGraph {
   getVertexByCoords(coords) {
     return geo.GeoGraph.getVertexByCoords(this.vertices, coords);
   }
@@ -741,9 +758,9 @@ const _OsmGraph = class extends geo.GeoGraph {
     }
   }
 };
+__publicField(_OsmGraph, "HIGHWAYS_PEDESTRIANS", HIGHWAYS_PEDESTRIANS);
+__publicField(_OsmGraph, "DEFAULT_WAY_SELECTOR", DEFAULT_WAY_SELECTOR);
 let OsmGraph = _OsmGraph;
-__publicField(OsmGraph, "HIGHWAYS_PEDESTRIANS", HIGHWAYS_PEDESTRIANS);
-__publicField(OsmGraph, "DEFAULT_WAY_SELECTOR", DEFAULT_WAY_SELECTOR);
 const buildStepsRules = (graphItinerary) => (currentCoords, nextCoords, previousStep) => {
   var _a, _b, _c, _d, _e;
   const edges = graphItinerary.edges;
@@ -808,7 +825,7 @@ const buildStepsRules = (graphItinerary) => (currentCoords, nextCoords, previous
     ...forceEndOfLevelChange && { forceEndOfLevelChange }
   };
 };
-const _WemapOsmRouter = class extends geo.GeoGraphRouter {
+const _WemapOsmRouter = class _WemapOsmRouter extends geo.GeoGraphRouter {
   constructor(graph) {
     super(graph);
   }
@@ -822,6 +839,21 @@ const _WemapOsmRouter = class extends geo.GeoGraphRouter {
     const graphItinerary = this.getShortestPath(start, end, options);
     return Itinerary.fromGraphItinerary(graphItinerary, "WALK", buildStepsRules(graphItinerary));
   }
+  getShortestPaths(start, ends, options = _WemapOsmRouter.DEFAULT_OPTIONS) {
+    return super.getShortestPaths(start, ends, options);
+  }
+  getItineraries(start, ends, options = _WemapOsmRouter.DEFAULT_OPTIONS) {
+    const graphItineraries = this.getShortestPaths(start, ends, options);
+    return graphItineraries.map((graphItinerary, idx) => {
+      if (graphItinerary === null || !graphItinerary.edges.length) {
+        const startCoords = start instanceof geo.GeoGraphVertex ? start.coords : start;
+        const end = ends[idx];
+        const endCoords = end instanceof geo.GeoGraphVertex ? end.coords : end;
+        return new Itinerary({ from: startCoords, to: endCoords, legs: [] });
+      }
+      return Itinerary.fromGraphItinerary(graphItinerary, "WALK", buildStepsRules(graphItinerary));
+    });
+  }
   static getTurnInfoFromAngle(_angle) {
     let direction, directionExtra;
     const directionAngle = maths.rad2deg(maths.diffAngle(_angle, Math.PI));
@@ -840,12 +872,12 @@ const _WemapOsmRouter = class extends geo.GeoGraphRouter {
   }
   getShortestTrip(waypoints, options = _WemapOsmRouter.DEFAULT_TRIP_OPTIONS) {
     const points = waypoints.map((waypoint) => {
-      const point = new salesman__default.default.Point(0, 0);
+      const point = new salesman.Point(0, 0);
       point.coords = waypoint;
       return point;
     });
     const cache = [];
-    const solution = salesman__default.default.solve(points, options.tspTempCoeff, void 0, (p, q) => {
+    const solution = salesman.solve(points, options.tspTempCoeff, void 0, (p, q) => {
       const osmItinerary = this.getShortestPath(
         p.coords,
         q.coords,
@@ -919,10 +951,10 @@ const _WemapOsmRouter = class extends geo.GeoGraphRouter {
     );
   }
 };
+__publicField(_WemapOsmRouter, "DEFAULT_OPTIONS", _WemapOsmRouter.buildOptions());
+__publicField(_WemapOsmRouter, "WITHOUT_STAIRS_OPTIONS", _WemapOsmRouter.buildOptions({ useStairs: false }));
+__publicField(_WemapOsmRouter, "DEFAULT_TRIP_OPTIONS", _WemapOsmRouter.buildTripOptions());
 let WemapOsmRouter = _WemapOsmRouter;
-__publicField(WemapOsmRouter, "DEFAULT_OPTIONS", _WemapOsmRouter.buildOptions());
-__publicField(WemapOsmRouter, "WITHOUT_STAIRS_OPTIONS", _WemapOsmRouter.buildOptions({ useStairs: false }));
-__publicField(WemapOsmRouter, "DEFAULT_TRIP_OPTIONS", _WemapOsmRouter.buildTripOptions());
 class RemoteRouter {
 }
 class RemoteRouterServerUnreachable extends Error {
@@ -1022,9 +1054,17 @@ function parseWKTGeometry(wktGeometry) {
   });
 }
 class CitywayRemoteRouter extends RemoteRouter {
+  /**
+   * @override
+   */
   get rname() {
     return "cityway";
   }
+  /**
+   * @override
+   * @throws {RoutingModeCorrespondanceNotFound}
+   * @throws {RemoteRouterServerUnreachable}
+   */
   async getItineraries(endpointUrl, mode, waypoints) {
     const url = this.getURL(endpointUrl, mode, waypoints);
     const res = await fetch(url).catch(() => {
@@ -1035,13 +1075,16 @@ class CitywayRemoteRouter extends RemoteRouter {
     });
     return this.createRouterResponseFromJson(jsonResponse, waypoints[0], waypoints[1]);
   }
+  /**
+   * @throws {RoutingModeCorrespondanceNotFound}
+   */
   getURL(endpointUrl, mode, waypoints) {
     const citywayMode = inputModeCorrespondance$2.get(mode);
     if (!citywayMode) {
       throw new RoutingModeCorrespondanceNotFound(this.rname, mode);
     }
     if (waypoints.length > 2) {
-      Logger__default.default.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
+      Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
     }
     const fromPlace = `DepartureLatitude=${waypoints[0].latitude}&DepartureLongitude=${waypoints[0].longitude}`;
     const toPlace = `ArrivalLatitude=${waypoints[1].latitude}&ArrivalLongitude=${waypoints[1].longitude}`;
@@ -1051,6 +1094,11 @@ class CitywayRemoteRouter extends RemoteRouter {
     search = (search ? `${search}&` : "?") + `${fromPlace}&${toPlace}&${queryMode}`;
     return `${url.origin}${url.pathname}${search}`;
   }
+  /**
+   * Generate multi itineraries from Cityway JSON
+   * @returns {!RouterResponse}
+   * @example https://preprod.api.lia2.cityway.fr/journeyplanner/api/opt/PlanTrips/json?DepartureLatitude=49.51509388236216&DepartureLongitude=0.09341749619366316&ArrivalLatitude=49.5067090188444&ArrivalLongitude=0.1694842115417831&DepartureType=COORDINATES&ArrivalType=COORDINATES
+   */
   createRouterResponseFromJson(json, from, to) {
     const routerResponse = new RouterResponse({ routerName: this.rname, from, to });
     if (json.StatusCode !== 200 || !json.Data || !json.Data.length) {
@@ -1144,7 +1192,7 @@ class CitywayRemoteRouter extends RemoteRouter {
               distance: jsonLeg.Distance
             }];
           } else {
-            Logger__default.default.warn(`[CitywayParser] Unknown leg mode: ${jsonLeg.TransportMode}`);
+            Logger.warn(`[CitywayParser] Unknown leg mode: ${jsonLeg.TransportMode}`);
             continue;
           }
           const leg = new Leg({
@@ -1172,6 +1220,10 @@ class CitywayRemoteRouter extends RemoteRouter {
       }
     return routerResponse;
   }
+  /**
+   * @param {string} iso8601Duration
+   * @see https://stackoverflow.com/a/29153059/2239938
+   */
   parseDuration(iso8601Duration) {
     const iso8601DurationRegex = /(-)?P(?:([.,\d]+)Y)?(?:([.,\d]+)M)?(?:([.,\d]+)W)?(?:([.,\d]+)D)?T(?:([.,\d]+)H)?(?:([.,\d]+)M)?(?:([.,\d]+)S)?/;
     const matches = iso8601Duration.match(iso8601DurationRegex);
@@ -1187,9 +1239,16 @@ class CitywayRemoteRouter extends RemoteRouter {
 }
 const CitywayRemoteRouter$1 = new CitywayRemoteRouter();
 class DeutscheBahnRemoteRouter extends RemoteRouter {
+  /**
+   * @override
+   */
   get rname() {
     return "deutsche-bahn";
   }
+  /**
+   * @override
+   * @throws {RemoteRouterServerUnreachable}
+   */
   async getItineraries(endpointUrl, mode, waypoints) {
     const url = this.getURL(endpointUrl, mode, waypoints);
     const res = await fetch(url).catch(() => {
@@ -1245,7 +1304,7 @@ routingModeCorrespondance.set("Funicular", "FUNICULAR");
 routingModeCorrespondance.set("LocalTrain", "TRAIN");
 routingModeCorrespondance.set("LongDistanceTrain", "TRAIN");
 routingModeCorrespondance.set("Metro", "METRO");
-routingModeCorrespondance.set("M\xE9tro", "METRO");
+routingModeCorrespondance.set("Métro", "METRO");
 routingModeCorrespondance.set("RailShuttle", "TRAIN");
 routingModeCorrespondance.set("RapidTransit", "BUS");
 routingModeCorrespondance.set("Shuttle", "BUS");
@@ -1300,9 +1359,16 @@ function dateStringToTimestamp(stringDate, timeZone) {
   ).getTime();
 }
 class IdfmRemoteRouter extends RemoteRouter {
+  /**
+   * @override
+   */
   get rname() {
     return "idfm";
   }
+  /**
+   * @throws {IdfmRemoteRouterTokenError}
+   * @throws {RemoteRouterServerUnreachable}
+   */
   async getItineraries(endpointUrl, mode, waypoints, options = {}) {
     const url = this.getURL(endpointUrl, mode, waypoints, options);
     const res = await fetch(url, {
@@ -1326,7 +1392,7 @@ class IdfmRemoteRouter extends RemoteRouter {
   }
   getURL(endpointUrl, mode, waypoints, options) {
     if (waypoints.length > 2) {
-      Logger__default.default.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
+      Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
     }
     const url = new URL(endpointUrl);
     const coreParams = new URLSearchParams();
@@ -1391,6 +1457,11 @@ class IdfmRemoteRouter extends RemoteRouter {
       to
     };
   }
+  /**
+   * Since the IDFM API does not provide coords for each step, we need to compute them
+   * We trim the coordinates of the leg with the distance of each step and keep the last result as the coords of the step
+   * @param {Leg} leg
+   */
   findStepsCoord(legCoords, steps) {
     const coords = legCoords;
     const duplicatedCoords = [...coords];
@@ -1516,9 +1587,16 @@ inputModeCorrespondance$1.set("BIKE", "bike");
 inputModeCorrespondance$1.set("BUS", "bus");
 inputModeCorrespondance$1.set("MULTI", "walking");
 class OsrmRemoteRouter extends RemoteRouter {
+  /**
+   * @override
+   */
   get rname() {
     return "osrm";
   }
+  /**
+   * @throws {RemoteRouterServerUnreachable}
+   * @throws {RoutingModeCorrespondanceNotFound}
+   */
   async getItineraries(endpointUrl, mode, waypoints, options = {}) {
     const url = this.getURL(endpointUrl, mode, waypoints, options);
     const res = await fetch(url).catch(() => {
@@ -1532,6 +1610,9 @@ class OsrmRemoteRouter extends RemoteRouter {
     const osrmMode = inputModeCorrespondance$1.get(mode);
     return this.createRouterResponseFromJson(jsonResponse, from, to, osrmMode);
   }
+  /**
+   * @throws {RoutingModeCorrespondanceNotFound}
+   */
   getURL(endpointUrl, mode, waypoints, options = {}) {
     let osrmMode = inputModeCorrespondance$1.get(mode);
     if (!osrmMode) {
@@ -1554,6 +1635,10 @@ class OsrmRemoteRouter extends RemoteRouter {
     }
     return [lng, lat, level];
   }
+  /**
+   * @param {object} json
+   * @returns {Coordinates}
+   */
   jsonToCoordinates(json) {
     const coords = new geo.Coordinates(json[1], json[0]);
     if (json.length > 2) {
@@ -1592,6 +1677,9 @@ class OsrmRemoteRouter extends RemoteRouter {
       message
     };
   }
+  /**
+   * @deprecated
+   */
   itineraryToOsrmJson(itinerary) {
     const lastLegId = itinerary.legs.length - 1;
     const itinerarySteps = itinerary.steps;
@@ -1715,6 +1803,10 @@ class OtpRemoteRouter extends RemoteRouter {
   get rname() {
     return "otp";
   }
+  /**
+   * @throws {RemoteRouterServerUnreachable}
+   * @throws {RoutingModeCorrespondanceNotFound}
+   */
   async getItineraries(endpointUrl, mode, waypoints) {
     const url = this.getURL(endpointUrl, mode, waypoints);
     const res = await fetch(url).catch(() => {
@@ -1725,13 +1817,16 @@ class OtpRemoteRouter extends RemoteRouter {
     });
     return this.createRouterResponseFromJson(jsonResponse, waypoints[0], waypoints[1]);
   }
+  /**
+   * @throws {RoutingModeCorrespondanceNotFound}
+   */
   getURL(endpointUrl, mode, waypoints) {
     const otpMode = inputModeCorrespondance.get(mode);
     if (!otpMode) {
       throw new RoutingModeCorrespondanceNotFound(this.rname, mode);
     }
     if (waypoints.length > 2) {
-      Logger__default.default.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
+      Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
     }
     const fromPlace = `fromPlace=${waypoints[0].latitude},${waypoints[0].longitude}`;
     const toPlace = `toPlace=${waypoints[1].latitude},${waypoints[1].longitude}`;
@@ -1741,6 +1836,9 @@ class OtpRemoteRouter extends RemoteRouter {
     search = (search ? `${search}&` : "?") + `${fromPlace}&${toPlace}&${queryMode}`;
     return `${url.origin}${url.pathname}${search}`;
   }
+  /**
+   * Generate multi itineraries from OTP JSON
+   */
   createRouterResponseFromJson(json, from, to) {
     const routerResponse = new RouterResponse({ routerName: this.rname, from, to });
     const { plan: jsonPlan } = json;
@@ -1752,7 +1850,7 @@ class OtpRemoteRouter extends RemoteRouter {
     for (const jsonItinerary of jsonPlan.itineraries) {
       const legs = [];
       for (const jsonLeg of jsonItinerary.legs) {
-        const legCoords = Polyline__default.default.decode(jsonLeg.legGeometry.points).map(([lat, lon]) => new geo.Coordinates(lat, lon));
+        const legCoords = Polyline.decode(jsonLeg.legGeometry.points).map(([lat, lon]) => new geo.Coordinates(lat, lon));
         let transportInfo;
         let minStepsInfo;
         if (isLegPT(jsonLeg)) {
@@ -1872,6 +1970,11 @@ class RemoteRouterManager {
   getRouterByName(name) {
     return remoteRouters.find((remoteRouter) => remoteRouter.rname === name);
   }
+  /**
+   * @throws {RemoteRouterServerUnreachable}
+   * @throws {RoutingModeCorrespondanceNotFound}
+   * @throws {IdfmRemoteRouterTokenError}
+   */
   async getItineraries(name, endpointUrl, mode, waypoints, options) {
     const router = this.getRouterByName(name);
     if (!router) {
@@ -1879,6 +1982,11 @@ class RemoteRouterManager {
     }
     return router.getItineraries(endpointUrl, mode, waypoints, options);
   }
+  /**
+   * @throws {RemoteRouterServerUnreachable}
+   * @throws {RoutingModeCorrespondanceNotFound}
+   * @throws {IdfmRemoteRouterTokenError}
+   */
   async getItinerariesWithFallback(remoteRouters2, mode, waypoints, options) {
     let routerResponse;
     for (const { name, endpointUrl } of remoteRouters2) {
@@ -1920,7 +2028,7 @@ class WemapMultiRouter {
       if (ioMapsToTest.length !== targetMaps.length) {
         ioMapsToTest.forEach((map) => {
           if (map.name && !targetMaps.includes(map.name)) {
-            Logger__default.default.warn(`CustomNetworkMap "${map.name}" not found in WemapMultiRouter`);
+            Logger.warn(`CustomNetworkMap "${map.name}" not found in WemapMultiRouter`);
           }
         });
       }
@@ -1961,10 +2069,26 @@ class WemapMultiRouter {
       itineraries: [tripItinerary]
     });
   }
+  async getItinerariesMultipleDestinations(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;
+    }, null);
+    const wemapOsmRouterOptions = this.convertOptionsToWemapOsmOptions(options);
+    const itineraries = mapOfWaypoints.getItinerariesMultipleDestinationsInsideMap(start, ends, wemapOsmRouterOptions);
+    return {
+      routerName: this.rname,
+      itineraries
+    };
+  }
   async getItineraries(mode, waypoints, options = null) {
     var _a;
     if (waypoints.length > 2) {
-      Logger__default.default.warn(`WemapMultiRouter uses only the first 2 waypoints (asked ${waypoints.length})`);
+      Logger.warn(`WemapMultiRouter uses only the first 2 waypoints (asked ${waypoints.length})`);
     }
     const start = waypoints[0];
     const end = waypoints[1];
@@ -2143,7 +2267,7 @@ class CustomNetworkMap {
       this.bounds = bounds;
     } else {
       const polygon = [graph.vertices.map((vertex) => [vertex.coords.lng, vertex.coords.lat])];
-      const convexHull = convexHullFn__default.default({ type: "polygon", coordinates: polygon });
+      const convexHull = convexHullFn({ type: "polygon", coordinates: polygon });
       if (!convexHull) {
         throw new Error(`Cannot calculate convexHull of network "${name}"`);
       }
@@ -2182,8 +2306,14 @@ class CustomNetworkMap {
     return new CustomNetworkMap(graph, entryPoints, bounds, name);
   }
   isPointInside(coordinates) {
-    return pointInPolygon__default.default([coordinates.lng, coordinates.lat], this.bounds);
-  }
+    return pointInPolygon([coordinates.lng, coordinates.lat], this.bounds);
+  }
+  /**
+   * Get the list of entry points sorted by the lowest distance between:
+   * start -> entry point -> end
+   * (as the crow flies)
+   *
+   */
   getOrderedEntryPointsSortedByDistance(start, end) {
     const entryPointsCopy = [...this.entryPoints];
     const levelDiffFactor = 50;
@@ -2197,6 +2327,17 @@ class CustomNetworkMap {
       return distance2D + levelDiff * levelDiffFactor;
     });
   }
+  /**
+   * Get the best itinerary from any entry point to an end coordinates.
+   *
+   * The algorithm works as following:
+   * 1 - Entry points are sorted using distance (as the crow flies) between start - entry point - end
+   * 2 - Try to calculate an itinerary from the first entry point to the end coordinates.
+   * 3 - If an itinerary is found, it is returned. Otherwise it tries from the next entry point.
+   *
+   * /!\ start is only used to sort the entry points (step 1).
+   *
+   */
   getBestItineraryFromEntryPointsToEnd(start, end, options) {
     const sortedEntryPoints = this.getOrderedEntryPointsSortedByDistance(start, end);
     for (const entryPoint of sortedEntryPoints) {
@@ -2211,6 +2352,17 @@ class CustomNetworkMap {
       `No route found from entry points to ${end.toString()} in map: ${this.name}`
     );
   }
+  /**
+   * Get the best itinerary from start coordinates to any entry point.
+   *
+   * The algorithm works as following:
+   * 1 - Entry points are sorted using distance (as the crow flies) between start - entry point - end
+   * 2 - Try to calculate an itinerary from the start coordinates to the first entry point.
+   * 3 - If an itinerary is found, it is returned. Otherwise it tries to the next entry point.
+   *
+   * /!\ end is only used to sort the entry points (step 1).
+   *
+   */
   getBestItineraryFromStartToEntryPoints(start, end, options) {
     const sortedEntryPoints = this.getOrderedEntryPointsSortedByDistance(start, end);
     for (const entryPoint of sortedEntryPoints) {
@@ -2231,6 +2383,9 @@ class CustomNetworkMap {
   getTripInsideMap(waypoints, options) {
     return this.router.getTripItinerary(waypoints, options);
   }
+  getItinerariesMultipleDestinationsInsideMap(start, ends, options) {
+    return this.router.getItineraries(start, ends, options);
+  }
   enableWay(osmId) {
     this.graph.edges.filter((edge) => edge.data.id === osmId).forEach((e) => this.router.disabledEdges.delete(e));
     this.disabledWays.delete(osmId);