atriusmaps-node-sdk 3.3.196 → 3.3.225

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

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var e = require('ramda');
-var a = require('zousan');
+var R = require('ramda');
+var Zousan = require('zousan');
 var buildStructureLookup = require('../../../src/utils/buildStructureLookup.js');
 var geodesy = require('../../../src/utils/geodesy.js');
 var findRoute = require('./findRoute.js');
@@ -14,27 +14,602 @@ var segmentBuilder = require('./segmentBuilder.js');
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 function _interopNamespace(e) {
-	if (e && e.__esModule) return e;
-	var n = Object.create(null);
-	if (e) {
-		Object.keys(e).forEach(function (k) {
-			if (k !== 'default') {
-				var d = Object.getOwnPropertyDescriptor(e, k);
-				Object.defineProperty(n, k, d.get ? d : {
-					enumerable: true,
-					get: function () { return e[k]; }
-				});
-			}
-		});
-	}
-	n["default"] = e;
-	return Object.freeze(n);
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
 }
 
-var e__namespace = /*#__PURE__*/_interopNamespace(e);
-var a__default = /*#__PURE__*/_interopDefaultLegacy(a);
+var R__namespace = /*#__PURE__*/_interopNamespace(R);
+var Zousan__default = /*#__PURE__*/_interopDefaultLegacy(Zousan);
 
