@wemap/routers 11.4.0 → 11.7.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);
   }
@@ -590,53 +607,98 @@ const _OsmGraph = class extends geo.GeoGraph {
     return super.getEdgeByName(name);
   }
   static fromOsmModel(osmModel, waySelectionFilter = DEFAULT_WAY_SELECTOR) {
-    const nodes = [];
+    const vertices = [];
     const edges = [];
-    const nodesCreated = {};
-    const elevatorNodes = [];
-    const getOrCreateNode = (osmNode) => {
-      let node = nodesCreated[osmNode.id];
-      if (!node) {
-        node = new geo.GeoGraphVertex(osmNode.coords, { data: osmNode, name: osmNode.tags.name });
-        nodesCreated[osmNode.id] = node;
-        nodes.push(node);
-        if (osmNode.tags.highway === "elevator") {
-          elevatorNodes.push(node);
+    const elevatorVertices = [];
+    const getOrCreateVertex = (osmNode, forceLevel = null) => {
+      let vertex = vertices.find(
+        (vertex2) => vertex2.data.id === osmNode.id && (forceLevel !== null ? geo.Level.intersect(vertex2.coords.level, forceLevel) : true)
+      ) || null;
+      if (vertex) {
+        return vertex;
+      }
+      const otherVertex = vertices.find((v) => v.data.id === osmNode.id);
+      if (otherVertex) {
+        if (otherVertex && otherVertex.coords.level !== null) {
+          throw new Error(`An error occured because repeat_on as not been set on node ${osmNode.coords} for level ${forceLevel}`);
+        }
+        otherVertex.coords.level = forceLevel;
+      }
+      let levelsToGenerate = [null];
+      if ("level" in osmNode.tags) {
+        levelsToGenerate = [osmNode.coords.level];
+        if ("repeat_on" in osmNode.tags) {
+          levelsToGenerate.push(...osmNode.tags.repeat_on.split(";").map(geo.Level.fromString));
         }
+      } else if (forceLevel !== null) {
+        levelsToGenerate = [forceLevel];
       }
-      return node;
+      levelsToGenerate.forEach((level) => {
+        const newVertex = new geo.GeoGraphVertex(osmNode.coords.clone(), { data: osmNode, name: osmNode.tags.name });
+        newVertex.coords.level = level;
+        vertices.push(newVertex);
+        if (geo.Level.intersect(newVertex.coords.level, forceLevel) || forceLevel === null && "level" in osmNode.tags) {
+          vertex = newVertex;
+        }
+      });
+      if (!vertex) {
+        throw new Error(`Unable to parse vertex {id: ${osmNode.id}, coords: ${osmNode.coords.lat}, ${osmNode.coords.lng}}. Please check "level" tag.`);
+      }
+      if (osmNode.tags.highway === "elevator" && vertex) {
+        elevatorVertices.push(vertex);
+      }
+      return vertex;
     };
     osmModel.ways.forEach((way) => {
       if (!waySelectionFilter(way)) {
         return;
       }
-      let firstNode = getOrCreateNode(way.nodes[0]);
-      for (let i = 1; i < way.nodes.length; i++) {
-        const secondNode = getOrCreateNode(way.nodes[i]);
-        const edge = new geo.GeoGraphEdge(
-          firstNode,
-          secondNode,
-          { data: way, name: way.tags.name, level: way.level }
-        );
-        _OsmGraph.manageOneWay(edge, way);
-        edges.push(edge);
-        firstNode = secondNode;
+      let levelsToGenerate = [null];
+      if ("level" in way.tags) {
+        levelsToGenerate = [way.level];
+        if ("repeat_on" in way.tags) {
+          levelsToGenerate.push(...way.tags.repeat_on.split(";").map(geo.Level.fromString));
+        }
       }
+      levelsToGenerate.forEach((level) => {
+        let firstVertex = getOrCreateVertex(way.nodes[0], level);
+        for (let i = 1; i < way.nodes.length; i++) {
+          const secondVertex = getOrCreateVertex(way.nodes[i], level);
+          const edge = new geo.GeoGraphEdge(
+            firstVertex,
+            secondVertex,
+            { data: way, name: way.tags.name, level }
+          );
+          _OsmGraph.manageOneWay(edge, way);
+          edges.push(edge);
+          firstVertex = secondVertex;
+        }
+      });
     });
     osmModel.ways.filter((way) => way.isElevator).forEach((way) => {
-      way.nodes.forEach((node) => {
-        const connectedWays = node.ways.filter((otherWay) => otherWay != way);
-        if (connectedWays.length) {
-          const graphVertex = getOrCreateNode(node);
-          graphVertex.data.tags.highway = "elevator";
-          elevatorNodes.push(graphVertex);
-        }
+      const entryVertices = way.nodes.map((node) => vertices.filter((v) => v.data.id === node.id)).flat();
+      const elevatorLevel = entryVertices.reduce((acc, v) => geo.Level.union(acc, v.coords.level), null);
+      const elevatorCenter = way.nodes.reduce((acc, node) => [acc[0] + node.coords.lat, acc[1] + node.coords.lng], [0, 0]).map((val) => val / way.nodes.length);
+      const elevatorCenterCoords = new geo.Coordinates(elevatorCenter[0], elevatorCenter[1], null, elevatorLevel);
+      const elevatorCenterVertex = new geo.GeoGraphVertex(elevatorCenterCoords, { data: way, name: way.tags.name });
+      vertices.push(elevatorCenterVertex);
+      entryVertices.forEach((entryVertex) => {
+        const newEdge = new geo.GeoGraphEdge(
+          elevatorCenterVertex,
+          entryVertex,
+          {
+            level: geo.Level.intersection(elevatorCenterVertex.coords.level, entryVertex.coords.level),
+            data: way
+          }
+        );
+        edges.push(newEdge);
       });
+      elevatorVertices.push(elevatorCenterVertex);
     });
-    elevatorNodes.forEach((node) => {
-      _OsmGraph.createNodesAndEdgesFromElevator(nodes, edges, node);
+    elevatorVertices.forEach((node) => {
+      _OsmGraph.createNodesAndEdgesFromElevator(vertices, edges, node);
     });
-    return new _OsmGraph(nodes, edges, true);
+    return new _OsmGraph(vertices, edges, true);
   }
   static manageOneWay(edge, way) {
     const { highway, oneway, conveying } = way.tags;
@@ -647,59 +709,58 @@ const _OsmGraph = class extends geo.GeoGraph {
       edge.vertex2 = tmpNode;
     }
   }
-  static createNodesAndEdgesFromElevator(nodes, edges, elevatorNode) {
-    const createdNodes = [];
+  static createNodesAndEdgesFromElevator(vertices, edges, elevatorVertex) {
+    const createdVertices = [];
     const getOrCreateLevelVertex = (level) => {
-      let levelVertex = createdNodes.find(({ coords }) => geo.Level.equals(level, coords.level));
+      let levelVertex = createdVertices.find(({ coords }) => geo.Level.equals(level, coords.level));
       if (!levelVertex) {
-        levelVertex = new geo.GeoGraphVertex(elevatorNode.coords.clone(), {
-          data: elevatorNode.data,
-          name: `${elevatorNode.name} (elevator lvl: ${level})`
+        levelVertex = new geo.GeoGraphVertex(elevatorVertex.coords.clone(), {
+          data: elevatorVertex.data,
+          name: `${elevatorVertex.name} (elevator lvl: ${level})`
         });
         levelVertex.coords.level = level;
-        createdNodes.push(levelVertex);
-        nodes.push(levelVertex);
+        createdVertices.push(levelVertex);
+        vertices.push(levelVertex);
       }
       return levelVertex;
     };
-    elevatorNode.edges.forEach((edge) => {
+    elevatorVertex.edges.forEach((edge) => {
       if (geo.Level.isRange(edge.level)) {
-        throw new Error("Cannot handle this elevator edge due to ambiguity");
+        throw new Error(`Cannot handle this elevator edge due to ambiguity (vertex: ${edge.vertex1.coords})`);
       }
       const levelVertex = getOrCreateLevelVertex(edge.level);
-      if (edge.vertex1 === elevatorNode) {
+      if (edge.vertex1 === elevatorVertex) {
         edge.vertex1 = levelVertex;
       } else {
         edge.vertex2 = levelVertex;
       }
-      levelVertex.edges.push(edge);
     });
-    for (let i = 0; i < createdNodes.length; i++) {
-      for (let j = i + 1; j < createdNodes.length; j++) {
-        const createdNode1 = createdNodes[i];
-        const createdNode2 = createdNodes[j];
-        if (createdNode1.coords.level === null || createdNode2.coords.level === null) {
+    for (let i = 0; i < createdVertices.length; i++) {
+      for (let j = i + 1; j < createdVertices.length; j++) {
+        const createdVertex1 = createdVertices[i];
+        const createdVertex2 = createdVertices[j];
+        if (createdVertex1.coords.level === null || createdVertex2.coords.level === null) {
           continue;
         }
-        const minLevel = Math.min(createdNode1.coords.level, createdNode2.coords.level);
-        const maxLevel = Math.max(createdNode1.coords.level, createdNode2.coords.level);
+        const minLevel = Math.min(createdVertex1.coords.level, createdVertex2.coords.level);
+        const maxLevel = Math.max(createdVertex1.coords.level, createdVertex2.coords.level);
         const newEdge = new geo.GeoGraphEdge(
-          createdNode1,
-          createdNode2,
-          { data: elevatorNode.data, name: elevatorNode.name, level: [minLevel, maxLevel] }
+          createdVertex1,
+          createdVertex2,
+          { data: elevatorVertex.data, name: elevatorVertex.name, level: [minLevel, maxLevel] }
         );
         edges.push(newEdge);
       }
     }
-    const elevatorNodeIndex = nodes.indexOf(elevatorNode);
+    const elevatorNodeIndex = vertices.indexOf(elevatorVertex);
     if (elevatorNodeIndex > -1) {
-      nodes.splice(elevatorNodeIndex, 1);
+      vertices.splice(elevatorNodeIndex, 1);
     }
   }
 };
+__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;
@@ -764,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);
   }
@@ -796,12 +857,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,
@@ -875,10 +936,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 {
@@ -978,9 +1039,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(() => {
@@ -991,13 +1060,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}`;
@@ -1007,6 +1079,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) {
@@ -1100,7 +1177,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({
@@ -1128,6 +1205,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);
@@ -1143,9 +1224,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(() => {
@@ -1201,7 +1289,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");
@@ -1256,9 +1344,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, {
@@ -1282,7 +1377,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();
@@ -1347,6 +1442,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];
@@ -1472,9 +1572,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(() => {
@@ -1488,6 +1595,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) {
@@ -1510,6 +1620,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) {
@@ -1548,6 +1662,9 @@ class OsrmRemoteRouter extends RemoteRouter {
       message
     };
   }
+  /**
+   * @deprecated
+   */
   itineraryToOsrmJson(itinerary) {
     const lastLegId = itinerary.legs.length - 1;
     const itinerarySteps = itinerary.steps;
@@ -1671,6 +1788,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(() => {
@@ -1681,13 +1802,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}`;
@@ -1697,6 +1821,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;
@@ -1708,7 +1835,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)) {
@@ -1828,6 +1955,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) {
@@ -1835,6 +1967,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) {
@@ -1876,7 +2013,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`);
           }
         });
       }
@@ -1920,7 +2057,7 @@ class WemapMultiRouter {
   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];
@@ -2099,7 +2236,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}"`);
       }
@@ -2138,8 +2275,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;
@@ -2153,6 +2296,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) {
@@ -2167,6 +2321,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) {