atriusmaps-node-sdk 3.3.196 → 3.3.226

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

@@ -2,13 +2,401 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var e = require('ramda');
+var R = require('ramda');
 var geohasher = require('../../../src/extModules/geohasher.js');
 var geodesy = require('../../../src/utils/geodesy.js');
 var minPriorityQueue = require('./minPriorityQueue.js');
 
-const d=9999;function f(r,s,l,u){const d={},f={};let a={};r.nodes.forEach((o=>{const n=s(o.floorId),e$1=l(o.floorId);!function(t){const o=t.floorId+":"+geohasher.encode(t.lat,t.lng).substr(0,7),n=t.floorId+":"+geohasher.encode(t.lat,t.lng).substr(0,8);f[o]||(f[o]=[]);f[o].push(t),f[n]||(f[n]=[]);f[n].push(t),d[t.id]=t;}({...e.pick(["id","lat","lng","floorId"],o),edges:[],ordinal:n,structureId:e$1});})),r.edges.forEach((t=>d[t.s].edges.push(function(t,n){const e$1=function(t){return t.x?"Security Checkpoint":""===t.t?"Ground":t.t}(t),r="escalator"!==e$1.toLowerCase()&&"stairs"!==e$1.toLowerCase(),i=c(t.s,t.d,n),s=t.l||i/60,l=t=>t.map((t=>({start:{lat:t.s[0],lng:t.s[1]},out:{lat:t.o[0],lng:t.o[1]},in:{lat:t.i[0],lng:t.i[1]},end:{lat:t.e[0],lng:t.e[1]}}))),u=t.p?l(t.p):null;return {distance:i,dst:t.d,o:t.o,isAccessible:r,isDriveway:!e.isNil(t.h)&&!t.h,src:t.s,transitTime:s,type:e$1,path:u,weight:s}}(t,d))));const h=t=>{if(void 0===t.floorId&&void 0===t.ordinal)throw Error("Endpoint specified in findRoute without floorId nor an ordinal");const o=t.lat||t.latitude,n=t.lng||t.longitude;return t.floorId?C(t.floorId,o,n,f,d):S(t.ordinal,o,n,d)};return {_nodes:d,_geoDb:f,findClosestNode:(t,o,n)=>C(t,o,n,f,d),findShortestPath:(t,o,n)=>function(t,o,n,e={}){return b(h(t),h(o),n,a,u,e)}(t,o,d,n),findAllShortestPaths:function(t,o,n){const e=h(t),r=o.map((t=>h(t)));return e&&r.length?function(t,o,n,e={},r={},i={}){return o.map((o=>{try{return b(t,o,n,e,r,i)}catch(t){return null}}))}(e,r,d,a,u,n):[]},floorIdToOrdinal:s,floorIdToStructureId:l,updateWithSecurityWaitTime:function(t){a=e.map(e.omit(["lastUpdated"]),t),I();},clearCache:I}}function c(t,o,n){const e=n[t],r=n[o];return geodesy.distance(e.lat,e.lng,r.lat,r.lng)}let a,h,p,g,m,y;const I=()=>{a={},h={},p={},g=new minPriorityQueue,m=null,y={};};function b(t,o,n,e$1={},i={},s={}){for(t.id===m&&y===JSON.stringify(s)||(I(),g.offerWithPriority(t.id,0),a[t.id]=0,p[t.id]=!0,m=t.id,y=JSON.stringify(s));!g.isEmpty()&&!p[o.id];){const t=n[g.poll()],o=a[t.id];for(let n=0;n<t.edges.length;n++){const l=t.edges[n];if(p[l.dst])continue;if(s.requiresAccessibility&&!l.isAccessible)continue;let u=l.weight;if(l.o&&e$1[l.o]){const t=e$1[l.o];t.queueTime&&(u=t.queueTime),t.isTemporarilyClosed&&(u=d),l.securityWaitTimes=t;}if(l.o&&i[l.o]){l.securityLane=i[l.o];const{type:t,id:o}=i[l.o],n=e.path(["selectedSecurityLanes",t],s);if(n&&!n.includes(o))continue}void 0===a[l.dst]?(h[l.dst]=t,a[l.dst]=o+u,g.offerWithPriority(l.dst,o+u)):a[l.dst]>o+u&&(a[l.dst]=o+u,h[l.dst]=t,g.raisePriority(l.dst,o+u));}p[t.id]=!0;}if(!p[o.id])return null;const l=[];let u=o;for(;u;)l.push(u),u=h[u.id];return l.reverse()}function w(t,o,n,e){const r=o.substr(0,e),i=[];i.push(t+":"+geohasher.calculateAdjacent(geohasher.calculateAdjacent(r,"top"),"left")),i.push(t+":"+geohasher.calculateAdjacent(r,"top")),i.push(t+":"+geohasher.calculateAdjacent(geohasher.calculateAdjacent(r,"top"),"right")),i.push(t+":"+geohasher.calculateAdjacent(r,"left")),i.push(t+":"+r),i.push(t+":"+geohasher.calculateAdjacent(r,"right")),i.push(t+":"+geohasher.calculateAdjacent(geohasher.calculateAdjacent(r,"bottom"),"left")),i.push(t+":"+geohasher.calculateAdjacent(r,"bottom")),i.push(t+":"+geohasher.calculateAdjacent(geohasher.calculateAdjacent(r,"bottom"),"right"));const l=[];for(let t=0;t<i.length;t++){const o=n[i[t]];if(o)for(let t=0;t<o.length;t++)l.push(o[t]);}return l}function C(t,o,n,e,r){const s=function(t,o,n,e){let r=w(t,o,n,8);return r.length>0?r:(r=w(t,o,n,7),r.length>0?r:null)}(t,geohasher.encode(o,n),e)||function(t,o,n,e){const r=Object.values(e).filter((o=>o.floorId===t)).map((t=>[t,geodesy.distance(t.lat,t.lng,o,n)]));if(!r.length)throw Error(`findClosestNodeByFloor2 found no nodes on floor ${t}`);return T(r)}(t,o,n,r),u=[];for(let t=0;t<s.length;t++){const e=geodesy.distance(o,n,s[t].lat,s[t].lng);u.push([s[t],e]);}u.sort((function(t,o){return t[1]-o[1]}));const d=[];for(let t=0;t<u.length;t++)d.push(u[t][0]);return d[0]}function S(t,o,n,e){const r=Object.values(e).filter((o=>o.ordinal===t)).map((t=>[t,geodesy.distance(t.lat,t.lng,o,n)]));if(!r.length)throw Error(`findClosestNodeByOrdinal found no nodes on ordinal ${t}`);return T(r)}function T(t){let o=t[0];for(let n=1;n<t.length;n++)t[n][1]<o[1]&&(o=t[n]);return o[0]}
+const DEFAULT_WALKING_SPEED_M_PER_MIN = 60;
+const CLOSED_CHECKPOINT_EDGE_WEIGHT = 9999;
 