-const u={SECURITY:"SecurityLane",IMMIGRATION:"ImmigrationLane"};function d(d,l){const p=d.log.sublog("wayfinder"),c=async()=>{d.bus.send("venueData/loadNavGraph");};let f=new a__default["default"];d.bus.on("wayfinder/_getNavGraph",(()=>f)),d.bus.on("venueData/navGraphLoaded",(async({navGraphData:t,structures:n})=>{const e=buildStructureLookup.buildStructuresLookup(n),i=await y(),a=navGraph.createNavGraph(t,e.floorIdToOrdinal,e.floorIdToStructureId,i);f.resolve(a);}));const y=async()=>{const n=await d.bus.get("poi/getByCategoryId",{categoryId:"security"});return e__namespace.pipe(e__namespace.map(m),e__namespace.filter(e__namespace.identity))(n)},m=n=>n.queue&&{type:e__namespace.path(["queue","queueType"],n),id:e__namespace.path(["queue","queueSubtype"],n)};d.bus.on("wayfinder/showNavLineFromPhysicalLocation",(async({toEndpoint:t,selectedSecurityLanes:n=null,requiresAccessibility:o})=>async function(t,n,o){const e=await T({fromEndpoint:t,toEndpoint:n,options:o});if(e){const{segments:t}=e;o.primary&&d.bus.send("map/resetNavlineFeatures"),d.bus.send("map/showNavlineFeatures",{segments:t,category:o.primary?"primary":"alternative"});}return e}(await d.bus.get("user/getPhysicalLocation"),t,{selectedSecurityLanes:n,requiresAccessibility:o,primary:!0})));const h=(t,n)=>d.bus.get("poi/getById",{id:t}).then((o=>{if(o&&o.position)return w(o,n);throw Error("Unknown POI ID "+t)}));const I=["lat","lng","floorId","ordinal"],g=e__namespace.pipe(e__namespace.pick(I),e__namespace.keys,e__namespace.propEq("length",I.length),Boolean),w=(t,n)=>({lat:t.position.latitude,lng:t.position.longitude,floorId:t.position.floorId,ordinal:n(t.position.floorId),title:t.name});async function T({fromEndpoint:t,toEndpoint:n,options:o={}}){return f.then((async e=>{o.compareFindPaths=l.compareFindPaths;const r=findRoute.findRoute(e,t,n,o);if(!r)return null;t.floorId&&n.floorId&&b(t,n,r);const a=await d.bus.get("venueData/getFloorIdToNameMap"),u=await d.bus.get("venueData/getQueueTypes"),c=d.gt();o.requiresAccessibility;const{steps:f,segments:y}=segmentBuilder.buildSegments(r.waypoints,t,n,a,c,u);p.info("route",r);const m=Math.round(r.waypoints.reduce(((t,{eta:n})=>t+n),0)),h=Math.round(r.waypoints.reduce(((t,{distance:n})=>t+n),0));return {...r,segments:y,steps:f,time:m,distance:h}}))}d.bus.on("wayfinder/getNavigationEndpoint",(({ep:t})=>async function(t){return f.then((n=>{if(!t)throw Error("wayfinder: Invalid endpoint definition",t);if("number"==typeof t)return h(t,n.floorIdToOrdinal);if("string"==typeof t){if(t.match(/^\d+$/))return h(parseInt(t),n.floorIdToOrdinal);if(t.indexOf(",")>0){let[o,e,i,r]=t.split(",");if(!n.floorIdToStructureId(i))throw Error("Unknown floorId in endpoint: "+i);return r||(r="Starting Point"),{lat:parseFloat(o),lng:parseFloat(e),ordinal:n.floorIdToOrdinal(i),floorId:i,title:r}}}if(g(t))return t;if(t.latitude)return {lat:t.latitude,lng:t.longitude,floorId:t.floorId,ordinal:n.floorIdToOrdinal(t.floorId),title:t.title};if(t.position&&t.name)return w(t,n.floorIdToOrdinal);throw Error("Invalid start or end point: "+t)}))}(t))),d.bus.on("wayfinder/checkIfPathHasSecurity",(({fromEndpoint:n,toEndpoint:o,options:e={}})=>f.then((r=>{e.compareFindPaths=l.compareFindPaths;const a=findRoute.findRoute(r,n,o,e);if(!a)return {routeExists:!1};const s=n=>Boolean(a.waypoints.find(e__namespace.pathEq(["securityLane","type"],n)));return {routeExists:!0,queues:a.waypoints.filter((n=>e__namespace.pathEq(["securityLane","type"],u.SECURITY,n)||e__namespace.pathEq(["securityLane","type"],u.IMMIGRATION,n))),hasSecurity:s(u.SECURITY),hasImmigration:s(u.IMMIGRATION)}})))),d.bus.on("wayfinder/getRoute",T);const b=(t,n,o)=>d.bus.send("session/submitEvent",{type:"navigation",startPosition:{venueId:t.floorId.split("-")[0],buildingId:o.waypoints[0].position.structureId,floorId:o.waypoints[0].position.floorId,lat:o.waypoints[0].position.lat,lng:o.waypoints[0].position.lng},endPosition:{venueId:n.floorId.split("-")[0],buildingId:o.waypoints[o.waypoints.length-1].position.structureId,floorId:o.waypoints[o.waypoints.length-1].position.floorId,lat:o.waypoints[o.waypoints.length-1].position.lat,lng:o.waypoints[o.waypoints.length-1].position.lng}});function v(n,o,e,i){let r=e__namespace.clone(n);return r=E(r,e,i),o&&o.length?{...r,transitTime:S(o,"transitTime"),distance:S(o,"distance")}:(r.distance="start"===i?P(r,e):P(e,r),r.transitTime=L(r.distance),r)}function S(n,o){return e__namespace.aperture(2,n).map((([n,o])=>{return (e=o.id,n=>e__namespace.find((t=>t.dst===e),n.edges))(n);var e;})).map(e__namespace.prop(o)).reduce(((t,n)=>t+n),0)}function E(t,n,o){return {...t,[o+"Information"]:{lat:n?.lat||n?.position?.latitude,lng:n?.lng||n?.position?.longitude,floorId:n?.floorId||n?.position?.floorId}}}function P(t,n){return geodesy.distance(n?.lat||n?.position?.latitude,n?.lng||n?.position?.longitude,t?.lat||t?.position?.latitude,t?.lng||t?.position?.longitude)}function L(t){return t/60}function O(n){const o=n.filter((t=>null!==t));return e__namespace.sortBy(e__namespace.propOr(1/0,"transitTime"),o)}function q(n,o,e,i,r){const a=M(o,i,n),s=M(e,n,r);if(!a||!s)return null;const u=N(o,a),d=N(e,s);let l=e__namespace.clone(n);return l=E(l,i,"start"),l=E(l,r,"end"),{...l,transitTime:u+d,distance:a+s,startInformation:{...l.startInformation,transitTime:u,distance:a},endInformation:{...l.endInformation,transitTime:d,distance:s}}}function N(t,n){return t&&t.length?S(t,"transitTime"):L(n)}function M(t,n,o){return t&&t.length?S(t,"distance"):P(o,n)}return d.bus.on("wayfinder/addPathTimeSingle",(async({poi:t,startLocation:n,options:o={}})=>n?f.then((e=>function(t,n,o,e){const i=w(o,t.floorIdToOrdinal),r=t.findShortestPath(e,i,n);return v(o,r,e,"start")}(e,o,t,n))):t)),d.bus.on("wayfinder/addPathTimeMultiple",(async({pois:n,startLocation:o,options:e={}})=>o?f.then((i=>function(n,o,e,i){try{const r=e__namespace.clone(e),a=r.map((t=>w(t,n.floorIdToOrdinal))),s=n.findAllShortestPaths(i,a,o);return O(r.map(((t,n)=>v(t,s[n],i,"start"))))}catch(t){return p.error(t),e}}(i,e,n,o))):n)),d.bus.on("wayfinder/multipointAddPathTimeMultiple",(async({pois:n,startLocation:o,endLocation:e,options:i={}})=>o||e?f.then((r=>function(n,o,e,i,r){try{const a=e__namespace.clone(e),s=a.map((t=>w(t,n.floorIdToOrdinal)));let u,d,l;return i&&(u=n.findAllShortestPaths(i,s,o)),r&&(d=function(t,n,o,e){const i=[];for(const r of n)i.push(t.findShortestPath(r,o,e));return i}(n,s,r,o)),l=i&&r?a.map(((t,n)=>q(t,u[n],d[n],i,r))):i?a.map(((t,n)=>v(t,u[n],i,"start"))):a.map(((t,n)=>v(t,d[n],r,"end"))),O(l)}catch(t){return p.error(t),e}}(r,i,n,o,e))):n)),d.bus.on("wayfinder/multipointAddPathTimeSingle",(async({poi:t,startLocation:n,endLocation:o,options:e={}})=>n||o?f.then((i=>function(t,n,o,e,i){const r=w(o,t.floorIdToOrdinal);let a,s;e&&(a=t.findShortestPath(e,r,n));i&&(s=t.findShortestPath(r,i,n));return e&&i?q(o,a,s,e,i):e?v(o,a,e,"start"):i?v(o,s,i,"end"):o}(i,e,t,n,o))):t)),d.bus.on("venueData/loadNewVenue",(()=>{f=new a__default["default"],c();})),d.bus.on("poi/setDynamicData",(({plugin:t,idValuesMap:n})=>{"security"===t&&f.then((t=>t.updateWithSecurityWaitTime(n)));})),d.bus.on("wayfinder/getNavGraphFeatures",(()=>f.then((({_nodes:t})=>navGraphDebug.enrichDebugNavGraph(t))))),{init:c,internal:{resolveNavGraph:t=>f.resolve(t),prepareSecurityLanes:y}}}
+const DEFAULT_WALKING_SPEED_M_PER_MIN = 60;
 
