atriusmaps-node-sdk 3.3.898 → 3.3.900

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

@@ -7,164 +7,93 @@ var minPriorityQueue = require('./minPriorityQueue.js');
 
 const DEFAULT_WALKING_SPEED_M_PER_MIN = 60;
 const CLOSED_CHECKPOINT_EDGE_WEIGHT = 9999;
-
-/**
- * @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 = {};
-  const nodesToAvoid = new Set();
+  const nodesToAvoid = /* @__PURE__ */ new Set();
   let securityWaitTimes = {};
-
-  data.nodes.forEach(nodeData => {
+  data.nodes.forEach((nodeData) => {
     const ordinal = floorIdToOrdinal(nodeData.floorId);
     const structureId = floorIdToStructureId(nodeData.floorId);
     const node = {
-      ...R.pick(['id', 'lat', 'lng', 'floorId'], nodeData),
+      ...R.pick(["id", "lat", "lng", "floorId"], nodeData),
       edges: [],
       ordinal,
-      structureId,
+      structureId
     };
     addNode(node);
   });
-
-  data.edges.forEach(ed => nodes[ed.s].edges.push(createEdge(ed, nodes)));
-
+  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);
-
+    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);
+  function createEdge(data2, nodes2) {
+    const type = getEdgeType(data2);
     const typeLower = type.toLowerCase();
-    // All edge types are accessible except Escalator and regular Stairs (AccessibleStairs are accessible)
-    const isAccessible = typeLower !== 'escalator' && typeLower !== '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;
-
+    const isAccessible = typeLower !== "escalator" && typeLower !== "stairs";
+    const distance = distanceBetweenNodes(data2.s, data2.d, nodes2);
+    const transitTime = data2.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 = data2.p ? buildCurvedPath(data2.p) : null;
     return {
       distance,
-      dst: data.d,
-      o: data.o,
+      dst: data2.d,
+      o: data2.o,
       isAccessible,
-      isDriveway: !R.isNil(data.h) && !data.h,
-      src: data.s,
+      isDriveway: !R.isNil(data2.h) && !data2.h,
+      src: data2.s,
       transitTime,
       type,
       path,
-      weight: transitTime,
+      weight: transitTime
     };
   }
