atriusmaps-node-sdk 3.3.632 → 3.3.633

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

@@ -24,52 +24,35 @@ function _interopNamespaceDefault(e) {
 
 var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
 
-const setSegmentCategory = (segments) => {
+const setSegmentCategory = segments => {
   // Set the category of each segment based on the type of the current segment or the type of the next segment in case we are walking
   // to a portal or to a security checkpoint
   segments.forEach((segment, index) => {
-    if (index === 0)
-      segment.segmentCategory = segmentCategories.START;
+    if (index === 0) segment.segmentCategory = segmentCategories.START;
     else if (segment.waypoints[segment.waypoints.length - 1].isDestination)
       segment.segmentCategory = segmentCategories.WALKING_TO_END;
-    else if (segment.type === 'Security Checkpoint')
-      segment.segmentCategory = segmentCategories.SECURITY_CHECKPOINT;
-    else if (segment.type === 'Bus')
-      segment.segmentCategory = segmentCategories.BUS;
-    else if (segment.type === 'Train')
-      segment.segmentCategory = segmentCategories.TRAIN;
+    else if (segment.type === 'Security Checkpoint') segment.segmentCategory = segmentCategories.SECURITY_CHECKPOINT;
+    else if (segment.type === 'Bus') segment.segmentCategory = segmentCategories.BUS;
+    else if (segment.type === 'Train') segment.segmentCategory = segmentCategories.TRAIN;
     else if (segment.type === 'Stairs') {
-      if (segment.levelDifference > 0)
-        segment.segmentCategory = segmentCategories.STAIRS_UP;
-      else if (segment.levelDifference < 0)
-        segment.segmentCategory = segmentCategories.STAIRS_DOWN;
-      else
-        segment.segmentCategory = segmentCategories.STAIRS;
+      if (segment.levelDifference > 0) segment.segmentCategory = segmentCategories.STAIRS_UP;
+      else if (segment.levelDifference < 0) segment.segmentCategory = segmentCategories.STAIRS_DOWN;
+      else segment.segmentCategory = segmentCategories.STAIRS;
     } else if (segment.type === 'Elevator') {
-      if (segment.levelDifference > 0)
-        segment.segmentCategory = segmentCategories.ELEVATOR_UP;
-      else if (segment.levelDifference < 0)
-        segment.segmentCategory = segmentCategories.ELEVATOR_DOWN;
-      else
-        segment.segmentCategory = segmentCategories.ELEVATOR;
+      if (segment.levelDifference > 0) segment.segmentCategory = segmentCategories.ELEVATOR_UP;
+      else if (segment.levelDifference < 0) segment.segmentCategory = segmentCategories.ELEVATOR_DOWN;
+      else segment.segmentCategory = segmentCategories.ELEVATOR;
     } else if (segment.type === 'Escalator') {
-      if (segment.levelDifference > 0)
-        segment.segmentCategory = segmentCategories.ESCALATOR_UP;
-      else if (segment.levelDifference < 0)
-        segment.segmentCategory = segmentCategories.ESCALATOR_DOWN;
-      else
-        segment.segmentCategory = segmentCategories.ESCALATOR;
+      if (segment.levelDifference > 0) segment.segmentCategory = segmentCategories.ESCALATOR_UP;
+      else if (segment.levelDifference < 0) segment.segmentCategory = segmentCategories.ESCALATOR_DOWN;
+      else segment.segmentCategory = segmentCategories.ESCALATOR;
     } else if (segment.type === 'Ramp') {
-      if (segment.levelDifference > 0)
-        segment.segmentCategory = segmentCategories.RAMP_UP;
-      else if (segment.levelDifference < 0)
-        segment.segmentCategory = segmentCategories.RAMP_DOWN;
-      else
-        segment.segmentCategory = segmentCategories.RAMP;
+      if (segment.levelDifference > 0) segment.segmentCategory = segmentCategories.RAMP_UP;
+      else if (segment.levelDifference < 0) segment.segmentCategory = segmentCategories.RAMP_DOWN;
+      else segment.segmentCategory = segmentCategories.RAMP;
     } else if (segments[index + 1].type === 'Security Checkpoint')
       segment.segmentCategory = segmentCategories.WALKING_TO_SECURITY_CHECKPOINT;
-    else if (segments[index + 1].type !== 'Walk')
-      segment.segmentCategory = segmentCategories.WALKING_TO_PORTAL;
+    else if (segments[index + 1].type !== 'Walk') segment.segmentCategory = segmentCategories.WALKING_TO_PORTAL;
   });
 };
 
@@ -86,7 +69,7 @@ const existsEnd = (segments, lastWaypoint) => {
 };
 
 // todo refactor to not affect step builder
-const joinSegments = (segments) => {
+const joinSegments = segments => {
   segments.forEach((segment, index) => {
     if (index > 1) {
       const firstWaypointOfSegment = R__namespace.head(segment.waypoints);
@@ -103,18 +86,19 @@ const calculateCurveLineCoordinates = segment =>
     // todo index > 0 is hacky fix
     if (index > 0 && waypoint.curvedPathForward && waypoint.curvedPathForward.length > 0) {
       return waypoint.curvedPathForward
-        .flatMap(p => geom.bezierCurveTo(p.start.lng, p.start.lat, p.in.lng, p.in.lat, p.out.lng, p.out.lat, p.end.lng, p.end.lat))
-        .map(el => [el.x, el.y])
+        .flatMap(p =>
+          geom.bezierCurveTo(p.start.lng, p.start.lat, p.in.lng, p.in.lat, p.out.lng, p.out.lat, p.end.lng, p.end.lat),
+        )
+        .map(el => [el.x, el.y]);
     } else {
-      return [[waypoint.position.lng, waypoint.position.lat]]
+      return [[waypoint.position.lng, waypoint.position.lat]];
     }
   });
 
-const addCurveLineCoordinates = R__namespace.map(
-  R__namespace.converge(R__namespace.assoc('coordinates'), [calculateCurveLineCoordinates, R__namespace.identity]));
+const addCurveLineCoordinates = R__namespace.map(R__namespace.converge(R__namespace.assoc('coordinates'), [calculateCurveLineCoordinates, R__namespace.identity]));
 
 // todo refactor
-const createSegments = (waypoints) => {
+const createSegments = waypoints => {
   const segments = [];
   let segment = { segmentCategory: undefined, waypoints: [] };
   let lastWaypoint = null;
@@ -129,30 +113,33 @@ const createSegments = (waypoints) => {
   waypoints.forEach(waypoint => {
     segmentWaypoints.push(waypoint);
 
-    if (!lastWaypoint) { // true on first waypoint only
+    if (!lastWaypoint) {
+      // true on first waypoint only
       segment.type = waypoint.isPortal ? waypoint.portalType : 'Walk';
       lastWaypoint = waypoint;
     } else {
-      if ((lastWaypoint.isPortal === waypoint.isPortal) &&
-        (lastWaypoint.isSecurityCheckpoint === waypoint.isSecurityCheckpoint)) { // todo not sure if this can happen
+      if (
+        lastWaypoint.isPortal === waypoint.isPortal &&
+        lastWaypoint.isSecurityCheckpoint === waypoint.isSecurityCheckpoint
+      ) {
+        // todo not sure if this can happen
         segment.levelDifference = waypoint.levelDifference;
       } else {
         segment.waypoints = segmentWaypoints;
 
         if (waypoint.isPortal || lastWaypoint.isPortal) {
-          if (segmentWaypoints.length > 1)
-            segmentWaypoints.pop();
+          if (segmentWaypoints.length > 1) segmentWaypoints.pop();
 
           // if the portal is not train or bus, we only want it to be one point segment
-          if (waypoint.isPortal && (waypoint.portalType.toLowerCase() === 'train' || waypoint.portalType.toLowerCase() === 'bus'))
+          if (
+            waypoint.isPortal &&
+            (waypoint.portalType.toLowerCase() === 'train' || waypoint.portalType.toLowerCase() === 'bus')
+          )
             segmentWaypoints = [segmentWaypoints[segmentWaypoints.length - 1], waypoint];
-          else
-            segmentWaypoints = [waypoint];
-        } else
-          segmentWaypoints = [];
+          else segmentWaypoints = [waypoint];
+        } else segmentWaypoints = [];
 
-        if (lastWaypoint.poiId)
-          segment.poiId = lastWaypoint.poiId;
+        if (lastWaypoint.poiId) segment.poiId = lastWaypoint.poiId;
         segments.push(segment);
 
         segment = { segmentCategory: undefined, waypoints: [] };
@@ -167,8 +154,7 @@ const createSegments = (waypoints) => {
 
   segment.waypoints = segmentWaypoints;
 
-  if (segmentWaypoints.length === 0)
-    segment.waypoints = [lastWaypoint];
+  if (segmentWaypoints.length === 0) segment.waypoints = [lastWaypoint];
 
   segments.push(segment);
 
@@ -178,20 +164,20 @@ const createSegments = (waypoints) => {
 
   joinSegments(segments);
 
-  return segments
+  return segments;
 };
 
-const getSegmentType = (segment) => {
+const getSegmentType = segment => {
   if (segment.type === 'Train') {
-    return 'nav.train'
+    return 'nav.train';
   }
   if (segment.type === 'Bus') {
-    return 'nav.transit'
+    return 'nav.transit';
   }
   if (segment.type === 'Security Checkpoint') {
-    return 'nav.secure'
+    return 'nav.secure';
   }
-  return 'nav.primary'
+  return 'nav.primary';
 };
 
 /**
@@ -217,16 +203,24 @@ const getSegmentType = (segment) => {
  * @param {boolean} requiresAccessibility
  * @return {{steps: Step[], segments: Segment[]}}
  */
-const buildSegments = (waypoints, fromEndpoint, toEndpoint, floorIdToNameMap, T, queueTypes, requiresAccessibility, securityPois, currentUnits) => {
+const buildSegments = (
+  waypoints,
+  fromEndpoint,
+  toEndpoint,
+  floorIdToNameMap,
+  T,
+  queueTypes,
+  requiresAccessibility,
+  securityPois,
+  currentUnits,
+) => {
   let rawSegments = createSegments(waypoints);
   rawSegments = addCurveLineCoordinates(rawSegments);
 
   // add start location (kiosk) as first coordinate to link it with the navline
-  if (fromEndpoint)
-    rawSegments[0].coordinates.unshift([fromEndpoint.lng, fromEndpoint.lat]);
+  if (fromEndpoint) rawSegments[0].coordinates.unshift([fromEndpoint.lng, fromEndpoint.lat]);
 
-  if (toEndpoint)
-    R__namespace.last(rawSegments).coordinates.push([toEndpoint.lng, toEndpoint.lat]);
+  if (toEndpoint) R__namespace.last(rawSegments).coordinates.push([toEndpoint.lng, toEndpoint.lat]);
 
   const segments = rawSegments.map((segment, index) => {
     const startWaypoint = R__namespace.last(segment.waypoints);
@@ -236,7 +230,7 @@ const buildSegments = (waypoints, fromEndpoint, toEndpoint, floorIdToNameMap, T,
       levelId: startWaypoint.position.structureId,
       ordinalId: `ordinal: ${startWaypoint.position.ordinal}`,
       coordinates,
-      shouldDrawSegment
+      shouldDrawSegment,
     };
 
     const badges = [];
@@ -244,24 +238,33 @@ const buildSegments = (waypoints, fromEndpoint, toEndpoint, floorIdToNameMap, T,
       const nextSegment = rawSegments[index + 1];
       badges.push({
         canonicalName: `wayfinding.${nextSegment.segmentCategory}`,
-        coordinates: R__namespace.last(coordinates)
+        coordinates: R__namespace.last(coordinates),
       });
     } else if (segmentCategories.START !== segment.segmentCategory) {
       badges.push({
         canonicalName: `wayfinding.${segment.segmentCategory}`,
-        coordinates: R__namespace.last(coordinates)
+        coordinates: R__namespace.last(coordinates),
       });
     }
     cookedSegment.badges = badges;
     cookedSegment.segmentType = getSegmentType(segment);
-    if (segment.poiId)
-      cookedSegment.poiId = segment.poiId;
-    return cookedSegment
+    if (segment.poiId) cookedSegment.poiId = segment.poiId;
+    return cookedSegment;
   });
 
-  const steps = stepBuilder(rawSegments, R__namespace.prop('title', fromEndpoint), R__namespace.prop('title', toEndpoint), floorIdToNameMap, T, queueTypes, requiresAccessibility, securityPois, currentUnits);
-
-  return { segments, steps }
+  const steps = stepBuilder(
+    rawSegments,
+    R__namespace.prop('title', fromEndpoint),
+    R__namespace.prop('title', toEndpoint),
+    floorIdToNameMap,
+    T,
+    queueTypes,
+    requiresAccessibility,
+    securityPois,
+    currentUnits,
+  );
+
+  return { segments, steps };
 };
 
 exports.buildSegments = buildSegments;

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

@@ -26,7 +26,7 @@ const segmentCategories = {
   SECURITY_CHECKPOINT: 'enduring security checkpoint',
   RAMP: 'ramp',
   RAMP_UP: 'ramp.up',
-  RAMP_DOWN: 'ramp.down'
+  RAMP_DOWN: 'ramp.down',
 };
 
 module.exports = segmentCategories;