@wemap/routers 11.0.0-alpha.25 → 11.0.0-alpha.26

package/dist/index.js

@@ -576,9 +576,9 @@ class RouterResponse {
 const HIGHWAYS_PEDESTRIANS = ["footway", "steps", "pedestrian", "living_street", "path", "track", "sidewalk", "elevator"];
 const DEFAULT_WAY_SELECTOR = (way) => {
   const isElevatorArea = way.tags.highway === "elevator" && way.isArea;
-  return HIGHWAYS_PEDESTRIANS.includes(way.tags.highway) && !isElevatorArea || way.tags.footway === "sidewalk" || way.tags.public_transport === "platform" || way.tags.railway === "platform";
+  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";
 };
-class OsmGraph extends geo.GeoGraph {
+const _OsmGraph = class extends geo.GeoGraph {
   getVertexByCoords(coords) {
     return geo.GeoGraph.getVertexByCoords(this.vertices, coords);
   }
@@ -617,7 +617,7 @@ class OsmGraph extends geo.GeoGraph {
           secondNode,
           { data: way, name: way.tags.name, level: way.level }
         );
-        OsmGraph.manageOneWay(edge, way);
+        _OsmGraph.manageOneWay(edge, way);
         edges.push(edge);
         firstNode = secondNode;
       }
@@ -633,9 +633,9 @@ class OsmGraph extends geo.GeoGraph {
       });
     });
     elevatorNodes.forEach((node) => {
-      OsmGraph.createNodesAndEdgesFromElevator(nodes, edges, node);
+      _OsmGraph.createNodesAndEdgesFromElevator(nodes, edges, node);
     });
-    return new OsmGraph(nodes, edges, true);
+    return new _OsmGraph(nodes, edges, true);
   }
   static manageOneWay(edge, way) {
     const { highway, oneway, conveying } = way.tags;
@@ -695,7 +695,10 @@ class OsmGraph extends geo.GeoGraph {
       nodes.splice(elevatorNodeIndex, 1);
     }
   }
-}
+};
+let OsmGraph = _OsmGraph;
+__publicField(OsmGraph, "HIGHWAYS_PEDESTRIANS", HIGHWAYS_PEDESTRIANS);
+__publicField(OsmGraph, "DEFAULT_WAY_SELECTOR", DEFAULT_WAY_SELECTOR);
 const DEFAULT_OPTIONS = Object.assign({}, geo.GeoGraphRouter.DEFAULT_OPTIONS, {
   weightEdgeFn: (edge) => edge.data instanceof osm.OsmNode && edge.data.isElevator ? 30 : getDurationFromLength(edge.length)
 });
@@ -807,9 +810,16 @@ class WemapOsmRouter extends geo.GeoGraphRouter {
     for (let i = 0; i < orderedPoints.length - 1; i++) {
       const p = orderedPoints[i];
       const q = orderedPoints[i + 1];
-      orderedItineraries.push(
-        cache.find((itinerary) => itinerary.start === p.coords && itinerary.end === q.coords || itinerary.end === p.coords && itinerary.start === q.coords)
-      );
+      let cachedItinerary = cache.find((itinerary) => itinerary.start === p.coords && itinerary.end === q.coords || itinerary.end === p.coords && itinerary.start === q.coords);
+      if (cachedItinerary.end === p.coords) {
+        cachedItinerary = geo.GeoGraphItinerary.fromGraphVertices(
+          cachedItinerary.end,
+          cachedItinerary.start,
+          cachedItinerary.vertices.reverse(),
+          cachedItinerary.edgesWeights
+        );
+      }
+      orderedItineraries.push(cachedItinerary);
     }
     return orderedItineraries;
   }
@@ -1788,6 +1798,51 @@ class WemapMultiRouter {
   removeIOMap(customNetworkMap) {
     this.maps = this.maps.filter((map) => map !== customNetworkMap);
   }
+  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__default.default.warn(`CustomNetworkMap "${map.name}" not found in WemapMultiRouter`);
+          }
+        });
+      }
+    }
+    return ioMapsToTest;
+  }
+  convertOptionsToWemapOsmOptions(options) {
+    return !options || !("useStairs" in options) || options.useStairs ? WemapOsmRouter.DEFAULT_OPTIONS : WemapOsmRouter.WITHOUT_STAIRS_OPTIONS;
+  }
+  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 wemapOsmRouterOptions = this.convertOptionsToWemapOsmOptions(options);
+    const tripItinerary = mapOfWaypoints.getTripInsideMap(waypoints, wemapOsmRouterOptions);
+    return new RouterResponse({
+      routerName: this.rname,
+      from: tripItinerary.from,
+      to: tripItinerary.to,
+      itineraries: [tripItinerary]
+    });
+  }
   async getItineraries(mode, waypoints, options = null) {
     var _a;
     if (waypoints.length > 2) {
@@ -1801,18 +1856,7 @@ class WemapMultiRouter {
       to: end
     });
     const remoteRouters2 = ((_a = options == null ? void 0 : options.remoteRouters) == null ? void 0 : _a.filter(({ name }) => name !== WemapMultiRemoteRouter$1.rname)) || [];
-    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__default.default.warn(`CustomNetworkMap "${map.name}" not found in WemapMultiRouter`);
-          }
-        });
-      }
-    }
+    const ioMapsToTest = this.getIoMapsFromOptions(options);
     if (!ioMapsToTest.length) {
       try {
         return await RemoteRouterManager$1.getItinerariesWithFallback(remoteRouters2, mode, waypoints);
@@ -1826,7 +1870,7 @@ class WemapMultiRouter {
     }
     let ioMapItinerary;
     const mapWithStart = ioMapsToTest.find((map) => map.isPointInside(start));
-    const wemapOsmRouterOptions = !options || !("useStairs" in options) || options.useStairs ? WemapOsmRouter.DEFAULT_OPTIONS : WemapOsmRouter.WITHOUT_STAIRS_OPTIONS;
+    const wemapOsmRouterOptions = this.convertOptionsToWemapOsmOptions(options);
     if (mapWithStart && mapWithStart.isPointInside(end)) {
       try {
         ioMapItinerary = mapWithStart.getItineraryInsideMap(start, end, wemapOsmRouterOptions);
@@ -2056,6 +2100,9 @@ class CustomNetworkMap {
   getItineraryInsideMap(start, end, options) {
     return this.router.getItinerary(start, end, options);
   }
+  getTripInsideMap(waypoints, options) {
+    return this.router.getTripItinerary(waypoints, options);
+  }
   enableWay(osmId) {
     this.graph.edges.filter((edge) => edge.data.id === osmId).forEach((e) => this.router.disabledEdges.delete(e));
     this.disabledWays.delete(osmId);