@wemap/routers 12.7.1 → 12.7.3

package/dist/index.js

@@ -3887,14 +3887,28 @@ class RemoteRouterManager {
   }
   async getItinerariesWithFallback(routerRequest, fallbackStrategy) {
     let itineraries;
+    const errors = [];
     for (const { name, endpointUrl } of fallbackStrategy) {
-      itineraries = await this.getItineraries(name, endpointUrl, routerRequest);
-      if (itineraries.length) {
-        return itineraries;
+      try {
+        itineraries = await this.getItineraries(name, endpointUrl, routerRequest);
+        if (itineraries.length) {
+          return itineraries;
+        }
+      } catch (error) {
+        if (error instanceof RemoteRoutingError) {
+          errors.push({
+            name,
+            endpointUrl,
+            error
+          });
+        } else {
+          throw error;
+        }
       }
     }
-    const routersNames = fallbackStrategy.map(({ name }) => name).join(",");
-    throw RemoteRoutingError.notFound(routersNames, `Could not find an itinerary with any of following servers: ${routersNames}`);
+    const routersNames = fallbackStrategy.map(({ name }) => name).join(", ");
+    const errorsMessages = errors.map((routerError) => `(${routerError.name}) Could not find an itinerary on endpoint: ${routerError.endpointUrl}. Details: ${routerError.error.message}`).join("\n");
+    throw RemoteRoutingError.notFound(routersNames, errorsMessages);
   }
 }
 const RemoteRouterManager$1 = new RemoteRouterManager();
@@ -4359,6 +4373,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;
@@ -4370,6 +4526,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;