@wemap/routers 11.5.0 → 11.7.0

package/dist/index.mjs

@@ -237,6 +237,8 @@ class Leg {
       stepsGenerationRules
     });
   }
+  // TODO: Remove when possible...
+  // Livemap specific
   multiplyLevel(levelFactor) {
     this.from.coords.level = Level.multiplyBy(this.from.coords.level, levelFactor);
     this.to.coords.level = Level.multiplyBy(this.to.coords.level, levelFactor);
@@ -277,6 +279,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
@@ -376,6 +379,9 @@ class Itinerary {
       legs
     });
   }
+  /**
+   * Convert lat/lng/level? points to Itinerary
+   */
   static fromOrderedPointsArray(points, start, end) {
     const pointToCoordinates = (point) => new Coordinates(point[0], point[1], null, point[2]);
     return this.fromOrderedCoordinates(
@@ -384,6 +390,9 @@ class Itinerary {
       pointToCoordinates(end)
     );
   }
+  /**
+   * Convert ordered Coordinates to Itinerary
+   */
   static fromOrderedCoordinates(coords, from, to, mode = "WALK") {
     const leg = new Leg({
       from: { coords: from },
@@ -438,11 +447,15 @@ class Itinerary {
       legs: [leg]
     });
   }
+  // TODO: Remove when possible...
+  // Livemap specific
   multiplyLevel(levelFactor) {
     this.from.level = Level.multiplyBy(this.from.level, levelFactor);
     this.to.level = 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;
@@ -474,6 +487,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();
@@ -558,6 +579,8 @@ class RouterResponse {
       error: json.error
     });
   }
+  // TODO: Remove when possible...
+  // Livemap specific
   multiplyLevel(levelFactor) {
     this.from.level = Level.multiplyBy(this.from.level, levelFactor);
     this.to.level = Level.multiplyBy(this.to.level, levelFactor);
@@ -571,7 +594,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 GeoGraph {
+const _OsmGraph = class _OsmGraph extends GeoGraph {
   getVertexByCoords(coords) {
     return GeoGraph.getVertexByCoords(this.vertices, coords);
   }
@@ -733,9 +756,9 @@ const _OsmGraph = class extends 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;
@@ -800,7 +823,7 @@ const buildStepsRules = (graphItinerary) => (currentCoords, nextCoords, previous
     ...forceEndOfLevelChange && { forceEndOfLevelChange }
   };
 };
-const _WemapOsmRouter = class extends GeoGraphRouter {
+const _WemapOsmRouter = class _WemapOsmRouter extends GeoGraphRouter {
   constructor(graph) {
     super(graph);
   }
@@ -911,10 +934,10 @@ const _WemapOsmRouter = class extends 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 {
@@ -1014,9 +1037,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(() => {
@@ -1027,6 +1058,9 @@ 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) {
@@ -1043,6 +1077,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) {
@@ -1164,6 +1203,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);
@@ -1179,9 +1222,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(() => {
@@ -1237,7 +1287,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");
@@ -1292,9 +1342,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, {
@@ -1383,6 +1440,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];
@@ -1508,9 +1570,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(() => {
@@ -1524,6 +1593,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) {
@@ -1546,6 +1618,10 @@ class OsrmRemoteRouter extends RemoteRouter {
     }
     return [lng, lat, level];
   }
+  /**
+   * @param {object} json
+   * @returns {Coordinates}
+   */
   jsonToCoordinates(json) {
     const coords = new Coordinates(json[1], json[0]);
     if (json.length > 2) {
@@ -1584,6 +1660,9 @@ class OsrmRemoteRouter extends RemoteRouter {
       message
     };
   }
+  /**
+   * @deprecated
+   */
   itineraryToOsrmJson(itinerary) {
     const lastLegId = itinerary.legs.length - 1;
     const itinerarySteps = itinerary.steps;
@@ -1707,6 +1786,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(() => {
@@ -1717,6 +1800,9 @@ 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) {
@@ -1733,6 +1819,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;
@@ -1864,6 +1953,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) {
@@ -1871,6 +1965,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) {
@@ -2176,6 +2275,12 @@ class CustomNetworkMap {
   isPointInside(coordinates) {
     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;
@@ -2189,6 +2294,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) {
@@ -2203,6 +2319,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) {