atriusmaps-node-sdk 3.3.898 → 3.3.900

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

@@ -1,31 +1,31 @@
 'use strict';
 
 const segmentBadges = {
-  START: 'wayfinding.start',
-  END: 'wayfinding.end',
-  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',
-  ACCESSIBLE_STAIRS: 'wayfinding.accessiblestairs',
-  ACCESSIBLE_STAIRS_UP: 'wayfinding.accessiblestairs.up',
-  ACCESSIBLE_STAIRS_DOWN: 'wayfinding.accessiblestairs.down',
-  ESCALATOR: 'wayfinding.escalator',
-  ESCALATOR_UP: 'wayfinding.escalator.up',
-  ESCALATOR_DOWN: 'wayfinding.escalator.down',
-  WALK: 'wayfinding.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',
+  START: "wayfinding.start",
+  END: "wayfinding.end",
+  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",
+  ACCESSIBLE_STAIRS: "wayfinding.accessiblestairs",
+  ACCESSIBLE_STAIRS_UP: "wayfinding.accessiblestairs.up",
+  ACCESSIBLE_STAIRS_DOWN: "wayfinding.accessiblestairs.down",
+  ESCALATOR: "wayfinding.escalator",
+  ESCALATOR_UP: "wayfinding.escalator.up",
+  ESCALATOR_DOWN: "wayfinding.escalator.down",
+  WALK: "wayfinding.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 = segmentBadges;

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

@@ -24,21 +24,19 @@ function _interopNamespaceDefault(e) {
 
 var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
 
-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
+const setSegmentCategory = (segments) => {
   segments.forEach((segment, index) => {
     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') {
+    } else if (segment.type === "Security Checkpoint") {
       segment.segmentCategory = segmentCategories.SECURITY_CHECKPOINT;
-    } else if (segment.type === 'Bus') {
+    } else if (segment.type === "Bus") {
       segment.segmentCategory = segmentCategories.BUS;
-    } else if (segment.type === 'Train') {
+    } else if (segment.type === "Train") {
       segment.segmentCategory = segmentCategories.TRAIN;
-    } else if (segment.type === 'Stairs') {
+    } else if (segment.type === "Stairs") {
       if (segment.levelDifference > 0) {
         segment.segmentCategory = segmentCategories.STAIRS_UP;
       } else if (segment.levelDifference < 0) {
@@ -46,7 +44,7 @@ const setSegmentCategory = segments => {
       } else {
         segment.segmentCategory = segmentCategories.STAIRS;
       }
-    } else if (segment.type === 'AccessibleStairs') {
+    } else if (segment.type === "AccessibleStairs") {
       if (segment.levelDifference > 0) {
         segment.segmentCategory = segmentCategories.ACCESSIBLE_STAIRS_UP;
       } else if (segment.levelDifference < 0) {
@@ -54,7 +52,7 @@ const setSegmentCategory = segments => {
       } else {
         segment.segmentCategory = segmentCategories.ACCESSIBLE_STAIRS;
       }
-    } else if (segment.type === 'Elevator') {
+    } else if (segment.type === "Elevator") {
       if (segment.levelDifference > 0) {
         segment.segmentCategory = segmentCategories.ELEVATOR_UP;
       } else if (segment.levelDifference < 0) {
@@ -62,7 +60,7 @@ const setSegmentCategory = segments => {
       } else {
         segment.segmentCategory = segmentCategories.ELEVATOR;
       }
-    } else if (segment.type === 'Escalator') {
+    } else if (segment.type === "Escalator") {
       if (segment.levelDifference > 0) {
         segment.segmentCategory = segmentCategories.ESCALATOR_UP;
       } else if (segment.levelDifference < 0) {
@@ -70,7 +68,7 @@ const setSegmentCategory = segments => {
       } else {
         segment.segmentCategory = segmentCategories.ESCALATOR;
       }
-    } else if (segment.type === 'Ramp') {
+    } else if (segment.type === "Ramp") {
       if (segment.levelDifference > 0) {
         segment.segmentCategory = segmentCategories.RAMP_UP;
       } else if (segment.levelDifference < 0) {
@@ -78,28 +76,23 @@ const setSegmentCategory = segments => {
       } else {
         segment.segmentCategory = segmentCategories.RAMP;
       }
-    } else if (segments[index + 1].type === 'Security Checkpoint') {
+    } else if (segments[index + 1].type === "Security Checkpoint") {
       segment.segmentCategory = segmentCategories.WALKING_TO_SECURITY_CHECKPOINT;
-    } else if (segments[index + 1].type !== 'Walk') {
+    } else if (segments[index + 1].type !== "Walk") {
       segment.segmentCategory = segmentCategories.WALKING_TO_PORTAL;
     }
   });
 };
-
 const existsEnd = (segments, lastWaypoint) => {
-  // if we have only one segment, add an extra segment with only the last point to simulate the end,
-  // that way we can draw separate markers for the start and the end of the navigation
   if (segments.length === 1) {
-    const segment = { segmentCategory: undefined, waypoints: [] };
+    const segment = { segmentCategory: void 0, waypoints: [] };
     segment.segmentCategory = segmentCategories.WALKING_TO_END;
-    segment.type = 'Walk';
+    segment.type = "Walk";
     segment.waypoints = [lastWaypoint];
     segments.push(segment);
   }
 };
-
-// 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);
@@ -110,63 +103,40 @@ const joinSegments = segments => {
     }
   });
 };
-
-const calculateCurveLineCoordinates = segment =>
-  segment.waypoints.flatMap((waypoint, index) => {
-    // 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]);
-    } else {
-      return [[waypoint.position.lng, waypoint.position.lat]];
-    }
-  });
-
-const addCurveLineCoordinates = R__namespace.map(R__namespace.converge(R__namespace.assoc('coordinates'), [calculateCurveLineCoordinates, R__namespace.identity]));
-
-// todo refactor
-const createSegments = waypoints => {
+const calculateCurveLineCoordinates = (segment) => segment.waypoints.flatMap((waypoint, index) => {
+  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]);
+  } else {
+    return [[waypoint.position.lng, waypoint.position.lat]];
+  }
+});
+const addCurveLineCoordinates = R__namespace.map(R__namespace.converge(R__namespace.assoc("coordinates"), [calculateCurveLineCoordinates, R__namespace.identity]));
+const createSegments = (waypoints) => {
   const segments = [];
-  let segment = { segmentCategory: undefined, waypoints: [] };
+  let segment = { segmentCategory: void 0, waypoints: [] };
   let lastWaypoint = null;
   let segmentWaypoints = [];
-
-  // Always add the first point to be the start of the route
   segment.waypoints = [waypoints[0]];
-  segment.type = waypoints[0].isPortal ? waypoints[0].portalType : 'Walk';
+  segment.type = waypoints[0].isPortal ? waypoints[0].portalType : "Walk";
   segments.push(segment);
-  segment = { segmentCategory: undefined, waypoints: [] };
-
-  waypoints.forEach(waypoint => {
+  segment = { segmentCategory: void 0, waypoints: [] };
+  waypoints.forEach((waypoint) => {
     segmentWaypoints.push(waypoint);
-
     if (!lastWaypoint) {
-      // true on first waypoint only
-      segment.type = waypoint.isPortal ? waypoint.portalType : 'Walk';
+      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) {
         segment.levelDifference = waypoint.levelDifference;
       } else {
         segment.waypoints = segmentWaypoints;
-
         if (waypoint.isPortal || lastWaypoint.isPortal) {
           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];
@@ -174,120 +144,69 @@ const createSegments = waypoints => {
         } else {
           segmentWaypoints = [];
         }
-
         if (lastWaypoint.poiId) {
           segment.poiId = lastWaypoint.poiId;
         }
         segments.push(segment);
-
-        segment = { segmentCategory: undefined, waypoints: [] };
-
-        segment.type = waypoint.isPortal ? waypoint.portalType : 'Walk';
+        segment = { segmentCategory: void 0, waypoints: [] };
+        segment.type = waypoint.isPortal ? waypoint.portalType : "Walk";
         segment.levelDifference = waypoint.levelDifference;
       }
-
       lastWaypoint = waypoint;
     }
   });
-
   segment.waypoints = segmentWaypoints;
-
   if (segmentWaypoints.length === 0) {
     segment.waypoints = [lastWaypoint];
   }
-
   segments.push(segment);
-
   setSegmentCategory(segments);
-
   existsEnd(segments, lastWaypoint);
-
   joinSegments(segments);
-
   return segments;
 };
-
-const getSegmentType = segment => {
-  if (segment.type === 'Train') {
-    return 'nav.train';
+const getSegmentType = (segment) => {
+  if (segment.type === "Train") {
+    return "nav.train";
   }
-  if (segment.type === 'Bus') {
-    return 'nav.transit';
+  if (segment.type === "Bus") {
+    return "nav.transit";
   }
-  if (segment.type === 'Security Checkpoint') {
-    return 'nav.secure';
+  if (segment.type === "Security Checkpoint") {
+    return "nav.secure";
   }
-  return 'nav.primary';
+  return "nav.primary";
 };
-
-/**
- *
- * @typedef Badge
- * @property {string} canonicalName
- * @property {Coordinate} coordinates
- *
- * @typedef Segment
- * @property {string} levelId
- * @property {string} ordinalId
- * @property {string} segmentType
- * @property {Boolean} shouldDrawSegment - to not show edges like stairs or elevator
- * @property {Array.<Coordinate>} coordinates - list of coordinate pairs [lng, lat]
- * @property {Array<Badge>} badges
- *
- * @param {Waypoint} waypoints
- * @param {Endpoint} fromEndpoint
- * @param {Endpoint} toEndpoint
- * @param {Object.<string, string>} floorIdToNameMap - dictionary of floor id to floor name
- * @param T - i18n translations function
- * @param {QueueTypes} queueTypes
- * @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 (toEndpoint) {
     R__namespace.last(rawSegments).coordinates.push([toEndpoint.lng, toEndpoint.lat]);
   }
-
   const segments = rawSegments.map((segment, index) => {
     const startWaypoint = R__namespace.last(segment.waypoints);
     const coordinates = segment.coordinates;
-    const shouldDrawSegment = !(segment.levelDifference && segment.waypoints.every(R__namespace.prop('isPortal')));
+    const shouldDrawSegment = !(segment.levelDifference && segment.waypoints.every(R__namespace.prop("isPortal")));
     const cookedSegment = {
       levelId: startWaypoint.position.structureId,
       ordinalId: `ordinal: ${startWaypoint.position.ordinal}`,
       coordinates,
-      shouldDrawSegment,
+      shouldDrawSegment
     };
-
     const badges = [];
     if (segmentCategories.WALKING_TO_PORTAL === segment.segmentCategory) {
       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;
@@ -297,19 +216,17 @@ const buildSegments = (
     }
     return cookedSegment;
   });
-
   const steps = stepBuilder(
     rawSegments,
-    R__namespace.prop('title', fromEndpoint),
-    R__namespace.prop('title', toEndpoint),
+    R__namespace.prop("title", fromEndpoint),
+    R__namespace.prop("title", toEndpoint),
     floorIdToNameMap,
     T,
     queueTypes,
     requiresAccessibility,
     securityPois,
-    currentUnits,
+    currentUnits
   );
-
   return { segments, steps };
 };
 

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

@@ -1,35 +1,35 @@
 'use strict';
 
 const segmentCategories = {
-  START: 'start',
-  WALKING_TO_SECURITY_CHECKPOINT: 'walking to security checkpoint',
-  WALKING_TO_PORTAL: 'walking to portal',
-  WALKING_TO_END: 'walking to end',
-  ELEVATOR: 'elevator',
-  ELEVATOR_UP: 'elevator.up',
-  ELEVATOR_DOWN: 'elevator.down',
-  STAIRS: 'stairs',
-  STAIRS_UP: 'stairs.up',
-  STAIRS_DOWN: 'stairs.down',
-  ACCESSIBLE_STAIRS: 'accessiblestairs',
-  ACCESSIBLE_STAIRS_UP: 'accessiblestairs.up',
-  ACCESSIBLE_STAIRS_DOWN: 'accessiblestairs.down',
-  ESCALATOR: 'escalator',
-  ESCALATOR_UP: 'escalator.up',
-  ESCALATOR_DOWN: 'escalator.down',
-  WALK: 'walk',
-  WALK_DOWN: 'walk.down',
-  WALK_UP: 'walk.up',
-  TRAIN: 'train',
-  TRAIN_UP: 'train.up',
-  TRAIN_DOWN: 'train.down',
-  BUS: 'bus',
-  BUS_UP: 'bus.up',
-  BUS_DOWN: 'bus.down',
-  SECURITY_CHECKPOINT: 'enduring security checkpoint',
-  RAMP: 'ramp',
-  RAMP_UP: 'ramp.up',
-  RAMP_DOWN: 'ramp.down',
+  START: "start",
+  WALKING_TO_SECURITY_CHECKPOINT: "walking to security checkpoint",
+  WALKING_TO_PORTAL: "walking to portal",
+  WALKING_TO_END: "walking to end",
+  ELEVATOR: "elevator",
+  ELEVATOR_UP: "elevator.up",
+  ELEVATOR_DOWN: "elevator.down",
+  STAIRS: "stairs",
+  STAIRS_UP: "stairs.up",
+  STAIRS_DOWN: "stairs.down",
+  ACCESSIBLE_STAIRS: "accessiblestairs",
+  ACCESSIBLE_STAIRS_UP: "accessiblestairs.up",
+  ACCESSIBLE_STAIRS_DOWN: "accessiblestairs.down",
+  ESCALATOR: "escalator",
+  ESCALATOR_UP: "escalator.up",
+  ESCALATOR_DOWN: "escalator.down",
+  WALK: "walk",
+  WALK_DOWN: "walk.down",
+  WALK_UP: "walk.up",
+  TRAIN: "train",
+  TRAIN_UP: "train.up",
+  TRAIN_DOWN: "train.down",
+  BUS: "bus",
+  BUS_UP: "bus.up",
+  BUS_DOWN: "bus.down",
+  SECURITY_CHECKPOINT: "enduring security checkpoint",
+  RAMP: "ramp",
+  RAMP_UP: "ramp.up",
+  RAMP_DOWN: "ramp.down"
 };
 
 module.exports = segmentCategories;