-exports.createNavGraph = f;
-exports.findClosestNodeByOrdinal = S;
-exports.findShortestPath = b;
+/**
+ * @typedef NavNode
+ * @property {number} ordinal
+ * @property {Array.<NavEdge>} edges
+ * @property {string} id
+ * @property {number} lat
+ * @property {number} lng
+ * @property {string} floorId
+ * @property {structureId} structureId
+ *
+ * @typedef NavEdge
+ * @property {string} dst - id of node at edge end
+ * @property {string} src - id of node at edge start
+ * @property {number} distance
+ * @property {string|undefined} o - id of security lane POI associated with this edge
+ * @property {CurvedPath|null} path - list of Bezier points if edge represents curve
+ * @property {boolean} isAccessible
+ * @property {boolean} isDriveway - true if edge points to POI, false if edge just connects other edges
+ * @property {number} transitTime
+ * @property {string} type
+ * @property {number} weight - value used by Dijkstra algorithm (usually edge time or distance)
+ *
+ * @param {RawNavGraph} data
+ * @param {function} floorIdToOrdinal
+ * @param {function} floorIdToStructureId
+ * @param {Array.<SecurityLane>} securityLanesMap - list of security lanes
+ * @return {Object}
+ */
+// todo remove dead commented code
+function createNavGraph (data, floorIdToOrdinal, floorIdToStructureId, securityLanesMap) {
+  const nodes = { };
+  const geoDb = { };
+  let securityWaitTimes = {};
+
+  data.nodes.forEach(nodeData => {
+    const ordinal = floorIdToOrdinal(nodeData.floorId);
+    const structureId = floorIdToStructureId(nodeData.floorId);
+    const node = {
+      ...R.pick(['id', 'lat', 'lng', 'floorId'], nodeData),
+      edges: [],
+      ordinal,
+      structureId
+    };
+    addNode(node);
+  });
+
+  data.edges.forEach(ed => nodes[ed.s].edges.push(createEdge(ed, nodes)));
+
+  function addNode (node) {
+    const largeGeo = node.floorId + ':' + geohasher.encode(node.lat, node.lng).substr(0, 7);
+    const mediumGeo = node.floorId + ':' + geohasher.encode(node.lat, node.lng).substr(0, 8);
+
+    if (!geoDb[largeGeo])
+      geoDb[largeGeo] = [];
+
+    geoDb[largeGeo].push(node);
+
+    if (!geoDb[mediumGeo])
+      geoDb[mediumGeo] = [];
+
+    geoDb[mediumGeo].push(node);
+
+    nodes[node.id] = node;
+  }
+
+  function createEdge (data, nodes) {
+    const type = getEdgeType(data);
+    const isAccessible = type.toLowerCase() !== 'escalator' && type.toLowerCase() !== 'stairs';
+    // todo consider calculating edge distance with 'path' differently
+    const distance = distanceBetweenNodes(data.s, data.d, nodes);
+    const transitTime = data.l || distance / DEFAULT_WALKING_SPEED_M_PER_MIN;
+
+    const buildCurvedPath = points => points.map(point => {
+      return {
+        start: { lat: point.s[0], lng: point.s[1] },
+        out: { lat: point.o[0], lng: point.o[1] },
+        in: { lat: point.i[0], lng: point.i[1] },
+        end: { lat: point.e[0], lng: point.e[1] }
+      }
+    });
+
+    const path = data.p ? buildCurvedPath(data.p) : null;
+
+    return {
+      distance,
+      dst: data.d,
+      o: data.o,
+      isAccessible,
+      isDriveway: !R.isNil(data.h) && !data.h,
+      src: data.s,
+      transitTime,
+      type,
+      path,
+      weight: transitTime
+    }
+  }
+
+  function getEdgeType (data) {
+    if (data.x) return 'Security Checkpoint'
+    if (data.t === '') return 'Ground'
+    return data.t
+  }
+
+  const findClosestNode = endpoint => {
+    if (endpoint.floorId === undefined && endpoint.ordinal === undefined) // one of these must be present
+      throw Error('Endpoint specified in findRoute without floorId nor an ordinal')
+    const lat = endpoint.lat || endpoint.latitude; // handle bluedot location
+    const lng = endpoint.lng || endpoint.longitude; // handle bluedot location
+    return endpoint.floorId
+      ? findClosestNodeByFloor(endpoint.floorId, lat, lng, geoDb, nodes)
+      : findClosestNodeByOrdinal(endpoint.ordinal, lat, lng, nodes)
+  };
+
+  function findShortestPathEntry (start, end, nodes, options = {}) {
+    const startNode = findClosestNode(start);
+    const endNode = findClosestNode(end);
+
+    // This code section does improve performance by about 10-20%, but comes at a cost
+    // of making the caching unusable in some cases
+    // if (start.structureId === end.structureId) {
+    //   options.minOrd = Math.min(start.ordinal, end.ordinal)
+    //   options.maxOrd = Math.max(start.ordinal, end.ordinal)
+    //   options.structureId = start.structureId
+    // }
+    return findShortestPath(startNode, endNode, nodes, securityWaitTimes, securityLanesMap, options)
+  }
+  /**
+   * @param  {Endpoint} start - start endpoint
+   * @param  {Array.<Endpoint>} destArray - list of destinations
+   * @param  {RouteOptions} options extra options (such as requireAccessibility)
+   * @returns {Array.<Array.<NavNode>>} array of routes corresponding to destinations specified
+   */
+  function findAllShortestPaths (start, destArray, options) {
+    const startNode = findClosestNode(start);
+    const destNodeArray = destArray.map(dest => findClosestNode(dest));
+    if (!startNode || !destNodeArray.length) return []
+    return findAllShortestPathsImpl(startNode, destNodeArray, nodes, securityWaitTimes, securityLanesMap, options)
+  }
+
+  function updateWithSecurityWaitTime (waitTimesData) {
+    securityWaitTimes = R.map(R.omit(['lastUpdated']), waitTimesData);
+    clearCache();
+  }
+
+  return {
+    _nodes: nodes,
+    _geoDb: geoDb,
+    findClosestNode: (floorId, lat, lng) => findClosestNodeByFloor(floorId, lat, lng, geoDb, nodes),
+    findShortestPath: (start, end, options) => findShortestPathEntry(start, end, nodes, options),
+    findAllShortestPaths,
+    floorIdToOrdinal, // todo lets get rid of this...
+    floorIdToStructureId, // todo lets get rid of this...,
+    updateWithSecurityWaitTime,
+    clearCache
+  }
+}
+
+function distanceBetweenNodes (n1, n2, nodes) {
+  const node1 = nodes[n1];
+  const node2 = nodes[n2];
+  const distance = geodesy.distance(node1.lat, node1.lng, node2.lat, node2.lng);
+  return distance
+}
+
+/**
+ * @param {Object.<Node>} start - a node in the navGraph to start on
+ * @param {Array.<Node>} destinations - array of nodes to find path to
+ * @param {Object.<string, NavNode>} nodes - dictionary of nodes by id
+ * @param {Object.<string, SecurityWaitTime>} securityWaitTimes - map of POI id to security wait time
+ * @param {Object.<string, SecurityLane>} securityLanesMap - map of POI id to security lane
+ * @param  {RouteOptions} [options={}] extra options (such as requireAccessibility)
+ * @returns {Array.<Array.<Node>>} list of shortest path to each destination
+ */
+function findAllShortestPathsImpl (start, destinations, nodes, securityWaitTimes = {}, securityLanesMap = {}, options = {}) {
+  // const previous = findPaths(start, start, nodes, options)
+
+  // const backtrackPath = node => buildBacktrackPath(nodes, previous, node)
+  // const poiNodeTuples = Array.from(destinations.entries())
+
+  // const poiPathTuples = poiNodeTuples.map(([poi, node]) => [poi, backtrackPath(node)])
+  // return new Map(poiPathTuples)
+  return destinations.map(d => {
+    try {
+      return findShortestPath(start, d, nodes, securityWaitTimes, securityLanesMap, options)
+    } catch (e) { return null }
+  })
+}
+
+let cost, prev, visited, visitQueue, lastStartId, lastOptionsStr;
+
+const clearCache = () => {
+  cost = { };
+  prev = { };
+  visited = { };
+  visitQueue = new minPriorityQueue();
+  lastStartId = null;
+  lastOptionsStr = {};
+};
+
+// This is a temporary name during a "probation" period - then I will
+// ditch findShortestPath and rewrite findAllShortestPaths and ditch
+// backtrackPath, etc.
+// NOTE: export just for testing
+/**
+ * @param  {Object<Node>} start a node in the navGraph to start on
+ * @param  {Object<Node>} end a node in the navGraph to find path to
+ * @param  {Object.<string, Node>} nodes dictionary of nodes by id
+ * @param {Object.<string, SecurityWaitTime>} securityWaitTimes - map of POI id to security wait time
+ * @param {Object.<string, SecurityLane>} securityLanesMap - map of POI id to security lane
+ * @param  {RouteOptions} options={} extra options (such as requireAccessibility)
+ * @returns {Array.<Node>} an array of nodes that represent the shortest route from start to end. null if no route exists.
+ */
+function findShortestPath (start, end, nodes, securityWaitTimes = {}, securityLanesMap = {}, options = { }) {
+  if (start.id !== lastStartId || lastOptionsStr !== JSON.stringify(options)) {
+    clearCache();
+    visitQueue.offerWithPriority(start.id, 0);
+    cost[start.id] = 0;
+    visited[start.id] = true;
+
+    lastStartId = start.id;
+    lastOptionsStr = JSON.stringify(options);
+  }
+
+  // continue crawling paths - but stop once we found destination
+  while (!visitQueue.isEmpty() && !visited[end.id]) {
+    const node = nodes[visitQueue.poll()]; // pop
+    const ccost = cost[node.id]; // current cost to this node
+    for (let ei = 0; ei < node.edges.length; ei++) {
+      const e = node.edges[ei]; // next edge from this node
+
+      if (visited[e.dst])
+        continue
+
+      if (options.requiresAccessibility && !e.isAccessible) {
+        // ignore not accessible edges if we're looking for an accessible route
+        continue
+      }
+
+      // This code section does improve performance by about 10-20%, but comes at a cost
+      // of making the caching unusable in some cases
+      // if ((options.minOrd !== undefined && nodes[e.dst].ordinal < options.minOrd) ||
+      //   (options.maxOrd !== undefined && nodes[e.dst].ordinal > options.maxOrd) ||
+      //   (options.structureId !== undefined && nodes[e.dst].structureId !== options.structureId))
+      //   continue
+
+      let weight = e.weight;
+      if (e.o && securityWaitTimes[e.o]) {
+        const dynamicData = securityWaitTimes[e.o];
+        if (dynamicData.queueTime) weight = dynamicData.queueTime;
+        if (dynamicData.isTemporarilyClosed) weight = CLOSED_CHECKPOINT_EDGE_WEIGHT;
+        e.securityWaitTimes = dynamicData;
+      }
+
+      if (e.o && securityLanesMap[e.o]) {
+        e.securityLane = securityLanesMap[e.o];
+        const { type, id } = securityLanesMap[e.o];
+        const securityLanesIds = R.path(['selectedSecurityLanes', type], options);
+        if (securityLanesIds && !securityLanesIds.includes(id))
+          continue
+      }
+
+      if (cost[e.dst] === undefined) {
+        prev[e.dst] = node;
+        cost[e.dst] = ccost + weight;
+        visitQueue.offerWithPriority(e.dst, ccost + weight); // add node to the toCheck array
+      } else
+      if (cost[e.dst] > (ccost + weight)) { // is this a shorter path? Relaxation...
+        // if so, update the cost and parent
+        cost[e.dst] = ccost + weight;
+        prev[e.dst] = node;
+        visitQueue.raisePriority(e.dst, ccost + weight);
+      }
+    }
+    visited[node.id] = true; // we have now been selected
+  }
+
+  if (!visited[end.id]) // if we never found our endpoint, it was inaccessible
+    return null
+
+  // build the path and return it
+  const path = [];
+  let node = end;
+  while (node) {
+    path.push(node);
+    node = prev[node.id];
+  }
+  return path.reverse()
+}
+
+function geohashSearch (floorId, geohash, geoDb, size) {
+  const geohashPrefix = geohash.substr(0, size);
+
+  const searchGeos = [];
+  searchGeos.push(floorId + ':' + geohasher.calculateAdjacent(geohasher.calculateAdjacent(geohashPrefix, 'top'), 'left'));
+  searchGeos.push(floorId + ':' + geohasher.calculateAdjacent(geohashPrefix, 'top'));
+  searchGeos.push(floorId + ':' + geohasher.calculateAdjacent(geohasher.calculateAdjacent(geohashPrefix, 'top'), 'right'));
+  searchGeos.push(floorId + ':' + geohasher.calculateAdjacent(geohashPrefix, 'left'));
+  searchGeos.push(floorId + ':' + geohashPrefix);
+  searchGeos.push(floorId + ':' + geohasher.calculateAdjacent(geohashPrefix, 'right'));
+  searchGeos.push(floorId + ':' + geohasher.calculateAdjacent(geohasher.calculateAdjacent(geohashPrefix, 'bottom'), 'left'));
+  searchGeos.push(floorId + ':' + geohasher.calculateAdjacent(geohashPrefix, 'bottom'));
+  searchGeos.push(floorId + ':' + geohasher.calculateAdjacent(geohasher.calculateAdjacent(geohashPrefix, 'bottom'), 'right'));
+
+  const nodes = [];
+  for (let i = 0; i < searchGeos.length; i++) {
+    const nodesFound = geoDb[searchGeos[i]];
+    if (nodesFound) {
+      for (let j = 0; j < nodesFound.length; j++)
+        nodes.push(nodesFound[j]);
+    }
+  }
+
+  return nodes
+}
+
+function findNodesByGeohash (floorId, geohash, geoDb, nodes) {
+  let foundNodes = geohashSearch(floorId, geohash, geoDb, 8);
+  if (foundNodes.length > 0)
+    return foundNodes
+
+  // broaden our search a bit and try again...
+  foundNodes = geohashSearch(floorId, geohash, geoDb, 7);
+  if (foundNodes.length > 0)
+    return foundNodes
+
+  // give up and let someone else try...
+  return null
+}
+
+/**
+ * @param floorId
+ * @param lat
+ * @param lng
+ * @param geoDb
+ * @param {Object<string, NavNode>} nodes - dictionary of node id to node object
+ * @return {NavNode} - node that is on the same floor and closest to the lat,lng point
+ */
+function findClosestNodeByFloor (floorId, lat, lng, geoDb, nodes) {
+  const cnodes = findNodesByGeohash(floorId, geohasher.encode(lat, lng), geoDb) ||
+    findClosestNodeByFloor2(floorId, lat, lng, nodes);
+
+  const nodeWithDistance = [];
+  for (let i = 0; i < cnodes.length; i++) {
+    // Attached distance to each node from the origin.
+    const distance = geodesy.distance(lat, lng, cnodes[i].lat, cnodes[i].lng);
+    nodeWithDistance.push([cnodes[i], distance]);
+  }
+  // todo do not sort, just find min node
+  // Sort by distance.
+  nodeWithDistance.sort(function (a, b) { return a[1] - b[1] });
+  const nodesSortedByDistance = [];
+  for (let i = 0; i < nodeWithDistance.length; i++)
+    nodesSortedByDistance.push(nodeWithDistance[i][0]);
+
+  return nodesSortedByDistance[0]
+}
+
+// A slightly slower alternative to findClosestNode (an experiment - its simpler, but slower)
+function findClosestNodeByFloor2 (floorId, lat, lng, nodes) {
+  const floorNodes = Object.values(nodes)
+    .filter(n => n.floorId === floorId)
+    .map(n => [n, geodesy.distance(n.lat, n.lng, lat, lng)]);
+  if (!floorNodes.length)
+    throw Error(`findClosestNodeByFloor2 found no nodes on floor ${floorId}`)
+  return selectShortest(floorNodes)
+}
+
+function findClosestNodeByOrdinal (ord, lat, lng, nodes) {
+  const ordNodes = Object.values(nodes)
+    .filter(n => n.ordinal === ord)
+    .map(n => [n, geodesy.distance(n.lat, n.lng, lat, lng)]);
+  if (!ordNodes.length)
+    throw Error(`findClosestNodeByOrdinal found no nodes on ordinal ${ord}`)
+  return selectShortest(ordNodes)
+}
+
+// companion to above function - it returns closest node
+// ar is 2-dim array - ar[i][0] = node, ar[i][1] = distance
+// TODO: use this approach in findClosestNode - no need to sort first!
+function selectShortest (ar) {
+  let shortest = ar[0];
+  for (let i = 1; i < ar.length; i++)
+    if (ar[i][1] < shortest[1]) shortest = ar[i];
+
+  return shortest[0]
+}
+
+exports.createNavGraph = createNavGraph;
+exports.findClosestNodeByOrdinal = findClosestNodeByOrdinal;
+exports.findShortestPath = findShortestPath;

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

