atriusmaps-node-sdk/dist/cjs/nodesdk/nodeEntry.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 http = require('node:http');
var https = require('node:https');
var httpsProxyAgent = require('https-proxy-agent');
var fetch = require('node-fetch');
var prepareSDKConfig = require('../deploy/prepareSDKConfig.js');
var _package = require('../package.json.js');
var controller = require('../src/controller.js');
var observable = require('../src/utils/observable.js');

const version = _package.default.version;
const LIB_NAME = 'Atrius Maps JS SDK Client';

function setupFetch (config) {
  const httpAgent = new http.Agent({ keepAlive: true });
  const httpsAgent = new https.Agent({ keepAlive: true });

  // provide easy proxy handling via config.proxy in form of { host, port }
  const proxyAgent = config.proxy ? new httpsProxyAgent.HttpsProxyAgent(`http://${config.proxy.host}:${config.proxy.port}`) : null;

  // Support a user defined agent - or a proxy agent - else we specify our own, forcing keepAlive to true (which is default in Node >= 19)
  const agent = config.agent || proxyAgent || (url => url.protocol === 'http:' ? httpAgent : httpsAgent);

  global.fetch = async (url, options) => fetch(url, { ...options, agent });
}

// logging setup
let sdkLogging = false;
const pad2 = x => x.toString().length < 2 ? '0' + x : x;
const ts = () => { const d = new Date(); return `${d.getHours()}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}.${d.getMilliseconds()}` };
const logPre = () => `AtriusMaps Node SDK (${ts()}): `;
const log = function () {
  if (sdkLogging) {
    let msg = logPre() + Array.from(arguments).map(arg => typeof arg === 'object' ? JSON.stringify(arg) : arg).join(' ');
    const lines = msg.split('\n');
    if (lines.length > 1)
      msg = lines[0] + `… (+ ${lines.length - 1} lines)`;
    else
      if (msg.length > 256)
        msg = msg.substring(0, 255) + `… (length: ${msg.length} chars)`;
    console.log(msg);
  }
};

// this iterates through available commands and makes them member functions of map
function addCommands (map, commands) {
  commands.forEach(sig => {
    map[sig.command] = function () {
      const cob = { command: sig.command };
      for (let i = 0; i < arguments.length; i++)
        cob[sig.args[i].name] = arguments[i];
      return map(cob)
    };
  });
}

async function newMap (sdkConfig) {
  return new Promise((resolve, reject) => {
    sdkConfig.headless = true;

    setupFetch(sdkConfig); // This installs the fetch function globally (overriding native if exists)

    const config = prepareSDKConfig(sdkConfig);

    controller.create(config)
      .then(app => {
        const map = (payload, arg2) => {
          if (typeof payload === 'string')
            payload = { ...arg2, command: payload };
          log('Sending command object: ', payload);
          return app.bus.get('clientAPI/execute', payload)
            .then(result => {
              log('Received Message: ', result);
              return result
            })
            .catch(e => {
              log('Error: ', e.message); // doesn't seem to ever get called?? WTF?
              throw e
            })
        };
        // map._app = app

        observable(map); // make map handle events pub/sub
        app.eventListener.observe(function () { map.fire.apply(map, arguments); }); // pass it on...

        map.on('ready', (eName, data) => {
          const { commands/*, customTypes */ } = data.commandJSON;
          addCommands(map, commands);
          resolve(map);
          log('map ready');
        });
      });
  })
}

const Init = {
  getVersion: () => version,
  newMap: config => newMap(config),
  setLogging: flag => { sdkLogging = flag; if (flag) log(`${LIB_NAME} v${version} Logging enabled.`); }
};

module.exports = Init;