atriusmaps-node-sdk 3.3.632 → 3.3.634

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

@@ -26,13 +26,13 @@ function _interopNamespaceDefault(e) {
 
 var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
 
-function create (app, config) {
+function create(app, config) {
   const state = {
     poiSearch: null,
     typeahead: null,
     indexesCreated: new Zousan(), // re-initialize this when changing venues
     defaultSearchTerms: null,
-    specialQueryTerms: {}
+    specialQueryTerms: {},
   };
 
   const init = async () => {
@@ -50,7 +50,7 @@ function create (app, config) {
   app.bus.on('search/queryNearby', async () => {
     const pois = await searchNearby();
     app.bus.send('search/showNearby', { pois, term: 'Nearby' });
-    return pois
+    return pois;
   });
 
   /**
@@ -59,14 +59,19 @@ function create (app, config) {
    */
   app.bus.on('search/queryNearbyAsync', searchNearby);
 
-  async function searchNearby () {
+  async function searchNearby() {
     const startLocation = await app.bus.getFirst('user/getPhysicalLocation');
-    if (!startLocation?.floorId) return []
-    const poisSameFloor = await app.bus.get('poi/getByFloorId', { floorId: startLocation?.floorId });
+    if (!startLocation?.floorId) return [];
+    const poisSameFloor = await app.bus.get('poi/getByFloorId', {
+      floorId: startLocation?.floorId,
+    });
     const isNotPortal = poi => poi.category.indexOf('portal') === -1 && poi.category !== 'element.door';
     const noPortalPois = Object.values(R__namespace.pickBy(isNotPortal, poisSameFloor));
-    const poisWithDistance = await app.bus.get('wayfinder/addPathTimeMultiple', { pois: noPortalPois, startLocation });
-    return R__namespace.sortBy(R__namespace.prop('distance'), Object.values(poisWithDistance)).slice(0, 50)
+    const poisWithDistance = await app.bus.get('wayfinder/addPathTimeMultiple', {
+      pois: noPortalPois,
+      startLocation,
+    });
+    return R__namespace.sortBy(R__namespace.prop('distance'), Object.values(poisWithDistance)).slice(0, 50);
   }
 
   /**
@@ -78,10 +83,9 @@ function create (app, config) {
    * @param {string} categoryName - label to display in search results input view
    */
   app.bus.on('search/queryCategory', async ({ category, categoryName, searchTerm }) => {
-    const pois = await state.indexesCreated.then(() =>
-      state.poiSearch.search({ query: searchTerm || category }));
+    const pois = await state.indexesCreated.then(() => state.poiSearch.search({ query: searchTerm || category }));
     app.bus.send('search/showCategory', { pois, category, categoryName });
-    return pois
+    return pois;
   });
 
   /**
@@ -95,8 +99,8 @@ function create (app, config) {
     return state.indexesCreated.then(() => {
       const pois = state.poiSearch.search({ query: term });
       app.bus.send('search/showSearchResults', { results: pois, term });
-      return pois
-    })
+      return pois;
+    });
   });
 
   /**
@@ -106,7 +110,7 @@ function create (app, config) {
    * @returns Array.<POI>
    */
   app.bus.on('search/queryAsync', ({ term }) =>
-    state.indexesCreated.then(() => state.poiSearch.search({ query: term }))
+    state.indexesCreated.then(() => state.poiSearch.search({ query: term })),
   );
 
   /**
@@ -120,9 +124,9 @@ function create (app, config) {
     if (state.specialQueryTerms[term]) {
       const { event, params } = state.specialQueryTerms[term];
       // use "send" as we can't gaurentee this event is a "get" or even returns POIs
-      return app.bus.send(event, params)
+      return app.bus.send(event, params);
     } else {
-      return app.bus.get('search/query', { term })
+      return app.bus.get('search/query', { term });
     }
   });
 
@@ -137,18 +141,16 @@ function create (app, config) {
   app.bus.on('search/getDefaultSearchTerms', async ({ limit = 5 } = {}) => {
     const defaultSearchTerms = state.defaultSearchTerms;
     const hasDefaultSearchTerms = defaultSearchTerms && defaultSearchTerms.length;
-    const keywords = hasDefaultSearchTerms
-      ? defaultSearchTerms
-      : await getUniqueRandomCategories(limit);
+    const keywords = hasDefaultSearchTerms ? defaultSearchTerms : await getUniqueRandomCategories(limit);
     app.bus.send('search/showDefaultSearchKeywords', { keywords });
-    return keywords
+    return keywords;
   });
 
-  async function getUniqueRandomCategories (limit) {
+  async function getUniqueRandomCategories(limit) {
     const allCategories = (await app.bus.send('poi/getAllCategories'))[0];
     const uniqueCategories = Array.from(new Set(allCategories));
     const shuffledUniqueCategories = rand.randomizeArray(uniqueCategories);
-    return shuffledUniqueCategories.slice(0, limit)
+    return shuffledUniqueCategories.slice(0, limit);
   }
 
   /**
@@ -161,7 +163,7 @@ function create (app, config) {
     const allPois = await app.bus.get('poi/getAll');
     const navigablePred = (val, key) => val.isNavigable;
     const navigablePois = R__namespace.pickBy(navigablePred, allPois);
-    return rand.arrayPick(Object.values(navigablePois), limit)
+    return rand.arrayPick(Object.values(navigablePois), limit);
   });
 
   /**
@@ -188,8 +190,8 @@ function create (app, config) {
    * @param {Array.<string>} keywords - list of new keywords
    */
   app.bus.on('search/addKeywords', ({ keywords }) =>
-    state.indexesCreated.then(() =>
-      keywords.forEach(keyword => state.typeahead.addKeyword(keyword))));
+    state.indexesCreated.then(() => keywords.forEach(keyword => state.typeahead.addKeyword(keyword))),
+  );
 
   /**
    * Returns lists of keywords and POIs matching search term.
@@ -202,10 +204,12 @@ function create (app, config) {
    * @param {number} limit - maximum number of results
    * @returns {{ pois: Array.<POI>, keywords: Array.<String>, term: string }} - list of keywords, list of POIs, search term
    */
-  app.bus.on('search/typeahead', ({ term, limit }) => state.indexesCreated.then(() => {
-    const { keywords, pois } = state.typeahead.query(term, limit);
-    return { keywords, pois, term }
-  }));
+  app.bus.on('search/typeahead', ({ term, limit }) =>
+    state.indexesCreated.then(() => {
+      const { keywords, pois } = state.typeahead.query(term, limit);
+      return { keywords, pois, term };
+    }),
+  );
 
   /**
    * Resets plugin state.
@@ -222,27 +226,25 @@ function create (app, config) {
    * @param {Object<string, Object>} - dictionary of POI id to dynamic data object
    */
   app.bus.on('poi/setDynamicData', async ({ plugin, idValuesMap }) => {
-    if (plugin !== 'grab') return
+    if (plugin !== 'grab') return;
 
-    const dynamicPoisPromises = Object.keys(idValuesMap)
-      .map(id => app.bus.get('poi/getById', { id }));
+    const dynamicPoisPromises = Object.keys(idValuesMap).map(id => app.bus.get('poi/getById', { id }));
 
-    return Promise.all(dynamicPoisPromises)
-      .then(pois =>
-        state.indexesCreated.then(() =>
-          state.poiSearch.updateMultiple(pois)))
+    return Promise.all(dynamicPoisPromises).then(pois =>
+      state.indexesCreated.then(() => state.poiSearch.updateMultiple(pois)),
+    );
   });
 
   const runTest = async (initialState, testRoutine) => {
     // state = { ...initialState }
     await testRoutine();
-    return state
+    return state;
   };
 
   return {
     init,
-    runTest
-  }
+    runTest,
+  };
 }
 
 exports.create = create;

package/dist/cjs/plugins/searchService/src/searchTypeahead.js

@@ -3,15 +3,15 @@
 var R = require('ramda');
 var utils = require('./utils.js');
 
-function createSearchTypeahead (pois, poiSearch, lang) {
+function createSearchTypeahead(pois, poiSearch, lang) {
   const suggestedKeywordsSearch = createSuggestedKeywordsSearch(pois, lang);
 
-  function queryPois (query, limit) {
+  function queryPois(query, limit) {
     const matches = poiSearch({ query, limit });
     const withSuggestions = poiSearch({ query, suggest: true, limit });
     const matchedIds = matches.map(poi => poi.poiId);
     const filteredSuggestions = withSuggestions.filter(poi => matchedIds.indexOf(poi.poiId) === -1);
-    return matches.concat(filteredSuggestions)
+    return matches.concat(filteredSuggestions);
   }
 
   const query = (query, limit) => {
@@ -20,46 +20,41 @@ function createSearchTypeahead (pois, poiSearch, lang) {
     const shouldQueryPois = !queryLengthUnderLimit && suggestedKeywords.length;
     const poisLimit = limit - suggestedKeywords.length;
     const pois = shouldQueryPois ? queryPois(query, poisLimit) : [];
-    return { keywords: suggestedKeywords, pois }
+    return { keywords: suggestedKeywords, pois };
   };
 
-  const addKeyword = (keyword) => {
+  const addKeyword = keyword => {
     suggestedKeywordsSearch.add(keyword);
   };
 
-  return { query, addKeyword }
+  return { query, addKeyword };
 }
 
-function createSuggestedKeywordsSearch (pois, lang) {
+function createSuggestedKeywordsSearch(pois, lang) {
   const categories = extractParentCategories(pois);
-  const poisKeywords = R.pipe(
-    R.values,
-    R.chain(R.prop('keywords')),
-    R.filter(R.prop('isUserSearchable')),
-    R.pluck('name')
-  )(pois);
+  const poisKeywords = R.pipe(R.values, R.chain(R.prop('keywords')), R.filter(R.prop('isUserSearchable')), R.pluck('name'))(pois);
   const allPotentialKeywords = [...categories, ...poisKeywords];
   const keywords = Array.from(new Set([...allPotentialKeywords]));
   const index = utils.getFlexSearchInstance({ lang, type: 'typeahead' });
 
   keywords.forEach((keyword, i) => index.add(i, keyword));
 
-  const search = (queryParams) => {
+  const search = queryParams => {
     const ids = index.search(queryParams);
-    return ids.map(index => keywords[index])
+    return ids.map(index => keywords[index]);
   };
-  const add = (newKeyword) => {
+  const add = newKeyword => {
     keywords.push(newKeyword);
     index.add(keywords.length - 1, newKeyword);
   };
-  return { search, add }
+  return { search, add };
 }
 
-function extractParentCategories (pois) {
+function extractParentCategories(pois) {
   return Object.values(pois)
     .map(poi => poi.category)
     .map(fullCategory => fullCategory.split('.'))
-    .map(subcategories => subcategories[0])
+    .map(subcategories => subcategories[0]);
 }
 
 module.exports = createSearchTypeahead;

package/dist/cjs/plugins/searchService/src/utils.js

@@ -12,17 +12,16 @@ const getFlexSearchInstance = ({ lang, type = 'standard' }) => {
     stemmer: {
       s: '',
       es: '',
-      ies: 'y'
+      ies: 'y',
     },
-    encode: simple.encode
+    encode: simple.encode,
   };
 
   // Use the full tokenizer for non-ASCII languages and for standard searching
   // but use "forward" for typeahead
-  if (NON_ASCII_LANGUAGES.includes(lang))
-    options.tokenize = 'full';
+  if (NON_ASCII_LANGUAGES.includes(lang)) options.tokenize = 'full';
 
-  return new FlexSearch.Index(options)
+  return new FlexSearch.Index(options);
 };
 
 exports.getFlexSearchInstance = getFlexSearchInstance;