atriusmaps-node-sdk/dist/cjs/plugins/sdkServer/src/sdkHeadless.js

This project provides an API to Atrius Personal Wayfinder maps within a Node environment. See the README.md for more information

'use strict';

var R = require('ramda');
var location = require('../../../src/utils/location.js');

function _interopNamespaceDefault(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 R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);

const headlessCommands = [
  { command: 'destroy' },
  {
    command: 'getDirections',
    args: [
      { name: 'from', type: 'location' },
      { name: 'to', type: 'location' },
      { name: 'accessible', type: 'boolean', 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 }
    ]
  },
  { command: 'getPOIDetails', args: [{ name: 'poiId', type: 'integer', min: 0 }] },
  { command: 'getAllPOIs' },
  { command: 'getStructures' },
  { command: 'getVenueData' },
  {
    command: 'search',
    args: [
      { name: 'term', type: 'string', minLength: 2 },
      { name: 'details', type: 'boolean', optional: true }
    ]
  }
];

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']))
  });

  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 })));
    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))
      },
      directions
    }
  });

  app.bus.on('clientAPI/getPOIDetails', async ({ poiId }) => app.bus.get('poi/getById', { id: poiId }));

  app.bus.on('clientAPI/getAllPOIs', async () => app.bus.get('poi/getAll'));

  app.bus.on('clientAPI/getStructures', () => location.getStructures(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)
  });

  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;
exports.headlessCommands = headlessCommands;