@@ -2,29 +2,119 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var e$1 = require('ramda');
+var R = require('ramda');
 
 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$1);
+var R__namespace = /*#__PURE__*/_interopNamespace(R);
 
-function e(e,s){const o=Object.values(e),n=function(a,e){const s=[e],o=new Set;for(;s.length;){const e=s.splice(0,1)[0];e&&!o.has(e)&&(o.add(e),e.edges.forEach((e=>{o.has(a[e.dst])||s.push(a[e.dst]);})));}return o}(e,s||o[0]),r=o.filter((a=>!n.has(a)));return console.log(`${r.length} Orphaned nodes found from ${o.length} total`),{orphaned:r,orphanedByFloor:e__namespace.groupBy(e__namespace.prop("floorId"),r),connected:Array.from(n)}}const s=a=>({nodes:n(a),edges:r(a)}),o=e=>e__namespace.map(e__namespace.pipe(e__namespace.assoc("isOrphaned",e),e__namespace.dissoc("edges"))),n=e__namespace.pipe(e,e__namespace.pick(["connected","orphaned"]),e__namespace.evolve({connected:o(!1),orphaned:o(!0)}),e__namespace.values,e__namespace.flatten),r=a=>Object.values(a).flatMap((a=>a.edges)).map((e=>t(e,a))),t=({src:a,dst:e,type:s,isDriveway:o},n)=>({startCoordinates:[n[a].lng,n[a].lat],endCoordinates:[n[e].lng,n[e].lat],isDriveway:o,ordinal:n[a].ordinal,category:d(s),defaultStrokeColor:l(s)}),l=e__namespace.cond([[e__namespace.equals("Stairs"),e__namespace.always("#EFBC9B")],[e__namespace.equals("Elevator"),e__namespace.always("#A491D3")],[e__namespace.equals("Escalator"),e__namespace.always("#563F1B")],[e__namespace.equals("Ramp"),e__namespace.always("#DBD053")],[e__namespace.T,e__namespace.always("#FF0000")]]),d=e__namespace.cond([[e__namespace.equals("Train"),e__namespace.always("nav.train")],[e__namespace.equals("Bus"),e__namespace.always("nav.transit")],[e__namespace.equals("Security Checkpoint"),e__namespace.always("nav.secure")],[e__namespace.equals("Ground"),e__namespace.always("nav.primary")],[e__namespace.T,e__namespace.always("")]]);
+/**
+ * Visits all nodes (breadth-first) from the nodes2visit
+ * array, adding them to vnodes and adding their connected
+ * nodes to nodes2visit - until nodes2visit is empty.
+ * Nothing is returned - but the vnodes array will have been
+ * altered.
+ * @param  {Object.<id:node>} nodes - the node pool you wish to scan
+ * @param  {Node} startingNode - which node to start the scan
+ */
+function visitAll (nodes, startingNode) {
+  // initialize nodes2visit with the specified node to start
+  const nodes2visit = [startingNode];
+  const vnodes = new Set(); // visited nodes
 
-exports.enrichDebugNavGraph = s;
-exports.orphanTest = e;
+  while (nodes2visit.length) {
+    const node = nodes2visit.splice(0, 1)[0]; // next node to visit
+    if (node && !vnodes.has(node)) {
+      vnodes.add(node);
+      node.edges.forEach(edge => {
+        if (!vnodes.has(nodes[edge.dst]))
+          nodes2visit.push(nodes[edge.dst]);
+      });
+    }
+  }
+
+  return vnodes
+}
+
+/**
+ * @param  {Object.<id:node>} nodes - the node pool you wish to scan
+ * @param  {Node} [startingNode] - which node to start the scan (default: "first" node)
+ * @returns two arrays of nodes in an object, { orphaned, connected }
+ */
+function orphanTest (nodes, startingNode) {
+  const nodesArray = Object.values(nodes); // Convert to array
+
+  const vnodes = visitAll(nodes, startingNode || nodesArray[0]); // If no node is specified, use the first one we find
+  const onodes = nodesArray.filter(n => !vnodes.has(n));
+
+  console.log(`${onodes.length} Orphaned nodes found from ${nodesArray.length} total`);
+
+  return { orphaned: onodes, orphanedByFloor: R__namespace.groupBy(R__namespace.prop('floorId'), onodes), connected: Array.from(vnodes) }
+}
+
+const enrichDebugNavGraph = (nodes) => ({
+  nodes: toOrphanedNodesArray(nodes),
+  edges: getNavEdgeFeatures(nodes)
+});
+
+const transformNodes = isOrphaned =>
+  R__namespace.map(R__namespace.pipe(R__namespace.assoc('isOrphaned', isOrphaned), R__namespace.dissoc('edges')));
+
+const toOrphanedNodesArray = R__namespace.pipe(
+  orphanTest,
+  R__namespace.pick(['connected', 'orphaned']),
+  R__namespace.evolve({
+    connected: transformNodes(false),
+    orphaned: transformNodes(true)
+  }),
+  R__namespace.values,
+  R__namespace.flatten
+);
+
+const getNavEdgeFeatures = nodes =>
+  Object.values(nodes).flatMap(node => node.edges)
+    .map(edge => mapEdge(edge, nodes));
+
+const mapEdge = ({ src, dst, type, isDriveway }, nodeMap) => ({
+  startCoordinates: [nodeMap[src].lng, nodeMap[src].lat],
+  endCoordinates: [nodeMap[dst].lng, nodeMap[dst].lat],
+  isDriveway,
+  ordinal: nodeMap[src].ordinal,
+  category: getEdgeCategory(type),
+  defaultStrokeColor: getStrokeColorForMissingCategory(type)
+});
+
+const getStrokeColorForMissingCategory = R__namespace.cond([
+  [R__namespace.equals('Stairs'), R__namespace.always('#EFBC9B')],
+  [R__namespace.equals('Elevator'), R__namespace.always('#A491D3')],
+  [R__namespace.equals('Escalator'), R__namespace.always('#563F1B')],
+  [R__namespace.equals('Ramp'), R__namespace.always('#DBD053')],
+  [R__namespace.T, R__namespace.always('#FF0000')]
+]);
+
+const getEdgeCategory = R__namespace.cond([
+  [R__namespace.equals('Train'), R__namespace.always('nav.train')],
+  [R__namespace.equals('Bus'), R__namespace.always('nav.transit')],
+  [R__namespace.equals('Security Checkpoint'), R__namespace.always('nav.secure')],
+  [R__namespace.equals('Ground'), R__namespace.always('nav.primary')],
+  [R__namespace.T, R__namespace.always('')]
+]);
+
+exports.enrichDebugNavGraph = enrichDebugNavGraph;
+exports.orphanTest = orphanTest;

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

