atriusmaps-node-sdk 1.0.0 → 3.2.28

package/lib/plugins/wayfinder/src/navGraphDebug.js

@@ -1,95 +1 @@
-import * as R from 'ramda';
-
-/**
- * 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
-
-  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.groupBy(R.prop('floorId'), onodes), connected: Array.from(vnodes) }
-}
-
-const enrichDebugNavGraph = (nodes) => ({
-  nodes: toOrphanedNodesArray(nodes),
-  edges: getNavEdgeFeatures(nodes)
-});
-
-const transformNodes = isOrphaned =>
-  R.map(R.pipe(R.assoc('isOrphaned', isOrphaned), R.dissoc('edges')));
-
-const toOrphanedNodesArray = R.pipe(
-  orphanTest,
-  R.pick(['connected', 'orphaned']),
-  R.evolve({
-    connected: transformNodes(false),
-    orphaned: transformNodes(true)
-  }),
-  R.values,
-  R.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.cond([
-  [R.equals('Stairs'), R.always('#EFBC9B')],
-  [R.equals('Elevator'), R.always('#A491D3')],
-  [R.equals('Escalator'), R.always('#563F1B')],
-  [R.equals('Ramp'), R.always('#DBD053')],
-  [R.T, R.always('#FF0000')]
-]);
-
-const getEdgeCategory = R.cond([
-  [R.equals('Train'), R.always('nav.train')],
-  [R.equals('Bus'), R.always('nav.transit')],
-  [R.equals('Security Checkpoint'), R.always('nav.secure')],
-  [R.equals('Ground'), R.always('nav.primary')],
-  [R.T, R.always('')]
-]);
-
-export { enrichDebugNavGraph, orphanTest };
+import*as a from"ramda";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:a.groupBy(a.prop("floorId"),r),connected:Array.from(n)}}const s=a=>({nodes:n(a),edges:r(a)}),o=e=>a.map(a.pipe(a.assoc("isOrphaned",e),a.dissoc("edges"))),n=a.pipe(e,a.pick(["connected","orphaned"]),a.evolve({connected:o(!1),orphaned:o(!0)}),a.values,a.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=a.cond([[a.equals("Stairs"),a.always("#EFBC9B")],[a.equals("Elevator"),a.always("#A491D3")],[a.equals("Escalator"),a.always("#563F1B")],[a.equals("Ramp"),a.always("#DBD053")],[a.T,a.always("#FF0000")]]),d=a.cond([[a.equals("Train"),a.always("nav.train")],[a.equals("Bus"),a.always("nav.transit")],[a.equals("Security Checkpoint"),a.always("nav.secure")],[a.equals("Ground"),a.always("nav.primary")],[a.T,a.always("")]]);export{s as enrichDebugNavGraph,e as orphanTest};

package/lib/plugins/wayfinder/src/segmentBadges.js

@@ -1,29 +1 @@
-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'
-};
-
-export default segmentBadges;
+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"};export{n as default};

package/lib/plugins/wayfinder/src/segmentBuilder.js

@@ -1,241 +1 @@
-import * as R from 'ramda';
-import { bezierCurveTo } from '../../../src/utils/geom.js';
-import segmentCategories from './segmentCategories.js';
-import getSteps from './stepBuilder.js';
-
-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;
-  });
-};
-
-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.head(segment.waypoints);
-      if (firstWaypointOfSegment.levelDifference === 0) {
-        const lastWaypointOfPreviousSegment = R.last(segments[index - 1].waypoints);
-        segment.waypoints = R.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 => 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.map(
-  R.converge(R.assoc('coordinates'), [calculateCurveLineCoordinates, R.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) {
-      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 = [];
-
-        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
- * @return {{steps: Step[], segments: Segment[]}}
- */
-const buildSegments = (waypoints, fromEndpoint, toEndpoint, floorIdToNameMap, T, queueTypes) => {
-  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.last(rawSegments).coordinates.push([toEndpoint.lng, toEndpoint.lat]);
-
-  const segments = rawSegments.map((segment, index) => {
-    const startWaypoint = R.last(segment.waypoints);
-    const coordinates = segment.coordinates;
-    const shouldDrawSegment = !(segment.levelDifference && segment.waypoints.every(R.prop('isPortal')));
-
-    const badges = [];
-    if (segmentCategories.WALKING_TO_PORTAL === segment.segmentCategory) {
-      const nextSegment = rawSegments[index + 1];
-      badges.push({
-        canonicalName: `wayfinding.${nextSegment.segmentCategory}`,
-        coordinates: R.last(coordinates)
-      });
-    } else if (segmentCategories.START !== segment.segmentCategory) {
-      badges.push({
-        canonicalName: `wayfinding.${segment.segmentCategory}`,
-        coordinates: R.last(coordinates)
-      });
-    }
-    const segmentType = getSegmentType(segment);
-    return {
-      levelId: startWaypoint.position.structureId,
-      ordinalId: `ordinal: ${startWaypoint.position.ordinal}`,
-      coordinates,
-      segmentType,
-      badges,
-      shouldDrawSegment
-    }
-  });
-
-  const steps = getSteps(rawSegments, R.prop('title', fromEndpoint), R.prop('title', toEndpoint), floorIdToNameMap, T, queueTypes);
-
-  return { segments, steps }
-};
-
-export { buildSegments };
+import*as e from"ramda";import{bezierCurveTo as t}from"../../../src/utils/geom.js";import o from"./segmentCategories.js";import a from"./stepBuilder.js";const n=e.map(e.converge(e.assoc("coordinates"),[e=>e.waypoints.flatMap(((e,o)=>o>0&&e.curvedPathForward&&e.curvedPathForward.length>0?e.curvedPathForward.flatMap((e=>t(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.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=o.START:t.waypoints[t.waypoints.length-1].isDestination?t.segmentCategory=o.WALKING_TO_END:"Security Checkpoint"===t.type?t.segmentCategory=o.SECURITY_CHECKPOINT:"Bus"===t.type?t.segmentCategory=o.BUS:"Train"===t.type?t.segmentCategory=o.TRAIN:"Stairs"===t.type?t.levelDifference>0?t.segmentCategory=o.STAIRS_UP:t.levelDifference<0?t.segmentCategory=o.STAIRS_DOWN:t.segmentCategory=o.STAIRS:"Elevator"===t.type?t.levelDifference>0?t.segmentCategory=o.ELEVATOR_UP:t.levelDifference<0?t.segmentCategory=o.ELEVATOR_DOWN:t.segmentCategory=o.ELEVATOR:"Escalator"===t.type?t.levelDifference>0?t.segmentCategory=o.ESCALATOR_UP:t.levelDifference<0?t.segmentCategory=o.ESCALATOR_DOWN:t.segmentCategory=o.ESCALATOR:"Ramp"===t.type?t.levelDifference>0?t.segmentCategory=o.RAMP_UP:t.levelDifference<0?t.segmentCategory=o.RAMP_DOWN:t.segmentCategory=o.RAMP:"Security Checkpoint"===e[a+1].type?t.segmentCategory=o.WALKING_TO_SECURITY_CHECKPOINT:"Walk"!==e[a+1].type&&(t.segmentCategory=o.WALKING_TO_PORTAL)}))})(a),((e,t)=>{if(1===e.length){const a={segmentCategory:void 0,waypoints:[]};a.segmentCategory=o.WALKING_TO_END,a.type="Walk",a.waypoints=[t],e.push(a)}})(a,r),(t=>{t.forEach(((o,a)=>{if(a>1&&0===e.head(o.waypoints).levelDifference){const n=e.last(t[a-1].waypoints);o.waypoints=e.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.last(y).coordinates.push([i.lng,i.lat]);return{segments:y.map(((t,a)=>{const n=e.last(t.waypoints),r=t.coordinates,s=!(t.levelDifference&&t.waypoints.every(e.prop("isPortal"))),i={levelId:n.position.structureId,ordinalId:`ordinal: ${n.position.ordinal}`,coordinates:r,shouldDrawSegment:s},p=[];if(o.WALKING_TO_PORTAL===t.segmentCategory){const t=y[a+1];p.push({canonicalName:`wayfinding.${t.segmentCategory}`,coordinates:e.last(r)})}else o.START!==t.segmentCategory&&p.push({canonicalName:`wayfinding.${t.segmentCategory}`,coordinates:e.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:a(y,e.prop("title",s),e.prop("title",i),p,l,g)}};export{s as buildSegments};

package/lib/plugins/wayfinder/src/segmentCategories.js

@@ -1,30 +1 @@
-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'
-};
-
-export default segmentCategories;
+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"};export{a as default};

package/lib/plugins/wayfinder/src/stepBuilder.js

@@ -1,236 +1 @@
-import { compose, not, includes, __, toLower, prop, find, drop, last, propEq } from 'ramda';
-import { findBoundsOfWaypoints } from '../../../src/utils/bounds.js';
-import segmentBadges from './segmentBadges.js';
-import segmentCategories from './segmentCategories.js';
-
-/**
- * @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
- * @return {Step[]} steps - list of navigation steps
- */
-function getSteps (segments, startName = '', destinationName = '', floorIdToNameMap, T, queueTypes = {}) {
-  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 = findBoundsOfWaypoints(segment.waypoints);
-    const isAccessible = checkIfAccessible(segment);
-
-    return {
-      primaryText,
-      secondaryText,
-      icon,
-      animationAnchor,
-      eta,
-      distance,
-      bounds,
-      isAccessible,
-      securityWaitTimes
-    }
-  })
-}
-
-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(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[last(segment.waypoints).position.floorId]
-}
-
-function getSecondaryText (segment, minutes, securityLaneName, T) {
-  const zeroOrOtherKeys = translateZeroOrOther(minutes, T);
-  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('Walk <1 minute to', 'Walk xx minute to')
-    case segmentCategories.WALK_DOWN: return zeroOrOtherKeys('Walk <1 minute down to', 'Walk xx minute down to')
-    case segmentCategories.WALK_UP: return zeroOrOtherKeys('Walk <1 minute up to', 'Walk 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 = compose(
-  not, includes(__, ['escalator', 'stairs']), toLower, prop('type'));
-
-const getSecurityLaneName = (queueTypes, waypoints) => {
-  const lane = findPropWaypoints('securityLane')(waypoints);
-  if (!lane) return
-  const types = prop(lane.type, queueTypes);
-  const laneType = find(propEq('id', lane.id), types);
-  return prop('displayText', laneType)
-};
-
-const findPropWaypoints = propName => compose(
-  prop(propName),
-  find(prop(propName)),
-  drop(1)); // because first waypoint is the end of previous segment and can be security checkpoint
-
-export default getSteps;
+import{compose as e,not as t,includes as r,__ as a,toLower as n,prop as s,find as c,drop as u,last as i,propEq as T}from"ramda";import{findBoundsOfWaypoints as o}from"../../../src/utils/bounds.js";import A from"./segmentBadges.js";import _ from"./segmentCategories.js";function R(e,t="",r="",a,n,c={}){return e.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(s("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 _.START:return A.START;case _.WALKING_TO_END:return A.END;case _.ELEVATOR:return A.ELEVATOR;case _.ELEVATOR_UP:return A.ELEVATOR_UP;case _.ELEVATOR_DOWN:return A.ELEVATOR_DOWN;case _.STAIRS:return A.STAIRS;case _.STAIRS_UP:return A.STAIRS_UP;case _.STAIRS_DOWN:return A.STAIRS_DOWN;case _.ESCALATOR:return A.ESCALATOR;case _.ESCALATOR_UP:return A.ESCALATOR_UP;case _.ESCALATOR_DOWN:return A.ESCALATOR_DOWN;case _.WALKING_TO_PORTAL:case _.WALK:case _.WALK_DOWN:case _.WALK_UP:return A.WALK;case _.TRAIN:return A.TRAIN;case _.TRAIN_UP:return A.TRAIN_UP;case _.TRAIN_DOWN:return A.TRAIN_DOWN;case _.BUS:return A.BUS;case _.BUS_UP:return A.BUS_UP;case _.BUS_DOWN:return A.BUS_DOWN;case _.SECURITY_CHECKPOINT:return A.SECURITY_CHECKPOINT;case _.RAMP:return A.RAMP;case _.RAMP_UP:return A.RAMP_UP;case _.RAMP_DOWN:return A.RAMP_DOWN;default:return A.WALK}}(u.segmentCategory),m=function(e,t){let r;switch(e){case _.START:r=0;break;case _.WALKING_TO_END:r=t.length-1;break;case _.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={primaryText:function(e,t,r,a,n,s){const c=e[t];switch(c.segmentCategory){case _.START:return O(c.waypoints[0].position,r);case _.WALKING_TO_END:return O(c.waypoints[c.waypoints.length-1].position,a);case _.WALKING_TO_SECURITY_CHECKPOINT:case _.WALKING_TO_PORTAL:return s(`wayfinder:${e[t+1].type}`);case _.SECURITY_CHECKPOINT:case _.ELEVATOR:case _.ELEVATOR_DOWN:case _.ELEVATOR_UP:case _.ESCALATOR:case _.ESCALATOR_DOWN:case _.ESCALATOR_UP:case _.STAIRS:case _.STAIRS_DOWN:case _.STAIRS_UP:return function(e,t){return t[i(e.waypoints).position.floorId]}(c,n);default:return s(`wayfinder:${c.type}`)}}(e,T,t,r,a,n),secondaryText:function(e,t,r,a){const n=S(t,a);switch(e.segmentCategory){case _.START:return a("wayfinder:Begin route at");case _.ELEVATOR:return a("wayfinder:Take elevator to");case _.ELEVATOR_UP:return a("wayfinder:Take elevator up to");case _.ELEVATOR_DOWN:return a("wayfinder:Take elevator down to");case _.STAIRS:return a("wayfinder:Take stairs to");case _.STAIRS_UP:return a("wayfinder:Take stairs up to");case _.STAIRS_DOWN:return a("wayfinder:Take stairs down to");case _.ESCALATOR:return a("wayfinder:Take escalator to");case _.ESCALATOR_UP:return a("wayfinder:Take escalator up to");case _.ESCALATOR_DOWN:return a("wayfinder:Take escalator down to");case _.WALK:case _.WALKING_TO_SECURITY_CHECKPOINT:case _.WALKING_TO_PORTAL:case _.WALKING_TO_END:return n("Walk <1 minute to","Walk xx minute to");case _.WALK_DOWN:return n("Walk <1 minute down to","Walk xx minute down to");case _.WALK_UP:return n("Walk <1 minute up to","Walk xx minute up to");case _.TRAIN:return n("Take train <1 minute","Take train xx minute");case _.BUS:return n("Take bus <1 minute","Take bus xx minute");case _.SECURITY_CHECKPOINT:return r?a("wayfinder:Through _security_ to",{name:r}):a("wayfinder:Through security to");case _.RAMP:return a("wayfinder:Take ramp to");case _.RAMP_UP:return a("wayfinder:Take ramp up to");case _.RAMP_DOWN:return a("wayfinder:Take ramp down to");default:return""}}(u,L,d(c,u.waypoints),n),icon:I,animationAnchor:m,eta:L,distance:y,bounds:o(u.waypoints),isAccessible:E(u),securityWaitTimes:R};return u.poiId&&(p.poiId=u.poiId),p}))}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(t,r(a,["escalator","stairs"]),n,s("type")),d=(e,t)=>{const r=N("securityLane")(t);if(!r)return;const a=s(r.type,e),n=c(T("id",r.id),a);return s("displayText",n)},N=t=>e(s(t),c(s(t)),u(1));export{R as default};