@wemap/routers 12.7.0 → 12.7.2

package/dist/index.js

@@ -2844,8 +2844,12 @@ __publicField(_OsmGraphUtils, "RESTRICTED_PEDESTRIANS_HIGHWAYS", ["motorway", "m
 __publicField(_OsmGraphUtils, "DEFAULT_WAY_SELECTOR", (way) => {
   if (way.isArea)
     return false;
+  if (way.tags.foot === "yes")
+    return true;
+  if (["no", "private"].includes(way.tags.access))
+    return false;
   const isElevatorArea = way.tags.highway === "elevator" && way.isGeometryClosed;
-  return way.tags.highway && !_OsmGraphUtils.RESTRICTED_PEDESTRIANS_HIGHWAYS.includes(way.tags.highway) && !isElevatorArea && !["no", "private"].includes(way.tags.access) || way.tags.footway === "sidewalk" || way.tags.public_transport === "platform" || way.tags.railway === "platform";
+  return way.tags.highway && !_OsmGraphUtils.RESTRICTED_PEDESTRIANS_HIGHWAYS.includes(way.tags.highway) && !isElevatorArea || way.tags.footway === "sidewalk" || way.tags.public_transport === "platform" || way.tags.railway === "platform";
 });
 let OsmGraphUtils = _OsmGraphUtils;
 class RemoteRouter {
@@ -4355,6 +4359,148 @@ class ItineraryInfoManager {
     return itineraryInfo;
   }
 }
+const _InstructionManager = class _InstructionManager {
+  static getTurnInfoFromAngle(_angle) {
+    let direction, directionExtra;
+    const directionAngle = maths.rad2deg(maths.diffAngle(_angle, Math.PI));
+    const directionAngleAbs = Math.abs(directionAngle);
+    if (directionAngleAbs <= 20) {
+      direction = "straight";
+    } else {
+      direction = directionAngle > 0 ? "left" : "right";
+      if (directionAngleAbs < 55) {
+        directionExtra = "slight";
+      } else if (directionAngleAbs > 120) {
+        directionExtra = "sharp";
+      }
+    }
+    return { direction, directionExtra };
+  }
+  static getInfoFromStep(step) {
+    let type, direction, directionExtra, levelChange;
+    if (step.levelChange) {
+      type = "level-change";
+      levelChange = step.levelChange;
+    } else {
+      type = "turn";
+      const turnInfo = _InstructionManager.getTurnInfoFromAngle(step.angle);
+      direction = turnInfo.direction;
+      directionExtra = turnInfo.directionExtra;
+    }
+    return {
+      type,
+      direction,
+      directionExtra,
+      levelChange,
+      name: step.name,
+      indoor: step.coords.level !== null
+    };
+  }
+  // eslint-disable-next-line max-statements, complexity
+  static getInstructionFromStep(step) {
+    var _a, _b;
+    const { direction, directionExtra } = _InstructionManager.getTurnInfoFromAngle(step.angle);
+    const isTurn = direction !== "straight";
+    if (step.lastStep) {
+      if (isTurn && direction === "left") {
+        return "Your destination is on your left";
+      } else if (isTurn && direction === "right") {
+        return "Your destination is on your right";
+      }
+    }
+    let suffix = "";
+    if ((_a = step.extras) == null ? void 0 : _a.isGate) {
+      suffix = ` on gate ${step.name}`;
+    } else if (step.name) {
+      suffix = ` on ${step.name}`;
+    }
+    if (step.levelChange) {
+      if (step.levelChange.direction === "up") {
+        if (step.levelChange.type === "stairs") {
+          return "Go up the stairs";
+        }
+        if (step.levelChange.type === "escalator") {
+          return "Go up the escalator";
+        }
+        if (step.levelChange.type === "elevator") {
+          return "Go up the elevator";
+        }
+        if (step.levelChange.type === "moving walkway") {
+          return "Go up the moving walkway";
+        }
+        return "Go up" + suffix;
+      }
+      if (step.levelChange.direction === "down") {
+        if (step.levelChange.type === "stairs") {
+          return "Go down the stairs";
+        }
+        if (step.levelChange.type === "escalator") {
+          return "Go down the escalator";
+        }
+        if (step.levelChange.type === "elevator") {
+          return "Go down the elevator";
+        }
+        if (step.levelChange.type === "moving walkway") {
+          return "Go down the moving walkway";
+        }
+        return "Go down" + suffix;
+      }
+      if ((_b = step.extras) == null ? void 0 : _b.subwayEntrance) {
+        return `Take exit ${step.extras.subwayEntranceRef}`;
+      }
+    }
+    if (isTurn) {
+      if (direction === "left") {
+        if (directionExtra === "slight") {
+          return "Turn slightly left" + suffix;
+        }
+        return "Turn left" + suffix;
+      }
+      if (direction === "right") {
+        if (directionExtra === "slight") {
+          return "Turn slightly right" + suffix;
+        }
+        return "Turn right" + suffix;
+      }
+    }
+    return "Continue straight";
+  }
+  static getInstructionFromPosition(itineraryInfoManager, position) {
+    const itineraryInfo = itineraryInfoManager.getInfo(position);
+    if (!itineraryInfo) {
+      return null;
+    }
+    if (this.useProposals && itineraryInfo.projection.distanceFromNearestElement > 15) {
+      return "It seems that we are a little bit lost, please start again the localization process";
+    }
+    const { nextStep } = itineraryInfo;
+    if (!nextStep) {
+      return "You are arrived";
+    }
+    const distNextStep = position.distanceTo(nextStep.coords);
+    const distRounded = maths.roundFactor(distNextStep, 5);
+    if (this.useProposals && distNextStep > 10) {
+      return `Continue straight for ${distRounded}m`;
+    }
+    let instruction = _InstructionManager.getInstructionFromStep(nextStep);
+    const stepWithImportantInfo = itineraryInfoManager._steps.find(
+      (step) => step.levelChange && step.number > nextStep.number && step.coords.distanceTo(nextStep.coords) < 10
+    ) || null;
+    if (stepWithImportantInfo && stepWithImportantInfo.levelChange) {
+      const nextBearing = nextStep.coords.bearingTo(stepWithImportantInfo.coords);
+      const { direction } = _InstructionManager.getTurnInfoFromAngle(nextBearing - nextStep.previousBearing);
+      instruction = direction === "straight" ? "Continue straight" : `Turn ${direction}`;
+      const { direction: levelDirection, type: levelType } = stepWithImportantInfo.levelChange;
+      instruction += ` and take the ${levelType} going ${levelDirection}`;
+    }
+    if (distNextStep >= 5) {
+      instruction += ` in ${distRounded}m`;
+    }
+    return instruction;
+  }
+};
+__publicField(_InstructionManager, "useProposals", false);
+let InstructionManager = _InstructionManager;
 exports.CitywayRemoteRouter = CitywayRemoteRouter$1;
 exports.CustomGraphMap = CustomGraphMap;
 exports.CustomGraphMapTester = CustomGraphMapTester;
@@ -4366,6 +4512,7 @@ exports.GraphRoute = GraphRoute;
 exports.GraphRouter = GraphRouter;
 exports.GraphRouterOptionsBuilder = GraphRouterOptionsBuilder;
 exports.IdfmRemoteRouter = IdfmRemoteRouter$1;
+exports.InstructionManager = InstructionManager;
 exports.Itinerary = Itinerary;
 exports.ItineraryInfoManager = ItineraryInfoManager;
 exports.Leg = Leg;