atriusmaps-node-sdk 3.3.31 → 3.3.225

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

@@ -2,31 +2,269 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var e = require('ramda');
+var R = require('ramda');
 var geom = require('../../../src/utils/geom.js');
 var segmentCategories = require('./segmentCategories.js');
 var stepBuilder = require('./stepBuilder.js');
 
 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 R__namespace = /*#__PURE__*/_interopNamespace(R);
 
-const n=e__namespace.map(e__namespace.converge(e__namespace.assoc("coordinates"),[e=>e.waypoints.flatMap(((e,o)=>o>0&&e.curvedPathForward&&e.curvedPathForward.length>0?e.curvedPathForward.flatMap((e=>geom.bezierCurveTo(e.start.lng,e.start.lat,e.in.lng,e.in.lat,e.out.lng,e.out.lat,e.end.lng,e.end.lat))).map((e=>[e.x,e.y])):[[e.position.lng,e.position.lat]])),e__namespace.identity])),r=t=>{const a=[];let n={segmentCategory:void 0,waypoints:[]},r=null,s=[];return n.waypoints=[t[0]],n.type=t[0].isPortal?t[0].portalType:"Walk",a.push(n),n={segmentCategory:void 0,waypoints:[]},t.forEach((e=>{s.push(e),r?(r.isPortal===e.isPortal&&r.isSecurityCheckpoint===e.isSecurityCheckpoint||(n.waypoints=s,e.isPortal||r.isPortal?(s.length>1&&s.pop(),s=!e.isPortal||"train"!==e.portalType.toLowerCase()&&"bus"!==e.portalType.toLowerCase()?[e]:[s[s.length-1],e]):s=[],r.poiId&&(n.poiId=r.poiId),a.push(n),n={segmentCategory:void 0,waypoints:[]},n.type=e.isPortal?e.portalType:"Walk"),n.levelDifference=e.levelDifference,r=e):(n.type=e.isPortal?e.portalType:"Walk",r=e);})),n.waypoints=s,0===s.length&&(n.waypoints=[r]),a.push(n),(e=>{e.forEach(((t,a)=>{0===a?t.segmentCategory=segmentCategories.START:t.waypoints[t.waypoints.length-1].isDestination?t.segmentCategory=segmentCategories.WALKING_TO_END:"Security Checkpoint"===t.type?t.segmentCategory=segmentCategories.SECURITY_CHECKPOINT:"Bus"===t.type?t.segmentCategory=segmentCategories.BUS:"Train"===t.type?t.segmentCategory=segmentCategories.TRAIN:"Stairs"===t.type?t.levelDifference>0?t.segmentCategory=segmentCategories.STAIRS_UP:t.levelDifference<0?t.segmentCategory=segmentCategories.STAIRS_DOWN:t.segmentCategory=segmentCategories.STAIRS:"Elevator"===t.type?t.levelDifference>0?t.segmentCategory=segmentCategories.ELEVATOR_UP:t.levelDifference<0?t.segmentCategory=segmentCategories.ELEVATOR_DOWN:t.segmentCategory=segmentCategories.ELEVATOR:"Escalator"===t.type?t.levelDifference>0?t.segmentCategory=segmentCategories.ESCALATOR_UP:t.levelDifference<0?t.segmentCategory=segmentCategories.ESCALATOR_DOWN:t.segmentCategory=segmentCategories.ESCALATOR:"Ramp"===t.type?t.levelDifference>0?t.segmentCategory=segmentCategories.RAMP_UP:t.levelDifference<0?t.segmentCategory=segmentCategories.RAMP_DOWN:t.segmentCategory=segmentCategories.RAMP:"Security Checkpoint"===e[a+1].type?t.segmentCategory=segmentCategories.WALKING_TO_SECURITY_CHECKPOINT:"Walk"!==e[a+1].type&&(t.segmentCategory=segmentCategories.WALKING_TO_PORTAL);}));})(a),((e,t)=>{if(1===e.length){const a={segmentCategory:void 0,waypoints:[]};a.segmentCategory=segmentCategories.WALKING_TO_END,a.type="Walk",a.waypoints=[t],e.push(a);}})(a,r),(t=>{t.forEach(((o,a)=>{if(a>1&&0===e__namespace.head(o.waypoints).levelDifference){const n=e__namespace.last(t[a-1].waypoints);o.waypoints=e__namespace.prepend(n,o.waypoints);}}));})(a),a},s=(t,s,i,p,l,g)=>{let y=r(t);y=n(y),s&&y[0].coordinates.unshift([s.lng,s.lat]),i&&e__namespace.last(y).coordinates.push([i.lng,i.lat]);return {segments:y.map(((t,a)=>{const n=e__namespace.last(t.waypoints),r=t.coordinates,s=!(t.levelDifference&&t.waypoints.every(e__namespace.prop("isPortal"))),i={levelId:n.position.structureId,ordinalId:`ordinal: ${n.position.ordinal}`,coordinates:r,shouldDrawSegment:s},p=[];if(segmentCategories.WALKING_TO_PORTAL===t.segmentCategory){const t=y[a+1];p.push({canonicalName:`wayfinding.${t.segmentCategory}`,coordinates:e__namespace.last(r)});}else segmentCategories.START!==t.segmentCategory&&p.push({canonicalName:`wayfinding.${t.segmentCategory}`,coordinates:e__namespace.last(r)});return i.badges=p,i.segmentType=(e=>"Train"===e.type?"nav.train":"Bus"===e.type?"nav.transit":"Security Checkpoint"===e.type?"nav.secure":"nav.primary")(t),t.poiId&&(i.poiId=t.poiId),i})),steps:stepBuilder(y,e__namespace.prop("title",s),e__namespace.prop("title",i),p,l,g)}};
+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;
+    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 === '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;
+    } 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;
+    } 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;
+    } 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;
+  });
+};
 
