atriusmaps-node-sdk/dist/cjs/src/app.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 Zousan = require('zousan-plus');
var i18n = require('./utils/i18n.js');
var isInitialState = require('./utils/isInitialState.js');
var _package = require('../package.json.js');
var debugTools = require('./debugTools.js');
var env = require('./env.js');
var bustle = require('./extModules/bustle.js');
var log = require('./extModules/log.js');

function _interopNamespaceDefaultOnly (e) { return Object.freeze({ __proto__: null, default: e }); }

const isBrowser = typeof window !== "undefined";
const TRACE = false;
async function setupPlugin(app, id, config) {
  if (!config) {
    app.log.info(`Plugin ${id} explicitly disabled`);
    return null;
  }
  if (config.active !== void 0) {
    if (config.active === false || config.active === "notLocalhost" && app.env.isLocalhost()) {
      app.log.info(`Plugin ${id} explicitly deativated`);
      return null;
    }
  }
  const load = id.includes("/") ? (() => {
    const [scope, shortName] = id.split("/");
    return import(`../plugins/${scope}/${shortName}/src/index.js`);
  })() : import(`../plugins/${id}/src/index.js`);
  return load.then((pluginModule) => {
    app.log.info(`Creating plugin ${id}`);
    return pluginModule.create(app, config);
  });
}
const getLang = (config) => {
  const supportedLanguages = config.supportedLanguages || [
    "am",
    "ar",
    "de",
    "el-GR",
    "en",
    "es",
    "fr",
    "hi",
    "is",
    "it",
    "ja",
    "ko",
    "nl",
    "pl",
    "pt",
    "ru",
    "so",
    "th",
    "zh-Hans",
    "zh-Hant"
  ];
  if (typeof window !== "undefined") {
    const queryParms = new URLSearchParams(location.search);
    let lang = queryParms.get("lang") || (typeof navigator ? navigator.language : null);
    while (lang) {
      if (lang && supportedLanguages.includes(lang)) {
        return lang;
      } else {
        lang = lang.substring(0, lang.lastIndexOf("-"));
      }
    }
  }
  return config.defaultLanguage || "en";
};
async function loadConfig(name) {
  return isBrowser ? import(`./configs/${name}.json`) : import(`./configs/${name}.json.js`);
}
async function extendConfig(config, extendsConfigs) {
  let newConfig = {};
  const extConfigFiles = await Promise.all(extendsConfigs.map(loadConfig));
  for (const extendsConfigMod of extConfigFiles) {
    let extendsConfig = extendsConfigMod.default;
    extendsConfig = extendsConfig.extends ? await extendConfig(extendsConfig, extendsConfig.extends) : extendsConfig;
    newConfig = R.mergeDeepRight(newConfig, extendsConfig);
  }
  newConfig = R.mergeDeepRight(newConfig, config);
  return newConfig;
}
const createPostProcessor = (name) => (config) => import(`./configs/postproc-${name}.ts`).then((pp) => pp.process(config));
const handleConfigPostProcess = async (config) => config.configPostProc ? Zousan.series(config, ...config.configPostProc.map(createPostProcessor)) : config;
async function create(rawConfig) {
  const appInstance = /* @__PURE__ */ Object.create(null);
  let config = rawConfig.extends ? await extendConfig(rawConfig, rawConfig.extends) : rawConfig;
  if (config.plugins?.monitoring) {
    try {
      const mon = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespaceDefaultOnly(require('../_virtual/_empty_module_placeholder.js')); });
      await mon.activate(config.plugins.monitoring);
    } catch (err) {
      console.warn("Monitoring plugin failed to load (continuing without it):", err?.message || err);
    }
  }
  config = await handleConfigPostProcess(config);
  const lang = getLang(config);
  const i18n$1 = await i18n.default(lang, { debug: config.debug });
  appInstance.i18n = () => i18n$1;
  appInstance.gt = () => i18n$1.t.bind(i18n$1);
  appInstance.config = config;
  appInstance.plugins = {};
  const appLog = log.initLog("web-engine", {
    enabled: !!config.debug,
    isBrowser,
    color: "cyan",
    logFilter: config.logFilter,
    truncateObjects: !isBrowser,
    trace: TRACE
  });
  appInstance.log = appLog.sublog(config.name);
  appInstance.bus = bustle.create({
    showEvents: true,
    reportAllErrors: true,
    log: appLog
  });
  appInstance.info = { wePkg: _package };
  if (typeof window !== "undefined") {
    if (config.debug) {
      appInstance.debug = R.map((fn) => fn.bind(appInstance), debugTools);
      debugTools.dndGo.call(appInstance);
    } else {
      appInstance.debug = {};
    }
    window._app = appInstance;
    if (window.document && window.document.title && config.setWindowTitle) {
      document.title = config.name;
    }
  }
  appInstance.env = env.buildEnv(appInstance);
  if (config.theme) {
    await Zousan.evaluate(
      { name: "ThemeManagerModule", value: Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespaceDefaultOnly(require('../_virtual/_empty_module_placeholder.js')); }) },
      { name: "HistoryManager", value: Promise.resolve().then(function () { return require('./historyManager.js'); }) },
      { name: "LayerManager", value: Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespaceDefaultOnly(require('../_virtual/_empty_module_placeholder.js')); }) }
    ).then(async ({ LayerManager, HistoryManager, ThemeManagerModule }) => {
      const ThemeManager = ThemeManagerModule.initThemeManager(appInstance);
      appInstance.themePack = await ThemeManager.buildTheme(config.theme, config.defaultTheme);
      isInitialState.startInitialStateListener();
      LayerManager.initLayerManager(appInstance);
      HistoryManager.initHistoryManager(appInstance);
      appInstance.destroy = () => LayerManager.destroy(appInstance);
    });
  } else {
    appInstance.destroy = () => {
    };
  }
  if (config.plugins) {
    for (const id in config.plugins) {
      try {
        const pluginConfig = config.plugins[id];
        if (appInstance.plugins[id]) {
          throw Error(`Duplicate plugin name "${id}"`);
        }
        const plugin = await setupPlugin(appInstance, id, pluginConfig);
        if (plugin) {
          appInstance.plugins[id] = plugin;
        }
      } catch (e) {
        appLog.error("Error instantiating plugin " + id);
        appLog.error(e);
      }
    }
    for (const id in appInstance.plugins) {
      appInstance.plugins[id].init();
    }
  }
  return appInstance;
}

exports.create = create;