atriusmaps-node-sdk 3.3.196 → 3.3.226

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

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var e = require('ramda');
-var a = require('zousan');
+var R = require('ramda');
+var Zousan = require('zousan');
 var configUtils = require('../../../src/utils/configUtils.js');
 var rand = require('../../../src/utils/rand.js');
 var poiSearch = require('./poiSearch.js');
@@ -12,26 +12,251 @@ var searchTypeahead = require('./searchTypeahead.js');
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 function _interopNamespace(e) {
-	if (e && e.__esModule) return e;
-	var n = Object.create(null);
-	if (e) {
-		Object.keys(e).forEach(function (k) {
-			if (k !== 'default') {
-				var d = Object.getOwnPropertyDescriptor(e, k);
-				Object.defineProperty(n, k, d.get ? d : {
-					enumerable: true,
-					get: function () { return e[k]; }
-				});
-			}
-		});
-	}
-	n["default"] = e;
-	return Object.freeze(n);
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
 }
 
-var e__namespace = /*#__PURE__*/_interopNamespace(e);
-var a__default = /*#__PURE__*/_interopDefaultLegacy(a);
+var R__namespace = /*#__PURE__*/_interopNamespace(R);
+var Zousan__default = /*#__PURE__*/_interopDefaultLegacy(Zousan);
 