-exports.SecurityLaneType = u;
-exports.create = d;
+const getEdgeTo = dst => node => R__namespace.find(e => e.dst === dst, node.edges);
+
+// todo may be not needed
+const SecurityLaneType = {
+  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 init = async () => {
+    app.bus.send('venueData/loadNavGraph');
+  };
+
+  let graphLoadedProm = new Zousan__default["default"]();
+
+  /**
+   * 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 }) => {
+    const structureLookup = buildStructureLookup.buildStructuresLookup(structures);
+    const securityLanesMap = await prepareSecurityLanes();
+    const graph = navGraph.createNavGraph(
+      navGraphData,
+      structureLookup.floorIdToOrdinal,
+      structureLookup.floorIdToStructureId,
+      securityLanesMap
+    );
+    graphLoadedProm.resolve(graph);
+  });
+
+  const prepareSecurityLanes = async () => {
+    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}
+   */
+  app.bus.on('wayfinder/showNavLineFromPhysicalLocation', async ({ toEndpoint, selectedSecurityLanes = null, requiresAccessibility }) => {
+    const physicalLocation = await app.bus.get('user/getPhysicalLocation');
+    return navigateFromTo(physicalLocation, toEndpoint, { selectedSecurityLanes, requiresAccessibility, 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/showNavlineFeatures', { segments, 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
+   */
+  async function getNavigationEndpoint (p) {
+    return graphLoadedProm.then(graph => {
+      if (!p)
+        throw Error('wayfinder: Invalid endpoint definition', p)
+
+      if (typeof p === 'number')
+        return poiIdToNavigationEndpoint(p, graph.floorIdToOrdinal)
+
+      if (typeof p === 'string') {
+        if (p.match(/^\d+$/)) // single integer - assume its poi id
+          return poiIdToNavigationEndpoint(parseInt(p), graph.floorIdToOrdinal)
+
+        if (p.indexOf(',') > 0) { // lat,lng,floorId,desc format
+          let [lat, lng, floorId, title] = p.split(',');
+          if (!graph.floorIdToStructureId(floorId))
+            throw Error('Unknown floorId in endpoint: ' + floorId)
+          if (!title)
+            title = 'Starting Point';
+
+          return {
+            lat: parseFloat(lat),
+            lng: parseFloat(lng),
+            ordinal: graph.floorIdToOrdinal(floorId),
+            floorId,
+            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
+        }
+
+      if (p.position && p.name) // looks like a POI or some other
+        return poiToNavigationEndpoint(p, graph.floorIdToOrdinal)
+
+      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('length', endpointProps.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
+  });
+
+  /**
+   * 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 => {
+      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(['securityLane', 'type'], SecurityLaneType.SECURITY, node) ||
+          R__namespace.pathEq(['securityLane', 'type'], SecurityLaneType.IMMIGRATION, node));
+      const containsSecurityLaneType = type => Boolean(route.waypoints.find(R__namespace.pathEq(['securityLane', 'type'], type)));
+      return {
+        routeExists: true,
+        queues,
+        hasSecurity: containsSecurityLaneType(SecurityLaneType.SECURITY),
+        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
+   */
+  async function getRoute ({ fromEndpoint, toEndpoint, options = {} }) {
+    return graphLoadedProm
+      .then(async graph => {
+        options.compareFindPaths = config.compareFindPaths;
+        const route = findRoute.findRoute(graph, fromEndpoint, toEndpoint, options);
+        if (!route) return null
+        if (fromEndpoint.floorId && toEndpoint.floorId) // these usually have floorId defined, but can be only ordinal
+          sendRouteAnalytic(fromEndpoint, toEndpoint, route); // todo move to analytics (NOTE: we call this twice for each nav, doubling stats!)
+        const floorIdToNameMap = await app.bus.get('venueData/getFloorIdToNameMap');
+        const queueTypes = await app.bus.get('venueData/getQueueTypes');
+        const translate = app.gt();
+        options.requiresAccessibility;
+        const { steps, segments } = segmentBuilder.buildSegments(
+          route.waypoints,
+          fromEndpoint,
+          toEndpoint,
+          floorIdToNameMap,
+          translate,
+          queueTypes);
+
+        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));
+        return { ...route, segments, steps, time, distance }
+      })
+  }
+
+  const sendRouteAnalytic = (start, end, navigationPath) => app.bus.send('session/submitEvent', {
+    type: 'navigation',
+    startPosition: {
+      venueId: start.floorId.split('-')[0],
+      buildingId: navigationPath.waypoints[0].position.structureId,
+      floorId: navigationPath.waypoints[0].position.floorId,
+      lat: navigationPath.waypoints[0].position.lat,
+      lng: navigationPath.waypoints[0].position.lng
+    },
+    endPosition: {
+      venueId: end.floorId.split('-')[0],
+      buildingId: navigationPath.waypoints[navigationPath.waypoints.length - 1].position.structureId,
+      floorId: navigationPath.waypoints[navigationPath.waypoints.length - 1].position.floorId,
+      lat: navigationPath.waypoints[navigationPath.waypoints.length - 1].position.lat,
+      lng: navigationPath.waypoints[navigationPath.waypoints.length - 1].position.lng
+    }
+  });
+
+  /**
+   * Calculates transit time and distance of shortest path to start location which satisfies passed options
+   * and returns copy of POI with these new properties
+   *
+   * @param {Endpoint} startLocation
+   * @param {RouteOptions} options
+   * @returns {Object} - POI
+   */
+  app.bus.on('wayfinder/addPathTimeSingle', async ({ poi, startLocation, options = {} }) => {
+    if (!startLocation) return poi
+    return graphLoadedProm.then(graph => addPathTimeSingle(graph, options, poi, startLocation))
+  });
+
+  function addPathTimeSingle (graph, options, poi, start) {
+    const end = poiToNavigationEndpoint(poi, graph.floorIdToOrdinal);
+    const path = graph.findShortestPath(start, end, options);
+
+    return resolveAndAddPathProps(poi, path, start, 'start')
+  }
+
+  /**
+   * 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 = {} }) => {
+    if (!startLocation) return pois
+    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 paths = graph.findAllShortestPaths(start, poiLocations, options);
+      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')
+      }
+    } else {
+      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)
+  }
+
+  function addEndpointInformation (poi, endpoint, endpointType) {
+    return {
+      ...poi,
+      [endpointType + 'Information']: {
+        lat: (endpoint?.lat || endpoint?.position?.latitude),
+        lng: (endpoint?.lng || endpoint?.position?.longitude),
+        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))
+  }
+
+  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 {Endpoint} startLocation
+   * @param {Endpoint} endLocation
+   * @param {RouteOptions} options
+   * @param pois: array of pois
+   * @returns Array.<Object> - list of POIs
+   */
+  app.bus.on('wayfinder/multipointAddPathTimeMultiple', async ({ pois, startLocation, endLocation, options = {} }) => {
+    if (!startLocation && !endLocation) return pois
+    return graphLoadedProm.then(graph => multipointAddPathTimeMultiple(graph, options, pois, startLocation, endLocation))
+  });
+
+  function multipointAddPathTimeMultiple (graph, options, pois, start, end) {
+    try {
+      const poisList = R__namespace.clone(pois);
+      const poiLocations = poisList.map(poi => poiToNavigationEndpoint(poi, graph.floorIdToOrdinal));
+
+      let pathsPrimary, pathsSecondary;
+      if (start) { pathsPrimary = graph.findAllShortestPaths(start, poiLocations, options); }
+      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));
+      } else if (start) {
+        poisWithPathProps = poisList.map((poi, i) => resolveAndAddPathProps(poi, pathsPrimary[i], start, 'start'));
+      } else {
+        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)
+  }
+
+  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');
+
+    return {
+      ...updatedPoi,
+      transitTime: timePrimary + timeSecondary,
+      distance: distancePrimary + distanceSecondary,
+      startInformation: { ...updatedPoi.startInformation, transitTime: timePrimary, distance: distancePrimary },
+      endInformation: { ...updatedPoi.endInformation, transitTime: timeSecondary, distance: distanceSecondary }
+    }
+  }
+
+  function getAllSecondaryPaths (graph, poiLocations, endLocation, options) {
+    const pathsSecondary = [];
+    for (const pointAsStart of poiLocations) {
+      pathsSecondary.push(graph.findShortestPath(pointAsStart, endLocation, options));
+    }
+    return pathsSecondary
+  }
+
+  function resolvePathTime (path, 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)
+  }
+
+  /**
+   * Calculates transit time and distance of shortest path from start location to POI
+   * and calculates transit time and distance of shortest path from POI to end location,
+   * where both calculates must satisfy the passed options,
+   * then adds the transit times and distances to create a total for the POI
+   * and returns copy of POI with these new properties
+   *
+   * @param {Endpoint} endLocation
+   * @param {Endpoint} startLocation
+   * @param {RouteOptions} options
+   * @returns {Object} - POI
+   */
+  app.bus.on('wayfinder/multipointAddPathTimeSingle', async ({ poi, startLocation, endLocation, options = {} }) => {
+    if (!startLocation && !endLocation) return poi
+    return graphLoadedProm.then(graph => multipointAddPathTimeSingle(graph, options, poi, startLocation, endLocation))
+  });
+
+  function multipointAddPathTimeSingle (graph, options, poi, start, end) {
+    const poiLocation = poiToNavigationEndpoint(poi, graph.floorIdToOrdinal);
+
+    let pathPrimary, pathSecondary;
+    if (start) { pathPrimary = graph.findShortestPath(start, poiLocation, options); }
+    if (end) { pathSecondary = graph.findShortestPath(poiLocation, end, options); }
+
+    // add two distances and times
+    if (start && end) {
+      return resolveAndAddMultipointPathProps(poi, pathPrimary, pathSecondary, start, end)
+    } else if (start) {
+      return resolveAndAddPathProps(poi, pathPrimary, start, 'start')
+    } else if (end) {
+      return resolveAndAddPathProps(poi, pathSecondary, end, 'end')
+    } else return poi
+  }
+
+  /**
+   * Resets plugin state
+   */
+  app.bus.on('venueData/loadNewVenue', () => {
+    graphLoadedProm = new Zousan__default["default"]();
+    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') return
+    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)));
+
+  return {
+    init,
+    internal: {
+      resolveNavGraph: graph => graphLoadedProm.resolve(graph),
+      prepareSecurityLanes
+    }
+  }
+}
+
+exports.SecurityLaneType = SecurityLaneType;
+exports.create = create;