atriusmaps-node-sdk 3.3.898 → 3.3.899

package/dist/cjs/plugins/wayfinder/src/wayfinder.js

@@ -29,324 +29,171 @@ function _interopNamespaceDefault(e) {
 var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
 
 const DEFAULT_WALKING_SPEED_M_PER_MIN = 60;
-
-const getEdgeTo = dst => node => R__namespace.find(e => e.dst === dst, node.edges);
-
-// todo may be not needed
+const getEdgeTo = (dst) => (node) => R__namespace.find((e) => e.dst === dst, node.edges);
 const SecurityLaneType = {
-  SECURITY: 'SecurityLane',
-  IMMIGRATION: 'ImmigrationLane',
+  SECURITY: "SecurityLane",
+  IMMIGRATION: "ImmigrationLane"
 };
-
-/**
- * @typedef {Object} Endpoint
- * @property {number} lat - latitude
- * @property {number} lng - longitude
- * @property {string} title
- * @property {string} [floorId] - usually present
- * @property {number} [ordinal] - optional
- *
- * @typedef SecurityLaneIdsMap
- * @property {string[]} SecurityLane - list of ids of security lanes
- * @property {string[]} ImmigrationLane - list of ids of immigration lanes
- *
- * @typedef Route
- * @property {Step[]} steps - list of navigation steps
- * @property {Segment[]} segments - list of navigation line segments
- * @property {number} time - total route time
- * @property {number} distance - total route distance
- *
- * @typedef RouteOptions
- * @property {SecurityLaneIdsMap} selectedSecurityLanes - map of selected lane ids by type
- * @property {boolean} requiresAccessibility - true if route should be accessible
- * @property {boolean} compareFindPaths - indicate whether to calculate path using 2 methods and then compare their performance
- *
- * @typedef SecurityWaitTime
- * @property {number} queueTime
- * @property {boolean} timeIsReal
- * @property {boolean} isTemporarilyClosed
- *
- * @typedef {Array<number>} Coordinate - pair of lng and lat
- *
- */
 function create(app, config) {
-  const log = app.log.sublog('wayfinder');
+  const log = app.log.sublog("wayfinder");
   const init = async () => {
-    app.bus.send('venueData/loadNavGraph');
+    app.bus.send("venueData/loadNavGraph");
   };
-
   let graphLoadedProm = new Zousan();
-
-  /**
-   * Returns nav graph object for testing purposes.
-   * Result includes nav nodes, edges, functions to update dynamic data and calculate shortest paths
-   *
-   * @returns {Object}
-   */
-  app.bus.on('wayfinder/_getNavGraph', () => graphLoadedProm);
-
-  /**
-   * @typedef RawNavGraph
-   * @property Array.<RawNavEdge> edges
-   * @property Array.<RawNavNode> nodes
-   *
-   * @typedef RawNavEdge
-   * @property {string} s - id of start node
-   * @property {string} d - id of destination node
-   * @property {number} l - custom transit time
-   * @property {boolean} h - is edge a driveway
-   * @property {string} t - edge type
-   * @property {Array.<{ s, o, i, e }>|null} p - list of Bezier points
-   *
-   * @typedef RawNavNode
-   * @property {string} id
-   * @property {string} floorId
-   * @property {number} lat
-   * @property {number} lng
-   *
-   * Transforms raw nav graph data and list of structures
-   * to nav graph object with functions to build shortest paths
-   *
-   * @param {RawNavGraph} navGraphData
-   * @param {Array.<Structure>} structures
-   */
-  app.bus.on('venueData/navGraphLoaded', async ({ navGraphData, structures }) => {
+  app.bus.on("wayfinder/_getNavGraph", () => graphLoadedProm);
+  app.bus.on("venueData/navGraphLoaded", async ({ navGraphData, structures }) => {
     const structureLookup = buildStructureLookup.buildStructuresLookup(structures);
     const securityLanesMap = await prepareSecurityLanes();
     const graph = navGraph.createNavGraph(
       navGraphData,
       structureLookup.floorIdToOrdinal,
       structureLookup.floorIdToStructureId,
-      securityLanesMap,
+      securityLanesMap
     );
     graphLoadedProm.resolve(graph);
   });
-
-  app.bus.on('poi/setDynamicRouting', async ({ idValuesMap }) => {
+  app.bus.on("poi/setDynamicRouting", async ({ idValuesMap }) => {
     const graph = await graphLoadedProm;
     const poisToAvoid = Object.values(idValuesMap);
-    const nodesToAvoid = poisToAvoid
-      .filter(
-        poi => poi.position && poi.position.floorId !== undefined && poi.position.latitude && poi.position.longitude,
-      )
-      .map(poi => graph.findClosestNode(poi.position.floorId, poi.position.latitude, poi.position.longitude).id);
+    const nodesToAvoid = poisToAvoid.filter(
+      (poi) => poi.position && poi.position.floorId !== void 0 && poi.position.latitude && poi.position.longitude
+    ).map((poi) => graph.findClosestNode(poi.position.floorId, poi.position.latitude, poi.position.longitude).id);
     graph.addNodesToAvoid(nodesToAvoid);
   });
-
   const prepareSecurityLanes = async () => {
-    const securityPois = await app.bus.get('poi/getByCategoryId', {
-      categoryId: 'security',
+    const securityPois = await app.bus.get("poi/getByCategoryId", {
+      categoryId: "security"
     });
     return R__namespace.pipe(R__namespace.map(getSecurityLane), R__namespace.filter(R__namespace.identity))(securityPois);
   };
-
-  const getSecurityLane = poi =>
-    poi.queue && {
-      type: R__namespace.path(['queue', 'queueType'], poi),
-      id: R__namespace.path(['queue', 'queueSubtype'], poi),
-    };
-
-  /**
-   * Returns a shortest path from user physical location to provided destination
-   * and triggers rendering navigation line on the map
-   *
-   * @param {Endpoint} toEndpoint
-   * @param {Boolean} requiresAccessibility
-   * @param {SecurityLaneIdsMap} selectedSecurityLanes
-   * @returns {Route}
-   */
+  const getSecurityLane = (poi) => poi.queue && {
+    type: R__namespace.path(["queue", "queueType"], poi),
+    id: R__namespace.path(["queue", "queueSubtype"], poi)
+  };
   app.bus.on(
-    'wayfinder/showNavLineFromPhysicalLocation',
+    "wayfinder/showNavLineFromPhysicalLocation",
     async ({ toEndpoint, selectedSecurityLanes = null, requiresAccessibility }) => {
-      const physicalLocation = await app.bus.getFirst('user/getPhysicalLocation');
+      const physicalLocation = await app.bus.getFirst("user/getPhysicalLocation");
       return navigateFromTo(physicalLocation, toEndpoint, {
         selectedSecurityLanes,
         requiresAccessibility,
-        primary: true,
+        primary: true
       });
-    },
+    }
   );
-
   async function navigateFromTo(fromEndpoint, toEndpoint, options) {
     const route = await getRoute({ fromEndpoint, toEndpoint, options });
     if (route) {
       const { segments } = route;
       if (options.primary) {
-        app.bus.send('map/resetNavlineFeatures');
+        app.bus.send("map/resetNavlineFeatures");
       }
-      app.bus.send('map/showNavlineFeatures', {
+      app.bus.send("map/showNavlineFeatures", {
         segments,
-        category: options.primary ? 'primary' : 'alternative',
+        category: options.primary ? "primary" : "alternative"
       });
     }
-
     return route;
   }
-
-  const poiIdToNavigationEndpoint = (id, floorIdToOrdinal) =>
-    app.bus.get('poi/getById', { id }).then(poi => {
-      if (poi && poi.position) {
-        return poiToNavigationEndpoint(poi, floorIdToOrdinal);
-      } else {
-        throw Error('Unknown POI ID ' + id);
-      }
-    });
-
-  /**
-   * @busEvent wayfinder/getNavigationEndpoint
-   *
-   * Returns an object of the Endoint type.
-   * wayfinding uses this structure to find the closest node
-   * for shortestPath calculations, etc.
-   * @param  {Object} p - can be a POI (or similar) or a string with lat,lng[,floorId[,name]] or location defined as { latitutde, longitude [, floorId] [, title] }
-   * @returns {Endpoint} navigational endpoint
-   */
+  const poiIdToNavigationEndpoint = (id, floorIdToOrdinal) => app.bus.get("poi/getById", { id }).then((poi) => {
+    if (poi && poi.position) {
+      return poiToNavigationEndpoint(poi, floorIdToOrdinal);
+    } else {
+      throw Error("Unknown POI ID " + id);
+    }
+  });
   async function getNavigationEndpoint(p) {
-    return graphLoadedProm.then(graph => {
+    return graphLoadedProm.then((graph) => {
       if (!p) {
-        throw Error('wayfinder: Invalid endpoint definition', p);
+        throw Error("wayfinder: Invalid endpoint definition", p);
       }
-
-      if (typeof p === 'number') {
+      if (typeof p === "number") {
         return poiIdToNavigationEndpoint(p, graph.floorIdToOrdinal);
       }
-
-      if (typeof p === 'string') {
-        if (p.match(/^\d+$/)) // single integer - assume its poi id
-        {
+      if (typeof p === "string") {
+        if (p.match(/^\d+$/)) {
           return poiIdToNavigationEndpoint(parseInt(p), graph.floorIdToOrdinal);
         }
-
-        if (p.indexOf(',') > 0) {
-          // lat,lng,floorId,desc format
-          const [lat, lng, floorId, initialTitle] = p.split(',');
+        if (p.indexOf(",") > 0) {
+          const [lat, lng, floorId, initialTitle] = p.split(",");
           if (!graph.floorIdToStructureId(floorId)) {
-            throw Error('Unknown floorId in endpoint: ' + floorId);
+            throw Error("Unknown floorId in endpoint: " + floorId);
           }
           let title = initialTitle;
           if (!title) {
-            title = 'Starting Point';
+            title = "Starting Point";
           }
-
           return {
             lat: parseFloat(lat),
             lng: parseFloat(lng),
             ordinal: graph.floorIdToOrdinal(floorId),
             floorId,
-            title,
+            title
           };
         }
       }
-
       if (isEndpoint(p)) {
         return p;
       }
-
       if (p.latitude) {
         return {
           lat: p.latitude,
           lng: p.longitude,
           floorId: p.floorId,
           ordinal: graph.floorIdToOrdinal(p.floorId),
-          title: p.title,
+          title: p.title
         };
       }
-
-      if (p.position && p.name) // looks like a POI or some other
-      {
+      if (p.position && p.name) {
         return poiToNavigationEndpoint(p, graph.floorIdToOrdinal);
       }
-
-      throw Error('Invalid start or end point: ' + p);
+      throw Error("Invalid start or end point: " + p);
     });
   }
-
-  const endpointProps = ['lat', 'lng', 'floorId', 'ordinal'];
-  const isEndpoint = R__namespace.pipe(R__namespace.pick(endpointProps), R__namespace.keys, R__namespace.propEq(endpointProps.length, 'length'), Boolean);
-
+  const endpointProps = ["lat", "lng", "floorId", "ordinal"];
+  const isEndpoint = R__namespace.pipe(R__namespace.pick(endpointProps), R__namespace.keys, R__namespace.propEq(endpointProps.length, "length"), Boolean);
   const poiToNavigationEndpoint = (poi, floorIdToOrdinal) => ({
     lat: poi.position.latitude,
     lng: poi.position.longitude,
     floorId: poi.position.floorId,
     ordinal: floorIdToOrdinal(poi.position.floorId),
-    title: poi.name,
+    title: poi.name
   });
-
-  /**
-   * Transforms provided data to endpoint type object
-   *
-   * @return {Endpoint} - navigation endpoint
-   */
-  app.bus.on('wayfinder/getNavigationEndpoint', ({ ep }) => getNavigationEndpoint(ep));
-
-  /**
-   * @typedef PathSecurityInfo
-   * @property {boolean} routeExists
-   * @property {boolean} [hasSecurity]
-   * @property {boolean} [hasImmigration]
-   *
-   * Checks if there is a path between 2 endpoints which satisfies passed options
-   * and if this path includes security and immigration lanes
-   *
-   * @param {Endpoint} fromEndpoint
-   * @param {Endpoint} toEndpoint
-   * @param {RouteOptions} options
-   * @returns {PathSecurityInfo}
-   */
-  app.bus.on('wayfinder/checkIfPathHasSecurity', ({ fromEndpoint, toEndpoint, options = {} }) =>
-    graphLoadedProm.then(graph => {
+  app.bus.on("wayfinder/getNavigationEndpoint", ({ ep }) => getNavigationEndpoint(ep));
+  app.bus.on(
+    "wayfinder/checkIfPathHasSecurity",
+    ({ fromEndpoint, toEndpoint, options = {} }) => graphLoadedProm.then((graph) => {
       options.compareFindPaths = config.compareFindPaths;
       const route = findRoute.findRoute(graph, fromEndpoint, toEndpoint, options);
-
       if (!route) {
         return { routeExists: false };
       }
-
       const queues = route.waypoints.filter(
-        node =>
-          R__namespace.pathEq(SecurityLaneType.SECURITY, ['securityLane', 'type'], node) ||
-          R__namespace.pathEq(SecurityLaneType.IMMIGRATION, ['securityLane', 'type'], node),
+        (node) => R__namespace.pathEq(SecurityLaneType.SECURITY, ["securityLane", "type"], node) || R__namespace.pathEq(SecurityLaneType.IMMIGRATION, ["securityLane", "type"], node)
       );
-      const containsSecurityLaneType = type => Boolean(route.waypoints.find(R__namespace.pathEq(type, ['securityLane', 'type'])));
+      const containsSecurityLaneType = (type) => Boolean(route.waypoints.find(R__namespace.pathEq(type, ["securityLane", "type"])));
       return {
         routeExists: true,
         queues,
         hasSecurity: containsSecurityLaneType(SecurityLaneType.SECURITY),
-        hasImmigration: containsSecurityLaneType(SecurityLaneType.IMMIGRATION),
+        hasImmigration: containsSecurityLaneType(SecurityLaneType.IMMIGRATION)
       };
-    }),
+    })
   );
-
-  app.bus.on('wayfinder/getRoute', getRoute);
-
-  /**
-   * @busEvent wayfinder/getRoute
-   *
-   * Builds the shortest path between 2 endpoints which satisfies passed options
-   *
-   * @param {RouteOptions} options
-   * @param {Endpoint} fromEndpoint
-   * @param {Endpoint} toEndpoint
-   *
-   * @return {(Route|null)} route - route or null if no route available
-   */
+  app.bus.on("wayfinder/getRoute", getRoute);
   async function getRoute({ fromEndpoint, toEndpoint, options = {} }) {
-    const rawPois = (await app.bus.get('poi/getAll')) || {};
-    // Extract the POI objects (assuming rawPois is an array with one object)
+    const rawPois = await app.bus.get("poi/getAll") || {};
     const allPois = Array.isArray(rawPois) ? rawPois[0] : rawPois;
-    // Convert the object values to an array and filter by category
-    const securityPois = Object.values(allPois).filter(poi => poi.category && poi.category.startsWith('security'));
-
-    const currentUnits = (await app.bus.getFirst('directions/getPreferredUnits')) || 'meters'; // can be 'meters' or 'yards'
-
-    return graphLoadedProm.then(async graph => {
+    const securityPois = Object.values(allPois).filter((poi) => poi.category && poi.category.startsWith("security"));
+    const currentUnits = await app.bus.getFirst("directions/getPreferredUnits") || "meters";
+    return graphLoadedProm.then(async (graph) => {
       options.compareFindPaths = config.compareFindPaths;
       const route = findRoute.findRoute(graph, fromEndpoint, toEndpoint, options);
       if (!route) {
         return null;
       }
-      const floorIdToNameMap = await app.bus.get('venueData/getFloorIdToNameMap');
-      const queueTypes = await app.bus.get('venueData/getQueueTypes');
+      const floorIdToNameMap = await app.bus.get("venueData/getFloorIdToNameMap");
+      const queueTypes = await app.bus.get("venueData/getQueueTypes");
       const translate = app.gt();
       const isAccessible = options.requiresAccessibility;
       const { steps, segments } = segmentBuilder.buildSegments(
@@ -358,130 +205,88 @@ function create(app, config) {
         queueTypes,
         isAccessible,
         securityPois,
-        currentUnits,
+        currentUnits
       );
-
-      log.info('route', route);
+      log.info("route", route);
       const time = Math.round(route.waypoints.reduce((total, { eta }) => total + eta, 0));
-      const distance = Math.round(route.waypoints.reduce((total, { distance }) => total + distance, 0));
-
+      const distance = Math.round(route.waypoints.reduce((total, { distance: distance2 }) => total + distance2, 0));
       return { ...route, segments, steps, time, distance };
     });
   }
-
-  /**
-   * Calculates transit time and distance of shortest path from each POI to start location which satisfies passed options
-   * and returns list of copies of POI with these new properties
-   *
-   * @param {Endpoint} startLocation
-   * @param {RouteOptions} options
-   * @param pois: array of pois
-   * @returns Array.<Object> - list of POIs
-   */
-  app.bus.on('wayfinder/addPathTimeMultiple', async ({ pois, startLocation, options = {} }) => {
+  app.bus.on("wayfinder/addPathTimeMultiple", async ({ pois, startLocation, options = {} }) => {
     if (!startLocation) {
       return pois;
     }
-    return graphLoadedProm.then(graph => addPathTimeMultiple(graph, options, pois, startLocation));
+    return graphLoadedProm.then((graph) => addPathTimeMultiple(graph, options, pois, startLocation));
   });
-
   function addPathTimeMultiple(graph, options, pois, start) {
     try {
       const poisList = R__namespace.clone(pois);
-      const poiLocations = poisList.map(poi => poiToNavigationEndpoint(poi, graph.floorIdToOrdinal));
-
+      const poiLocations = poisList.map((poi) => poiToNavigationEndpoint(poi, graph.floorIdToOrdinal));
       const paths = graph.findAllShortestPaths(start, poiLocations, options);
-      const poisWithPathProps = poisList.map((poi, i) => resolveAndAddPathProps(poi, paths[i], start, 'start'));
-
+      const poisWithPathProps = poisList.map((poi, i) => resolveAndAddPathProps(poi, paths[i], start, "start"));
       return filterAndSort(poisWithPathProps);
     } catch (e) {
       log.error(e);
       return pois;
     }
   }
-
   function resolveAndAddPathProps(poi, path, endpoint, endpointType) {
     let updatedPoi = R__namespace.clone(poi);
     updatedPoi = addEndpointInformation(updatedPoi, endpoint, endpointType);
-
     if (path && path.length) {
       return {
         ...updatedPoi,
-        transitTime: calculateTotalPathProperty(path, 'transitTime'),
-        distance: calculateTotalPathProperty(path, 'distance'),
+        transitTime: calculateTotalPathProperty(path, "transitTime"),
+        distance: calculateTotalPathProperty(path, "distance")
       };
     } else {
-      updatedPoi.distance =
-        endpointType === 'start' ? getGeoDistance(updatedPoi, endpoint) : getGeoDistance(endpoint, updatedPoi);
+      updatedPoi.distance = endpointType === "start" ? getGeoDistance(updatedPoi, endpoint) : getGeoDistance(endpoint, updatedPoi);
       updatedPoi.transitTime = getTransitTime(updatedPoi.distance);
       return updatedPoi;
     }
   }
-
   function calculateTotalPathProperty(path, propertyName) {
-    return R__namespace.aperture(2, path)
-      .map(([from, to]) => getEdgeTo(to.id)(from))
-      .map(R__namespace.prop(propertyName))
-      .reduce((totalTime, edgeTime) => totalTime + edgeTime, 0);
+    return R__namespace.aperture(2, path).map(([from, to]) => getEdgeTo(to.id)(from)).map(R__namespace.prop(propertyName)).reduce((totalTime, edgeTime) => totalTime + edgeTime, 0);
   }
-
   function addEndpointInformation(poi, endpoint, endpointType) {
     return {
       ...poi,
-      [endpointType + 'Information']: {
+      [endpointType + "Information"]: {
         lat: endpoint?.lat || endpoint?.position?.latitude,
         lng: endpoint?.lng || endpoint?.position?.longitude,
-        floorId: endpoint?.floorId || endpoint?.position?.floorId,
-      },
+        floorId: endpoint?.floorId || endpoint?.position?.floorId
+      }
     };
   }
-
   function getGeoDistance(endLocation, startLocation) {
     return geodesy.distance(
       startLocation?.lat || startLocation?.position?.latitude,
       startLocation?.lng || startLocation?.position?.longitude,
       endLocation?.lat || endLocation?.position?.latitude,
-      endLocation?.lng || endLocation?.position?.longitude,
+      endLocation?.lng || endLocation?.position?.longitude
     );
   }
-
   function getTransitTime(distance) {
     return distance / DEFAULT_WALKING_SPEED_M_PER_MIN;
   }
-
-  /**
-   * Calculates transit time and distance of shortest path from the start location to each POI
-   * and calculates transit time and distance of shortest path from each POI to end location,
-   * where both calculates must satisfy the passed options,
-   * then adds the transit times and distances to create a total for each POI
-   * and returns list of copies of POI with these new properties
-   *
-   * @param {Poi} startLocation
-   * @param {Poi} endLocation
-   * @param {Endpoint} currentLocation
-   * @param {RouteOptions} options
-   * @param pois: array of pois
-   * @returns Array.<Object> - list of POIs
-   */
   app.bus.on(
-    'wayfinder/multipointAddPathTimeMultiple',
+    "wayfinder/multipointAddPathTimeMultiple",
     async ({ pois, startLocation, endLocation, currentLocation, options = {} }) => {
       if (!startLocation && !endLocation && !currentLocation) {
         return pois;
       }
-      return graphLoadedProm.then(graph =>
-        multipointAddPathTimeMultiple(graph, options, pois, startLocation, endLocation, currentLocation),
+      return graphLoadedProm.then(
+        (graph) => multipointAddPathTimeMultiple(graph, options, pois, startLocation, endLocation, currentLocation)
       );
-    },
+    }
   );
-
   function multipointAddPathTimeMultiple(graph, options, pois, startPoi, endPoi, currentLocation) {
     try {
       const start = startPoi ? poiToNavigationEndpoint(startPoi, graph.floorIdToOrdinal) : currentLocation;
       const end = endPoi ? poiToNavigationEndpoint(endPoi, graph.floorIdToOrdinal) : null;
       const poisList = R__namespace.clone(pois);
-      const poiLocations = poisList.map(poi => poiToNavigationEndpoint(poi, graph.floorIdToOrdinal));
-
+      const poiLocations = poisList.map((poi) => poiToNavigationEndpoint(poi, graph.floorIdToOrdinal));
       let pathsPrimary, pathsSecondary;
       if (start) {
         pathsPrimary = graph.findAllShortestPaths(start, poiLocations, options);
@@ -489,46 +294,37 @@ function create(app, config) {
       if (end) {
         pathsSecondary = getAllSecondaryPaths(graph, poiLocations, end, options);
       }
-
       let poisWithPathProps;
       if (start && end) {
-        poisWithPathProps = poisList.map((poi, i) =>
-          resolveAndAddMultipointPathProps(poi, pathsPrimary[i], pathsSecondary[i], start, end),
+        poisWithPathProps = poisList.map(
+          (poi, i) => resolveAndAddMultipointPathProps(poi, pathsPrimary[i], pathsSecondary[i], start, end)
         );
       } else if (start) {
-        poisWithPathProps = poisList.map((poi, i) => resolveAndAddPathProps(poi, pathsPrimary[i], start, 'start'));
+        poisWithPathProps = poisList.map((poi, i) => resolveAndAddPathProps(poi, pathsPrimary[i], start, "start"));
       } else {
-        poisWithPathProps = poisList.map((poi, i) => resolveAndAddPathProps(poi, pathsSecondary[i], end, 'end'));
+        poisWithPathProps = poisList.map((poi, i) => resolveAndAddPathProps(poi, pathsSecondary[i], end, "end"));
       }
-
       return filterAndSort(poisWithPathProps);
     } catch (e) {
       log.error(e);
       return pois;
     }
   }
-
   function filterAndSort(pois) {
-    const poisWithPathProps = pois.filter(poi => poi !== null);
-    return R__namespace.sortBy(R__namespace.propOr(Infinity, 'transitTime'), poisWithPathProps);
+    const poisWithPathProps = pois.filter((poi) => poi !== null);
+    return R__namespace.sortBy(R__namespace.propOr(Infinity, "transitTime"), poisWithPathProps);
   }
-
   function resolveAndAddMultipointPathProps(poi, pathPrimary, pathSecondary, startLocation, endLocation) {
     const distancePrimary = resolvePathDistance(pathPrimary, startLocation, poi);
     const distanceSecondary = resolvePathDistance(pathSecondary, poi, endLocation);
-
     if (!distancePrimary || !distanceSecondary) {
       return null;
-    } // ensure poi is reachable from both locations
-
+    }
     const timePrimary = resolvePathTime(pathPrimary, distancePrimary);
     const timeSecondary = resolvePathTime(pathSecondary, distanceSecondary);
-
-    // create deep copy of poi and add information on the start and end locations
     let updatedPoi = R__namespace.clone(poi);
-    updatedPoi = addEndpointInformation(updatedPoi, startLocation, 'start');
-    updatedPoi = addEndpointInformation(updatedPoi, endLocation, 'end');
-
+    updatedPoi = addEndpointInformation(updatedPoi, startLocation, "start");
+    updatedPoi = addEndpointInformation(updatedPoi, endLocation, "end");
     return {
       ...updatedPoi,
       transitTime: timePrimary + timeSecondary,
@@ -536,16 +332,15 @@ function create(app, config) {
       startInformation: {
         ...updatedPoi.startInformation,
         transitTime: timePrimary,
-        distance: distancePrimary,
+        distance: distancePrimary
       },
       endInformation: {
         ...updatedPoi.endInformation,
         transitTime: timeSecondary,
-        distance: distanceSecondary,
-      },
+        distance: distanceSecondary
+      }
     };
   }
-
   function getAllSecondaryPaths(graph, poiLocations, endLocation, options) {
     const pathsSecondary = [];
     for (const pointAsStart of poiLocations) {
@@ -553,68 +348,29 @@ function create(app, config) {
     }
     return pathsSecondary;
   }
-
   function resolvePathTime(path, distance) {
-    return path && path.length ? calculateTotalPathProperty(path, 'transitTime') : getTransitTime(distance);
+    return path && path.length ? calculateTotalPathProperty(path, "transitTime") : getTransitTime(distance);
   }
-
   function resolvePathDistance(path, startLocation, endLocation) {
-    return path && path.length
-      ? calculateTotalPathProperty(path, 'distance')
-      : getGeoDistance(endLocation, startLocation);
+    return path && path.length ? calculateTotalPathProperty(path, "distance") : getGeoDistance(endLocation, startLocation);
   }
-
-  /**
-   * Resets plugin state
-   */
-  app.bus.on('venueData/loadNewVenue', () => {
+  app.bus.on("venueData/loadNewVenue", () => {
     graphLoadedProm = new Zousan();
     init();
   });
-
-  /**
-   * Updates nav graph dynamic data if security data is passed
-   *
-   * @param {string} plugin - type of dynamic data
-   * @param {Object<string, SecurityWaitTime|Object>} - dictionary of POI id to dynamic data object
-   */
-  app.bus.on('poi/setDynamicData', ({ plugin, idValuesMap }) => {
-    if (plugin !== 'security') {
+  app.bus.on("poi/setDynamicData", ({ plugin, idValuesMap }) => {
+    if (plugin !== "security") {
       return;
     }
-    graphLoadedProm.then(graph => graph.updateWithSecurityWaitTime(idValuesMap));
+    graphLoadedProm.then((graph) => graph.updateWithSecurityWaitTime(idValuesMap));
   });
-
-  /**
-   * Returns a list of edges and nodes in a format convenient to display them on the map
-   *
-   * @typedef DebugNode
-   * @property {string} floorId
-   * @property {string} id
-   * @property {boolean} isOrphaned
-   * @property {number} lat
-   * @property {number} lng
-   * @property {number} ordinal
-   * @property {string} structureId
-   *
-   * @typedef DebugEdge
-   * @property {Coordinate} startCoordinates
-   * @property {Coordinate} endCoordinates
-   * @property {boolean} isDriveway
-   * @property {number} ordinal
-   * @property {string} category
-   * @property {string} defaultStrokeColor
-   *
-   * @returns {{nodes: DebugNode[], edges: DebugEdge[]}} debug nav graph
-   */
-  app.bus.on('wayfinder/getNavGraphFeatures', () => graphLoadedProm.then(({ _nodes }) => navGraphDebug.enrichDebugNavGraph(_nodes)));
-
+  app.bus.on("wayfinder/getNavGraphFeatures", () => graphLoadedProm.then(({ _nodes }) => navGraphDebug.enrichDebugNavGraph(_nodes)));
   return {
     init,
     internal: {
-      resolveNavGraph: graph => graphLoadedProm.resolve(graph),
-      prepareSecurityLanes,
-    },
+      resolveNavGraph: (graph) => graphLoadedProm.resolve(graph),
+      prepareSecurityLanes
+    }
   };
 }