atriusmaps-node-sdk 3.3.898 → 3.3.899

package/dist/cjs/src/extModules/flexapi/src/validate.js

@@ -1,142 +1,102 @@
 'use strict';
 
-// small helper for showing args
-const SQ = "'"; // single quote
-const sqStr = function (str) {
+const SQ = "'";
+const sqStr = function(str) {
   return SQ + str + SQ;
 };
-
 function validate(library, sig, cob) {
   if (sig.args) {
     checkTypeList(library.customTypes, sig.args, cob);
   }
 }
-
 function getSigMatch(library, cob) {
-  const matches = library.commandDefsList.filter(cd => cd.sig.command === cob.command && matchesArgs(cd.sig, cob));
+  const matches = library.commandDefsList.filter((cd) => cd.sig.command === cob.command && matchesArgs(cd.sig, cob));
   if (matches.length > 1) {
-    throw Error('Command matches multiple signatures!');
+    throw Error("Command matches multiple signatures!");
   }
   if (matches.length > 0) {
     return matches[0];
   }
-  return null; // no matching signature found
+  return null;
 }
-
-// returns true if each of the required arguments in the command
-// spec (c) is defined within the command object (o) - else false
 function matchesArgs(c, o) {
   if (!c.args) {
     return true;
-  } // no args
-  return c.args.reduce(function (cs, argOb) {
-    return o[argOb.name] !== undefined || argOb.optional ? cs : false;
+  }
+  return c.args.reduce(function(cs, argOb) {
+    return o[argOb.name] !== void 0 || argOb.optional ? cs : false;
   }, true);
 }
-
 function checkMinMax(name, typeSpec, value) {
-  if (typeSpec.min !== undefined && value < typeSpec.min) {
-    throw Error('argument ' + sqStr(name) + ' must be at least ' + typeSpec.min + ' but is ' + value);
+  if (typeSpec.min !== void 0 && value < typeSpec.min) {
+    throw Error("argument " + sqStr(name) + " must be at least " + typeSpec.min + " but is " + value);
   }
-  if (typeSpec.max !== undefined && value > typeSpec.max) {
-    throw Error('argument ' + sqStr(name) + ' must be at most ' + typeSpec.max + ' but is ' + value);
+  if (typeSpec.max !== void 0 && value > typeSpec.max) {
+    throw Error("argument " + sqStr(name) + " must be at most " + typeSpec.max + " but is " + value);
   }
 }
-
-/**
- * Checks an argument value against that arguments spec. If there are no violations of the argSpec, true is returned.
- * If there is a violation, an error is thrown.
- * @param {object} customTypes any defined custom types
- * @param {object} typeSpec An type spec object which inclues a type and other constraints if applicable
- * @param {*} value The JSON value to be checked against this spec
- * @return {true|string} returns true if arg is valid, else a string description of the problem
- */
 function checkType(customTypes, typeSpec, value) {
-  if (!typeSpec) // if there is no typespec to validate against, any value is ok
-  {
+  if (!typeSpec) {
     return true;
   }
-
-  const name = typeSpec.name || '';
-
-  // if type is a reference/custom, grab that type def but allow "optional" override - TODO: consider other overrides (perhaps all but "type"?)
+  const name = typeSpec.name || "";
   if (customTypes && customTypes[typeSpec.type]) {
     typeSpec = Object.assign({}, customTypes[typeSpec.type], typeSpec, {
-      type: customTypes[typeSpec.type].type,
+      type: customTypes[typeSpec.type].type
     });
   }
-
-  if (typeSpec.type === 'integer') {
-    if (typeof value === 'string') {
+  if (typeSpec.type === "integer") {
+    if (typeof value === "string") {
       value = parseInt(value, 10);
     }
     if (!Number.isInteger(value)) {
-      throw Error('expected integer argument for argument ' + sqStr(name) + ' but received ' + value);
+      throw Error("expected integer argument for argument " + sqStr(name) + " but received " + value);
     }
     checkMinMax(name, typeSpec, value);
-  } else if (typeSpec.type === 'float') {
-    if (typeof value === 'string') {
+  } else if (typeSpec.type === "float") {
+    if (typeof value === "string") {
       value = parseFloat(value);
     }
     if (!Number.isFinite(value)) {
-      throw Error('expected float argument for argument ' + sqStr(name) + " but received '" + value + "'");
+      throw Error("expected float argument for argument " + sqStr(name) + " but received '" + value + "'");
     }
     checkMinMax(name, typeSpec, value);
-  } else if (typeSpec.type === 'string') {
-    if (typeof value !== 'string') {
+  } else if (typeSpec.type === "string") {
+    if (typeof value !== "string") {
       throw Error(`argument ${sqStr(name)} must be a string but is not (value: ${value})`);
     }
     if (typeSpec.minLength && value.length < typeSpec.minLength) {
       throw Error(
-        `argument ${sqStr(name)} must be a at least ${typeSpec.minLength} characters but is '${value}' (${value.length} chars)`,
+        `argument ${sqStr(name)} must be a at least ${typeSpec.minLength} characters but is '${value}' (${value.length} chars)`
       );
     }
     if (typeSpec.maxLength && value.length > typeSpec.maxLength) {
       throw Error(
-        `argument ${sqStr(name)} must be a at most ${typeSpec.maxLength} characters but is '${value}' (${value.length} chars)`,
+        `argument ${sqStr(name)} must be a at most ${typeSpec.maxLength} characters but is '${value}' (${value.length} chars)`
       );
     }
-  } else if (typeSpec.type === 'boolean') {
-    if (
-      value !== true &&
-      value !== false &&
-      value !== 'false' &&
-      value !== 'true' &&
-      value !== 'yes' &&
-      value !== 'no'
-    ) {
+  } else if (typeSpec.type === "boolean") {
+    if (value !== true && value !== false && value !== "false" && value !== "true" && value !== "yes" && value !== "no") {
       throw Error(
-        'argument ' + sqStr(name) + ' must be a boolean but is type ' + typeof value + ' with value of ' + value,
+        "argument " + sqStr(name) + " must be a boolean but is type " + typeof value + " with value of " + value
       );
     }
-  } else if (typeSpec.type === 'list') {
+  } else if (typeSpec.type === "list") {
     if (!Array.isArray(value)) {
-      throw Error('argument ' + sqStr(name) + ' must be a list but is not. Value = ' + value);
+      throw Error("argument " + sqStr(name) + " must be a list but is not. Value = " + value);
     }
-    if (typeSpec.minLength !== undefined && typeSpec.minLength > value.length) {
+    if (typeSpec.minLength !== void 0 && typeSpec.minLength > value.length) {
       throw Error(
-        'argument ' +
-          sqStr(name) +
-          ' must contain at least ' +
-          typeSpec.minLength +
-          ' items but only contains ' +
-          value.length +
-          ' items',
+        "argument " + sqStr(name) + " must contain at least " + typeSpec.minLength + " items but only contains " + value.length + " items"
       );
     }
-    if (typeSpec.maxLength !== undefined && typeSpec.maxLength < value.length) {
+    if (typeSpec.maxLength !== void 0 && typeSpec.maxLength < value.length) {
       throw Error(
-        'argument ' +
-          sqStr(name) +
-          ' must contain at most ' +
-          typeSpec.maxLength +
-          ' items but contains ' +
-          value.length +
-          ' items',
+        "argument " + sqStr(name) + " must contain at most " + typeSpec.maxLength + " items but contains " + value.length + " items"
       );
     }
     if (typeSpec.itemType) {
-      const allItemsValid = value.reduce(function (isValid, curItem) {
+      const allItemsValid = value.reduce(function(isValid, curItem) {
         try {
           checkType(customTypes, typeSpec.itemType, curItem);
         } catch {
@@ -146,22 +106,22 @@ function checkType(customTypes, typeSpec, value) {
       }, true);
       if (!allItemsValid) {
         throw Error(
-          `argument ${sqStr(name)} contains an invalid item(s). All items in the list must be of type: ${JSON.stringify(typeSpec.itemType)} - list: ${JSON.stringify(value)}`,
+          `argument ${sqStr(name)} contains an invalid item(s). All items in the list must be of type: ${JSON.stringify(typeSpec.itemType)} - list: ${JSON.stringify(value)}`
         );
       }
     }
-  } else if (typeSpec.type === 'object') {
-    if (typeof value !== 'object' || Array.isArray(value)) {
-      throw Error('argument ' + sqStr(name) + ' must be an object but is not. Value = ' + value);
+  } else if (typeSpec.type === "object") {
+    if (typeof value !== "object" || Array.isArray(value)) {
+      throw Error("argument " + sqStr(name) + " must be an object but is not. Value = " + value);
     }
     try {
       if (typeSpec.props) {
         checkTypeList(customTypes, typeSpec.props, value);
       }
     } catch (e) {
-      throw Error('Within ' + name + ', ' + e.message);
+      throw Error("Within " + name + ", " + e.message);
     }
-  } else if (typeSpec.type === 'multi') {
+  } else if (typeSpec.type === "multi") {
     const oneTypeValid = typeSpec.types.reduce((isValid, curType) => {
       try {
         checkType(customTypes, curType, value);
@@ -174,24 +134,16 @@ function checkType(customTypes, typeSpec, value) {
       throw Error(`Argument ${sqStr(name)} can be of several types, but is not valid for any: ${value}`);
     }
   } else {
-    throw Error('type ' + typeSpec.type + ' is an unknown type');
+    throw Error("type " + typeSpec.type + " is an unknown type");
   }
-
   return true;
 }
-
-/**
- * Given a value and a typelist, ensure the value abides by the typelist
- * @param types custom defined types
- * @param typeList A list of types to check
- * @param args The properties object to check against
- */
 function checkTypeList(customTypes, typeList, args) {
-  typeList.forEach(nextType => {
-    if (args[nextType.name] !== undefined) {
+  typeList.forEach((nextType) => {
+    if (args[nextType.name] !== void 0) {
       checkType(customTypes, nextType, args[nextType.name]);
     } else if (!nextType.optional) {
-      throw Error('you must include a value for ' + nextType.name);
+      throw Error("you must include a value for " + nextType.name);
     }
   });
 }

package/dist/cjs/src/extModules/geohasher.js

@@ -1,62 +1,45 @@
 'use strict';
 
-// Ported from https://github.com/JacksonTian/geohasher
-// to ESM as it was not bundling properly via Rollup as a CJS
-
-// Geohash library for Javascript
-// (c) 2008 David Troy
-// (c) 2010 Chris Williams
-// (c) 2013 Jackson Tian
-// Distributed under the MIT License
-
 const BITS = [16, 8, 4, 2, 1];
-
-const BASE32 = '0123456789bcdefghjkmnpqrstuvwxyz';
-
+const BASE32 = "0123456789bcdefghjkmnpqrstuvwxyz";
 const NEIGHBORS = {
-  right: { even: 'bc01fg45238967deuvhjyznpkmstqrwx' },
-  left: { even: '238967debc01fg45kmstqrwxuvhjyznp' },
-  top: { even: 'p0r21436x8zb9dcf5h7kjnmqesgutwvy' },
-  bottom: { even: '14365h7k9dcfesgujnmqp0r2twvyx8zb' },
+  right: { even: "bc01fg45238967deuvhjyznpkmstqrwx" },
+  left: { even: "238967debc01fg45kmstqrwxuvhjyznp" },
+  top: { even: "p0r21436x8zb9dcf5h7kjnmqesgutwvy" },
+  bottom: { even: "14365h7k9dcfesgujnmqp0r2twvyx8zb" }
 };
-
 const BORDERS = {
-  right: { even: 'bcfguvyz' },
-  left: { even: '0145hjnp' },
-  top: { even: 'prxz' },
-  bottom: { even: '028b' },
+  right: { even: "bcfguvyz" },
+  left: { even: "0145hjnp" },
+  top: { even: "prxz" },
+  bottom: { even: "028b" }
 };
-
 NEIGHBORS.bottom.odd = NEIGHBORS.left.even;
 NEIGHBORS.top.odd = NEIGHBORS.right.even;
 NEIGHBORS.left.odd = NEIGHBORS.bottom.even;
 NEIGHBORS.right.odd = NEIGHBORS.top.even;
-
 BORDERS.bottom.odd = BORDERS.left.even;
 BORDERS.top.odd = BORDERS.right.even;
 BORDERS.left.odd = BORDERS.bottom.even;
 BORDERS.right.odd = BORDERS.top.even;
-
 function calculateAdjacent(srcHash, dir) {
   srcHash = srcHash.toLowerCase();
   const lastChr = srcHash.charAt(srcHash.length - 1);
-  const type = srcHash.length % 2 ? 'odd' : 'even';
+  const type = srcHash.length % 2 ? "odd" : "even";
   let base = srcHash.substring(0, srcHash.length - 1);
   if (BORDERS[dir][type].indexOf(lastChr) !== -1) {
     base = calculateAdjacent(base, dir);
   }
   return base + BASE32[NEIGHBORS[dir][type].indexOf(lastChr)];
 }
-
 function encode(latitude, longitude, precision) {
   let isEven = 1;
-  const lat = [-90, 90.0];
-  const lng = [-180, 180.0];
+  const lat = [-90, 90];
+  const lng = [-180, 180];
   let bit = 0;
   let ch = 0;
   precision = precision || 12;
-
-  let geohash = '';
+  let geohash = "";
   while (geohash.length < precision) {
     let mid;
     if (isEven) {
@@ -76,7 +59,6 @@ function encode(latitude, longitude, precision) {
         lat[1] = mid;
       }
     }
-
     isEven = !isEven;
     if (bit < 4) {
       bit++;

package/dist/cjs/src/extModules/log.js

@@ -1,24 +1,21 @@
 'use strict';
 
-// https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
 const nodeColorsOb = {
-  black: '\x1b[30m',
-  red: '\x1b[31m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  magenta: '\x1b[35m',
-  cyan: '\x1b[36m',
-  white: '\x1b[37m',
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m"
 };
-
 function clog(name, options = {}) {
-  let prefix = name + ': ';
+  let prefix = name + ": ";
   let style = null;
-
   if (options.color) {
     if (options.isBrowser) {
-      prefix = '%c' + prefix;
+      prefix = "%c" + prefix;
       style = `color: ${options.color}`;
     } else {
       const cstring = nodeColorsOb[options.color];
@@ -27,14 +24,11 @@ function clog(name, options = {}) {
       }
     }
   }
-
-  const trunc = (str, len) => (str && str.length > len ? str.substring(0, len) + '...' : str);
-  const checkPassesFilter = (args, filter) =>
-    typeof filter === 'string' ? args[0].includes(filter) : filter.test(args[0]);
-
+  const trunc = (str, len) => str && str.length > len ? str.substring(0, len) + "..." : str;
+  const checkPassesFilter = (args, filter) => typeof filter === "string" ? args[0].includes(filter) : filter.test(args[0]);
   function logGen(cmethod) {
-    return function (...restArgs) {
-      const isEnabled = options.enabled === undefined ? true : !!options.enabled;
+    return function(...restArgs) {
+      const isEnabled = options.enabled === void 0 ? true : !!options.enabled;
       if (isEnabled || cmethod === console.error) {
         let args = [...restArgs];
         if (style) {
@@ -42,8 +36,8 @@ function clog(name, options = {}) {
         }
         args.unshift(prefix);
         if (options.truncateObjects && cmethod !== console.error) {
-          args = args.map(arg => {
-            if (typeof arg === 'object') {
+          args = args.map((arg) => {
+            if (typeof arg === "object") {
               return trunc(JSON.stringify(arg), parseInt(options.truncateObjects) || 100);
             }
             return arg;
@@ -56,24 +50,19 @@ function clog(name, options = {}) {
       }
     };
   }
-
   const log = logGen(options.trace ? console.trace : console.log);
   log.info = log;
   log.warn = logGen(console.warn);
   log.detailed = logGen(console.debug);
   log.error = logGen(console.error);
-
-  log.setEnabled = e => {
+  log.setEnabled = (e) => {
     options.enabled = e;
   };
-
   return log;
 }
-
 function initLog(name, options) {
   const log = clog(name, options);
-  log.sublog = (sublogName, sublogOptions) =>
-    initLog(name + '.' + sublogName, Object.assign(Object.create(options), sublogOptions));
+  log.sublog = (sublogName, sublogOptions) => initLog(name + "." + sublogName, Object.assign(Object.create(options), sublogOptions));
   return log;
 }
 

package/dist/cjs/src/historyManager.js

@@ -2,17 +2,15 @@
 
 const initHistoryManager = ({ bus }) => {
   const stepStack = [];
-  bus.on('history/register', ({ viewId, event, params = {} }) => {
+  bus.on("history/register", ({ viewId, event, params = {} }) => {
     stepStack.push({ viewId, event, params });
   });
-  bus.on('history/stepBack', () => {
+  bus.on("history/stepBack", () => {
     const layersToHide = [];
     const current = stepStack.pop();
-
     if (!current) {
       return;
     }
-
     layersToHide.push(current.viewId);
     for (let i = stepStack.length - 1; i >= 0; --i) {
       if (stepStack[i].event === current.event) {
@@ -22,11 +20,11 @@ const initHistoryManager = ({ bus }) => {
         break;
       }
     }
-    bus.send('layers/hideMultiple', layersToHide);
+    bus.send("layers/hideMultiple", layersToHide);
     const { event, params } = stepStack.pop();
     bus.send(event, params);
   });
-  bus.on('history/clean', () => {
+  bus.on("history/clean", () => {
     stepStack.length = 0;
   });
 };

package/dist/cjs/src/utils/bounds.js

@@ -3,17 +3,15 @@
 var R = require('ramda');
 
 function findBoundsOfWaypoints(waypoints) {
-  const latitudes = waypoints.map(R.path(['position', 'lat'])).filter(R.identity);
-  const longitudes = waypoints.map(R.path(['position', 'lng'])).filter(R.identity);
+  const latitudes = waypoints.map(R.path(["position", "lat"])).filter(R.identity);
+  const longitudes = waypoints.map(R.path(["position", "lng"])).filter(R.identity);
   return findBounds(latitudes, longitudes);
 }
-
 function findBoundsOfCoordinates(coordinates) {
   const latitudes = coordinates.map(R.prop(0)).filter(R.identity);
   const longitudes = coordinates.map(R.prop(1)).filter(R.identity);
   return findBounds(latitudes, longitudes);
 }
-
 function findBounds(latitudes, longitudes) {
   const n = Math.max(...latitudes);
   const s = Math.min(...latitudes);

package/dist/cjs/src/utils/buildStructureLookup.js

@@ -21,17 +21,17 @@ function _interopNamespaceDefault(e) {
 
 var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
 
-const buildStructuresLookup = structures => {
-  const floors = R__namespace.mergeAll(structures.map(R__namespace.prop('levels')));
-  const floorIdToFloor = floorId => floors[floorId];
-  const floorIdToOrdinal = R__namespace.pipe(floorIdToFloor, R__namespace.prop('ordinal'));
-  const floorIdToStructure = floorId => R__namespace.find(R__namespace.path(['levels', floorId]), structures);
-  const floorIdToStructureId = R__namespace.pipe(floorIdToStructure, R__namespace.prop('id'));
+const buildStructuresLookup = (structures) => {
+  const floors = R__namespace.mergeAll(structures.map(R__namespace.prop("levels")));
+  const floorIdToFloor = (floorId) => floors[floorId];
+  const floorIdToOrdinal = R__namespace.pipe(floorIdToFloor, R__namespace.prop("ordinal"));
+  const floorIdToStructure = (floorId) => R__namespace.find((s) => s.levels && s.levels[floorId])(structures);
+  const floorIdToStructureId = (floorId) => floorIdToStructure(floorId)?.id;
   return {
     floorIdToOrdinal,
     floorIdToFloor,
     floorIdToStructureId,
-    floorIdToStructure,
+    floorIdToStructure
   };
 };
 

package/dist/cjs/src/utils/configUtils.js

@@ -1,72 +1,36 @@
 'use strict';
 
-/**
- * Follows a localization scheme of checking for named values with locales appended,
- * and checking more generally if values not found.
- *
- * For example, calling getLocalized("foo", "es-MX", "bar") would check the following keys in this order:
- *  "foo-es-MX"
- *  "foo-es"
- *  "foo"
- *
- * As soon as a value is found, it is returned, else the checks continue. If no value is found from any of these,
- * the def value is returned. (If def is undefined, the undefined is returned)
- *
- * @param  {object} config the configuration to inspect
- * @param  {string} name root key name to look up
- * @param  {string} lang language code
- * @param  {any} def default value to return if no value is found through localized checks
- */
 function getLocalized(config, name, lang, def) {
   let key = name;
   if (lang) {
-    key += '-' + lang;
+    key += "-" + lang;
   }
-
   const value = config[key];
-
   if (value) {
     return value;
   }
-
   if (lang) {
-    if (lang.indexOf('-') > 0) // we have sublocales, so strip last one and try again
-    {
-      return getLocalized(config, name, lang.substring(0, lang.indexOf('-')), def);
-    }
-    // no sublanguage, so next is try the name on its own
-    else {
+    if (lang.indexOf("-") > 0) {
+      return getLocalized(config, name, lang.substring(0, lang.indexOf("-")), def);
+    } else {
       return getLocalized(config, name, null, def);
     }
   }
-
-  // we are here means we just checked the name (no lang arg) and there was no value found, so
-  // we simply return the def
   return def;
 }
-
-// A debug property is considered "true" if:
-//  The key is defined as a property within the debug object AND
-//  the value of that key is not "no" or "false" or false (boolean) or undefined or null
-// Any other value will be considered true - even 0 and ""
 function debugIsTrue(app, key) {
   if (!app.config.debug) {
     return false;
   }
-
   let value = app.config.debug[key];
-
-  if (value === undefined || value === null || value === false) {
+  if (value === void 0 || value === null || value === false) {
     return false;
   }
-
   if (value === true) {
     return true;
   }
-
-  value = value.toLowerCase ? value.toLowerCase() : value; // lower case it if possible
-
-  return value !== 'no' && value !== 'false';
+  value = value.toLowerCase ? value.toLowerCase() : value;
+  return value !== "no" && value !== "false";
 }
 
 exports.debugIsTrue = debugIsTrue;

package/dist/cjs/src/utils/date.js

@@ -2,28 +2,16 @@
 
 var luxon = require('luxon');
 
-/**
- * Pass in a luxon DateTime object and receive a simple formatted time string
- * This adjusts for odd handling of Icelandic times by Chromium/Blink browser engines.
- * @param {DateTime|Date} datetime A JS Date or a luxon DateTime holding the time you wish to display
- * @param {string} locale The locale (2 character country code - plus optional variant)
- * @returns {string} A time formatted for display
- */
-const formatTime = (datetime, locale = 'en') => {
+const formatTime = (datetime, locale = "en") => {
   if (datetime instanceof Date) {
-    datetime = luxon.DateTime(datetime);
+    datetime = luxon.DateTime.fromJSDate(datetime);
   }
-
-  // The following is to force Icelandic (is) locale to display in 24 hour format (the "ca" locale
-  // is an arbitrarily selected locale that uses 24 hour format)
-  // This is due to Chrome/Chromium/Blink not supporting Icelandic well. See https://issues.chromium.org/issues/40624456
-  if (locale === 'is') {
-    locale = 'ca';
+  if (locale === "is") {
+    locale = "ca";
   }
-
   return datetime.setLocale(locale).toLocaleString(luxon.DateTime.TIME_SIMPLE);
 };
-const msToMin = ms => Math.ceil(ms / 60 / 1000);
+const msToMin = (ms) => Math.ceil(ms / 60 / 1e3);
 
 exports.formatTime = formatTime;
 exports.msToMin = msToMin;

package/dist/cjs/src/utils/distance.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const yardsPerMeter = 1.0936132983377; // 1 meter ≈ 1.0936 yards
-const metersToYards = meters => Math.round(meters * yardsPerMeter);
+const yardsPerMeter = 1.0936132983377;
+const metersToYards = (meters) => Math.round(meters * yardsPerMeter);
 
 exports.metersToYards = metersToYards;