atriusmaps-node-sdk 3.3.898 → 3.3.899

package/dist/cjs/nodesdk/nodeEntry.js

@@ -10,50 +10,36 @@ 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';
-
+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));
-
+  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 pad2 = (x) => x.toString().length < 2 ? "0" + x : x;
 const ts = () => {
-  const d = new Date();
+  const d = /* @__PURE__ */ new Date();
   return `${d.getHours()}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}.${d.getMilliseconds()}`;
 };
 const logPre = () => `AtriusMaps Node SDK (${ts()}): `;
-const log = function (...logArgs) {
+const log = function(...logArgs) {
   if (sdkLogging) {
-    let msg =
-      logPre() +
-      Array.from(logArgs)
-        .map(arg => (typeof arg === 'object' ? JSON.stringify(arg) : arg))
-        .join(' ');
-    const lines = msg.split('\n');
+    let msg = logPre() + Array.from(logArgs).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)`;
+      msg = lines[0] + `\u2026 (+ ${lines.length - 1} lines)`;
     } else if (msg.length > 256) {
-      msg = msg.substring(0, 255) + `… (length: ${msg.length} chars)`;
+      msg = msg.substring(0, 255) + `\u2026 (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 (...args) {
+  commands.forEach((sig) => {
+    map[sig.command] = function(...args) {
       const cob = { command: sig.command };
       for (let i = 0; i < args.length; i++) {
         cob[sig.args[i].name] = args[i];
@@ -62,59 +48,51 @@ function addCommands(map, commands) {
     };
   });
 }
-
 async function newMap(sdkConfig) {
-  return new Promise(resolve => {
+  return new Promise((resolve) => {
     sdkConfig.headless = true;
-
-    setupFetch(sdkConfig); // This installs the fetch function globally (overriding native if exists)
-
+    setupFetch(sdkConfig);
     const config = prepareSDKConfig(sdkConfig);
-    config.plugins.monitoring = null; // disable inherited browser-only monitoring plugin in the Node SDK path
-
-    controller.create(config).then(app => {
+    config.plugins.monitoring = null;
+    controller.create(config).then((app) => {
       const map = (payload, arg2) => {
-        if (typeof payload === 'string') {
+        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;
-          });
+        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);
+          throw e;
+        });
       };
-      // map._app = app
-
-      observable(map); // make map handle events pub/sub
-      app.eventListener.observe(function (...args) {
+      observable(map);
+      app.eventListener.observe(function(...args) {
         map.fire(...args);
-      }); // pass it on...
-
-      map.on('ready', (eName, data) => {
-        const { commands /*, customTypes */ } = data.commandJSON;
+      });
+      map.on("ready", (eName, data) => {
+        const {
+          commands
+          /*, customTypes */
+        } = data.commandJSON;
         addCommands(map, commands);
         resolve(map);
-        log('map ready');
+        log("map ready");
       });
     });
   });
 }
-
 const Init = {
   getVersion: () => version,
-  newMap: config => newMap(config),
-  setLogging: flag => {
+  newMap: (config) => newMap(config),
+  setLogging: (flag) => {
     sdkLogging = flag;
     if (flag) {
       log(`${LIB_NAME} v${version} Logging enabled.`);
     }
-  },
+  }
 };
 
 module.exports = Init;

package/dist/cjs/package.json.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var name = "web-engine";
-var version = "3.3.898";
+var version = "3.3.899";
 var license = "UNLICENSED";
 var type = "module";
 var main = "src/main.ts";
@@ -17,7 +17,7 @@ var workspaces = [
 ];
 var scripts = {
 	"build-storybook": "storybook build",
-	colors: "cat utils/colors1.txt && node --experimental-strip-types utils/processColors.ts | pbcopy && cat utils/colors2.txt",
+	colors: "cat utils/colors1.txt && node utils/processColors.ts | pbcopy && cat utils/colors2.txt",
 	demo: "cd demo/ && yarn start",
 	dev: "yarn mol e2e",
 	"format:check": "yarn prettier . --check",
@@ -43,7 +43,8 @@ var scripts = {
 	"test:comp:ui": "VITE_COMP_UI=1 vitest --project browser --ui --browser.headless=false",
 	"test:all": "yarn lint && yarn format:check && yarn test && yarn playwright:ci",
 	"test:mod": "playwright test --config=playwright.mod.config.ts",
-	typecheck: "tsc -p tsconfig.checkjs.json"
+	typecheck: "tsc -p tsconfig.checkjs.json",
+	"typecheck:strict": "tsc -p tsconfig.strict.json"
 };
 var browserslist = [
 	"defaults"
@@ -113,6 +114,7 @@ var devDependencies = {
 	"@azure/identity": "^4.13.0",
 	"@azure/playwright": "^1.0.0",
 	"@playwright/test": "~1.59.1",
+	"@rollup/plugin-typescript": "^12.3.0",
 	"@storybook/addon-essentials": "^8.6.15",
 	"@storybook/blocks": "^8.6.15",
 	"@storybook/react": "^8.6.15",
@@ -121,6 +123,7 @@ var devDependencies = {
 	"@testing-library/jest-dom": "^6.6.3",
 	"@testing-library/react": "^16.3.0",
 	"@testing-library/user-event": "^14.5.2",
+	"@types/luxon": "^3.7.2",
 	"@types/react": "^19.0.10",
 	"@types/react-dom": "^19.0.4",
 	"@typescript-eslint/eslint-plugin": "^8.26.1",
@@ -144,6 +147,7 @@ var devDependencies = {
 	"nx-remotecache-azure": "^19.0.0",
 	"os-browserify": "^0.3.0",
 	prettier: "^3.8.3",
+	"rollup-plugin-esbuild": "^6.2.1",
 	"start-server-and-test": "^2.0.11",
 	storybook: "^8.6.15",
 	typescript: "^5.8.2",
@@ -175,7 +179,7 @@ var pkg = {
 		"prettier --check"
 	],
 	"src/i18n/**/*.json": [
-		"node --experimental-strip-types utils/sort-json.ts",
+		"node utils/sort-json.ts",
 		"prettier --write"
 	]
 },

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

@@ -4,14 +4,16 @@ var index = require('../../../src/extModules/flexapi/src/index.js');
 
 function create(app) {
   const api = index();
-  app.bus.on('clientAPI/registerCommand', ob =>
-    api.registerCommand(ob, cob => app.bus.get(`clientAPI/${cob.command}`, cob)),
+  app.bus.on(
+    "clientAPI/registerCommand",
+    (ob) => api.registerCommand(ob, (cob) => app.bus.get(`clientAPI/${cob.command}`, cob))
   );
-  app.bus.on('clientAPI/registerCustomType', ({ name, spec }) => api.registerCustomType(name, spec));
-  app.bus.on('clientAPI/execute', cob => api.execute(cob));
-
+  app.bus.on("clientAPI/registerCustomType", ({ name, spec }) => api.registerCustomType(name, spec));
+  app.bus.on("clientAPI/execute", (cob) => api.execute(cob));
   return {
-    init: () => {}, // nothing more to do
+    init: () => {
+    }
+    // nothing more to do
   };
 }
 

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

@@ -3,129 +3,65 @@
 var Zousan = require('zousan');
 var processors = require('./processors.js');
 
-/*
-    This service obtains dynamic POI data from our own backend REST API service.
-    Currently it drives dynamic data for Security Wait Times and Parking Status.
-
-    Configuration Properties Recognized:
-      urlBase : to override the REST url base. i.e. for alpha use 'https://rest-alpha.locuslabs.com/v1'. You can also reference
-          a local file, such as './testDynamicPois.json'
-
-    Values defined by 'parking':
-      lotName: Name of the lot for this POI, such as 'East'
-      lotStatus: returns either 'Closed' or 'Open'
-      timeIsReal: If true, the time here is live and valid, else its a default fallback
-      rateDay: Daily Rate expressed in English: '$17 per day'
-      rateHour: Hourly Rate expressed in English: '$5 per hour'
-      timeToTerminal1: Time in walking or by shuttle to Terminal 1 : 'Shuttle 5-7'
-      timeToTerminal2: Time in nwalking or by shuttle to Terminal 2 : 'Walking 5-10'
-      lastUpdated: timestamp of last update (as sent by server)
-
-    Values defined by 'security'
-      queueTime: Estimated Time in queue (in minutes) : i.e. 45
-      isTemporarilyClosed: If true, this line is closed - else it is open
-      timeIsReal: If true, the time here is live and valid, else its a default fallback
-      lastUpdated: timestamp of last update (as sent by server)
- */
-
-
-let REFRESH_FREQUENCY = 1000 * 30; // every 30 seconds
-const MARKETPLACE_URL_BASE = 'https://marketplace.locuslabs.com';
-
-const MAX_FETCH_FAILS = 3; // 3 strikes and you're out!
-
-const ACCOUNT_ID_HEADER = 'x-account-id';
-const isObject = value => typeof value === 'object' && value !== null && !Array.isArray(value);
-
+let REFRESH_FREQUENCY = 1e3 * 30;
+const MARKETPLACE_URL_BASE = "https://marketplace.locuslabs.com";
+const MAX_FETCH_FAILS = 3;
+const ACCOUNT_ID_HEADER = "x-account-id";
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function create(app, config = {}) {
   const state = {
-    dynamicDataNotPending: new Zousan(),
+    dynamicDataNotPending: new Zousan()
   };
   const T = app.gt();
-
-  /**
-   * Returns security checkpoint POIs that have dynamic security data.
-   *
-   * @param {{ isOpen?: boolean }} [options] Optional open-state filter. Omit to return all checkpoints,
-   * set to true for open checkpoints, or false for temporarily closed checkpoints.
-   * @returns {Promise<Array<{id: number, name: string, queueTime?: number, isTemporarilyClosed?: boolean, timeIsReal?: boolean, lastUpdated?: string}>>}
-   */
   const getSecurityWaitTimes = async ({ isOpen } = {}) => {
-    const pois = await app.bus.get('poi/getAll');
-    return Object.values(pois)
-      .filter(
-        poi =>
-          poi.category === 'security.checkpoint' &&
-          poi?.dynamicData?.security &&
-          isObject(poi?.dynamicData?.security) &&
-          (isOpen === undefined ? true : poi?.dynamicData?.security?.isTemporarilyClosed !== isOpen),
-      )
-      .map(poi => ({
-        id: poi.poiId,
-        name: poi.name,
-        ...poi.dynamicData.security,
-      }));
+    const pois = await app.bus.get("poi/getAll");
+    return Object.values(pois).filter(
+      (poi) => poi.category === "security.checkpoint" && poi?.dynamicData?.security && isObject(poi?.dynamicData?.security) && (isOpen === void 0 ? true : poi?.dynamicData?.security?.isTemporarilyClosed !== isOpen)
+    ).map((poi) => ({
+      id: poi.poiId,
+      name: poi.name,
+      ...poi.dynamicData.security
+    }));
   };
-
-  // used in testing
   if (config._overrideRefreshFrequency) {
     REFRESH_FREQUENCY = config._overrideRefreshFrequency;
   }
-
-  // Tracks the last-emitted name override per POI to detect changes across poll cycles.
-  // poiId (string) -> string | null
-  const previousNameOverrides = new Map();
-
-  // by returning this dynamicDataLoaded promise, we hold sdkReady event until this is resolved
-  app.bus.on('system/readywhenyouare', () => state.dynamicDataNotPending);
-  app.bus.on('dynamicPois/getSecurityWaitTimes', getSecurityWaitTimes);
-
+  const previousNameOverrides = /* @__PURE__ */ new Map();
+  app.bus.on("system/readywhenyouare", () => state.dynamicDataNotPending);
+  app.bus.on("dynamicPois/getSecurityWaitTimes", getSecurityWaitTimes);
   const init = async () => {
     const [accountId, venueId] = await Promise.all([
-      app.bus.get('venueData/getAccountId'),
-      app.bus.get('venueData/getVenueId'),
+      app.bus.get("venueData/getAccountId"),
+      app.bus.get("venueData/getVenueId")
     ]);
-
     const dynamicPoisUrl = `${MARKETPLACE_URL_BASE}/venueId/${venueId}/dynamic-poi`;
-
     let fetchFailuresCount = 0;
     let fetchSuccessCount = 0;
     let fetchIntervalHandle;
     const updateFromAPI = async () => {
       const response = await fetch(dynamicPoisUrl, {
-        headers: { [ACCOUNT_ID_HEADER]: accountId },
+        headers: { [ACCOUNT_ID_HEADER]: accountId }
       });
-      if (response.ok) // 404 if customer does not have dynamic POIs
-      {
-        return response
-          .json()
-          .then(({ data }) => processDynamicPois(data))
-          .then(() => {
-            fetchSuccessCount++;
-          })
-          .catch(console.error);
+      if (response.ok) {
+        return response.json().then(({ data }) => processDynamicPois(data)).then(() => {
+          fetchSuccessCount++;
+        }).catch(console.error);
       } else {
-        console.warn('dynamicPois: fetch response status not ok', response);
+        console.warn("dynamicPois: fetch response status not ok", response);
         fetchFailuresCount++;
-        // Don't keep trying after multiple fails unless past success is at least 50%
         if (fetchFailuresCount >= MAX_FETCH_FAILS && fetchFailuresCount > fetchSuccessCount) {
           clearInterval(fetchIntervalHandle);
         }
       }
     };
-
-    await updateFromAPI()
-      .then(() => {
-        fetchIntervalHandle = setInterval(updateFromAPI, REFRESH_FREQUENCY);
-        if (typeof fetchIntervalHandle.unref === 'function') {
-          fetchIntervalHandle.unref();
-        } // Node only - do not keep-alive Lambda or other short-term environments
-      })
-      .finally(() => state.dynamicDataNotPending.resolve(true)); // even in case of failure, we don't want to hold up the UI
-
+    await updateFromAPI().then(() => {
+      fetchIntervalHandle = setInterval(updateFromAPI, REFRESH_FREQUENCY);
+      if (typeof fetchIntervalHandle.unref === "function") {
+        fetchIntervalHandle.unref();
+      }
+    }).finally(() => state.dynamicDataNotPending.resolve(true));
     return () => clearInterval(fetchIntervalHandle);
   };
-
   async function processDynamicPois(pois) {
     processParkingPOIS(pois);
     processOpenClosedPois(pois);
@@ -133,108 +69,80 @@ function create(app, config = {}) {
     processDynamicRouting(pois);
     processDynamicAttributes(pois);
   }
-
-  /**
-   * Extracts `dynamicData.poiAttributes.name` overrides from each POI in the API response and emits
-   * `poi/setCoreAttributes` and `map/mutateFeature` for any changes. A `null` name signals a revert to the original value.
-   * Only emits when a value actually changes to avoid unnecessary downstream updates.
-   *
-   * @param {Object} poiDataMap - The `data` map from the /dynamic-poi API response
-   */
   async function processDynamicAttributes(poiDataMap) {
     const updates = {};
-
     for (const [poiId, poiData] of Object.entries(poiDataMap)) {
       const name = poiData?.dynamicData?.poiAttributes?.name ?? null;
-      const previous = previousNameOverrides.get(poiId); // undefined if never tracked
-
-      if (previous === undefined) {
-        // First time seeing this POI: only track and emit if there's an actual name override
+      const previous = previousNameOverrides.get(poiId);
+      if (previous === void 0) {
         if (name !== null) {
           updates[poiId] = { name };
           previousNameOverrides.set(poiId, name);
         }
       } else if (previous !== name) {
-        // Value changed (including override → null revert)
         updates[poiId] = { name };
         previousNameOverrides.set(poiId, name);
       }
     }
-
-    // Emit null for any POIs that were previously overridden but are no longer in the response
     for (const [poiId, prevName] of previousNameOverrides.entries()) {
       if (!(poiId in poiDataMap) && prevName !== null) {
         updates[poiId] = { name: null };
         previousNameOverrides.set(poiId, null);
       }
     }
-
     if (Object.keys(updates).length > 0) {
-      app.bus.send('poi/setCoreAttributes', updates);
+      app.bus.send("poi/setCoreAttributes", updates);
       const originalNames = await getPoiOriginalNames(Object.keys(updates));
-      app.bus.send('map/mutateFeature', {
-        functor: processors.mutatePoiName(T, updates, originalNames),
+      app.bus.send("map/mutateFeature", {
+        functor: processors.mutatePoiName(T, updates, originalNames)
       });
     }
   }
-
   function processParkingPOIS(poiMap) {
     const idValuesMap = processors.processParkingPOIS(poiMap);
-    app.bus.send('poi/setDynamicData', { plugin: 'parking', idValuesMap });
+    app.bus.send("poi/setDynamicData", { plugin: "parking", idValuesMap });
   }
-
-  const getPOILabels = async idArray => {
+  const getPOILabels = async (idArray) => {
     const nameMap = {};
     for (const poiId of idArray) {
-      const poi = await app.bus.get('poi/getById', { id: poiId });
+      const poi = await app.bus.get("poi/getById", { id: poiId });
       if (poi) {
         nameMap[poiId] = poi.name;
       }
     }
     return nameMap;
   };
-
-  const getPoiOriginalNames = async idArray => {
+  const getPoiOriginalNames = async (idArray) => {
     const nameMap = {};
     for (const poiId of idArray) {
-      const poi = await app.bus.get('poi/getById', { id: poiId });
+      const poi = await app.bus.get("poi/getById", { id: poiId });
       if (poi) {
         nameMap[poiId] = poi._originalName ?? poi.name;
       }
     }
     return nameMap;
   };
-
-  /*
-          API response: https://gitlab.com/locuslabs/core-data-team/json-schemas/-/blob/develop/src/api-marketplace/dynamic-queue-data.json
-         */
   async function processSecurityWaitTimes(poiMap) {
     const idValuesMap = processors.processSecurityWaitTimes(poiMap);
-
-    app.bus.send('poi/setDynamicData', { plugin: 'security', idValuesMap });
-
-    const labels = await getPOILabels(Object.keys(idValuesMap)); // get a map of labels for the POIs - used in wait time labeling
-
-    app.bus.send('map/mutateFeature', {
-      functor: processors.mutateSecurityCheckpointLabel(T, idValuesMap, labels),
+    app.bus.send("poi/setDynamicData", { plugin: "security", idValuesMap });
+    const labels = await getPOILabels(Object.keys(idValuesMap));
+    app.bus.send("map/mutateFeature", {
+      functor: processors.mutateSecurityCheckpointLabel(T, idValuesMap, labels)
     });
   }
-
   function processOpenClosedPois(poiMap) {
     const idValuesMap = processors.processOpenClosedPois(poiMap);
-    app.bus.send('poi/setDynamicData', {
-      plugin: 'open-closed-status',
-      idValuesMap,
+    app.bus.send("poi/setDynamicData", {
+      plugin: "open-closed-status",
+      idValuesMap
     });
   }
-
   async function processDynamicRouting(poiMap) {
     const idValuesMap = await processors.processRoutingPois(poiMap);
-    app.bus.send('poi/setDynamicRouting', { plugin: 'routing', idValuesMap });
+    app.bus.send("poi/setDynamicRouting", { plugin: "routing", idValuesMap });
   }
-
   return {
-    init,
+    init
   };
 }
 

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

@@ -21,29 +21,21 @@ function _interopNamespaceDefault(e) {
 
 var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
 
-/**
- *
- * @param {Record<Number, DynamicQueueTime} queueTimes A map of POI Ids to dynamic queue times
- * @param {Record<Number, String>} labels A map of POI Ids to map labels
- * @param {*} feature A GeoJson feature
- * @returns feature
- */
-const mutateSecurityCheckpointLabel = (T, queueTimes, labels) => feature => {
+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?
     const { queueTime, isTemporarilyClosed } = dynamicData;
-    const secondaryText = isTemporarilyClosed ? T('ui:Closed') : T('ui:_xx_ minute wait', { count: queueTime });
-    feature.properties.text = `${label}\n${secondaryText}`;
+    const secondaryText = isTemporarilyClosed ? T("ui:Closed") : T("ui:_xx_ minute wait", { count: queueTime });
+    feature.properties.text = `${label}
+${secondaryText}`;
   }
   return feature;
 };
-
-const mutatePoiName = (_T, nameOverrides, originalNames) => feature => {
+const mutatePoiName = (_T, nameOverrides, originalNames) => (feature) => {
   const id = feature.properties?.id;
-  const override = id !== undefined && nameOverrides?.[String(id)];
+  const override = id !== void 0 && nameOverrides?.[String(id)];
   if (!override) {
     return feature;
   }
@@ -58,71 +50,57 @@ const mutatePoiName = (_T, nameOverrides, originalNames) => feature => {
   }
   return feature;
 };
-
-const processParkingPOIS = poiMap => {
+const processParkingPOIS = (poiMap) => {
   const idValuesMap = R__namespace.pipe(
-    R__namespace.filter(poi => poi.category === 'parking'),
-    R__namespace.map(poi => {
+    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,
-            };
-
+      const age = (Date.now() - poi.timestamp) / 1e3;
+      const props = age < da["parking.timeToLive"] ? R__namespace.pick(["lotStatus", "rateDay", "rateHour", "timeIsReal", "timeToTerminal1", "timeToTerminal2"], poi) : {
+        lotStatus: da["parking.default"],
+        rateDay: "$ -",
+        rateHour: "$ -",
+        timeIsReal: false
+      };
       return { ...props, lastUpdated: poi.timestamp, lotName: poi.lotName };
-    }),
+    })
   )(poiMap);
   return idValuesMap;
 };
-
-const processOpenClosedPois = poiMap => {
-  const pathToOpenClosedData = ['dynamicData', 'openClosed'];
+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);
-
-  if (R__namespace.all(R__namespace.both(R__namespace.has('isOpen'), R__namespace.has('expiration')), R__namespace.values(openClosedStatuses))) {
-    const isExpired = R__namespace.pipe(R__namespace.prop('expiration'), R__namespace.lt(Date.now()));
+  if (R__namespace.all(R__namespace.both(R__namespace.has("isOpen"), R__namespace.has("expiration")), R__namespace.values(openClosedStatuses))) {
+    const isExpired = R__namespace.pipe(R__namespace.prop("expiration"), R__namespace.lt(Date.now()));
     const idValuesMap = R__namespace.filter(isExpired, openClosedStatuses);
-
     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 queuePath = ['dynamicData', 'queue'];
+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 => ({
+    (queue) => ({
       isTemporarilyClosed: queue.isTemporarilyClosed,
       queueTime: queue.queueTime,
       timeIsReal: !queue.isQueueTimeDefault && queue.expiration > Date.now(),
-      lastUpdated: Date.now(),
+      lastUpdated: Date.now()
     }),
-    queues,
+    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 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);
 };