atriusmaps-node-sdk 3.3.898 → 3.3.900

package/dist/cjs/plugins/venueDataLoader/src/venueLoadingUtils.js

@@ -27,98 +27,65 @@ const fetchURL = async (token, url) => {
     return fetch(url);
   }
 };
-
-const createFetchJson = token => url => fetchURL(token, url).then(response => response.json());
-const createFetchText = token => url => fetchURL(token, url).then(response => response.text());
-
-const baseContentUrl = contentStage => `https://api.content.locuslabs.com/${contentStage}`;
-
+const createFetchJson = (token) => (url) => fetchURL(token, url).then((response) => response.json());
+const createFetchText = (token) => (url) => fetchURL(token, url).then((response) => response.text());
+const baseContentUrl = (contentStage) => `https://api.content.locuslabs.com/${contentStage}`;
 const remapContentUrl = (url, category, contentStage, accountId, venueId, key) => {
-  if (key === 'theme' || key === 'style') {
+  if (key === "theme" || key === "style") {
     return `${baseContentUrl(contentStage)}/${category}/${key}/${venueId}/${accountId}/${key}.json`;
   }
   return url.replace(/https:\/\/content.locuslabs.com/gi, baseContentUrl(contentStage));
 };
-
-const remapEachURLForContentStage = (category, files, contentStage, accountId, venueId) =>
-  R__namespace.mapObjIndexed((file, key) => remapContentUrl(file, category, contentStage, accountId, venueId, key), files);
-
-const getContentStage = vconfig => {
+const remapEachURLForContentStage = (category, files, contentStage, accountId, venueId) => R__namespace.mapObjIndexed((file, key) => remapContentUrl(file, category, contentStage, accountId, venueId, key), files);
+const getContentStage = (vconfig) => {
   const stage = vconfig.deepLinkProps ? vconfig.deepLinkProps.contentStage : null;
-  return stage === 'alpha' || stage === 'beta' || stage === 'prod' ? stage : null;
+  return stage === "alpha" || stage === "beta" || stage === "prod" ? stage : null;
 };
-
-// Groups of locale tags that refer to the same language variant and should match each other
-// when no exact match is available. zh-CN/zh-SG use simplified script; zh-TW/zh-HK/zh-MO use traditional.
 const LOCALE_ALIAS_GROUPS = [
-  ['zh-CN', 'zh-SG', 'zh-Hans'],
-  ['zh-TW', 'zh-HK', 'zh-MO', 'zh-Hant'],
+  ["zh-CN", "zh-SG", "zh-Hans"],
+  ["zh-TW", "zh-HK", "zh-MO", "zh-Hant"]
 ];
-
-const getLocaleAliases = locale => {
-  const group = LOCALE_ALIAS_GROUPS.find(g => g.includes(locale));
-  return group ? group.filter(l => l !== locale) : [];
+const getLocaleAliases = (locale) => {
+  const group = LOCALE_ALIAS_GROUPS.find((g) => g.includes(locale));
+  return group ? group.filter((l) => l !== locale) : [];
 };
-
-// Three tiers of locale match, from most to least specific. Returned as predicates
-// so the resolver below can walk all venues at each tier before falling to the next.
-//   1. Exact full-tag match (e.g. "zh-Hans" === "zh-Hans")
-//   2. Known aliases (e.g. browser "zh-CN" matches venue "zh-Hans")
-//   3. Two-char language-subtag prefix on both sides (e.g. "fr-FR" vs "fr_CA" both reduce to "fr")
-const getLocaleMatchTiers = browserLang => {
+const getLocaleMatchTiers = (browserLang) => {
   const aliases = getLocaleAliases(browserLang);
   const prefix = browserLang.slice(0, 2);
   return [
-    locale => locale === browserLang,
-    locale => aliases.includes(locale),
-    locale => locale.slice(0, 2) === prefix,
+    (locale) => locale === browserLang,
+    (locale) => aliases.includes(locale),
+    (locale) => locale.slice(0, 2) === prefix
   ];
 };
-
-// Resolve a browser locale to a venue. Within each tier, prefer `currentVenue` over
-// other siblings when both would match — this keeps the caller on their intended venue
-// when it satisfies the preference, and prevents a lower-tier match (e.g. "en" prefix)
-// from yanking a user off an exactly-matching region sibling.
 const findVenueForLocale = (venues, browserLang, currentVenue = null) => {
   for (const matches of getLocaleMatchTiers(browserLang)) {
     if (currentVenue && matches(currentVenue.locale)) {
       return currentVenue;
     }
-    const venue = venues.find(v => matches(v.locale));
+    const venue = venues.find((v) => matches(v.locale));
     if (venue) {
       return venue;
     }
   }
   return null;
 };
-
 const getVenueDataFromUrls = async (vconfig, fetchJson, languagesToTry) => {
   const stages = {
-    alpha: 'alpha-a.locuslabs.com',
-    beta: 'beta-a.locuslabs.com',
-    gamma: 'gamma-a.locuslabs.com',
-    prod: 'a.locuslabs.com',
+    alpha: "alpha-a.locuslabs.com",
+    beta: "beta-a.locuslabs.com",
+    gamma: "gamma-a.locuslabs.com",
+    prod: "a.locuslabs.com"
   };
-
   const { assetStage, accountId, formatVersion } = vconfig;
   let { venueId } = vconfig;
   const stageUrl = stages[assetStage] || stages.prod;
   const accountUrl = `https://${stageUrl}/accounts/${accountId}`;
-  const assetFormat = formatVersion || 'v5';
-
-  // Load the v5.json resource
-  const venueList =
-    vconfig.dataFetch && globalThis[vconfig.dataFetch] && globalThis[vconfig.dataFetch].getFiles
-      ? await globalThis[vconfig.dataFetch].getFiles(vconfig)
-      : await fetchJson(`${accountUrl}/${assetFormat}.json`);
-
-  // Reassign venue id to venueId+language preference if that venue in that language is available to us in the venue list.
-  // Only attempt language resolution when the venue has a venueCode (indicating language siblings may exist).
-  // Venues without a venueCode (e.g. custom tiled maps provided via dataFetch) skip resolution entirely.
+  const assetFormat = formatVersion || "v5";
+  const venueList = vconfig.dataFetch && globalThis[vconfig.dataFetch] && globalThis[vconfig.dataFetch].getFiles ? await globalThis[vconfig.dataFetch].getFiles(vconfig) : await fetchJson(`${accountUrl}/${assetFormat}.json`);
   const venueCode = venueList[venueId] ? venueList[venueId].venueCode : null;
-
   if (venueCode) {
-    const venuesWithSameVenueCode = Object.values(venueList).filter(v => v.venueCode === venueCode);
+    const venuesWithSameVenueCode = Object.values(venueList).filter((v) => v.venueCode === venueCode);
     const currentVenue = venueList[venueId];
     for (const browserLang of languagesToTry) {
       const venue = findVenueForLocale(venuesWithSameVenueCode, browserLang, currentVenue);
@@ -129,121 +96,75 @@ const getVenueDataFromUrls = async (vconfig, fetchJson, languagesToTry) => {
       }
     }
   }
-
   if (!venueList[venueId]) {
     throw Error(`Attempt to access venue ${venueId} which is not within venue list: ${Object.keys(venueList)}`);
   }
-  const files = venueList[venueId].files; // mapping of asset "types" (spritesheet, style, badges, etc) to their URL
-  const fetchedData =
-    vconfig.dataFetch && globalThis[vconfig.dataFetch] && globalThis[vconfig.dataFetch].getVenueData
-      ? await globalThis[vconfig.dataFetch].getVenueData(vconfig)
-      : await fetchJson(files.venueData);
-
+  const files = venueList[venueId].files;
+  const fetchedData = vconfig.dataFetch && globalThis[vconfig.dataFetch] && globalThis[vconfig.dataFetch].getVenueData ? await globalThis[vconfig.dataFetch].getVenueData(vconfig) : await fetchJson(files.venueData);
   const venueData = fetchedData[venueId];
-
-  // For tilemaps, we need to embellish the venue data with structure
   if (venueData.tileServerAuthInfo) {
     embellishTilemapVenueData(venueData);
   }
-
   venueData.venueList = venueList;
   const contentStage = getContentStage(vconfig);
-  venueData.files = contentStage // if a contentStage is defined, remap content URLs (see docs/Content-And-Asset-Loading/contentStaging.md)
-    ? remapEachURLForContentStage(venueData.category, files, contentStage, accountId, venueId)
-    : files;
-
+  venueData.files = contentStage ? remapEachURLForContentStage(venueData.category, files, contentStage, accountId, venueId) : files;
   return venueData;
 };
-
-const buildStructures = venueData => {
+const buildStructures = (venueData) => {
   const { structureOrder, structures } = venueData;
-  return structureOrder.map(structureId => {
+  return structureOrder.map((structureId) => {
     const structure = structures[structureId];
-    // Was going to use this for selecting floors - but it seems floor bounds are incorrect? (was testing LAX/lax-msc-2 for example)
-    Object.values(structure.levels).forEach(level => (level.bounds = bounds.findBoundsOfCoordinates(level.boundsPolygon)));
+    Object.values(structure.levels).forEach((level) => level.bounds = bounds.findBoundsOfCoordinates(level.boundsPolygon));
     const bounds$1 = bounds.findBoundsOfCoordinates(structure.boundsPolygon);
     return { ...structure, bounds: bounds$1 };
   });
 };
-
 function embellishTilemapVenueData(venueData) {
   const additionalFields = {
-    defaultOrdinal: 0, // this and below override the venue data
-    defaultStructureId: 'singleBuilding',
-    formatVersion: 'v5',
+    defaultOrdinal: 0,
+    // this and below override the venue data
+    defaultStructureId: "singleBuilding",
+    formatVersion: "v5",
     // Note: this structures object does not represent the "buildingsAndLevels" as
     // managed within this app. This is a mock structure for the purposes of rendering
     // a tiled map. It is always a single building, single floor. If user switches
     // buildings or floors, it unmounts this map and remounts a new map with that building/floor
     structures: {
       singleBuilding: {
-        name: 'singleBuilding',
+        name: "singleBuilding",
         boundsPolygon: [],
-        defaultLevelId: 'singleLevel',
-        id: 'singleBuilding',
+        defaultLevelId: "singleLevel",
+        id: "singleBuilding",
         levels: {
           singleLevel: {
             boundsPolygon: [],
             clfloor: 0,
-            details: '',
-            id: 'singleLevel',
-            name: 'singleLevel',
-            ordinal: 0,
-          },
-        },
-      },
+            details: "",
+            id: "singleLevel",
+            name: "singleLevel",
+            ordinal: 0
+          }
+        }
+      }
     },
-    structureOrder: ['singleBuilding'],
+    structureOrder: ["singleBuilding"]
   };
-
   for (const key in additionalFields) {
     venueData[key] = additionalFields[key];
   }
 }
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const between = (val, lim1, lim2) => (val > lim1 ? val <= lim2 : val => lim2);
-
-// exchanges the first and second items in an array, preserving the rest of the array untouched
-// i.e. [1,2,3,4,5] => [2,1,3,4,5]
+const between = (val, lim1, lim2) => val > lim1 ? val <= lim2 : (val2) => lim2;
 const swapFirstTwoItems = ([c1, c2, ...c3]) => [c2, c1, ...c3];
-
-/**
- * Since coordinates are often expressed as [lat, lng] but required by GeoJSON to be [lng, lat],
- * this function will take a list of coordinate pairs and ensure they are in the required format
- * by comparing to the venue bounds.
- *
- * @param  {array.array.float} coords list of coordinate pairs, such as [[36.3,-115.85], [36.5, -115.34]]
- * @param  {object} venueBounds contains props {ne, sw} which each are objects containing {lat,lng} properties
- * @returns {array.array.float} with [lng,lat,...] for each item
- */
 const normalizeCoords = (coords, venueBounds) => {
   if (!coords || !Array.isArray(coords) || coords.length < 1) {
     return coords;
   }
-
-  if (between(coords[0][0], venueBounds.ne.lng, venueBounds.sw.lng)) // looks like a lat - so already in proper order
-  {
+  if (between(coords[0][0], venueBounds.ne.lng, venueBounds.sw.lng)) {
     return coords;
   }
-
-  // wrong order, so swtich em
   return coords.map(swapFirstTwoItems);
 };
 
-// If config.useDynamicUrlParams is true, allow changing even security-related parameters in
-// the URL - else, only allow the changing of "end-user-changable" parameters, such as vid
-// export function updateConfigWithUrlParams (config) {
-//   const dlp = config.deepLinkProps
-//   if (dlp) {
-//     const venueId = dlp.vid ? dlp.vid : config.venueId
-//     const assetStage = config.useDynamicUrlParams && dlp.stage ? dlp.stage : config.assetStage
-//     const accountId = assetStage === 'alpha' ? 'A1VPTJKREFJWX5' : config.accountId
-//     return { ...config, venueId, assetStage, accountId }
-//   }
-//   return config
-// }
-
 exports.buildStructures = buildStructures;
 exports.createFetchJson = createFetchJson;
 exports.createFetchText = createFetchText;

package/dist/cjs/plugins/wayfinder/src/findRoute.js

@@ -22,102 +22,40 @@ function _interopNamespaceDefault(e) {
 
 var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
 
-const getEdgeTo = dst => node => R__namespace.find(e => e.dst === dst, node.edges);
-
-/**
- * Returns the shortest route (or path) from start to end.
- * @param  {Object} start must include {floorId, lat, lng}
- * @param  {Object} end must include {floorId, lat, lng}
- * @param  {Object} options optional settings for choosing route
- * @param  {boolean} options.requiresAccessibility if true, only accessible routes are returned (no stairs or escalators)
- * @returns {[nodes]} array of NavGraph nodes OR null if no route exists
- * @throws if start or end is not defined
- */
+const getEdgeTo = (dst) => (node) => R__namespace.find((e) => e.dst === dst, node.edges);
 const calculateRoute = (graph, start, end, options) => {
   if (!start || !end) {
-    throw Error('bad calculate Route request!');
+    throw Error("bad calculate Route request!");
   }
   return graph.findShortestPath(start, end, options);
 };
-
-/**
- * @typedef Waypoint
- * @property {FullPosition} position
- * @property {number} distance
- * @property {number} eta
- * @property {boolean} isSecurityCheckpoint
- * @property {boolean} isPortal
- * @property {string} portalType
- * @property {number} levelDifference
- * @property {boolean} isDestination
- * @property {SecurityWaitTime|null} securityWaitTimes
- * @property {SecurityLane|null} securityLane
- * @property {CurvedPath|null} curvedPathForward
- *
- * @typedef SecurityLane
- * @property {string} id
- * @property {string} type
- *
- * @typedef FullPosition
- * @property {string} floorId
- * @property {string} lat
- * @property {number} lng
- * @property {number} ordinal
- * @property {string} structureId
- *
- * @typedef {Array.<CurvedPoint>} CurvedPath
- *
- * @typedef CurvedPoint
- * @property {ObjCoordinate} end
- * @property {ObjCoordinate} in
- * @property {ObjCoordinate} out
- * @property {ObjCoordinate} start
- *
- * @typedef {{lng: number, lat: number}} ObjCoordinate
- *
- * Returns the shortest route (or path) from start to end.
- * @param graph
- * @param {Endpoint} start
- * @param {Endpoint} destination
- * @param {RouteOptions} options
- * @return {{waypoints: Array.<Waypoint>}|null}
- */
-// todo refactor
 const findRoute = (graph, start, destination, options = {}) => {
   const waypoints = [];
   const queues = [];
-
   let hasSecurity = false;
   let hasImmigration = false;
-
   const routeNodes = calculateRoute(graph, start, destination, options);
-
   if (routeNodes === null) {
     return null;
   }
-
   let previousRouteNode = null;
   for (let i = 0; i < routeNodes.length; i++) {
     const waypoint = {
       distance: 0,
-      eta: 0,
+      eta: 0
     };
-
     if (previousRouteNode) {
       const edgeUsed = getEdgeTo(routeNodes[i].id)(previousRouteNode);
       if (edgeUsed != null) {
         waypoint.distance = edgeUsed.distance;
         waypoint.eta = edgeUsed.transitTime;
-
-        if (edgeUsed.type !== 'Ground') {
+        if (edgeUsed.type !== "Ground") {
           waypoint.portalType = edgeUsed.type;
           waypoint.isPortal = true;
         }
-
         if (edgeUsed.o) {
           waypoint.poiId = edgeUsed.o;
         }
-
         if (edgeUsed.path) {
           waypoint.curvedPathForward = edgeUsed.path;
         }
@@ -125,7 +63,6 @@ const findRoute = (graph, start, destination, options = {}) => {
           waypoint.securityWaitTimes = edgeUsed.securityWaitTimes;
           waypoint.eta = waypoint.securityWaitTimes.queueTime;
         }
-
         if (edgeUsed.securityLane) {
           waypoint.securityLane = edgeUsed.securityLane;
           waypoint.isSecurityCheckpoint = true;
@@ -141,21 +78,17 @@ const findRoute = (graph, start, destination, options = {}) => {
         }
       }
     }
-
     waypoint.levelDifference = previousRouteNode ? routeNodes[i].ordinal - previousRouteNode.ordinal : 0;
-    waypoint.position = R__namespace.omit(['edges', 'id'], { ...routeNodes[i] });
-
+    waypoint.position = R__namespace.omit(["edges", "id"], { ...routeNodes[i] });
     waypoints.push(waypoint);
-
     previousRouteNode = routeNodes[i];
   }
   R__namespace.last(waypoints).isDestination = true;
-
   return {
     waypoints,
     queues,
     hasSecurity,
-    hasImmigration,
+    hasImmigration
   };
 };
 

package/dist/cjs/plugins/wayfinder/src/minPriorityQueue.js

@@ -2,88 +2,68 @@
 
 class MinPriorityQueue {
   constructor() {
-    this.heap = [null]; // array representation of binary heap
+    this.heap = [null];
     this.heapMap = {};
   }
-
   offerWithPriority(node, priority) {
     const index = this.heap.push([node, priority]) - 1;
-
     this.heapMap[node] = index;
     this.bubble(index);
   }
-
   raisePriority(node, priority) {
     const index = this.heapMap[node];
     this.heap[index][1] = priority;
-
     this.bubble(index);
   }
-
   poll() {
     if (this.heap.length === 1) {
       return null;
     }
     if (this.heap.length === 2) {
-      const value = this.heap.pop()[0];
-      delete this.heapMap[value];
-      return value;
+      const value2 = this.heap.pop()[0];
+      delete this.heapMap[value2];
+      return value2;
     }
-
     const value = this.heap[1][0];
     delete this.heapMap[value];
-
     this.heap[1] = this.heap.pop();
     this.heapMap[this.heap[1][0]] = 1;
-
     this.sink(1);
-
     return value;
   }
-
   isEmpty() {
     return this.heap.length === 1;
   }
-
   bubble(i) {
     while (i > 1) {
-      const parentIndex = i >> 1; // floor(i/2)
-
+      const parentIndex = i >> 1;
       if (!this.isHigherPriority(i, parentIndex)) {
         break;
       }
-
       this.swap(i, parentIndex);
       i = parentIndex;
     }
   }
-
   sink(i) {
     while (i * 2 < this.heap.length) {
-      const isRightChildHigherPriority =
-        this.heap[i * 2 + 1] === undefined ? false : this.isHigherPriority(i * 2 + 1, i * 2); // i*2 +1 might be null
+      const isRightChildHigherPriority = this.heap[i * 2 + 1] === void 0 ? false : this.isHigherPriority(i * 2 + 1, i * 2);
       const childIndex = isRightChildHigherPriority ? i * 2 + 1 : i * 2;
-
       if (this.isHigherPriority(i, childIndex)) {
         break;
       }
-
       this.swap(i, childIndex);
       i = childIndex;
     }
   }
-
   swap(i, j) {
     this.heapMap[this.heap[i][0]] = j;
     this.heapMap[this.heap[j][0]] = i;
-
     const temp = this.heap[i];
     this.heap[i] = this.heap[j];
     this.heap[j] = temp;
   }
-
   isHigherPriority(i, j) {
-    return this.heap[i][1] < this.heap[j][1]; // lower score -> higher priority
+    return this.heap[i][1] < this.heap[j][1];
   }
 }