@@ -1,5 +1,31 @@
 'use strict';
 
-const n={START:"wayfinding.start",END:"wayfinding.end",WALKING_TO_SECURITY_CHECKPOINT:"wayfinding.security",ELEVATOR:"wayfinding.elevator",ELEVATOR_UP:"wayfinding.elevator.up",ELEVATOR_DOWN:"wayfinding.elevator.down",STAIRS:"wayfinding.stairs",STAIRS_UP:"wayfinding.stairs.up",STAIRS_DOWN:"wayfinding.stairs.down",ESCALATOR:"wayfinding.escalator",ESCALATOR_UP:"wayfinding.escalator.up",ESCALATOR_DOWN:"wayfinding.escalator.down",WALK:"wayfinding.movingwalkway",WALK_DOWN:"walk.movingwalkway",WALK_UP:"walk.movingwalkway",TRAIN:"wayfinding.train",TRAIN_UP:"wayfinding.train.up",TRAIN_DOWN:"wayfinding.train.down",BUS:"wayfinding.bus",BUS_UP:"wayfinding.bus.up",BUS_DOWN:"wayfinding.bus.down",SECURITY_CHECKPOINT:"wayfinding.security",RAMP:"wayfinding.ramp",RAMP_UP:"wayfinding.ramp.up",RAMP_DOWN:"wayfinding.ramp.down"};
+const segmentBadges = {
+  START: 'wayfinding.start',
+  END: 'wayfinding.end',
+  WALKING_TO_SECURITY_CHECKPOINT: 'wayfinding.security',
+  ELEVATOR: 'wayfinding.elevator',
+  ELEVATOR_UP: 'wayfinding.elevator.up',
+  ELEVATOR_DOWN: 'wayfinding.elevator.down',
+  STAIRS: 'wayfinding.stairs',
+  STAIRS_UP: 'wayfinding.stairs.up',
+  STAIRS_DOWN: 'wayfinding.stairs.down',
+  ESCALATOR: 'wayfinding.escalator',
+  ESCALATOR_UP: 'wayfinding.escalator.up',
+  ESCALATOR_DOWN: 'wayfinding.escalator.down',
+  WALK: 'wayfinding.movingwalkway',
+  WALK_DOWN: 'walk.movingwalkway',
+  WALK_UP: 'walk.movingwalkway',
+  TRAIN: 'wayfinding.train',
+  TRAIN_UP: 'wayfinding.train.up',
+  TRAIN_DOWN: 'wayfinding.train.down',
+  BUS: 'wayfinding.bus',
+  BUS_UP: 'wayfinding.bus.up',
+  BUS_DOWN: 'wayfinding.bus.down',
+  SECURITY_CHECKPOINT: 'wayfinding.security',
+  RAMP: 'wayfinding.ramp',
+  RAMP_UP: 'wayfinding.ramp.up',
+  RAMP_DOWN: 'wayfinding.ramp.down'
+};
 
-module.exports = n;
+module.exports = segmentBadges;