-exports.buildSegments = s;
+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: [] };
+    segment.segmentCategory = segmentCategories.WALKING_TO_END;
+    segment.type = 'Walk';
+    segment.waypoints = [lastWaypoint];
+    segments.push(segment);
+  }
+};
+
+// todo refactor to not affect step builder
+const joinSegments = (segments) => {
+  segments.forEach((segment, index) => {
+    if (index > 1) {
+      const firstWaypointOfSegment = R__namespace.head(segment.waypoints);
+      if (firstWaypointOfSegment.levelDifference === 0) {
+        const lastWaypointOfPreviousSegment = R__namespace.last(segments[index - 1].waypoints);
+        segment.waypoints = R__namespace.prepend(lastWaypointOfPreviousSegment, segment.waypoints);
+      }
+    }
+  });
+};
+
+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 segments = [];
+  let segment = { segmentCategory: undefined, 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';
+  segments.push(segment);
+  segment = { segmentCategory: undefined, waypoints: [] };
+
+  waypoints.forEach(waypoint => {
+    segmentWaypoints.push(waypoint);
+
+    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
+        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'))
+            segmentWaypoints = [segmentWaypoints[segmentWaypoints.length - 1], waypoint];
+          else
+            segmentWaypoints = [waypoint];
+        } else
+          segmentWaypoints = [];
+
+        if (lastWaypoint.poiId)
+          segment.poiId = lastWaypoint.poiId;
+        segments.push(segment);
+
+        segment = { segmentCategory: undefined, 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'
+  }
+  if (segment.type === 'Bus') {
+    return 'nav.transit'
+  }
+  if (segment.type === 'Security Checkpoint') {
+    return 'nav.secure'
+  }
+  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) => {
+  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 cookedSegment = {
+      levelId: startWaypoint.position.structureId,
+      ordinalId: `ordinal: ${startWaypoint.position.ordinal}`,
+      coordinates,
+      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)
+      });
+    } else if (segmentCategories.START !== segment.segmentCategory) {
+      badges.push({
+        canonicalName: `wayfinding.${segment.segmentCategory}`,
+        coordinates: R__namespace.last(coordinates)
+      });
+    }
+    cookedSegment.badges = badges;
+    cookedSegment.segmentType = getSegmentType(segment);
+    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);
+
+  return { segments, steps }
+};
+
+exports.buildSegments = buildSegments;

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

