atriusmaps-node-sdk 3.3.632 → 3.3.634

package/dist/cjs/plugins/dynamicPois/src/processors.js

@@ -32,33 +32,39 @@ const mutateSecurityCheckpointLabel = (T, queueTimes, labels) => feature => {
   const id = feature.properties.id;
   const dynamicData = queueTimes[id];
   const label = labels[id];
-  if (dynamicData) { // should we only show this message when "timeIsReal" is true?
+  if (dynamicData) {
+    // should we only show this message when "timeIsReal" is true?
     const { queueTime, isTemporarilyClosed } = dynamicData;
     const secondaryText = isTemporarilyClosed ? T('ui:Closed') : T('ui:_xx_ minute wait', { count: queueTime });
     feature.properties.text = `${label}\n${secondaryText}`;
   }
-  return feature
+  return feature;
 };
 
-const processParkingPOIS = (poiMap) => {
-  const idValuesMap =
-    R__namespace.pipe(
-      R__namespace.filter(poi => poi.category === 'parking'),
-      R__namespace.map(poi => {
-        const da = poi.dynamicAttributes;
-        if (!da)
-          throw Error(`No dynamicAttributes defined for parking POI ${poi.poiId}`)
-        const age = (Date.now() - poi.timestamp) / 1000; // how long ago this was updated by backend (in seconds)
-        const props = (age < da['parking.timeToLive']) // if this update is recent enough, consider it "valid"
+const processParkingPOIS = poiMap => {
+  const idValuesMap = R__namespace.pipe(
+    R__namespace.filter(poi => poi.category === 'parking'),
+    R__namespace.map(poi => {
+      const da = poi.dynamicAttributes;
+      if (!da) throw Error(`No dynamicAttributes defined for parking POI ${poi.poiId}`);
+      const age = (Date.now() - poi.timestamp) / 1000; // how long ago this was updated by backend (in seconds)
+      const props =
+        age < da['parking.timeToLive'] // if this update is recent enough, consider it "valid"
           ? R__namespace.pick(['lotStatus', 'rateDay', 'rateHour', 'timeIsReal', 'timeToTerminal1', 'timeToTerminal2'], poi)
-          : { lotStatus: da['parking.default'], rateDay: '$ -', rateHour: '$ -', timeIsReal: false };
+          : {
+              lotStatus: da['parking.default'],
+              rateDay: '$ -',
+              rateHour: '$ -',
+              timeIsReal: false,
+            };
 
-        return { ...props, lastUpdated: poi.timestamp, lotName: poi.lotName }
-      }))(poiMap);
-  return idValuesMap
+      return { ...props, lastUpdated: poi.timestamp, lotName: poi.lotName };
+    }),
+  )(poiMap);
+  return idValuesMap;
 };
 
-const processOpenClosedPois = (poiMap) => {
+const processOpenClosedPois = poiMap => {
   const pathToOpenClosedData = ['dynamicData', 'openClosed'];
   const openClosedPois = R__namespace.filter(R__namespace.hasPath(pathToOpenClosedData), poiMap);
   const openClosedStatuses = R__namespace.map(R__namespace.path(pathToOpenClosedData), openClosedPois);
@@ -67,38 +73,38 @@ const processOpenClosedPois = (poiMap) => {
     const isExpired = R__namespace.pipe(R__namespace.prop('expiration'), R__namespace.lt(Date.now()));
     const idValuesMap = R__namespace.filter(isExpired, openClosedStatuses);
 
-    return idValuesMap
+    return idValuesMap;
   } else {
-    throw Error('Open Closed poi status is malformed.')
+    throw Error('Open Closed poi status is malformed.');
   }
 };
 
 /*
     API response: https://gitlab.com/locuslabs/core-data-team/json-schemas/-/blob/develop/src/api-marketplace/dynamic-queue-data.json
    */
-const processSecurityWaitTimes = (poiMap) => {
+const processSecurityWaitTimes = poiMap => {
   const queuePath = ['dynamicData', 'queue'];
   const queuePois = R__namespace.filter(R__namespace.hasPath(queuePath), poiMap);
   const queues = R__namespace.map(R__namespace.path(queuePath), queuePois);
-  return R__namespace.map(queue => ({
-    isTemporarilyClosed: queue.isTemporarilyClosed,
-    queueTime: queue.queueTime,
-    timeIsReal: !queue.isQueueTimeDefault && queue.expiration > Date.now(),
-    lastUpdated: Date.now()
-  }), queues)
+  return R__namespace.map(
+    queue => ({
+      isTemporarilyClosed: queue.isTemporarilyClosed,
+      queueTime: queue.queueTime,
+      timeIsReal: !queue.isQueueTimeDefault && queue.expiration > Date.now(),
+      lastUpdated: Date.now(),
+    }),
+    queues,
+  );
 };
 
-const processRoutingPois = (poiMap) => {
+const processRoutingPois = poiMap => {
   const now = Date.now();
 
-  return R__namespace.filter(
-    poi => {
-      const navGraphHidden = R__namespace.path(['dynamicData', 'dynamic-routing', 'navGraphHidden'], poi);
-      const expiration = R__namespace.path(['dynamicData', 'dynamic-routing', 'expiration'], poi);
-      return navGraphHidden === true && expiration > now
-    },
-    poiMap
-  )
+  return R__namespace.filter(poi => {
+    const navGraphHidden = R__namespace.path(['dynamicData', 'dynamic-routing', 'navGraphHidden'], poi);
+    const expiration = R__namespace.path(['dynamicData', 'dynamic-routing', 'expiration'], poi);
+    return navGraphHidden === true && expiration > now;
+  }, poiMap);
 };
 
 exports.mutateSecurityCheckpointLabel = mutateSecurityCheckpointLabel;

package/dist/cjs/plugins/poiDataManager/src/poiDataManager.js

@@ -25,7 +25,7 @@ function _interopNamespaceDefault(e) {
 
 var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
 
-async function create (app, config) {
+async function create(app, config) {
   const log = app.log.sublog('poiDataManager');
   const init = () => {
     app.bus.send('venueData/loadPoiData');
@@ -38,7 +38,7 @@ async function create (app, config) {
     const structure = structuresLookup.floorIdToStructure(position.floorId);
     if (!structure) {
       log.error(`No structure found for floorId: ${position.floorId} for POI ${poi.poiId}`);
-      return { ...poi }
+      return { ...poi };
     }
     const floor = structuresLookup.floorIdToFloor(position.floorId);
     const detailedPosition = {
@@ -46,9 +46,9 @@ async function create (app, config) {
       structureName: structure.name,
       buildingId: structure.id,
       floorName: floor.name,
-      floorOrdinal: floor.ordinal
+      floorOrdinal: floor.ordinal,
     };
-    return { ...poi, position: detailedPosition }
+    return { ...poi, position: detailedPosition };
   };
 
   // todo R.map may be enough to update dictionary values
@@ -60,18 +60,23 @@ async function create (app, config) {
         poi.isNavigable = poi.isNavigable === undefined || poi.isNavigable === true; // isNavigable is true as default, and is optional in the POI data
         // poi.isNavigable = /^[a-mA-M]+/.test(poi.name) // uncomment for easy testing of isNavigable
         if (poi.capacity)
-          addToRoomInfo(poi, { name: `Seats ${poi.capacity.join('-')}`, svgId: 'number-of-seats' });
+          addToRoomInfo(poi, {
+            name: `Seats ${poi.capacity.join('-')}`,
+            svgId: 'number-of-seats',
+          });
         if (poi.category.startsWith('meeting'))
-          addToRoomInfo(poi, { name: app.gt()('poiView:Conference Room'), svgId: 'conference-room' });
+          addToRoomInfo(poi, {
+            name: app.gt()('poiView:Conference Room'),
+            svgId: 'conference-room',
+          });
 
         const roomId = getRoomId(poi);
-        if (roomId)
-          poi.roomId = roomId;
+        if (roomId) poi.roomId = roomId;
 
-        return [poi.poiId, fixPositionInfo(poi, structuresLookup)]
+        return [poi.poiId, fixPositionInfo(poi, structuresLookup)];
       }),
-      R__namespace.fromPairs
-    )(pois)
+      R__namespace.fromPairs,
+    )(pois);
   };
 
   const addToRoomInfo = (poi, value) => {
@@ -85,10 +90,10 @@ async function create (app, config) {
     R__namespace.propOr([], 'externalIds'),
     R__namespace.find(R__namespace.propEq('roomId', 'type')),
     R__namespace.prop('id'),
-    R__namespace.unless(R__namespace.isNil, R__namespace.tail)
+    R__namespace.unless(R__namespace.isNil, R__namespace.tail),
   );
 
-  async function checkNavgraph (pois) {
+  async function checkNavgraph(pois) {
     const start = Date.now();
     const badPois = [];
     const navGraph = await app.bus.get('wayfinder/_getNavGraph');
@@ -96,32 +101,34 @@ async function create (app, config) {
       try {
         const pos = poi.position;
         const n = navGraph.findClosestNode(pos.floorId, pos.latitude, pos.longitude);
-        if (!n)
-          badPois.push({ id: poi.poiId, e: 'No closest Navgraph Node' });
+        if (!n) badPois.push({ id: poi.poiId, e: 'No closest Navgraph Node' });
       } catch (e) {
         log.error(e);
         badPois.push({ id: poi.poiId, e: e.message });
       }
     });
 
-    if (badPois.length)
-      log.warn('badPois:', badPois);
+    if (badPois.length) log.warn('badPois:', badPois);
 
     log(`Total time for navgraph POI check: ${Date.now() - start}ms`);
   }
 
-  function filterBadPois (pois) {
+  function filterBadPois(pois) {
     const badPois = [];
     Object.values(pois).forEach(poi => {
       try {
         const pos = poi.position;
-        if (!pos)
-          badPois.push({ poi, e: 'No position information' });
+        if (!pos) badPois.push({ poi, e: 'No position information' });
         else {
-          ;['buildingId', 'structureName', 'floorId', 'floorName', 'floorOrdinal', 'latitude', 'longitude'].forEach(k => {
-            if (pos[k] === null || pos[k] === undefined)
-              badPois.push({ id: poi.poiId, e: `invalid position property: ${k}: ${pos[k]}` });
-          });
+          ['buildingId', 'structureName', 'floorId', 'floorName', 'floorOrdinal', 'latitude', 'longitude'].forEach(
+            k => {
+              if (pos[k] === null || pos[k] === undefined)
+                badPois.push({
+                  id: poi.poiId,
+                  e: `invalid position property: ${k}: ${pos[k]}`,
+                });
+            },
+          );
         }
       } catch (e) {
         log.error(e);
@@ -131,49 +138,48 @@ async function create (app, config) {
 
     if (badPois.length) {
       log.warn('badPois:', badPois);
-      badPois.forEach(ob => { delete pois[ob.id]; });
+      badPois.forEach(ob => {
+        delete pois[ob.id];
+      });
     }
 
-    return pois
+    return pois;
   }
 
-  async function enhanceImages (pois) {
-    for (const poi of Object.values(pois))
-      await addImages(poi);
+  async function enhanceImages(pois) {
+    for (const poi of Object.values(pois)) await addImages(poi);
 
-    return pois
+    return pois;
   }
 
   app.bus.on('venueData/poiDataLoaded', async ({ pois, structures }) => {
     const structuresLookup = buildStructureLookup.buildStructuresLookup(structures);
     pois = formatPois(pois, structuresLookup);
     if (configUtils.debugIsTrue(app, 'pseudoTransPois'))
-      for (const id in pois)
-        pois[id] = pseudoTransPoi(pois[id], app.i18n().language);
+      for (const id in pois) pois[id] = pseudoTransPoi(pois[id], app.i18n().language);
 
     pois = filterBadPois(pois);
 
     await enhanceImages(pois);
     poisLoaded.resolve(pois);
 
-    if (app.config.debug && app.env.isBrowser)
-      window._pois = pois;
+    if (app.config.debug && app.env.isBrowser) window._pois = pois;
 
-    if (app.config.debug)
-      checkNavgraph(pois); // this doesn't change the pois, but warns in the console...
+    if (app.config.debug) checkNavgraph(pois); // this doesn't change the pois, but warns in the console...
   });
 
   app.bus.on('poi/getById', async ({ id }) => {
-    return poisLoaded.then(pois => pois[id])
+    return poisLoaded.then(pois => pois[id]);
   });
 
-  app.bus.on('poi/getByFloorId', async ({ floorId }) => poisLoaded.then(
-    R__namespace.pickBy(R__namespace.pathEq(floorId, ['position', 'floorId']))));
+  app.bus.on('poi/getByFloorId', async ({ floorId }) =>
+    poisLoaded.then(R__namespace.pickBy(R__namespace.pathEq(floorId, ['position', 'floorId']))),
+  );
 
   app.bus.on('poi/getByCategoryId', async ({ categoryId }) => {
     // returns true for exact category matches or parent category matches
-    const categoryMatch = (poi) => poi.category === categoryId || poi.category.startsWith(categoryId + '.');
-    return poisLoaded.then(R__namespace.pickBy(categoryMatch))
+    const categoryMatch = poi => poi.category === categoryId || poi.category.startsWith(categoryId + '.');
+    return poisLoaded.then(R__namespace.pickBy(categoryMatch));
   });
 
   app.bus.on('poi/getAll', async () => poisLoaded);
@@ -182,21 +188,22 @@ async function create (app, config) {
   const addOtherSecurityLanesIfNeeded = async poi => {
     const primaryCheckpointId = R__namespace.path(checkpointPath, poi);
 
-    if (!primaryCheckpointId) return poi
+    if (!primaryCheckpointId) return poi;
 
     const queueTypes = await app.bus.get('venueData/getQueueTypes');
-    const securityPoisMap = await app.bus.get('poi/getByCategoryId', { categoryId: 'security' });
+    const securityPoisMap = await app.bus.get('poi/getByCategoryId', {
+      categoryId: 'security',
+    });
     const securityPoisList = Object.values(securityPoisMap);
 
     poi.queue.otherQueues = prepareOtherSecurityLanes(queueTypes, poi, securityPoisList);
-    return poi
+    return poi;
   };
 
   const prepareOtherSecurityLanes = (queueTypes, currentPoi, securityPois) => {
     const queueTypePath = ['queue', 'queueType'];
     const queueType = R__namespace.path(queueTypePath, currentPoi);
-    if (!queueType)
-      return null
+    if (!queueType) return null;
 
     const queueSubtypes = queueTypes[queueType];
     const primaryCheckpointId = R__namespace.path(checkpointPath, currentPoi);
@@ -206,56 +213,61 @@ async function create (app, config) {
       .map(poi => {
         const laneId = R__namespace.path(['queue', 'queueSubtype'], poi);
         const lane = getLaneData(laneId)(queueSubtypes);
-        return { poiId: poi.poiId, ...lane }
-      })
+        return { poiId: poi.poiId, ...lane };
+      });
   };
 
   // if the value passed is non-null, simply return it. Else throw the error with the message specified.
   // This is useful to insert into pipelines.
   const ensureDefined = errorMsg => value => {
-    if (value != null)
-      return value
-    throw Error(errorMsg)
+    if (value != null) return value;
+    throw Error(errorMsg);
   };
 
-  const getLaneData = laneId => R__namespace.pipe(
-    R__namespace.find(R__namespace.propEq(laneId, 'id')),
-    ensureDefined(`No queue found with ID: ${laneId}`),
-    R__namespace.pick(['displayText', 'imageId'])
-  );
+  const getLaneData = laneId =>
+    R__namespace.pipe(
+      R__namespace.find(R__namespace.propEq(laneId, 'id')),
+      ensureDefined(`No queue found with ID: ${laneId}`),
+      R__namespace.pick(['displayText', 'imageId']),
+    );
 
   /**
    * Updates security checkpoint POI with a list of related security checkpoints.
    */
   app.bus.on('poi/addOtherSecurityLanes', ({ poi }) => addOtherSecurityLanesIfNeeded(poi));
 
-  const isFullUrl = (url) => !!url?.startsWith('https:');
+  const isFullUrl = url => !!url?.startsWith('https:');
 
-  async function addImages (poi) {
-    if (!poi) return
-    const dpr = typeof window === 'undefined' ? 1 : (window.devicePixelRatio || 1);
+  async function addImages(poi) {
+    if (!poi) return;
+    const dpr = typeof window === 'undefined' ? 1 : window.devicePixelRatio || 1;
     const size = `${Math.round(351 * dpr)}x${Math.round(197 * dpr)}`;
 
     if (!R__namespace.length(poi.images)) {
       poi.images = [];
-    } else if (!isFullUrl(poi.images[0])) { // then images are not yet transformed
+    } else if (!isFullUrl(poi.images[0])) {
+      // then images are not yet transformed
       poi.images = await Zousan.all(
-        poi.images.map(imageName =>
-          app.bus.get('venueData/getPoiImageUrl', { imageName, size })));
+        poi.images.map(imageName => app.bus.get('venueData/getPoiImageUrl', { imageName, size })),
+      );
     }
 
     if (!R__namespace.length(poi.fullImages)) {
       poi.fullImages = [];
-    } else if (!isFullUrl(poi.fullImages[0]?.url)) { // then images are not yet transformed
+    } else if (!isFullUrl(poi.fullImages[0]?.url)) {
+      // then images are not yet transformed
       poi.fullImages = await Zousan.all(
         poi.fullImages.map(async ({ url, ...rest }) => {
-          const fullUrl = await app.bus.get('venueData/getPoiImageUrl', { imageName: url, size });
-          return { url: fullUrl, ...rest }
-        })
+          const fullUrl = await app.bus.get('venueData/getPoiImageUrl', {
+            imageName: url,
+            size,
+          });
+          return { url: fullUrl, ...rest };
+        }),
       );
     }
 
-    return poi
+    return poi;
   }
 
   const getUniqueCategories = R__namespace.memoizeWith(R__namespace.identity, R__namespace.pipe(R__namespace.pluck('category'), R__namespace.values, R__namespace.uniq));
@@ -268,21 +280,20 @@ async function create (app, config) {
 
   // See architectural document at  https://docs.google.com/document/d/1NoBAboHR9BiX_vvLef-vp3ButrIQDWYofcTsdilEWvs/edit#
   app.bus.on('poi/setDynamicData', ({ plugin, idValuesMap }) => {
-    poisLoaded
-      .then(pois => {
-        for (const poiId in idValuesMap) {
-          // const dd = { [plugin]: idValuesMap[poiId] }
-          const dynamicData = pois[poiId].dynamicData || {};
-          dynamicData[plugin] = { ...idValuesMap[poiId] };
-          const newPoi = R__namespace.mergeRight(pois[poiId], { dynamicData });
-          pois[poiId] = newPoi;
-        }
-      });
+    poisLoaded.then(pois => {
+      for (const poiId in idValuesMap) {
+        // const dd = { [plugin]: idValuesMap[poiId] }
+        const dynamicData = pois[poiId].dynamicData || {};
+        dynamicData[plugin] = { ...idValuesMap[poiId] };
+        const newPoi = R__namespace.mergeRight(pois[poiId], { dynamicData });
+        pois[poiId] = newPoi;
+      }
+    });
   });
 
-  const runTest = async (testRoutine) => {
+  const runTest = async testRoutine => {
     await testRoutine();
-    return poisLoaded
+    return poisLoaded;
   };
 
   return {
@@ -290,27 +301,23 @@ async function create (app, config) {
     runTest,
     internal: {
       addImages,
-      pseudoTransPoi
-    }
-  }
+      pseudoTransPoi,
+    },
+  };
 }
 
-function pseudoTransPoi (poi, lang) {
-  ['description', 'nearbyLandmark', 'name', 'phone', 'operationHours']
-    .forEach(p => {
-      if (poi[p])
-        poi[p] = i18n.toLang(poi[p], lang);
-    });
+function pseudoTransPoi(poi, lang) {
+  ['description', 'nearbyLandmark', 'name', 'phone', 'operationHours'].forEach(p => {
+    if (poi[p]) poi[p] = i18n.toLang(poi[p], lang);
+  });
   if (poi.keywords)
     poi.keywords = poi.keywords.map(keyword => {
       keyword.name = i18n.toLang(keyword.name, lang);
-      return keyword
+      return keyword;
     });
-  if (poi.position.floorName)
-    poi.position.floorName = i18n.toLang(poi.position.floorName, lang);
-  if (poi.position.structureName)
-    poi.position.structureName = i18n.toLang(poi.position.structureName, lang);
-  return poi
+  if (poi.position.floorName) poi.position.floorName = i18n.toLang(poi.position.floorName, lang);
+  if (poi.position.structureName) poi.position.structureName = i18n.toLang(poi.position.structureName, lang);
+  return poi;
 }
 
 exports.create = create;

package/dist/cjs/plugins/sdkServer/src/sdkHeadless.js

@@ -30,18 +30,31 @@ const headlessCommands = [
       { name: 'from', type: 'location' },
       { name: 'to', type: 'location' },
       { name: 'accessible', type: 'boolean', optional: true },
-      { name: 'queueTypes', type: 'list', itemType: { type: 'string' }, optional: true }
-    ]
+      {
+        name: 'queueTypes',
+        type: 'list',
+        itemType: { type: 'string' },
+        optional: true,
+      },
+    ],
   },
   {
     command: 'getDirectionsMultiple',
     args: [
       { name: 'locations', type: 'list', itemType: { type: 'location' } },
       { name: 'accessible', type: 'boolean', optional: true },
-      { name: 'queueTypes', type: 'list', itemType: { type: 'string' }, optional: true }
-    ]
+      {
+        name: 'queueTypes',
+        type: 'list',
+        itemType: { type: 'string' },
+        optional: true,
+      },
+    ],
+  },
+  {
+    command: 'getPOIDetails',
+    args: [{ name: 'poiId', type: 'integer', min: 0 }],
   },
-  { command: 'getPOIDetails', args: [{ name: 'poiId', type: 'integer', min: 0 }] },
   { command: 'getAllPOIs' },
   { command: 'getStructures' },
   { command: 'getVenueData' },
@@ -49,39 +62,45 @@ const headlessCommands = [
     command: 'search',
     args: [
       { name: 'term', type: 'string', minLength: 2 },
-      { name: 'details', type: 'boolean', optional: true }
-    ]
-  }
+      { name: 'details', type: 'boolean', optional: true },
+    ],
+  },
 ];
 
-function handleHeadless (app) {
+function handleHeadless(app) {
   app.bus.on('clientAPI/destroy', async () => app.destroy());
 
   app.bus.on('clientAPI/getDirections', async ({ from, to, accessible, queueTypes }) => {
     const fromEndpoint = await location.locationToEndpoint(app, from);
     const toEndpoint = await location.locationToEndpoint(app, to);
     const options = { requiresAccessibility: !!accessible };
-    if (queueTypes)
-      options.selectedSecurityLanes = { SecurityLane: queueTypes };
-    return app.bus.get('wayfinder/getRoute', { fromEndpoint, toEndpoint, options })
-      .then(R__namespace.pick(['distance', 'time', 'steps', 'navline', 'waypoints']))
+    if (queueTypes) options.selectedSecurityLanes = { SecurityLane: queueTypes };
+    return app.bus
+      .get('wayfinder/getRoute', { fromEndpoint, toEndpoint, options })
+      .then(R__namespace.pick(['distance', 'time', 'steps', 'navline', 'waypoints']));
   });
 
   app.bus.on('clientAPI/getDirectionsMultiple', async ({ locations, accessible, queueTypes }) => {
     const endpoints = await Promise.all(locations.map(async l => location.locationToEndpoint(app, l)));
     const options = { requiresAccessibility: !!accessible };
-    if (queueTypes)
-      options.selectedSecurityLanes = { SecurityLane: queueTypes };
-    const routes = await Promise.all(R__namespace.aperture(2, endpoints).map(async a =>
-      app.bus.get('wayfinder/getRoute', { fromEndpoint: a[0], toEndpoint: a[1], options })));
+    if (queueTypes) options.selectedSecurityLanes = { SecurityLane: queueTypes };
+    const routes = await Promise.all(
+      R__namespace.aperture(2, endpoints).map(async a =>
+        app.bus.get('wayfinder/getRoute', {
+          fromEndpoint: a[0],
+          toEndpoint: a[1],
+          options,
+        }),
+      ),
+    );
     const directions = R__namespace.map(R__namespace.pick(['distance', 'time', 'steps', 'navline', 'waypoints']), routes);
     return {
       total: {
         distance: R__namespace.sum(R__namespace.map(d => d.distance, directions)),
-        time: R__namespace.sum(R__namespace.map(d => d.time, directions))
+        time: R__namespace.sum(R__namespace.map(d => d.time, directions)),
       },
-      directions
-    }
+      directions,
+    };
   });
 
   app.bus.on('clientAPI/getPOIDetails', async ({ poiId }) => app.bus.get('poi/getById', { id: poiId }));
@@ -93,14 +112,21 @@ function handleHeadless (app) {
   const isNotFunction = o => typeof o !== 'function';
   app.bus.on('clientAPI/getVenueData', async () => {
     const vd = await app.bus.get('venueData/getVenueData');
-    return R__namespace.filter(isNotFunction, vd)
+    return R__namespace.filter(isNotFunction, vd);
   });
 
-  app.bus.on('clientAPI/search', async ({ term, details }) => app.bus.get('search/queryAsync', { term }).then(poiList => {
-    const poiIdList = poiList.map(poi => poi.poiId);
-    app.bus.send('event/search', { referrer: 'prog', searchMethod: null, query: term, entities: poiIdList });
-    return details ? poiList : poiIdList
-  }));
+  app.bus.on('clientAPI/search', async ({ term, details }) =>
+    app.bus.get('search/queryAsync', { term }).then(poiList => {
+      const poiIdList = poiList.map(poi => poi.poiId);
+      app.bus.send('event/search', {
+        referrer: 'prog',
+        searchMethod: null,
+        query: term,
+        entities: poiIdList,
+      });
+      return details ? poiList : poiIdList;
+    }),
+  );
 }
 
 exports.handleHeadless = handleHeadless;