-function o(o,i){const c={poiSearch:null,typeahead:null,indexesCreated:new a__default["default"],defaultSearchTerms:null,specialQueryTerms:{}},u=async()=>{const e=await o.bus.get("poi/getAll");c.poiSearch=poiSearch(e,o.i18n().language),c.typeahead=searchTypeahead(e,c.poiSearch.search,o.i18n().language),c.defaultSearchTerms=configUtils.getLocalized(i,"defaultSearchTerms",o.i18n().language),c.indexesCreated.resolve();};async function d(){const r=await o.bus.get("user/getPhysicalLocation"),a=await o.bus.get("poi/getByFloorId",{floorId:r.floorId}),s=Object.values(e__namespace.pickBy((e=>-1===e.category.indexOf("portal")&&"element.door"!==e.category),a)),t=await o.bus.get("wayfinder/addPathTimeMultiple",{pois:s,startLocation:r});return e__namespace.sortBy(e__namespace.prop("distance"),Object.values(t)).slice(0,50)}o.bus.on("search/queryNearby",(async()=>{const e=await d();return o.bus.send("search/showNearby",{pois:e,term:"Nearby"}),e})),o.bus.on("search/queryNearbyAsync",d),o.bus.on("search/queryCategory",(async({category:e,categoryName:r,searchTerm:a})=>{const s=await c.indexesCreated.then((()=>c.poiSearch.search({query:a||e})));return o.bus.send("search/showCategory",{pois:s,category:e,categoryName:r}),s})),o.bus.on("search/query",(({term:e})=>c.indexesCreated.then((()=>{const r=c.poiSearch.search({query:e});return o.bus.send("search/showSearchResults",{results:r,term:e}),r})))),o.bus.on("search/queryAsync",(({term:e})=>c.indexesCreated.then((()=>c.poiSearch.search({query:e}))))),o.bus.on("search/queryWithSpecial",(({term:e})=>{if(c.specialQueryTerms[e]){const{event:r,params:a}=c.specialQueryTerms[e];return o.bus.send(r,a)}return o.bus.get("search/query",{term:e})})),o.bus.on("search/getDefaultSearchTerms",(async({limit:e=5}={})=>{const r=c.defaultSearchTerms,a=r&&r.length?r:await async function(e){const r=(await o.bus.send("poi/getAllCategories"))[0],a=Array.from(new Set(r));return function(e){for(let r=e.length-1;r>0;r--){const a=Math.floor(Math.random()*(r+1));[e[r],e[a]]=[e[a],e[r]];}return e}(a).slice(0,e)}(e);return o.bus.send("search/showDefaultSearchKeywords",{keywords:a}),a})),o.bus.on("search/getDefaultSearchPois",(async({limit:r=5}={})=>{const a=await o.bus.get("poi/getAll"),t=e__namespace.pickBy(((e,r)=>e.isNavigable),a);return rand.arrayPick(Object.values(t),r)})),o.bus.on("search/registerSpecialQuery",(({term:e,event:r,params:a,addKeyword:s=!0})=>{c.indexesCreated.then((()=>{s&&c.typeahead.addKeyword(e),c.specialQueryTerms[e]={event:r,params:a};}));})),o.bus.on("search/addKeywords",(({keywords:e})=>c.indexesCreated.then((()=>e.forEach((e=>c.typeahead.addKeyword(e))))))),o.bus.on("search/typeahead",(({term:e,limit:r})=>c.indexesCreated.then((()=>{const{keywords:a,pois:s}=c.typeahead.query(e,r);return {keywords:a,pois:s,term:e}})))),o.bus.on("venueData/loadNewVenue",(()=>{c.indexesCreated=new a__default["default"],u();})),o.bus.on("poi/setDynamicData",(async({plugin:e,idValuesMap:r})=>{if("grab"!==e)return;const a=Object.keys(r).map((e=>o.bus.get("poi/getById",{id:e})));return Promise.all(a).then((e=>c.indexesCreated.then((()=>c.poiSearch.updateMultiple(e)))))}));return {init:u,runTest:async(e,r)=>(await r(),c)}}
+function create (app, config) {
+  const state = {
+    poiSearch: null,
+    typeahead: null,
+    indexesCreated: new Zousan__default["default"](), // re-initialize this when changing venues
+    defaultSearchTerms: null,
+    specialQueryTerms: {}
+  };
 
-exports.create = o;
+  const init = async () => {
+    const pois = await app.bus.get('poi/getAll');
+    state.poiSearch = poiSearch(pois, app.i18n().language);
+    state.typeahead = searchTypeahead(pois, state.poiSearch.search, app.i18n().language);
+    state.defaultSearchTerms = configUtils.getLocalized(config, 'defaultSearchTerms', app.i18n().language);
+    state.indexesCreated.resolve();
+  };
+
+  /**
+   * Prepares and send an event with up to 50 non-portal POIs sorted by distance to user location.
+   */
+  // todo check if async events (events which send a new event as a result) are still needed
+  app.bus.on('search/queryNearby', async () => {
+    const pois = await searchNearby();
+    app.bus.send('search/showNearby', { pois, term: 'Nearby' });
+    return pois
+  });
+
+  /**
+   * Returns max 50 non-portal POIs sorted by distance to user location.
+   * @returns Array.<POI>
+   */
+  app.bus.on('search/queryNearbyAsync', searchNearby);
+
+  async function searchNearby () {
+    const startLocation = await app.bus.get('user/getPhysicalLocation');
+    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)
+  }
+
+  /**
+   * Searches for POIs with search term or category name
+   * and sends a new event 'search/showCategory' with search result POIs.
+   *
+   * @param {string} searchTerm - term to search POIs
+   * @param {string} category - category name, fallback term to search POIs
+   * @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 }));
+    app.bus.send('search/showCategory', { pois, category, categoryName });
+    return pois
+  });
+
+  /**
+   * Searches for POIs with search term
+   * and sends a new event 'search/showCategory' with search result POIs.
+   *
+   * @param {string} term - search term
+   */
+  // todo introduce consistent naming for parameters are return values (searchTem or term, pois or results, keywords or searchTerms)
+  app.bus.on('search/query', ({ term }) => {
+    return state.indexesCreated.then(() => {
+      const pois = state.poiSearch.search({ query: term });
+      app.bus.send('search/showSearchResults', { results: pois, term });
+      return pois
+    })
+  });
+
+  /**
+   * Search for POIs with search term.
+   *
+   * @param {string} term - search term
+   * @returns Array.<POI>
+   */
+  app.bus.on('search/queryAsync', ({ term }) =>
+    state.indexesCreated.then(() => state.poiSearch.search({ query: term }))
+  );
+
+  /**
+   * If search term matches any registered special query term,
+   * then send an event with params for this special query,
+   * otherwise search for POIs with term and send the event 'search/query' with search result POIs
+   *
+   * @param {string} term - search term or special query
+   */
+  app.bus.on('search/queryWithSpecial', ({ term }) => {
+    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)
+    } else {
+      return app.bus.get('search/query', { term })
+    }
+  });
+
+  /**
+   * Returns list of all localized default search terms declared in the configuration
+   * or list of up to 'limit' random unique POI categories as a fallback.
+   * Returns a list of keywords and sends an event 'search/showDefaultSearchKeywords' with same the list of keywords.
+   *
+   * @param {number} [limit=5] - Used to limit number of random unique categories list if default search terms are not defined in configuration.
+   * @returns Array.<string> - list of keywords
+   */
+  app.bus.on('search/getDefaultSearchTerms', async ({ limit = 5 } = {}) => {
+    const defaultSearchTerms = state.defaultSearchTerms;
+    const hasDefaultSearchTerms = defaultSearchTerms && defaultSearchTerms.length;
+    const keywords = hasDefaultSearchTerms
+      ? defaultSearchTerms
+      : await getUniqueRandomCategories(limit);
+    app.bus.send('search/showDefaultSearchKeywords', { keywords });
+    return keywords
+  });
+
+  async function getUniqueRandomCategories (limit) {
+    const allCategories = (await app.bus.send('poi/getAllCategories'))[0];
+    const uniqueCategories = Array.from(new Set(allCategories));
+    const shuffledUniqueCategories = shuffle(uniqueCategories);
+    return shuffledUniqueCategories.slice(0, limit)
+  }
+
+  function shuffle (a) {
+    for (let i = a.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [a[i], a[j]] = [a[j], a[i]];
+    }
+    return a
+  }
+
+  /**
+   * Returns list of up to 'limit' unique random navigable POIs.
+   *
+   * @param {number} [limit=5]
+   * @returns Array.<POI>
+   */
+  app.bus.on('search/getDefaultSearchPois', async ({ limit = 5 } = {}) => {
+    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)
+  });
+
+  /**
+   * Registers an event and event params for special query term.
+   * Optionally adds passed special query term to keywords search index.
+   *
+   * @param {string} term - special query term
+   * @param {string} event - name of associated event
+   * @param {Object} params - parameters for associated event
+   * @param {boolean} addKeyword - indicates if term has to be added to keywords search index
+   */
+  app.bus.on('search/registerSpecialQuery', ({ term, event, params, addKeyword = true }) => {
+    state.indexesCreated.then(() => {
+      if (addKeyword) {
+        state.typeahead.addKeyword(term);
+      }
+      state.specialQueryTerms[term] = { event, params };
+    });
+  });
+
+  /**
+   * Adds list of keywords to keywords search index.
+   *
+   * @param {Array.<string>} keywords - list of new keywords
+   */
+  app.bus.on('search/addKeywords', ({ keywords }) =>
+    state.indexesCreated.then(() =>
+      keywords.forEach(keyword => state.typeahead.addKeyword(keyword))));
+
+  /**
+   * Returns lists of keywords and POIs matching search term.
+   *
+   * For term shorter than 3 characters only keywords index is queried.
+   * If no keywords are found or when term is longer,
+   * then POIs index is queried for the the remaining results.
+   *
+   * @param {string} term - search term
+   * @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 }
+  }));
+
+  /**
+   * Resets plugin state.
+   */
+  app.bus.on('venueData/loadNewVenue', () => {
+    state.indexesCreated = new Zousan__default["default"]();
+    init();
+  });
+
+  /**
+   * Updates POIs search index with dynamic Grab POIs.
+   *
+   * @param {string} plugin - type of dynamic data
+   * @param {Object<string, Object>} - dictionary of POI id to dynamic data object
+   */
+  app.bus.on('poi/setDynamicData', async ({ plugin, idValuesMap }) => {
+    if (plugin !== 'grab') return
+
+    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)))
+  });
+
+  const runTest = async (initialState, testRoutine) => {
+    // state = { ...initialState }
+    await testRoutine();
+    return state
+  };
+
+  return {
+    init,
+    runTest
+  }
+}
+
+exports.create = create;

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