@@ -1,5 +1,32 @@
 'use strict';
 
-const a={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",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"};
+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',
+  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 = a;
+module.exports = segmentCategories;

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

@@ -1,10 +1,245 @@
 'use strict';
 
-var e = require('ramda');
+var R = require('ramda');
 var bounds = require('../../../src/utils/bounds.js');
 var segmentBadges = require('./segmentBadges.js');
 var segmentCategories = require('./segmentCategories.js');
 
-function R(e$1,t="",r="",a,n,c={}){return e$1.map(((u,T)=>{const R=N("securityWaitTimes")(u.waypoints),L=R&&!R.isTemporarilyClosed?R.queueTime:Math.round(1===(W=u.waypoints).length?W[0].eta:W.map(e.prop("eta")).slice(1).reduce(((e,t)=>e+t),0));var W;const y=Math.round(function(e){return 1===e.length?e[0].distance:e.map((e=>e.distance)).slice(1).reduce(((e,t)=>e+t),0)}(u.waypoints)),I=function(e){switch(e){case segmentCategories.START:return segmentBadges.START;case segmentCategories.WALKING_TO_END:return segmentBadges.END;case segmentCategories.ELEVATOR:return segmentBadges.ELEVATOR;case segmentCategories.ELEVATOR_UP:return segmentBadges.ELEVATOR_UP;case segmentCategories.ELEVATOR_DOWN:return segmentBadges.ELEVATOR_DOWN;case segmentCategories.STAIRS:return segmentBadges.STAIRS;case segmentCategories.STAIRS_UP:return segmentBadges.STAIRS_UP;case segmentCategories.STAIRS_DOWN:return segmentBadges.STAIRS_DOWN;case segmentCategories.ESCALATOR:return segmentBadges.ESCALATOR;case segmentCategories.ESCALATOR_UP:return segmentBadges.ESCALATOR_UP;case segmentCategories.ESCALATOR_DOWN:return segmentBadges.ESCALATOR_DOWN;case segmentCategories.WALKING_TO_PORTAL:case segmentCategories.WALK:case segmentCategories.WALK_DOWN:case segmentCategories.WALK_UP:return segmentBadges.WALK;case segmentCategories.TRAIN:return segmentBadges.TRAIN;case segmentCategories.TRAIN_UP:return segmentBadges.TRAIN_UP;case segmentCategories.TRAIN_DOWN:return segmentBadges.TRAIN_DOWN;case segmentCategories.BUS:return segmentBadges.BUS;case segmentCategories.BUS_UP:return segmentBadges.BUS_UP;case segmentCategories.BUS_DOWN:return segmentBadges.BUS_DOWN;case segmentCategories.SECURITY_CHECKPOINT:return segmentBadges.SECURITY_CHECKPOINT;case segmentCategories.RAMP:return segmentBadges.RAMP;case segmentCategories.RAMP_UP:return segmentBadges.RAMP_UP;case segmentCategories.RAMP_DOWN:return segmentBadges.RAMP_DOWN;default:return segmentBadges.WALK}}(u.segmentCategory),m=function(e,t){let r;switch(e){case segmentCategories.START:r=0;break;case segmentCategories.WALKING_TO_END:r=t.length-1;break;case segmentCategories.WALKING_TO_PORTAL:r=Math.min(t.length-1,Math.ceil(t.length/2));break;default:r=t.length-1;}return t[r].position}(u.segmentCategory,u.waypoints),p=function(e$1,t,r,a,n,s){const c=e$1[t];switch(c.segmentCategory){case segmentCategories.START:return O(c.waypoints[0].position,r);case segmentCategories.WALKING_TO_END:return O(c.waypoints[c.waypoints.length-1].position,a);case segmentCategories.WALKING_TO_SECURITY_CHECKPOINT:case segmentCategories.WALKING_TO_PORTAL:return s(`wayfinder:${e$1[t+1].type}`);case segmentCategories.SECURITY_CHECKPOINT:case segmentCategories.ELEVATOR:case segmentCategories.ELEVATOR_DOWN:case segmentCategories.ELEVATOR_UP:case segmentCategories.ESCALATOR:case segmentCategories.ESCALATOR_DOWN:case segmentCategories.ESCALATOR_UP:case segmentCategories.STAIRS:case segmentCategories.STAIRS_DOWN:case segmentCategories.STAIRS_UP:return function(e$1,t){return t[e.last(e$1.waypoints).position.floorId]}(c,n);default:return s(`wayfinder:${c.type}`)}}(e$1,T,t,r,a,n),P=function(e,t,r,a){const n=S(t,a);switch(e.segmentCategory){case segmentCategories.START:return a("wayfinder:Begin route at");case segmentCategories.ELEVATOR:return a("wayfinder:Take elevator to");case segmentCategories.ELEVATOR_UP:return a("wayfinder:Take elevator up to");case segmentCategories.ELEVATOR_DOWN:return a("wayfinder:Take elevator down to");case segmentCategories.STAIRS:return a("wayfinder:Take stairs to");case segmentCategories.STAIRS_UP:return a("wayfinder:Take stairs up to");case segmentCategories.STAIRS_DOWN:return a("wayfinder:Take stairs down to");case segmentCategories.ESCALATOR:return a("wayfinder:Take escalator to");case segmentCategories.ESCALATOR_UP:return a("wayfinder:Take escalator up to");case segmentCategories.ESCALATOR_DOWN:return a("wayfinder:Take escalator down to");case segmentCategories.WALK:case segmentCategories.WALKING_TO_SECURITY_CHECKPOINT:case segmentCategories.WALKING_TO_PORTAL:case segmentCategories.WALKING_TO_END:return n("Walk <1 minute to","Walk xx minute to");case segmentCategories.WALK_DOWN:return n("Walk <1 minute down to","Walk xx minute down to");case segmentCategories.WALK_UP:return n("Walk <1 minute up to","Walk xx minute up to");case segmentCategories.TRAIN:return n("Take train <1 minute","Take train xx minute");case segmentCategories.BUS:return n("Take bus <1 minute","Take bus xx minute");case segmentCategories.SECURITY_CHECKPOINT:return r?a("wayfinder:Through _security_ to",{name:r}):a("wayfinder:Through security to");case segmentCategories.RAMP:return a("wayfinder:Take ramp to");case segmentCategories.RAMP_UP:return a("wayfinder:Take ramp up to");case segmentCategories.RAMP_DOWN:return a("wayfinder:Take ramp down to");default:return ""}}(u,L,d(c,u.waypoints),n),w={primaryText:p,secondaryText:P,icon:I,animationAnchor:m,eta:L,distance:y,bounds:bounds.findBoundsOfWaypoints(u.waypoints),isAccessible:E(u),securityWaitTimes:R};return u.poiId&&(w.poiId=u.poiId),w}))}function O(e,t){return e.name?e.name:t}const S=(e,t)=>(r,a)=>0===e?t("wayfinder:"+r):t("wayfinder:"+a,{count:e}),E=e.compose(e.not,e.includes(e.__,["escalator","stairs"]),e.toLower,e.prop("type")),d=(e$1,t)=>{const r=N("securityLane")(t);if(!r)return;const a=e.prop(r.type,e$1),n=e.find(e.propEq("id",r.id),a);return e.prop("displayText",n)},N=t=>e.compose(e.prop(t),e.find(e.prop(t)),e.drop(1));
+/**
+ * @typedef Step
+ * @property {string} primaryText
+ * @property {string} secondaryText
+ * @property {string} icon
+ * @property {Position} animationAnchor
+ * @property {number} eta
+ * @property {number} distance
+ * @property {boolean} isAccessible
+ * @property {Bounds} bounds
+ * @property {SecurityWaitTime} securityWaitTimes
+ *
+ * @typedef Position
+ * @property {number} lat
+ * @property {number} lng
+ * @property {string} floorId
+ * @property {number} ordinal
+ * @property {string} structureId
+ *
+ * @param {Segment[]} segments
+ * @param {string} startName
+ * @param {string} destinationName
+ * @param floorIdToNameMap
+ * @param {function} T - translate function
+ * @param {QueueTypes} queueTypes
+ * @param {boolean} requiresAccessibility
+ * @return {Step[]} steps - list of navigation steps
+ */
+function getSteps (segments, startName = '', destinationName = '', floorIdToNameMap, T, queueTypes = {}, requiresAccessibility) {
+  return segments.map((segment, index) => {
+    const securityWaitTimes = findPropWaypoints('securityWaitTimes')(segment.waypoints);
+    const eta = (securityWaitTimes && !securityWaitTimes.isTemporarilyClosed) // if there is dynamic wait time and checkpoint is open, then use it
+      ? securityWaitTimes.queueTime
+      : Math.round(calculateSegmentEta(segment.waypoints));
+    const distance = Math.round(calculateSegmentDistance(segment.waypoints));
+    const icon = getIcon(segment.segmentCategory);
+    const animationAnchor = getAnimationAnchor(segment.segmentCategory, segment.waypoints);
+    const primaryText = getPrimaryText(segments, index, startName, destinationName, floorIdToNameMap, T);
+    const securityLaneName = getSecurityLaneName(queueTypes, segment.waypoints);
+    const secondaryText = getSecondaryText(segment, eta, securityLaneName, T);
+    const bounds$1 = bounds.findBoundsOfWaypoints(segment.waypoints);
+    const isAccessible = checkIfAccessible(segment);
 
-module.exports = R;
+    const step = {
+      primaryText,
+      secondaryText,
+      icon,
+      animationAnchor,
+      eta,
+      distance,
+      bounds: bounds$1,
+      isAccessible,
+      securityWaitTimes
+    };
+
+    if (segment.poiId)
+      step.poiId = segment.poiId;
+
+    return step
+  })
+}
+
+function calculateSegmentEta (waypoints) {
+  if (waypoints.length === 1) return waypoints[0].eta // for stairs/elevator segments. should be removed once segment builder will be refactored to not append waypoint from previous semgnent
+  return waypoints
+    .map(R.prop('eta'))
+    .slice(1) // first waypoint is end of previous segment and is added only to connect segments for navline calculation
+    .reduce((segmentEta, eta) => segmentEta + eta, 0.0)
+}
+
+function calculateSegmentDistance (waypoints) {
+  if (waypoints.length === 1) return waypoints[0].distance // for stairs/elevator segments. should be removed once segment builder will be refactored to not append waypoint from previous semgnent
+  return waypoints
+    .map(waypoint => waypoint.distance)
+    .slice(1) // first waypoint is end of previous segment and is added only to connect segments for navline calculation
+    .reduce((segmentDistance, distance) => segmentDistance + distance, 0.0)
+}
+
+function getIcon (segmentCategory) {
+  switch (segmentCategory) {
+    case segmentCategories.START:
+      return segmentBadges.START
+    case segmentCategories.WALKING_TO_END:
+      return segmentBadges.END
+    case segmentCategories.ELEVATOR:
+      return segmentBadges.ELEVATOR
+    case segmentCategories.ELEVATOR_UP:
+      return segmentBadges.ELEVATOR_UP
+    case segmentCategories.ELEVATOR_DOWN:
+      return segmentBadges.ELEVATOR_DOWN
+    case segmentCategories.STAIRS:
+      return segmentBadges.STAIRS
+    case segmentCategories.STAIRS_UP:
+      return segmentBadges.STAIRS_UP
+    case segmentCategories.STAIRS_DOWN:
+      return segmentBadges.STAIRS_DOWN
+    case segmentCategories.ESCALATOR:
+      return segmentBadges.ESCALATOR
+    case segmentCategories.ESCALATOR_UP:
+      return segmentBadges.ESCALATOR_UP
+    case segmentCategories.ESCALATOR_DOWN:
+      return segmentBadges.ESCALATOR_DOWN
+    case segmentCategories.WALKING_TO_PORTAL:
+    case segmentCategories.WALK:
+    case segmentCategories.WALK_DOWN:
+    case segmentCategories.WALK_UP:
+      return segmentBadges.WALK
+    case segmentCategories.TRAIN:
+      return segmentBadges.TRAIN
+    case segmentCategories.TRAIN_UP:
+      return segmentBadges.TRAIN_UP
+    case segmentCategories.TRAIN_DOWN:
+      return segmentBadges.TRAIN_DOWN
+    case segmentCategories.BUS:
+      return segmentBadges.BUS
+    case segmentCategories.BUS_UP:
+      return segmentBadges.BUS_UP
+    case segmentCategories.BUS_DOWN:
+      return segmentBadges.BUS_DOWN
+    case segmentCategories.SECURITY_CHECKPOINT:
+      return segmentBadges.SECURITY_CHECKPOINT
+    case segmentCategories.RAMP:
+      return segmentBadges.RAMP
+    case segmentCategories.RAMP_UP:
+      return segmentBadges.RAMP_UP
+    case segmentCategories.RAMP_DOWN:
+      return segmentBadges.RAMP_DOWN
+    default:
+      return segmentBadges.WALK
+  }
+}
+
+function getAnimationAnchor (segmentCategory, waypoints) {
+  let index;
+  switch (segmentCategory) {
+    case segmentCategories.START:
+      index = 0;
+      break
+    case segmentCategories.WALKING_TO_END:
+      index = waypoints.length - 1;
+      break
+    case segmentCategories.WALKING_TO_PORTAL:
+      index = Math.min(waypoints.length - 1, Math.ceil(waypoints.length / 2));
+      break
+    default:
+      index = waypoints.length - 1;
+  }
+  return waypoints[index].position
+}
+
+function getPrimaryText (segments, index, startName, destinationName, floorIdToNameMap, T) {
+  const segment = segments[index];
+  switch (segment.segmentCategory) {
+    case segmentCategories.START:
+      return getPositionName(segment.waypoints[0].position, startName)
+    case segmentCategories.WALKING_TO_END:
+      return getPositionName(segment.waypoints[segment.waypoints.length - 1].position, destinationName)
+    case segmentCategories.WALKING_TO_SECURITY_CHECKPOINT:
+    case segmentCategories.WALKING_TO_PORTAL:
+      return T(`wayfinder:${segments[index + 1].type}`)
+    case segmentCategories.SECURITY_CHECKPOINT:
+    case segmentCategories.ELEVATOR:
+    case segmentCategories.ELEVATOR_DOWN:
+    case segmentCategories.ELEVATOR_UP:
+    case segmentCategories.ESCALATOR:
+    case segmentCategories.ESCALATOR_DOWN:
+    case segmentCategories.ESCALATOR_UP:
+    case segmentCategories.STAIRS:
+    case segmentCategories.STAIRS_DOWN:
+    case segmentCategories.STAIRS_UP:
+      return getLevelName(segment, floorIdToNameMap)
+    default: return T(`wayfinder:${segment.type}`)
+  }
+}
+
+function getPositionName (position, poiName) {
+  if (position.name) { return position.name }
+  return poiName
+}
+
+function getLevelName (segment, floorIdToNameMap) {
+  return floorIdToNameMap[R.last(segment.waypoints).position.floorId]
+}
+
+function getSecondaryText (segment, minutes, securityLaneName, T, requiresAccessibility) {
+  const zeroOrOtherKeys = translateZeroOrOther(minutes, T);
+  const travelVerb = 'Proceed';
+  switch (segment.segmentCategory) {
+    case segmentCategories.START: return T('wayfinder:Begin route at')
+    case segmentCategories.ELEVATOR: return T('wayfinder:Take elevator to')
+    case segmentCategories.ELEVATOR_UP: return T('wayfinder:Take elevator up to')
+    case segmentCategories.ELEVATOR_DOWN: return T('wayfinder:Take elevator down to')
+    case segmentCategories.STAIRS: return T('wayfinder:Take stairs to')
+    case segmentCategories.STAIRS_UP: return T('wayfinder:Take stairs up to')
+    case segmentCategories.STAIRS_DOWN: return T('wayfinder:Take stairs down to')
+    case segmentCategories.ESCALATOR: return T('wayfinder:Take escalator to')
+    case segmentCategories.ESCALATOR_UP: return T('wayfinder:Take escalator up to')
+    case segmentCategories.ESCALATOR_DOWN: return T('wayfinder:Take escalator down to')
+    case segmentCategories.WALK:
+    case segmentCategories.WALKING_TO_SECURITY_CHECKPOINT:
+    case segmentCategories.WALKING_TO_PORTAL:
+    case segmentCategories.WALKING_TO_END: return zeroOrOtherKeys(`${travelVerb} <1 minute to`, `${travelVerb} xx minute to`)
+    case segmentCategories.WALK_DOWN: return zeroOrOtherKeys(`${travelVerb} <1 minute down to`, `${travelVerb} xx minute down to`)
+    case segmentCategories.WALK_UP: return zeroOrOtherKeys(`${travelVerb} <1 minute up to`, `${travelVerb} xx minute up to`)
+    // todo add stops for train and bus if needed
+    case segmentCategories.TRAIN: return zeroOrOtherKeys('Take train <1 minute', 'Take train xx minute')
+    case segmentCategories.BUS: return zeroOrOtherKeys('Take bus <1 minute', 'Take bus xx minute')
+    case segmentCategories.SECURITY_CHECKPOINT: return securityLaneName
+      ? T('wayfinder:Through _security_ to', { name: securityLaneName })
+      : T('wayfinder:Through security to')
+    case segmentCategories.RAMP: return T('wayfinder:Take ramp to')
+    case segmentCategories.RAMP_UP: return T('wayfinder:Take ramp up to')
+    case segmentCategories.RAMP_DOWN: return T('wayfinder:Take ramp down to')
+    default: return ''
+  }
+}
+
+const translateZeroOrOther = (count, T) => (zeroKey, otherKey) => count === 0
+  ? T('wayfinder:' + zeroKey)
+  : T('wayfinder:' + otherKey, { count });
+
+const checkIfAccessible = R.compose(
+  R.not, R.includes(R.__, ['escalator', 'stairs']), R.toLower, R.prop('type'));
+
+const getSecurityLaneName = (queueTypes, waypoints) => {
+  const lane = findPropWaypoints('securityLane')(waypoints);
+  if (!lane) return
+  const types = R.prop(lane.type, queueTypes);
+  const laneType = R.find(R.propEq('id', lane.id), types);
+  return R.prop('displayText', laneType)
+};
+
+const findPropWaypoints = propName => R.compose(
+  R.prop(propName),
+  R.find(R.prop(propName)),
+  R.drop(1)); // because first waypoint is the end of previous segment and can be security checkpoint
+
+module.exports = getSteps;