@zengenti/contensis-react-base 3.1.0 → 4.0.0-beta.2

package/esm/{sagas-933a8fc8.js → sagas-07e82e18.js}

@@ -55,8 +55,7 @@ var types = /*#__PURE__*/Object.freeze({
 });
 
 const withMappers = (action, mappers) => {
-  return {
-    ...action,
+  return { ...action,
     mappers
   };
 };
@@ -176,33 +175,38 @@ var actions = /*#__PURE__*/Object.freeze({
   updateSortOrder: updateSortOrder$1
 });
 
-let Context = /*#__PURE__*/function (Context) {
+let Context; // export type Context = 'facets' | 'listings' | 'minilist';
+
+(function (Context) {
   Context["facets"] = "facets";
   Context["listings"] = "listings";
   Context["minilist"] = "minilist";
-  return Context;
-}({});
-// export type Context = 'facets' | 'listings' | 'minilist';
+})(Context || (Context = {}));
 
-// Find a fromJS function from global that is dynamically loaded in createStore
 // or replace with a stub function for non-immutable gets
+
 const makeFromJS = (returnType = globalThis.STATE_TYPE || 'immutable') => {
   var _immutable, _immutable2;
+
   return returnType === 'immutable' ? ((_immutable = globalThis.immutable) === null || _immutable === void 0 ? void 0 : _immutable.fromJSOrdered) || ((_immutable2 = globalThis.immutable) === null || _immutable2 === void 0 ? void 0 : _immutable2.fromJS) || (v => v) : v => v;
 };
+
 const getImmutableOrJS = (state, stateKey, fallbackValue, returnType = globalThis.STATE_TYPE || 'immutable') => {
   // Find a fromJS function from global that is dynamically loaded in createStore
   // or replace with a stub function for non-immutable gets
   const fromJS = makeFromJS(returnType);
+
   if (state && 'get' in state && typeof state.get === 'function' && 'getIn' in state && typeof state.getIn === 'function' && 'toJS' in state && typeof state.toJS === 'function') {
     if (Array.isArray(stateKey)) return fromJS(state.getIn(stateKey, fallbackValue));
     return fromJS(state.get(stateKey, fallbackValue));
   }
+
   if (Array.isArray(stateKey) && state && typeof state === 'object') {
     const result = jpath(stateKey.join('.'), state);
     if (typeof result === 'undefined') return fallbackValue;
     return result;
   }
+
   const result = state && typeof state === 'object' ? state[stateKey] : undefined;
   if (typeof result === 'undefined') return fallbackValue;
   return result;
@@ -217,6 +221,7 @@ const getFacets = (state, returnType) => getImmutableOrJS(state, ['search', Cont
 const getTabFacets = state => Object.fromEntries(Object.entries(getFacets(state, 'js')).filter(([key]) => getImmutableOrJS(getFacets(state), [key, 'tabId'], 0) === getCurrentTab(state)));
 const getFacetTitles = state => Object.entries(getFacets(state, 'js')).map(([key, facet = {}]) => {
   var _facet$pagingInfo;
+
   return {
     isSelected: getCurrentFacet(state) === key,
     key,
@@ -243,9 +248,8 @@ const getFiltersToLoad = (state, facet, context = Context.facets, returnType) =>
     return typeof title !== 'undefined' && !!title;
   }).length > 0 && (f.isError || false) === false]);
   return loadedFilters.map(([filterKey, isLoaded]) => !isLoaded ? filterKey : null).filter(f => !!f);
-};
+}; // We lowercase the filter key unless it's an ISO date string where the T must be uppercase
 
-// We lowercase the filter key unless it's an ISO date string where the T must be uppercase
 const getSelectedFilters = (state, facet = '', context = Context.facets, returnType) => {
   const filters = getFilters(state, facet, context, 'js');
   const isoDateRegex = RegExp(/\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d/);
@@ -283,7 +287,6 @@ const getPageSize = (state, current = '', context = Context.facets) => {
   return getImmutableOrJS(state, ['search', context, current || getCurrent(state, context), 'pagingInfo', 'pageSize'], 0 // Defaults to 0 because we want it to fall back to a query param if not defined
   );
 };
-
 const getPrevPageIndex = (state, current = '', context = Context.facets) => {
   return getImmutableOrJS(state, ['search', context, current || getCurrent(state, context), 'pagingInfo', 'prevPageIndex']);
 };
@@ -326,8 +329,7 @@ const getTabsAndFacets = (state, returnType) => {
       if (!countFields || countFields.find((f = []) => (f === null || f === void 0 ? void 0 : f[0]) === facetName)) return getImmutableOrJS(facet, ['pagingInfo', 'totalCount']);
       return 0;
     }).reduce((a, b) => a + b, 0);
-    return {
-      ...tab,
+    return { ...tab,
       [Context.facets]: Object.fromEntries(thisTabFacets),
       totalCount: thisTabTotal
     };
@@ -344,12 +346,12 @@ const getFacetsTotalCount = state => {
   const facets = getFacets(state);
   const wholeSearchTotal = Object.entries(facets).map(([, t = {}]) => {
     var _t$pagingInfo;
+
     return ((_t$pagingInfo = t.pagingInfo) === null || _t$pagingInfo === void 0 ? void 0 : _t$pagingInfo.totalCount) || 0;
   }).reduce((a, b) => a + b, 0);
   return wholeSearchTotal;
-};
+}; // An exported copy of the relevant selectors scoped by default to a facets context
 
-// An exported copy of the relevant selectors scoped by default to a facets context
 const selectFacets = {
   getCurrent: getCurrentFacet,
   getCurrentTab,
@@ -386,9 +388,8 @@ const selectFacets = {
   getSearchTerm,
   getSearchTotalCount,
   getSelectedFilters
-};
+}; // An exported copy of the relevant selectors pre-scoped to a listing context
 
-// An exported copy of the relevant selectors pre-scoped to a listing context
 const selectListing = {
   getCurrent: getCurrentListing,
   getFeaturedResults: (state, listing = '') => getFeaturedResults(state, listing, Context.listings, 'js'),
@@ -469,23 +470,31 @@ const now = () => {
   if (typeof window == 'undefined') {
     return Date.now();
   }
+
   return window.performance.now();
 };
 
 const getClientConfig = (project, env) => {
-  let config = DELIVERY_API_CONFIG; /* global DELIVERY_API_CONFIG */
+  let config = DELIVERY_API_CONFIG;
+  /* global DELIVERY_API_CONFIG */
+
   if (project) {
     config.projectId = project;
   }
-  if (typeof window != 'undefined' && PROXY_DELIVERY_API /* global PROXY_DELIVERY_API */) {
+
+  if (typeof window != 'undefined' && PROXY_DELIVERY_API
+  /* global PROXY_DELIVERY_API */
+  ) {
     // ensure a relative url is used to bypass the need for CORS (separate OPTIONS calls)
     config.rootUrl = env || '';
     config.responseHandler = {
       404: () => null
     };
   }
+
   return config;
 };
+
 class CacheNode {
   constructor(key, value) {
     this.key = key;
@@ -493,7 +502,9 @@ class CacheNode {
     this.next = null;
     this.prev = null;
   }
+
 }
+
 class LruCache {
   constructor(limit = 100) {
     this.map = {};
@@ -502,6 +513,7 @@ class LruCache {
     this.limit = limit || 100;
     this.size = 0;
   }
+
   get(key) {
     if (this.map[key]) {
       let value = this.map[key].value;
@@ -511,8 +523,10 @@ class LruCache {
       return value;
     }
   }
+
   set(key, value) {
     let node = new CacheNode(key, value);
+
     if (this.map[key]) {
       this.remove(key);
     } else {
@@ -523,46 +537,60 @@ class LruCache {
         this.tail.next = null;
       }
     }
+
     this.setHead(node);
   }
+
   setHead(node) {
     node.next = this.head;
     node.prev = null;
+
     if (this.head) {
       this.head.prev = node;
     }
+
     this.head = node;
+
     if (!this.tail) {
       this.tail = node;
     }
+
     this.size++;
     this.map[node.key] = node;
   }
+
   remove(key) {
     let node = this.map[key];
+
     if (node.prev) {
       node.prev.next = node.next;
     } else {
       this.head = node.next;
     }
+
     if (node.next) {
       node.next.prev = node.prev;
     } else {
       this.tail = node.prev;
     }
+
     delete this.map[key];
     this.size--;
   }
+
 }
+
 class CachedSearch {
   constructor() {
     this.cache = new LruCache();
     this.taxonomyLookup = {};
   }
+
   search(query, linkDepth, project, env) {
     const client = Client.create(getClientConfig(project, env));
     return this.request(project + JSON.stringify(query) + linkDepth.toString(), () => client.entries.search(query, linkDepth));
   }
+
   getTaxonomyNodeByPath(path, project, env) {
     const client = Client.create(getClientConfig(project, env));
     return this.request(`[TAXONOMY NODE] ${path}`, () => client.taxonomy.getNodeByPath({
@@ -571,6 +599,7 @@ class CachedSearch {
       childDepth: 2
     }).then(node => this.extendTaxonomyNode(node)));
   }
+
   request(key, execute) {
     if (!this.cache.get(key) || typeof window == 'undefined') {
       let promise = execute();
@@ -579,36 +608,41 @@ class CachedSearch {
         this.cache.remove(key);
       });
     }
+
     return this.cache.get(key);
   }
+
   extendTaxonomyNode(node) {
     let id = this.getTaxonomyId(node);
     this.taxonomyLookup[id] = node.key;
-    return {
-      ...node,
+    return { ...node,
       id,
       children: node.children ? node.children.map(n => this.extendTaxonomyNode(n)) : null
     };
   }
+
   getTaxonomyId(node) {
     if (node.key) {
       let parts = node.key.split('/');
       return parts[parts.length - 1];
     }
+
     return '';
   }
+
   fetch(uri, opts = {}) {
     return this.request(`[FETCH] ${uri} ${JSON.stringify(opts)}`, () => fetch(uri, opts));
   }
+
 }
+
 const cachedSearch = new CachedSearch();
 
 // eslint-disable-next-line import/default
 function fixFreeTextForElastic(s) {
   const illegalChars = ['>', '<', '=', '|', '!', '{', '}', '[', ']', '^', '~', '*', '?', ':', '\\', '/'];
   const illegalRegEx = new RegExp(illegalChars.map(c => '\\' + c).join('|'), 'g');
-  s = s.replace(illegalRegEx, '');
-  // s = s.replace(encodedRegEx, ''); // (m) => '\\\\' + m);
+  s = s.replace(illegalRegEx, ''); // s = s.replace(encodedRegEx, ''); // (m) => '\\\\' + m);
 
   return s;
 }
@@ -628,11 +662,13 @@ const getItemsFromResult = result => {
   const {
     payload
   } = result || {};
+
   if (payload) {
     if (Array.isArray(payload)) return payload;
     if (Array.isArray(payload.items)) return payload.items;
     return payload;
   }
+
   return [];
 };
 const extractQuotedPhrases = searchTerm => {
@@ -644,7 +680,6 @@ const buildUrl = (route, params) => {
   const path = qs ? `${route}${route.includes('?') ? '&' : '?'}${qs}` : route;
   return path;
 };
-
 /**
  * Returns all params from the current route query string or static route
  * Supply static route argument if reading parameters from the route path
@@ -653,14 +688,15 @@ const buildUrl = (route, params) => {
  * @param location location object containing at least pathname and search
  * @returns Keyed params object
  */
+
 const routeParams = (staticRoute, location) => {
   var _staticRoute$match;
+
   // match.params is react-router-config/react-router@5 style
   // params is supplied with RouteObject in react-router@6
   const pathParams = (staticRoute === null || staticRoute === void 0 ? void 0 : (_staticRoute$match = staticRoute.match) === null || _staticRoute$match === void 0 ? void 0 : _staticRoute$match.params) || (staticRoute === null || staticRoute === void 0 ? void 0 : staticRoute.params) || {};
   const queryParams = parse(typeof window !== 'undefined' ? window.location.search : (location === null || location === void 0 ? void 0 : location.search) || '');
-  return {
-    ...pathParams,
+  return { ...pathParams,
     ...queryParams
   };
 };
@@ -668,11 +704,13 @@ const callCustomApi = async (customApi, filters) => {
   const apiUri = customApi.uri || '';
   let uri = buildUrl(apiUri, filters);
   if (!uri) throw new Error('uri is required to use customApi');
+
   if (typeof window == 'undefined') {
     if (!uri.startsWith('http')) uri = `http://localhost:3001${uri}`;
     const response = await fetch(uri);
     return await response.json();
   }
+
   const response = await cachedSearch.fetch(uri);
   return await response.clone().json();
 };
@@ -680,27 +718,32 @@ const removeEmptyAttributes = obj => {
   Object.entries(obj).forEach(([key, val]) => val && typeof val === 'object' && removeEmptyAttributes(val) || (typeof val === 'undefined' || val === null || val === '') && delete obj[key]);
   return obj;
 };
-const toArray = (obj, seperator = ',') => typeof obj === 'undefined' || obj === null ? obj : Array.isArray(obj) ? obj : obj.split(seperator);
+const toArray = (obj, seperator = ',') => typeof obj === 'undefined' || obj === null ? obj : Array.isArray(obj) ? obj : obj.split(seperator); // assumes array elements are primitive types
 
-// assumes array elements are primitive types
 const areArraysEqualSets = (a1, a2) => {
   const superSet = {};
+
   for (const ai of a1) {
     const e = ai + typeof ai;
     superSet[e] = 1;
   }
+
   for (const ai of a2) {
     const e = ai + typeof ai;
+
     if (!superSet[e]) {
       return false;
     }
+
     superSet[e] = 2;
   }
+
   for (const e in superSet) {
     if (superSet[e] === 1) {
       return false;
     }
   }
+
   return true;
 };
 
@@ -711,12 +754,12 @@ const searchUriTemplate = {
   }) => {
     const context = getSearchContext(state);
     const currentPath = selectCurrentPath(state) || '/search';
+
     if (context !== 'listings') {
       const currentFacet = facet || getCurrentFacet(state);
       const filters = getSelectedFilters(state, facet, context);
-      const currentFilter = filters.contentTypeId;
+      const currentFilter = filters.contentTypeId; // Check if we have a filter first
 
-      // Check if we have a filter first
       const newPath = (currentFilter === null || currentFilter === void 0 ? void 0 : currentFilter.length) > 0 && currentFacet ? `${currentPath}/${currentFacet}/${currentFilter}` : currentFacet ? `${currentPath}/${currentFacet}` : currentPath;
       return newPath;
     } else {
@@ -731,29 +774,29 @@ const searchUriTemplate = {
     pageIndex,
     pageSize
   }) => {
-    const searchContext = getSearchContext(state);
-    // Lose stateFilters and currentSearch if a new
+    const searchContext = getSearchContext(state); // Lose stateFilters and currentSearch if a new
     // term is passed via an argument
+
     const stateFilters = term ? {} : Object.fromEntries(Object.entries(getSelectedFilters(state, facet, searchContext, 'js')).map(([k, f]) => [k, f === null || f === void 0 ? void 0 : f.join(',')]));
     const currentSearch = !term && getImmutableOrJS(state, ['routing', 'location', 'search']);
     const currentQs = removeEmptyAttributes(parse(currentSearch));
     if (orderBy) currentQs.orderBy = orderBy;
-    const searchTerm = getSearchTerm(state);
-    // Use Immutable's merge to merge the stateFilters with any current Qs
+    const searchTerm = getSearchTerm(state); // Use Immutable's merge to merge the stateFilters with any current Qs
     // to build the new Qs.
+
     const mergedSearch = removeEmptyAttributes(merge(currentQs, stateFilters));
     if (searchTerm) mergedSearch.term = searchTerm;
     if (pageIndex) mergedSearch.pageIndex = pageIndex + 1;
     if (pageIndex === 0) mergedSearch.pageIndex = undefined;
-    if (pageSize) mergedSearch.pageSize = pageSize;
+    if (pageSize) mergedSearch.pageSize = pageSize; // We don't want these as search params in the url, we just need the search package to see them
 
-    // We don't want these as search params in the url, we just need the search package to see them
     return stringify(mergedSearch);
   },
   hash: ({
     state
   }) => getImmutableOrJS(state, ['routing', 'location', 'hash'], '').replace('#', '')
 };
+
 const mapStateToSearchUri = state => mapJson(state, searchUriTemplate);
 
 const DataFormats = {
@@ -788,8 +831,7 @@ const Fields = {
 
 const fieldExpression = (field, value, operator = 'equalTo', weight, fuzzySearch = false) => {
   if (!field || !value || Array.isArray(value) && value.length === 0) return [];
-  if (Array.isArray(field))
-    // If an array of fieldIds have been provided, call self for each fieldId
+  if (Array.isArray(field)) // If an array of fieldIds have been provided, call self for each fieldId
     // to generate expressions that are combined with an 'or' operator
     return [Op.or(...field.map(fieldId => fieldExpression(fieldId, value, operator, weight, fuzzySearch)).flat())];
   if (operator === 'between') return between(field, value);
@@ -798,15 +840,19 @@ const fieldExpression = (field, value, operator = 'equalTo', weight, fuzzySearch
 const contentTypeIdExpression = (contentTypeIds, webpageTemplates, assetTypes) => {
   const expressions = [];
   if (!contentTypeIds && !webpageTemplates && !assetTypes) return expressions;
+
   if (contentTypeIds && contentTypeIds.length > 0) {
     expressions.push(...dataFormatExpression(contentTypeIds, DataFormats.entry));
   }
+
   if (webpageTemplates && webpageTemplates.length > 0) {
     expressions.push(...dataFormatExpression(webpageTemplates, DataFormats.webpage));
   }
+
   if (assetTypes && assetTypes.length > 0) {
     expressions.push(...dataFormatExpression(assetTypes, DataFormats.asset));
   }
+
   if (expressions.length > 1) return [Op.or(...expressions)];
   return expressions;
 };
@@ -814,16 +860,14 @@ const filterExpressions = (filters, isOptional = false) => {
   if (!filters) return [];
   const expressions = [];
   filters.map(selectedFilter => {
-    if (selectedFilter.logicOperator === 'and')
-      // using 'and' logic operator we loop through each filter
+    if (selectedFilter.logicOperator === 'and') // using 'and' logic operator we loop through each filter
       // and loop through all values to add an expression for each filter value
       selectedFilter.values.forEach(value => expressions.push(...fieldExpression(selectedFilter.key, value, selectedFilter.fieldOperator || 'equalTo')));else if (selectedFilter.logicOperator === 'not') {
       const fieldExpressions = fieldExpression(selectedFilter.key, selectedFilter.values, selectedFilter.fieldOperator || 'in');
       fieldExpressions.forEach(expr => {
         expressions.push(Op.not(expr));
       });
-    }
-    // using 'or' logic operator we loop over each filter
+    } // using 'or' logic operator we loop over each filter
     // and simply add the array of values to an expression with an 'in' operator
     else expressions.push(...fieldExpression(selectedFilter.key, selectedFilter.values, selectedFilter.fieldOperator || 'in'));
     if (isOptional) expressions.push(Op.not(fieldExpression(selectedFilter.key, true, 'exists')[0]));
@@ -847,6 +891,7 @@ const dataFormatExpression = (contentTypeIds, dataFormat = DataFormats.entry) =>
     if (notContentTypeIds.length > 0 && notExpr) andExpr.add(notExpr);
     return [andExpr];
   }
+
   return [];
 };
 const featuredResultsExpression = ({
@@ -855,22 +900,24 @@ const featuredResultsExpression = ({
   fieldValue = true
 } = {}) => {
   const expressions = [];
+
   if (contentTypeId) {
     expressions.push(...contentTypeIdExpression(Array.isArray(contentTypeId) ? contentTypeId : [contentTypeId]));
   }
+
   if (fieldId && fieldValue) {
     expressions.push(...fieldExpression(fieldId, fieldValue));
   }
+
   return expressions;
 };
 const languagesExpression = languages => fieldExpression(Fields.sys.language, languages);
 const includeInSearchExpressions = (webpageTemplates, includeInSearchFields) => {
-  const expressions = [];
-  // Or include this expression if we have explicity specified non-default includeInSearch fields
-  if (Array.isArray(includeInSearchFields)) expressions.push(...includeInSearchFields.map(includeInSearchField => Op.or(Op.and(Op.exists(includeInSearchField, true), Op.equalTo(includeInSearchField, true)), Op.exists(includeInSearchField, false))));
+  const expressions = []; // Or include this expression if we have explicity specified non-default includeInSearch fields
 
-  // If webpageTemplates have been specified, include this expression
+  if (Array.isArray(includeInSearchFields)) expressions.push(...includeInSearchFields.map(includeInSearchField => Op.or(Op.and(Op.exists(includeInSearchField, true), Op.equalTo(includeInSearchField, true)), Op.exists(includeInSearchField, false)))); // If webpageTemplates have been specified, include this expression
   // with the default includeInSearch field from classic Contensis.
+
   if (Array.isArray(webpageTemplates) && webpageTemplates.length > 0) expressions.push(Op.or(Op.and(Op.exists(Fields.sys.includeInSearch, true), Op.equalTo(Fields.sys.includeInSearch, true)), Op.exists(Fields.sys.includeInSearch, false)));
   return expressions;
 };
@@ -890,52 +937,69 @@ const excludeIdsExpression = excludeIds => {
 };
 const orderByExpression = orderBy => {
   let expression;
+
   if (orderBy && orderBy.length > 0) {
     expression = OrderBy;
+
     for (const ob of orderBy) {
       var _expression, _expression2;
+
       expression = ob.startsWith('-') ? (_expression = expression) === null || _expression === void 0 ? void 0 : _expression.desc(ob.substring(1)) : (_expression2 = expression) === null || _expression2 === void 0 ? void 0 : _expression2.asc(ob);
     }
   }
+
   return expression;
 };
+
 const equalToOrIn = (field, value, operator = 'equalTo', fuzzySearch = false) => {
   if (value.length === 0) return [];
+
   if (Array.isArray(value)) {
     if (operator === 'equalTo' || operator === 'in') return [Op.in(field, ...value)];
     const expressions = value.map(innerValue => {
       var _between, _distanceWithin;
+
       switch (operator) {
         case 'between':
           return (_between = between(field, innerValue)) === null || _between === void 0 ? void 0 : _between[0];
+
         case 'distanceWithin':
           return (_distanceWithin = distanceWithin(field, innerValue)) === null || _distanceWithin === void 0 ? void 0 : _distanceWithin[0];
+
         case 'exists':
           return Op.exists(field, innerValue);
+
         case 'freeText':
           // TODO: Potentially needs further implementation of new options
           return Op[operator](field, innerValue, fuzzySearch, undefined);
+
         default:
           return Op[operator](field, innerValue);
       }
     });
     return (expressions === null || expressions === void 0 ? void 0 : expressions.length) > 1 ? [Op.or(...expressions)] : expressions || [];
   }
+
   switch (operator) {
     case 'between':
       return between(field, value);
+
     case 'distanceWithin':
       return distanceWithin(field, value);
+
     case 'freeText':
       // TODO: Potentially needs further implementation of new options
       return [Op.freeText(field, value, fuzzySearch, undefined)];
+
     default:
       return [Op[operator](field, value)];
   }
 };
+
 const between = (field, value) => {
   const handle = betweenValue => {
     const valArr = betweenValue.split('--');
+
     if (valArr.length > 1) {
       const [minimum, maximum] = valArr;
       return Op.between(field, minimum, maximum);
@@ -945,14 +1009,17 @@ const between = (field, value) => {
       return false;
     }
   };
+
   if (value.length === 0) return [];
   if (Array.isArray(value)) return [Op.or(...value.map(handle).filter(bc => bc !== false))];
   const op = handle(value);
   return op ? [op] : [];
 };
+
 const distanceWithin = (field, value) => {
   const handle = distanceValue => {
     const valArr = distanceValue.split(' ');
+
     if (valArr.length > 1) {
       const [lat, lon] = valArr;
       return Op.distanceWithin(field, Number(lat), Number(lon), (valArr === null || valArr === void 0 ? void 0 : valArr[2]) || '10mi');
@@ -962,27 +1029,28 @@ const distanceWithin = (field, value) => {
       return false;
     }
   };
+
   if (value.length === 0) return [];
   if (Array.isArray(value)) return [Op.or(...value.map(handle).filter(bc => bc !== false))];
   const op = handle(value);
   return op ? [op] : [];
 };
-
 /**
  * Accept HTTP style objects and map them to
  * their equivalent JS client "Op" expressions
  * @param {array} where the where array as you'd provide it to the HTTP API
  * @returns {array} array of constructed Delivery API Operators
  */
+
+
 const customWhereExpressions = where => {
-  if (!where || !Array.isArray(where)) return [];
+  if (!where || !Array.isArray(where)) return []; // Map each clause inside the where array
 
-  // Map each clause inside the where array
   return where.map(clause => {
-    let expression;
-    // Map through each property in the clause so we can
+    let expression; // Map through each property in the clause so we can
     // capture the values required and reconstruct them as
     // a Delivery API expression
+
     let operator;
     Object.keys(clause).map((key, idx) => {
       // The clause may contain only one key
@@ -990,6 +1058,7 @@ const customWhereExpressions = where => {
       const field = clause.field;
       const value = clause[Object.keys(clause).find(k => !['field', 'weight'].includes(k)) || ''];
       const weight = clause.weight;
+
       if (idx === 0) {
         if (operator === 'and' || operator === 'or') {
           // These are array expressions so we can call ourself recursively
@@ -997,21 +1066,24 @@ const customWhereExpressions = where => {
           const recurseExpr = customWhereExpressions(clause[operator]);
           expression = Op[operator](...recurseExpr);
         }
+
         if (['not'].includes(operator)) {
           // A 'not' expression is an object with only one inner field and inner operator
           Object.keys(value).map((notKey, notIdx) => {
             const innerOperator = notKey;
             const innerValue = value[notKey];
-            const innerField = value.field;
-            // Map the expression when we've looped and scoped to
+            const innerField = value.field; // Map the expression when we've looped and scoped to
             // the second property inside the clause
+
             if (notIdx === 1) expression = Op.not(makeJsExpression(innerOperator, innerField, innerValue));
           });
         }
-      }
-      // Map the expression when we've looped and scoped to
+      } // Map the expression when we've looped and scoped to
       // the second property inside the clause
+
+
       operator = Object.keys(clause).find(clauseKey => !['field', 'weight'].includes(clauseKey));
+
       if (idx === 1) {
         expression = makeJsExpression(operator, field, value);
         if (typeof weight === 'number') expression = expression.weight(weight);
@@ -1020,29 +1092,28 @@ const customWhereExpressions = where => {
     return expression;
   });
 };
+
 const makeJsExpression = (operator, field, value) => operator === 'freeText' || operator === 'contains' ? Op[operator](field, value) : operator === 'in' ? Op[operator](field, ...value) : operator === 'exists' ? Op[operator](field, value) : operator === 'between' ? Op[operator](field, value[0], value[1]) : operator === 'distanceWithin' ? Op[operator](field, value === null || value === void 0 ? void 0 : value.lat, value === null || value === void 0 ? void 0 : value.lon, value === null || value === void 0 ? void 0 : value.distance) : Op[operator](field, value);
+
 const termExpressions = (searchTerm, weightedSearchFields, fuzzySearch, omitSearchFields = []) => {
   if (searchTerm && weightedSearchFields && weightedSearchFields.length > 0) {
     // Extract any phrases in quotes to array
-    const quotedPhrases = extractQuotedPhrases(searchTerm);
+    const quotedPhrases = extractQuotedPhrases(searchTerm); // Modify the search term to remove any quoted phrases to leave any remaining terms
 
-    // Modify the search term to remove any quoted phrases to leave any remaining terms
     let modifiedSearchTerm = searchTerm;
-    quotedPhrases.forEach(qp => modifiedSearchTerm = modifiedSearchTerm.replace(qp, '').replace('""', '').trim());
+    quotedPhrases.forEach(qp => modifiedSearchTerm = modifiedSearchTerm.replace(qp, '').replace('""', '').trim()); // Push to the operators array to include in the query
 
-    // Push to the operators array to include in the query
-    const operators = [];
+    const operators = []; // Helper functions to generate Op expressions
 
-    // Helper functions to generate Op expressions
     const containsOp = (f, term) => fieldExpression(f.fieldId, fixFreeTextForElastic(term), 'contains', f.weight);
-    const freeTextOp = (f, term) => fieldExpression(f.fieldId, fixFreeTextForElastic(term), 'freeText', f.weight, fuzzySearch);
 
-    // For each weighted search field
+    const freeTextOp = (f, term) => fieldExpression(f.fieldId, fixFreeTextForElastic(term), 'freeText', f.weight, fuzzySearch); // For each weighted search field
+
+
     weightedSearchFields.forEach(wsf => {
       // Push to field operators
-      const fieldOperators = [];
+      const fieldOperators = []; // Add operator expressions for modified search term
 
-      // Add operator expressions for modified search term
       if (modifiedSearchTerm) {
         if ([Fields.keywords, Fields.sys.filename, Fields.sys.uri].includes(wsf.fieldId)) {
           fieldOperators.push(...containsOp(wsf, modifiedSearchTerm));
@@ -1053,35 +1124,33 @@ const termExpressions = (searchTerm, weightedSearchFields, fuzzySearch, omitSear
             fieldOperators.push(...freeTextOp(wsf, modifiedSearchTerm));
           }
         }
-      }
+      } // Add operator expressions for any quoted phrases
 
-      // Add operator expressions for any quoted phrases
-      quotedPhrases.forEach(qp => fieldOperators.push(...containsOp(wsf, qp)));
 
-      // If we are using multiple operators for a field we will
+      quotedPhrases.forEach(qp => fieldOperators.push(...containsOp(wsf, qp))); // If we are using multiple operators for a field we will
       // wrap each field inside an And operator so we will match
       // all terms/phrases rather than any terms/phrases
+
       if (fieldOperators.length > 1) {
         operators.push(Op.and(...fieldOperators));
       } else {
         operators.push(...fieldOperators);
       }
-    });
+    }); // Wrap operators in an Or operator
 
-    // Wrap operators in an Or operator
     const expressions = Op.or().addRange(operators);
-    if (!omitSearchFields.find(sf => sf === Fields.searchContent))
-      // include "searchContent" field by default unless omitted
+    if (!omitSearchFields.find(sf => sf === Fields.searchContent)) // include "searchContent" field by default unless omitted
       return [expressions.add(Op.freeText(Fields.searchContent, searchTerm, fuzzySearch))];else return [expressions];
   } else if (searchTerm) {
     // Searching without weightedSearchFields defined will fall back
     // to a default set of search fields with arbritary weights set.
-
     const exp = [];
+
     if (!omitSearchFields.find(sf => sf === Fields.entryTitle)) {
       exp.push(Op.equalTo(Fields.entryTitle, searchTerm).weight(10));
       exp.push(Op.freeText(Fields.entryTitle, searchTerm, fuzzySearch).weight(2));
     }
+
     if (!omitSearchFields.find(sf => sf === Fields.entryDescription)) exp.push(Op.freeText(Fields.entryDescription, searchTerm, fuzzySearch).weight(2));
     if (!omitSearchFields.find(sf => sf === Fields.keywords)) exp.push(Op.contains(Fields.keywords, searchTerm).weight(2));
     if (!omitSearchFields.find(sf => sf === Fields.sys.uri)) exp.push(Op.contains(Fields.sys.uri, searchTerm).weight(2));
@@ -1143,9 +1212,11 @@ const searchQuery = ({
   const query = new Query(...expressions);
   if (!searchTerm) query.orderBy = orderByExpression(orderBy);
   if (dynamicOrderBy && dynamicOrderBy.length) query.orderBy = orderByExpression(dynamicOrderBy);
+
   if (fields && fields.length > 0 && !isFeatured) {
     query.fields = fields;
   }
+
   query.pageIndex = isFeatured ? 0 : pageIndex;
   query.pageSize = isFeatured && typeof featuredResults.count === 'number' ? featuredResults.count : pageSize;
   return query;
@@ -1166,6 +1237,7 @@ const mapEntriesToSearchResults = ({
   const mapperFunc = mapper || mappers && mappers.results;
   return items && typeof mapperFunc === 'function' ? mapperFunc(items, facet, context, state) : [];
 };
+
 const facetTemplate = {
   type: () => SET_SEARCH_ENTRIES,
   context: 'action.context',
@@ -1208,9 +1280,11 @@ const facetTemplate = {
           pagesLoaded
         }) => {
           const loaded = [...(pagesLoaded || [])];
+
           if (isNaN(loaded.find(l => l === pageIndex))) {
             loaded.push(pageIndex);
           }
+
           return loaded.sort((a, b) => a - b);
         }
       },
@@ -1233,21 +1307,18 @@ const facetTemplate = {
         prevPageIndex
       } = action.queryParams;
       const results = mapEntriesToSearchResults(action, getItemsFromResult(result), state);
-      if (!loadMorePaging) return results;
+      if (!loadMorePaging) return results; // add a _pageIndex property to the returned results to help us later
 
-      // add a _pageIndex property to the returned results to help us later
       const nextResults = results.map((r, idx) => ({
         _pageIndex: pageIndex,
         _pagePosition: idx,
         ...r
       }));
-      const loadedPages = pagesLoaded || [];
-
-      // if pageIndex is found in loadedPages, we have already loaded this page
-      if (!isNaN(loadedPages.find(l => l === pageIndex))) return prevResults;
+      const loadedPages = pagesLoaded || []; // if pageIndex is found in loadedPages, we have already loaded this page
 
-      // Determine where we put the results depending on if we
+      if (!isNaN(loadedPages.find(l => l === pageIndex))) return prevResults; // Determine where we put the results depending on if we
       // are paging forwards, backwards, or doing a new search
+
       const firstResultSet = pageIndex > prevPageIndex ? prevResults || [] : nextResults;
       const secondResultSet = pageIndex > prevPageIndex ? nextResults : prevResults || [];
       const onlyResultSet = loadedPages.length === 0 ? nextResults : false;
@@ -1278,11 +1349,13 @@ const filterTemplate = {
       if (payload && (payload.items || payload.children)) {
         const items = (payload.items || payload.children).map(item => {
           var _item$sys;
+
           item.isSelected = selectedKeys === null || selectedKeys === void 0 ? void 0 : selectedKeys.includes((item === null || item === void 0 ? void 0 : (_item$sys = item.sys) === null || _item$sys === void 0 ? void 0 : _item$sys.id) || item.key);
           return item;
         });
         return mapper(items);
       }
+
       return [];
     }
   },
@@ -1305,22 +1378,22 @@ const filterExpressionMapper = {
   fieldOperator: 'fieldOperator',
   logicOperator: 'logicOperator'
 };
+
 const mapFilterToFilterExpression = filter => mapJson(filter, filterExpressionMapper);
 
 const mapFiltersToFilterExpression = (filters, selectedFilters) => {
   if (!selectedFilters || Object.keys(selectedFilters).length === 0) return [];
-  const filterExpressions = [];
-
-  // Iterate through the keys in selectedFilters and locate
+  const filterExpressions = []; // Iterate through the keys in selectedFilters and locate
   // the items that are selected and queryable
+
   Object.entries(selectedFilters).map(([fkey, selectedValues]) => {
     const filter = filters[fkey];
+
     if (selectedValues && filter) {
       // Where we have a value for a selectedFilter
       // and a filter is found for the current key
       // map the filter to a filterExpression object
-      const expr = mapFilterToFilterExpression({
-        ...filter,
+      const expr = mapFilterToFilterExpression({ ...filter,
         selectedValues
       });
       filterExpressions.push(expr);
@@ -1356,8 +1429,8 @@ const queryParamsTemplate = {
     context
   }) => {
     const stateFilters = getFilters(state, facet, context, 'js');
-    const selectedFilters = getSelectedFilters(state, facet, context, 'js');
-    // Use another mapping function to map the filter parameters for the query
+    const selectedFilters = getSelectedFilters(state, facet, context, 'js'); // Use another mapping function to map the filter parameters for the query
+
     const filterParams = mapFiltersToFilterExpression(stateFilters, selectedFilters);
     return filterParams;
   },
@@ -1407,6 +1480,7 @@ const queryParamsTemplate = {
     context
   }) => {
     var _getFacet;
+
     return ((_getFacet = getFacet(state, facet, context, 'js')) === null || _getFacet === void 0 ? void 0 : _getFacet.projectId) || selectCurrentProject(state);
   },
   searchTerm: root => root.context !== Context.minilist || getQueryParameter(root, 'useSearchTerm', false) ? getSearchTerm(root.state) : '',
@@ -1421,12 +1495,11 @@ const queryParamsTemplate = {
   weightedSearchFields: root => {
     const wsf = getQueryParameter(root, 'weightedSearchFields', []);
     const deduped = wsf.filter((v, i, a) => a.findIndex(t => t.fieldId === v.fieldId) === i);
-    return deduped;
-    // return wsf;
+    return deduped; // return wsf;
   },
-
   webpageTemplates: root => getQueryParameter(root, 'webpageTemplates', [])
 };
+
 const mapStateToQueryParams = sourceJson => mapJson(sourceJson, queryParamsTemplate);
 
 /**
@@ -1440,9 +1513,9 @@ const generateQueryParams = (action, state) => {
   const {
     context,
     facet
-  } = action;
-  // Map parameters using state and some additional
+  } = action; // Map parameters using state and some additional
   // inputs from the action
+
   const queryParams = mapStateToQueryParams({
     context,
     facet,
@@ -1451,12 +1524,12 @@ const generateQueryParams = (action, state) => {
   });
   return [queryParams, runSearch(action, state, queryParams)];
 };
-
 /**
  * Checks if we have already loaded everything we're asking for and tells us to run the search or not
  * @param action
  * @param state
  */
+
 const runSearch = (action, state, queryParams) => {
   const {
     context,
@@ -1468,14 +1541,13 @@ const runSearch = (action, state, queryParams) => {
   } = action;
   let willRun = false;
   const facetIsLoaded = defaultLang ? false : getIsLoaded(state, context, facet);
-  const stateParams = {
-    ...getQueryParams(ogState, facet, context)
+  const stateParams = { ...getQueryParams(ogState, facet, context)
   };
   stateParams.pageIndex = getPageIndex(ogState, facet, context);
   stateParams.searchTerm = getSearchTerm(ogState);
   stateParams.pageSize = getPageSize(ogState, facet, context);
-  if (context === Context.facets && ssr ||
-  // context === Context.minilist ||
+
+  if (context === Context.facets && ssr || // context === Context.minilist ||
   preload || !facetIsLoaded || filterParamsChanged(action) || defaultLang) {
     willRun = true;
   } else {
@@ -1483,24 +1555,28 @@ const runSearch = (action, state, queryParams) => {
     // are the same as what we already have in state
     Object.entries(stateParams).forEach(([param, value]) => {
       const queryParam = queryParams[param];
+
       if (JSON.stringify(value) !== JSON.stringify(queryParam)) {
         willRun = true;
       }
     });
   }
+
   const internalPaging = getIsInternalPaging(ogState, facet, context);
+
   if (internalPaging && facetIsLoaded) {
     willRun = false;
   }
+
   return willRun;
 };
-
 /**
  * This will tell us if filter parameters have been
  * changed by some external event such as a route change
  * @param action
  * @returns true or false
  */
+
 const filterParamsChanged = (action, state) => {
   const {
     context,
@@ -1515,13 +1591,12 @@ const filterParamsChanged = (action, state) => {
   });
   return paramsChanged.filter(f => f === true).length > 0;
 };
-
 /* eslint-disable no-console */
+
 const debugExecuteSearch = (action, state) => {
   const [queryParams, runSearch] = generateQueryParams(action, state);
   console.log('runSearch', runSearch, 'action', action, 'filterParamsChanged', filterParamsChanged(action, state), 'getIsLoaded(state, context, facet)', getIsLoaded(state, action.context, action.facet));
-  const stateParams = {
-    ...getQueryParams(action.ogState || state, action.facet, action.context),
+  const stateParams = { ...getQueryParams(action.ogState || state, action.facet, action.context),
     pageIndex: getPageIndex(action.ogState || state, action.facet, action.context),
     searchTerm: getSearchTerm(action.ogState || state)
   };
@@ -1530,8 +1605,7 @@ const debugExecuteSearch = (action, state) => {
 };
 const scrollTo = scrollToElement => {
   if (typeof window !== 'undefined') {
-    if (typeof scrollToElement === 'number')
-      // Used to be Y coordinate, deprecated, because it's not accessible
+    if (typeof scrollToElement === 'number') // Used to be Y coordinate, deprecated, because it's not accessible
       console.warn('updatePageIndex arg2 needs string');else if (typeof scrollToElement === 'string') {
       /* Effectively simulates an anchor link. Needed for accessibility, as window.scrollTo
          does not change focus, only scrolls the screen */
@@ -1540,11 +1614,10 @@ const scrollTo = scrollToElement => {
   }
 };
 
-// *** FILTER ITEM MAPPING ***
-
 // Base mapping, fields that are the same across all mappings
 // to save repeating these elements in every mapper, spread this
 // into your discrete mappings
+
 const base = {
   contentTypeId: Fields.sys.contentTypeId,
   title: 'entryTitle',
@@ -1552,13 +1625,16 @@ const base = {
   path: 'sys.slug',
   isSelected: 'isSelected'
 };
+
 const mapEntriesToFilterItems = entries => {
   if (!entries) return [];
   return entries.map(entry => {
     const template = base;
+
     if (template) {
       return mapJson(entry, template);
     }
+
     return entry;
   });
 };
@@ -1588,7 +1664,9 @@ const mapQueryParamsToCustomApi = queryParams => {
 };
 
 const searchSagas = [takeEvery(CLEAR_FILTERS, clearFilters), takeEvery(DO_SEARCH, doSearch), takeEvery(SET_ROUTE_FILTERS, loadFilters), takeEvery(SET_SEARCH_ENTRIES, preloadOtherFacets), takeEvery(UPDATE_CURRENT_FACET, updateCurrentFacet), takeEvery(UPDATE_CURRENT_TAB, updateCurrentTab), takeEvery(UPDATE_PAGE_INDEX, updatePageIndex), takeEvery(UPDATE_PAGE_SIZE, updatePageSize), takeEvery(UPDATE_SEARCH_TERM, updateSearchTerm), takeEvery(UPDATE_SORT_ORDER, updateSortOrder), takeEvery(UPDATE_SELECTED_FILTERS, applySearchFilter)];
+
 const toJS = obj => obj && 'toJS' in obj && typeof obj.toJS === 'function' ? obj.toJS() : obj;
+
 function* setRouteFilters(action) {
   const {
     mappers,
@@ -1599,17 +1677,17 @@ function* setRouteFilters(action) {
   } = action;
   const context = listingType ? Context.listings : Context.facets;
   const state = toJS(yield select());
-  const ssr = getIsSsr(state);
+  const ssr = getIsSsr(state); // Get current facet from params or state
 
-  // Get current facet from params or state
-  let currentFacet = params && params.facet || listingType;
+  let currentFacet = params && params.facet || listingType; // Pick the default facet from initialState
 
-  // Pick the default facet from initialState
   if (!currentFacet) {
     var _Object$keys;
+
     const tabs = getSearchTabs(state, 'js');
     currentFacet = (tabs === null || tabs === void 0 ? void 0 : tabs[0].defaultFacet) || ((_Object$keys = Object.keys(getFacets(state, 'js'))) === null || _Object$keys === void 0 ? void 0 : _Object$keys[0]) || '';
   }
+
   const nextAction = {
     type: SET_ROUTE_FILTERS,
     context,
@@ -1620,50 +1698,48 @@ function* setRouteFilters(action) {
     ssr,
     debug
   };
-  yield put(nextAction);
+  yield put(nextAction); // keep track of this state ref for comparing changes to params later
 
-  // keep track of this state ref for comparing changes to params later
   const ogState = {
     search: state.search
-  };
-
-  // Using call instead of triggering from the put
+  }; // Using call instead of triggering from the put
   // to allow this exported saga to continue during SSR
-  yield call(ensureSearch, {
-    ...nextAction,
+
+  yield call(ensureSearch, { ...nextAction,
     ogState
   });
 }
 function* doSearch(action) {
   var _action$params;
+
   const state = toJS(yield select());
+
   if (action.config) {
     // If the action contains a config object, we can add this to the
     // state at runtime
-    yield put({
-      ...action,
+    yield put({ ...action,
       type: APPLY_CONFIG
     });
   }
-  const nextAction = {
-    ...action,
+
+  const nextAction = { ...action,
     type: SET_SEARCH_FILTERS,
     ssr: getIsSsr(state),
     facet: action.facet || ((_action$params = action.params) === null || _action$params === void 0 ? void 0 : _action$params.facet)
   };
+
   if (nextAction.facet && (action.config || Object.keys(getFacet(state, nextAction.facet, action.context, 'js')).length > 0)) {
-    yield put(nextAction);
+    yield put(nextAction); // keep track of this state ref for comparing changes to params later
 
-    // keep track of this state ref for comparing changes to params later
     const ogState = {
       search: state.search
     };
-    yield call(ensureSearch, {
-      ...nextAction,
+    yield call(ensureSearch, { ...nextAction,
       ogState
     });
   }
 }
+
 function* loadFilters(action) {
   const {
     facet: facetKey,
@@ -1671,6 +1747,7 @@ function* loadFilters(action) {
     mappers = {}
   } = action;
   const filtersToLoad = yield select(getFiltersToLoad, facetKey, context, 'js');
+
   if (filtersToLoad.length > 0) {
     yield put({
       type: LOAD_FILTERS,
@@ -1696,6 +1773,7 @@ function* loadFilters(action) {
     if (filtersToLoadSagas) yield all(filtersToLoadSagas);
   }
 }
+
 function* loadFilter(action) {
   const {
     facetKey,
@@ -1721,6 +1799,7 @@ function* loadFilter(action) {
     selectedKeys,
     mapper
   };
+
   try {
     if (contentTypeId) {
       const versionStatus = yield select(selectVersionStatus);
@@ -1730,6 +1809,7 @@ function* loadFilter(action) {
       if (payload.type === 'error') throw payload;
       createStateFrom.payload = payload;
     }
+
     if (path) {
       const payload = yield cachedSearch.getTaxonomyNodeByPath(path, projectId);
       if (!payload) throw new Error(`No payload returned for taxonomy path: '${path}'`);
@@ -1740,33 +1820,35 @@ function* loadFilter(action) {
     createStateFrom.type = LOAD_FILTERS_ERROR;
     createStateFrom.error = error;
   }
+
   const nextAction = mapJson(createStateFrom, filterTemplate);
   yield put(nextAction);
 }
+
 function* ensureSearch(action) {
   const {
     context,
     facet,
     debug
   } = action;
+
   try {
     const state = yield select();
-    const nextAction = {
-      ...action,
+    const nextAction = { ...action,
       ogState: action.ogState || {
         search: state.search
       }
     };
     const [queryParams, runSearch] = generateQueryParams(nextAction, state);
     if (debug && (debug === true || debug.executeSearch)) debugExecuteSearch(nextAction, state);
+
     if (runSearch) {
       yield put({
         type: EXECUTE_SEARCH,
         facet,
         context
       });
-      yield call(executeSearch, {
-        ...nextAction,
+      yield call(executeSearch, { ...nextAction,
         context,
         facet,
         queryParams,
@@ -1778,6 +1860,7 @@ function* ensureSearch(action) {
     log.error(...['Error running search saga:', error, error.stack]);
   }
 }
+
 function* executeSearch(action) {
   const {
     context,
@@ -1785,12 +1868,14 @@ function* executeSearch(action) {
     queryParams,
     mappers
   } = action;
+
   try {
     const state = yield select();
     let result = {};
     let featuredResult;
     let featuredQuery;
     const customApi = getCustomApi(state, facet, context, 'js');
+
     if (customApi) {
       const apiParams = typeof mappers === 'object' && typeof mappers.customApi === 'function' && mappers.customApi(queryParams) || mapQueryParamsToCustomApi(queryParams);
       result.payload = yield callCustomApi(customApi, apiParams);
@@ -1798,16 +1883,19 @@ function* executeSearch(action) {
     } else {
       if (queryParams.featuredResults) {
         featuredQuery = searchQuery(queryParams, true);
-        featuredResult = yield timedSearch(featuredQuery, queryParams.linkDepth, queryParams.projectId, queryParams.env);
-        // eslint-disable-next-line require-atomic-updates
+        featuredResult = yield timedSearch(featuredQuery, queryParams.linkDepth, queryParams.projectId, queryParams.env); // eslint-disable-next-line require-atomic-updates
+
         queryParams.excludeIds = getItemsFromResult(featuredResult).map(fi => {
           var _fi$sys;
+
           return fi === null || fi === void 0 ? void 0 : (_fi$sys = fi.sys) === null || _fi$sys === void 0 ? void 0 : _fi$sys.id;
         }).filter(fi => typeof fi === 'string');
       }
+
       const query = searchQuery(queryParams);
       result = yield timedSearch(query, queryParams.linkDepth, queryParams.projectId, queryParams.env);
     }
+
     const createStateFrom = {
       action,
       featuredResult,
@@ -1823,6 +1911,7 @@ function* executeSearch(action) {
     log.error(...['Error running search saga:', error, error.stack]);
   }
 }
+
 function* preloadOtherFacets(action) {
   const {
     preload,
@@ -1832,19 +1921,18 @@ function* preloadOtherFacets(action) {
   } = action;
   const state = yield select();
   const currentFacet = getCurrentFacet(state);
+
   if (!preload && facet === currentFacet && context !== Context.listings) {
     const allFacets = getFacets(state, 'js');
     const otherFacets = Object.keys(allFacets).filter(f => f !== currentFacet);
     yield all(otherFacets.map((preloadFacet = '') => {
-      const preloadAction = {
-        ...action,
+      const preloadAction = { ...action,
         facet: preloadFacet,
         preload: true
       };
       const [queryParams, runSearch] = generateQueryParams(preloadAction, state);
       if (debug && (debug === true || debug.preloadOtherFacets)) debugExecuteSearch(preloadAction, state);
-      return runSearch && call(executeSearch, {
-        ...action,
+      return runSearch && call(executeSearch, { ...action,
         type: EXECUTE_SEARCH_PRELOAD,
         preload: true,
         facet: preloadFacet,
@@ -1853,6 +1941,7 @@ function* preloadOtherFacets(action) {
     }));
   }
 }
+
 function* updateCurrentTab(action) {
   const {
     id,
@@ -1862,16 +1951,19 @@ function* updateCurrentTab(action) {
   const facets = getFacets(state, 'js');
   const tabs = getSearchTabs(state, 'js');
   let nextFacet = tabs === null || tabs === void 0 ? void 0 : tabs[id].currentFacet;
+
   if (!nextFacet) {
     Object.entries(facets).map(([facetName, facet]) => {
       if (facet.tabId === id && (tabs === null || tabs === void 0 ? void 0 : tabs[id].defaultFacet) === facetName) nextFacet = facetName;
     });
-  }
-  // If the next Tab does not have a defaultFacet,
+  } // If the next Tab does not have a defaultFacet,
   // take the first facet for that tab
+
+
   if (!nextFacet) nextFacet = Object.entries(facets).filter(([, f]) => f.tabId === id)[0][0];
   yield put(withMappers(updateCurrentFacet$1(nextFacet), mappers));
 }
+
 function* clearFilters(action) {
   const {
     mappers
@@ -1879,6 +1971,7 @@ function* clearFilters(action) {
   const uri = yield buildUri({}, mappers);
   yield put(navigate(uri));
 }
+
 function* updateCurrentFacet(action) {
   const {
     facet,
@@ -1891,6 +1984,7 @@ function* updateCurrentFacet(action) {
   }, mappers);
   yield put(navigate(uri));
 }
+
 function* updateSearchTerm(action) {
   const {
     term,
@@ -1901,6 +1995,7 @@ function* updateSearchTerm(action) {
   }, mappers);
   yield put(navigate(uri));
 }
+
 function* updateSortOrder(action) {
   const {
     orderBy,
@@ -1913,6 +2008,7 @@ function* updateSortOrder(action) {
   }, mappers);
   yield put(navigate(uri));
 }
+
 function* updatePageIndex(action) {
   const {
     pageIndex,
@@ -1925,6 +2021,7 @@ function* updatePageIndex(action) {
   yield put(navigate(uri));
   if (typeof scrollToElement !== 'undefined') scrollTo(scrollToElement);
 }
+
 function* updatePageSize(action) {
   const {
     pageSize,
@@ -1937,6 +2034,7 @@ function* updatePageSize(action) {
   yield put(navigate(uri));
   if (typeof scrollToElement !== 'undefined') scrollTo(scrollToElement);
 }
+
 function* applySearchFilter(action) {
   const {
     mappers,
@@ -1946,6 +2044,7 @@ function* applySearchFilter(action) {
   yield put(navigate(uri));
   if (typeof scrollToElement !== 'undefined') scrollTo(scrollToElement);
 }
+
 function* buildUri({
   facet,
   orderBy,
@@ -1962,10 +2061,11 @@ function* buildUri({
     pageIndex,
     pageSize,
     term
-  });
-  // return uri;
+  }); // return uri;
+
   return `${uri.path}${uri.search && `?${uri.search}` || ''}${uri.hash && `#${uri.hash}` || ''}`;
 }
+
 function* triggerMinilistSsr(options) {
   yield call(doSearch, {
     type: DO_SEARCH,
@@ -1980,4 +2080,4 @@ function* triggerSearchSsr(options) {
 }
 
 export { EXECUTE_SEARCH as $, clearFilters$1 as A, updateCurrentFacet$1 as B, updateCurrentTab$1 as C, updatePageIndex$1 as D, updatePageSize$1 as E, updateSearchTerm$1 as F, updateSelectedFilters as G, updateSortOrder$1 as H, selectListing as I, mapStateToSearchUri as J, Context as K, selectFacets as L, triggerSearch as M, getFilters as N, toArray as O, UPDATE_SELECTED_FILTERS as P, UPDATE_SEARCH_TERM as Q, UPDATE_PAGE_SIZE as R, UPDATE_PAGE_INDEX as S, SET_SEARCH_FILTERS as T, UPDATE_SORT_ORDER as U, SET_SEARCH_ENTRIES as V, SET_ROUTE_FILTERS as W, LOAD_FILTERS_COMPLETE as X, LOAD_FILTERS_ERROR as Y, LOAD_FILTERS as Z, EXECUTE_SEARCH_ERROR as _, customWhereExpressions as a, CLEAR_FILTERS as a0, APPLY_CONFIG as a1, actions as a2, selectors as a3, types as a4, expressions as a5, queries as a6, doSearch as a7, setRouteFilters as a8, searchSagas as a9, triggerListingSsr as aa, triggerMinilistSsr as ab, triggerSearchSsr as ac, routeParams as ad, getPageIndex as b, contentTypeIdExpression as c, defaultExpressions as d, getCurrentTab as e, filterExpressions as f, getCurrentFacet as g, getFacet as h, getTabFacets as i, getFacetsTotalCount as j, getFacetTitles as k, getFeaturedResults as l, getRenderableFilters as m, getIsLoading as n, orderByExpression as o, getPaging as p, getPageIsLoading as q, getResults as r, getSearchTerm as s, termExpressions as t, getSearchTotalCount as u, getSelectedFilters as v, getQueryParameter as w, getTabsAndFacets as x, getTotalCount as y, withMappers as z };
-//# sourceMappingURL=sagas-933a8fc8.js.map
+//# sourceMappingURL=sagas-07e82e18.js.map