@@ -1,8 +1,65 @@
 'use strict';
 
-var e = require('ramda');
+var R = require('ramda');
 var utils = require('./utils.js');
 
-function s(s,d,u){const c=function(s,d){const u=function(e){return Object.values(e).map((e=>e.category)).map((e=>e.split("."))).map((e=>e[0]))}(s),c=e.pipe(e.values,e.chain(e.prop("keywords")),e.filter(e.prop("isUserSearchable")),e.pluck("name"))(s),m=[...u,...c],p=Array.from(new Set([...m])),l=utils.getFlexSearchInstance({lang:d,type:"typeahead"});p.forEach(((e,r)=>l.add(r,e)));return {search:e=>l.search(e).map((e=>p[e])),add:e=>{p.push(e),l.add(p.length-1,e);}}}(s,u);return {query:(e,r)=>{const t=c.search({query:e,limit:r}),a=!(e.length<3)&&t.length,n=r-t.length,o=a?function(e,r){const t=d({query:e,limit:r}),a=d({query:e,suggest:!0,limit:r}),n=t.map((e=>e.poiId)),o=a.filter((e=>-1===n.indexOf(e.poiId)));return t.concat(o)}(e,n):[];return {keywords:t,pois:o}},addKeyword:e=>{c.add(e);}}}
+function createSearchTypeahead (pois, poiSearch, lang) {
+  const suggestedKeywordsSearch = createSuggestedKeywordsSearch(pois, lang);
 
-module.exports = s;
+  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)
+  }
+
+  const query = (query, limit) => {
+    const suggestedKeywords = suggestedKeywordsSearch.search({ query, limit });
+    const queryLengthUnderLimit = query.length < 3;
+    const shouldQueryPois = !queryLengthUnderLimit && suggestedKeywords.length;
+    const poisLimit = limit - suggestedKeywords.length;
+    const pois = shouldQueryPois ? queryPois(query, poisLimit) : [];
+    return { keywords: suggestedKeywords, pois }
+  };
+
+  const addKeyword = (keyword) => {
+    suggestedKeywordsSearch.add(keyword);
+  };
+
+  return { query, addKeyword }
+}
+
+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 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 ids = index.search(queryParams);
+    return ids.map(index => keywords[index])
+  };
+  const add = (newKeyword) => {
+    keywords.push(newKeyword);
+    index.add(keywords.length - 1, newKeyword);
+  };
+  return { search, add }
+}
+
+function extractParentCategories (pois) {
+  return Object.values(pois)
+    .map(poi => poi.category)
+    .map(fullCategory => fullCategory.split('.'))
+    .map(subcategories => subcategories[0])
+}
+
+module.exports = createSearchTypeahead;

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

@@ -2,12 +2,31 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var e = require('flexsearch');
+var FlexSearch = require('flexsearch');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var e__default = /*#__PURE__*/_interopDefaultLegacy(e);
+var FlexSearch__default = /*#__PURE__*/_interopDefaultLegacy(FlexSearch);
 
-const n=["ko","ja","zh-Hans","zh-Hant"],r=({lang:r,type:t="standard"})=>{const s={tokenize:"forward",rtl:"ar"===r,stemmer:{s:"",es:"",ies:"y"}};return n.includes(r)&&(s.tokenize="full"),new e__default["default"].Index(s)};
+const NON_ASCII_LANGUAGES = ['ko', 'ja', 'zh-Hans', 'zh-Hant'];
 
-exports.getFlexSearchInstance = r;
+const getFlexSearchInstance = ({ lang, type = 'standard' }) => {
+  const options = {
+    tokenize: 'forward',
+    rtl: lang === 'ar', // only for arabic
+    stemmer: {
+      s: '',
+      es: '',
+      ies: 'y'
+    }
+  };
+
+  // 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';
+
+  return new FlexSearch__default["default"].Index(options)
+};
+
+exports.getFlexSearchInstance = getFlexSearchInstance;