-
-  function getEdgeType(data) {
-    if (data.x) {
-      return 'Security Checkpoint';
+  function getEdgeType(data2) {
+    if (data2.x) {
+      return "Security Checkpoint";
     }
-    if (data.t === '') {
-      return 'Ground';
+    if (data2.t === "") {
+      return "Ground";
     }
-    return data.t;
+    return data2.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 findClosestNode = (endpoint) => {
+    if (endpoint.floorId === void 0 && endpoint.ordinal === void 0) {
+      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);
+    const lat = endpoint.lat || endpoint.latitude;
+    const lng = endpoint.lng || endpoint.longitude;
+    return endpoint.floorId ? findClosestNodeByFloor(endpoint.floorId, lat, lng, geoDb, nodes) : findClosestNodeByOrdinal(endpoint.ordinal, lat, lng, nodes);
   };
-
-  function findShortestPathEntry(start, end, nodes, options = {}) {
+  function findShortestPathEntry(start, end, nodes2, 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, nodesToAvoid, securityWaitTimes, securityLanesMap, options);
+    return findShortestPath(startNode, endNode, nodes2, nodesToAvoid, securityWaitTimes, securityLanesMap, options);
   }
-
-  /**
-   *
-   * @param {Array.<string>} nodes - Array of nodes to avoid
-   */
-  function updateNodesToAvoid(nodes) {
-    // We want to replace entire list when we get new nodes, not just add
+  function updateNodesToAvoid(nodes2) {
     nodesToAvoid.clear();
-    nodes.forEach(n => nodesToAvoid.add(n));
+    nodes2.forEach((n) => nodesToAvoid.add(n));
   }
-  /**
-   * @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));
+    const destNodeArray = destArray.map((dest) => findClosestNode(dest));
     if (!startNode || !destNodeArray.length) {
       return [];
     }
@@ -175,64 +104,37 @@ function createNavGraph(data, floorIdToOrdinal, floorIdToStructureId, securityLa
       nodesToAvoid,
       securityWaitTimes,
       securityLanesMap,
-      options,
+      options
     );
   }
-
   function updateWithSecurityWaitTime(waitTimesData) {
-    securityWaitTimes = R.map(R.omit(['lastUpdated']), waitTimesData);
+    securityWaitTimes = R.map(R.omit(["lastUpdated"]), waitTimesData);
     clearCache();
   }
-
   return {
     _nodes: nodes,
     _geoDb: geoDb,
     _nodesToAvoid: nodesToAvoid,
-    addNodesToAvoid: nodes => updateNodesToAvoid(nodes),
+    addNodesToAvoid: (nodes2) => updateNodesToAvoid(nodes2),
     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...,
+    floorIdToOrdinal,
+    // todo lets get rid of this...
+    floorIdToStructureId,
+    // todo lets get rid of this...,
     updateWithSecurityWaitTime,
-    clearCache,
+    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 {Set.<string>} nodesToAvoid - set of nodes to avoid
- * @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,
-  nodesToAvoid,
-  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 => {
+function findAllShortestPathsImpl(start, destinations, nodes, nodesToAvoid, securityWaitTimes = {}, securityLanesMap = {}, options = {}) {
+  return destinations.map((d) => {
     try {
       return findShortestPath(start, d, nodes, nodesToAvoid, securityWaitTimes, securityLanesMap, options);
     } catch {
@@ -240,9 +142,7 @@ function findAllShortestPathsImpl(
     }
   });
 }
-
 let cost, prev, visited, visitQueue, lastStartId, lastOptionsStr;
-
 const clearCache = () => {
   cost = {};
   prev = {};
@@ -251,66 +151,29 @@ const clearCache = () => {
   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 {Set.<string>} nodesToAvoid - set of nodes to avoid
- * @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,
-  nodesToAvoid,
-  securityWaitTimes = {},
-  securityLanesMap = {},
-  options = {},
-) {
+function findShortestPath(start, end, nodes, nodesToAvoid, 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
-
+    const node2 = nodes[visitQueue.poll()];
+    const ccost = cost[node2.id];
+    for (let ei = 0; ei < node2.edges.length; ei++) {
+      const e = node2.edges[ei];
       if (nodesToAvoid.size > 0 && nodesToAvoid.has(e.dst)) {
         continue;
       }
       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];
@@ -322,37 +185,29 @@ function findShortestPath(
         }
         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);
+        const securityLanesIds = R.path(["selectedSecurityLanes", type], options);
         if (securityLanesIds && !securityLanesIds.includes(id)) {
           continue;
         }
       }
-
-      if (cost[e.dst] === undefined) {
-        prev[e.dst] = node;
+      if (cost[e.dst] === void 0) {
+        prev[e.dst] = node2;
         cost[e.dst] = ccost + weight;
-        visitQueue.offerWithPriority(e.dst, ccost + weight); // add node to the toCheck array
+        visitQueue.offerWithPriority(e.dst, ccost + weight);
       } 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;
+        prev[e.dst] = node2;
         visitQueue.raisePriority(e.dst, ccost + weight);
       }
     }
-    visited[node.id] = true; // we have now been selected
+    visited[node2.id] = true;
   }
-
-  if (!visited[end.id]) // if we never found our endpoint, it was inaccessible
-  {
+  if (!visited[end.id]) {
     return null;
   }
-
-  // build the path and return it
   const path = [];
   let node = end;
   while (node) {
@@ -361,21 +216,18 @@ function findShortestPath(
   }
   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'));
-
+  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]];
@@ -385,81 +237,49 @@ function geohashSearch(floorId, geohash, geoDb, size) {
       }
     }
   }
-
   return nodes;
 }
-
 function findNodesByGeohash(floorId, geohash, geoDb) {
   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 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) {
+  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)]);
+  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)]);
+  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++) {
@@ -467,7 +287,6 @@ function selectShortest(ar) {
       shortest = ar[i];
     }
   }
-
   return shortest[0];
 }
 

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

@@ -21,101 +21,70 @@ function _interopNamespaceDefault(e) {
 
 var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
 
-/**
- * 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
-
+  const vnodes = /* @__PURE__ */ new Set();
   while (nodes2visit.length) {
-    const node = nodes2visit.splice(0, 1)[0]; // next node to visit
+    const node = nodes2visit.splice(0, 1)[0];
     if (node && !vnodes.has(node)) {
       vnodes.add(node);
-      node.edges.forEach(edge => {
+      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));
-
+  const nodesArray = Object.values(nodes);
+  const vnodes = visitAll(nodes, startingNode || nodesArray[0]);
+  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),
+    orphanedByFloor: R__namespace.groupBy(R__namespace.prop("floorId"), onodes),
+    connected: Array.from(vnodes)
   };
 }
-
-const enrichDebugNavGraph = nodes => ({
+const enrichDebugNavGraph = (nodes) => ({
   nodes: toOrphanedNodesArray(nodes),
-  edges: getNavEdgeFeatures(nodes),
+  edges: getNavEdgeFeatures(nodes)
 });
-
-const transformNodes = isOrphaned => R__namespace.map(R__namespace.pipe(R__namespace.assoc('isOrphaned', isOrphaned), R__namespace.dissoc('edges')));
-
+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.pick(["connected", "orphaned"]),
   R__namespace.evolve({
     connected: transformNodes(false),
-    orphaned: transformNodes(true),
+    orphaned: transformNodes(true)
   }),
   R__namespace.values,
-  R__namespace.flatten,
+  R__namespace.flatten
 );
-
-const getNavEdgeFeatures = nodes =>
-  Object.values(nodes)
-    .flatMap(node => node.edges)
-    .map(edge => mapEdge(edge, nodes));
-
+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),
+  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')],
+  [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('')],
+  [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;