@zengenti/contensis-react-base 3.0.0-beta.4 → 3.0.0-beta.43

package/esm/search.js

@@ -1,18 +1,18 @@
 import React, { useMemo, useEffect } from 'react';
 import { connect, useDispatch, useSelector } from 'react-redux';
 import mapJson, { jpath } from 'jsonpath-mapper';
-import { produce } from 'immer';
+import * as log from 'loglevel';
 import { takeEvery, select, put, call, all } from '@redux-saga/core/effects';
 import { Client } from 'contensis-delivery-api';
-import queryString from 'query-string';
-import { error } from 'loglevel';
-import { createSelector } from 'reselect';
+import { stringify, parse } from 'query-string';
 import { Op, OrderBy, Query } from 'contensis-core-api';
 import merge from 'deepmerge';
+import { createSelector } from 'reselect';
+import { produce } from 'immer';
 import equals from 'deep-equal';
 
 /* eslint-disable import/default */
-const toJS = WrappedComponent => wrappedComponentProps => {
+const toJS$1 = WrappedComponent => wrappedComponentProps => {
   const KEY = 0;
   const VALUE = 1;
   const propsJS = Object.entries(wrappedComponentProps).reduce((newProps, wrappedComponentProp) => {
@@ -121,43 +121,44 @@ const navigate = (path, state) => {
     state
   };
 };
-const clearFilters = () => {
+const clearFilters$1 = () => {
   return {
     type: CLEAR_FILTERS
   };
 };
-const updatePageIndex = pageIndex => {
+const updatePageIndex$1 = pageIndex => {
   return {
     type: UPDATE_PAGE_INDEX,
     pageIndex
   };
 };
-const updateCurrentFacet = facet => {
+const updateCurrentFacet$1 = facet => {
   return {
     type: UPDATE_CURRENT_FACET,
     facet
   };
 };
-const updateCurrentTab = id => {
+const updateCurrentTab$1 = id => {
   return {
     type: UPDATE_CURRENT_TAB,
     id
   };
 };
-const updateSearchTerm = term => {
+const updateSearchTerm$1 = term => {
   return {
     type: UPDATE_SEARCH_TERM,
     term
   };
 };
-const updateSelectedFilters = (filter, key) => {
+const updateSelectedFilters = (filter, key, isUnknownItem = false) => {
   return {
     type: UPDATE_SELECTED_FILTERS,
     filter,
-    key
+    key,
+    isUnknownItem
   };
 };
-const updateSortOrder = (orderBy, facet) => {
+const updateSortOrder$1 = (orderBy, facet) => {
   return {
     type: UPDATE_SORT_ORDER,
     orderBy,
@@ -171,22 +172,22 @@ var actions = /*#__PURE__*/Object.freeze({
   triggerSearch: triggerSearch,
   initListing: initListing,
   navigate: navigate,
-  clearFilters: clearFilters,
-  updatePageIndex: updatePageIndex,
-  updateCurrentFacet: updateCurrentFacet,
-  updateCurrentTab: updateCurrentTab,
-  updateSearchTerm: updateSearchTerm,
+  clearFilters: clearFilters$1,
+  updatePageIndex: updatePageIndex$1,
+  updateCurrentFacet: updateCurrentFacet$1,
+  updateCurrentTab: updateCurrentTab$1,
+  updateSearchTerm: updateSearchTerm$1,
   updateSelectedFilters: updateSelectedFilters,
-  updateSortOrder: updateSortOrder
+  updateSortOrder: updateSortOrder$1
 });
 
-let Context; // export type Context = 'facets' | 'listings' | 'minilist';
+let Context$1; // export type Context = 'facets' | 'listings' | 'minilist';
 
 (function (Context) {
   Context["facets"] = "facets";
   Context["listings"] = "listings";
   Context["minilist"] = "minilist";
-})(Context || (Context = {}));
+})(Context$1 || (Context$1 = {}));
 
 // or replace with a stub function for non-immutable gets
 
@@ -217,12 +218,12 @@ const getImmutableOrJS = (state, stateKey, fallbackValue, returnType = globalThi
   return result;
 };
 
-const getSearchContext = state => getImmutableOrJS(state, ['search', 'context'], Context.facets);
-const getCurrent = (state, context = Context.facets) => context === Context.facets ? getCurrentFacet(state) : getCurrentListing(state);
+const getSearchContext = state => getImmutableOrJS(state, ['search', 'context'], Context$1.facets);
+const getCurrent$1 = (state, context = Context$1.facets) => context === Context$1.facets ? getCurrentFacet(state) : getCurrentListing(state);
 const getCurrentFacet = state => getImmutableOrJS(state, ['search', 'currentFacet']);
 const getCurrentListing = state => getImmutableOrJS(state, ['search', 'currentListing']);
-const getCurrentTab = state => getImmutableOrJS(state, ['search', Context.facets, getCurrentFacet(state), 'tabId'], 0);
-const getFacets = (state, returnType) => getImmutableOrJS(state, ['search', Context.facets], {}, returnType);
+const getCurrentTab = state => getImmutableOrJS(state, ['search', Context$1.facets, getCurrentFacet(state), 'tabId'], 0);
+const getFacets = (state, returnType) => getImmutableOrJS(state, ['search', Context$1.facets], {}, returnType);
 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;
@@ -233,19 +234,19 @@ const getFacetTitles = state => Object.entries(getFacets(state, 'js')).map(([key
     totalCount: (_facet$pagingInfo = facet.pagingInfo) === null || _facet$pagingInfo === void 0 ? void 0 : _facet$pagingInfo.totalCount
   };
 });
-const getFacet = (state, facetName = '', context = Context.facets, returnType) => {
+const getFacet = (state, facetName = '', context = Context$1.facets, returnType) => {
   const currentFacet = facetName || getCurrentFacet(state);
   return getImmutableOrJS(state, ['search', context, currentFacet], {}, returnType);
 };
-const getListing = (state, listing = '') => {
+const getListing$1 = (state, listing = '') => {
   const currentListing = listing || getCurrentListing(state);
-  return getImmutableOrJS(state, ['search', Context.listings, currentListing], {});
+  return getImmutableOrJS(state, ['search', Context$1.listings, currentListing], {});
 };
-const getFilters = (state, facet, context = Context.facets, returnType) => {
-  return getImmutableOrJS(state, ['search', context, facet || getCurrent(state, context), 'filters'], {}, returnType);
+const getFilters = (state, facet, context = Context$1.facets, returnType) => {
+  return getImmutableOrJS(state, ['search', context, facet || getCurrent$1(state, context), 'filters'], {}, returnType);
 };
-const getRenderableFilters = (state, facet = '', context = Context.facets) => Object.fromEntries(Object.entries(getFilters(state, facet, context, 'js')).filter(([, f = {}]) => typeof f.renderable !== 'boolean' ? true : f.renderable));
-const getFiltersToLoad = (state, facet, context = Context.facets, returnType) => {
+const getRenderableFilters$1 = (state, facet = '', context = Context$1.facets) => Object.fromEntries(Object.entries(getFilters(state, facet, context, 'js')).filter(([, f = {}]) => typeof f.renderable !== 'boolean' ? true : f.renderable));
+const getFiltersToLoad = (state, facet, context = Context$1.facets, returnType) => {
   const filters = getFilters(state, facet, context, returnType);
   const loadedFilters = Object.entries(filters).map(([key, f = {}]) => [key, (f.items || []).filter(i => {
     const title = i === null || i === void 0 ? void 0 : i.title;
@@ -254,68 +255,68 @@ const getFiltersToLoad = (state, facet, context = Context.facets, returnType) =>
   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
 
-const getSelectedFilters = (state, facet = '', context = Context.facets, returnType) => {
+const getSelectedFilters = (state, facet = '', context = Context$1.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/);
   const selectedFilters = Object.fromEntries(Object.entries(filters).map(([key, filter = {}]) => [key, (filter.items || []).filter(item => !!(item.isSelected || false)).map(item => {
     const key = (item === null || item === void 0 ? void 0 : item.key) || '';
     const isIsoDate = isoDateRegex.test(key);
-    return isIsoDate ? key : key.toLowerCase();
+    return isIsoDate ? key : typeof key.toLowerCase !== 'undefined' ? key.toLowerCase() : key;
   })]));
   const fromJS = makeFromJS(returnType);
   return fromJS(selectedFilters);
 };
-const getResults = (state, current = '', context = Context.facets, returnType) => {
-  return getImmutableOrJS(state, ['search', context, current || getCurrent(state, context), 'results'], [], returnType);
+const getResults$1 = (state, current = '', context = Context$1.facets, returnType) => {
+  return getImmutableOrJS(state, ['search', context, current || getCurrent$1(state, context), 'results'], [], returnType);
 };
-const getIsInternalPaging = (state, current, context = Context.facets) => {
-  return getImmutableOrJS(state, ['search', context, current || getCurrent(state, context), 'queryParams', 'internalPaging'], false);
+const getIsInternalPaging = (state, current, context = Context$1.facets) => {
+  return getImmutableOrJS(state, ['search', context, current || getCurrent$1(state, context), 'queryParams', 'internalPaging'], false);
 };
-const getIsLoaded = (state, context = Context.facets, facet) => {
-  return !!getImmutableOrJS(state, ['search', context, facet || getCurrent(state, context), 'queryDuration'], 0);
+const getIsLoaded = (state, context = Context$1.facets, facet) => {
+  return !!getImmutableOrJS(state, ['search', context, facet || getCurrent$1(state, context), 'queryDuration'], 0);
 };
-const getIsLoading = (state, context = Context.facets, facet) => {
-  return getImmutableOrJS(state, ['search', context, facet || getCurrent(state, context), 'entries', 'isLoading']);
+const getIsLoading$1 = (state, context = Context$1.facets, facet) => {
+  return getImmutableOrJS(state, ['search', context, facet || getCurrent$1(state, context), 'entries', 'isLoading']);
 };
 const getIsSsr = state => getImmutableOrJS(state, ['search', 'config', 'ssr'], false);
-const getFeaturedResults = (state, current = '', context = Context.facets) => {
-  return getImmutableOrJS(state, ['search', context, current || getCurrent(state, context), 'featuredResults'], []);
+const getFeaturedResults$1 = (state, current = '', context = Context$1.facets) => {
+  return getImmutableOrJS(state, ['search', context, current || getCurrent$1(state, context), 'featuredResults'], []);
 };
-const getPaging = (state, current = '', context = Context.facets, returnType) => {
-  return getImmutableOrJS(state, ['search', context, current || getCurrent(state, context), 'pagingInfo'], {}, returnType);
+const getPaging$1 = (state, current = '', context = Context$1.facets, returnType) => {
+  return getImmutableOrJS(state, ['search', context, current || getCurrent$1(state, context), 'pagingInfo'], {}, returnType);
 };
-const getPageIndex = (state, current = '', context = Context.facets) => {
-  return getImmutableOrJS(state, ['search', context, current || getCurrent(state, context), 'pagingInfo', 'pageIndex']);
+const getPageIndex$1 = (state, current = '', context = Context$1.facets) => {
+  return getImmutableOrJS(state, ['search', context, current || getCurrent$1(state, context), 'pagingInfo', 'pageIndex']);
 };
-const getPrevPageIndex = (state, current = '', context = Context.facets) => {
-  return getImmutableOrJS(state, ['search', context, current || getCurrent(state, context), 'pagingInfo', 'prevPageIndex']);
+const getPrevPageIndex = (state, current = '', context = Context$1.facets) => {
+  return getImmutableOrJS(state, ['search', context, current || getCurrent$1(state, context), 'pagingInfo', 'prevPageIndex']);
 };
-const getPageIsLoading = (state, current = '', context = Context.facets) => {
-  return getImmutableOrJS(state, ['search', context, current || getCurrent(state, context), 'pagingInfo', 'isLoading']);
+const getPageIsLoading$1 = (state, current = '', context = Context$1.facets) => {
+  return getImmutableOrJS(state, ['search', context, current || getCurrent$1(state, context), 'pagingInfo', 'isLoading']);
 };
-const getPagesLoaded = (state, current = '', context = Context.facets) => {
-  return getImmutableOrJS(state, ['search', context, current || getCurrent(state, context), 'pagingInfo', 'pagesLoaded'], [], 'js');
+const getPagesLoaded = (state, current = '', context = Context$1.facets) => {
+  return getImmutableOrJS(state, ['search', context, current || getCurrent$1(state, context), 'pagingInfo', 'pagesLoaded'], [], 'js');
 };
-const getTotalCount = (state, current = '', context = Context.facets) => {
-  return getImmutableOrJS(state, ['search', context, current || getCurrent(state, context), 'pagingInfo', 'totalCount']);
+const getTotalCount = (state, current = '', context = Context$1.facets) => {
+  return getImmutableOrJS(state, ['search', context, current || getCurrent$1(state, context), 'pagingInfo', 'totalCount']);
 };
-const getSearchTerm = state => getImmutableOrJS(state, ['search', 'term']);
+const getSearchTerm$1 = state => getImmutableOrJS(state, ['search', 'term']);
 const getSearchTabs = (state, returnType) => getImmutableOrJS(state, ['search', 'tabs'], [], returnType);
-const getQueryParams = (state, current = '', context = Context.facets) => {
-  return getImmutableOrJS(state, ['search', context, current || getCurrent(state, context), 'queryParams'], {}, 'js');
+const getQueryParams = (state, current = '', context = Context$1.facets) => {
+  return getImmutableOrJS(state, ['search', context, current || getCurrent$1(state, context), 'queryParams'], {}, 'js');
 };
-const getQueryParameter = ({
+const getQueryParameter$1 = ({
   state,
   facet,
-  context = Context.facets
+  context = Context$1.facets
 }, key, ifnull = null) => {
   return getImmutableOrJS(getQueryParams(state, facet, context), key, ifnull, 'js');
 };
-const getCustomApi = (state, current, context = Context.facets, returnType) => {
-  return getImmutableOrJS(state, ['search', context, current || getCurrent(state, context), 'customApi'], null, returnType);
+const getCustomApi = (state, current, context = Context$1.facets, returnType) => {
+  return getImmutableOrJS(state, ['search', context, current || getCurrent$1(state, context), 'customApi'], null, returnType);
 };
-const getCustomEnv = (state, current, context = Context.facets) => {
-  return getImmutableOrJS(state, ['search', context, current || getCurrent(state, context), 'env']);
+const getCustomEnv = (state, current, context = Context$1.facets) => {
+  return getImmutableOrJS(state, ['search', context, current || getCurrent$1(state, context), 'env']);
 };
 const getTabsAndFacets = (state, returnType) => {
   const tabs = getSearchTabs(state, 'js');
@@ -330,7 +331,7 @@ const getTabsAndFacets = (state, returnType) => {
       return 0;
     }).reduce((a, b) => a + b, 0);
     return { ...tab,
-      [Context.facets]: Object.fromEntries(thisTabFacets),
+      [Context$1.facets]: Object.fromEntries(thisTabFacets),
       totalCount: thisTabTotal
     };
   });
@@ -361,69 +362,70 @@ const selectFacets = {
   getFacetTitles,
   getFacets,
   getFacetsTotalCount,
-  getFeaturedResults,
+  getFeaturedResults: getFeaturedResults$1,
   getFilters,
   getFiltersToLoad,
   getIsLoaded,
-  getIsLoading,
-  getPageIndex,
-  getPageIsLoading,
+  getIsLoading: getIsLoading$1,
+  getPageIndex: getPageIndex$1,
+  getPageIsLoading: getPageIsLoading$1,
   getPagesLoaded,
-  getPaging,
-  getQueryParams: (state, facet) => getQueryParams(state, facet, Context.facets),
+  getPaging: getPaging$1,
+  getQueryParams: (state, facet) => getQueryParams(state, facet, Context$1.facets),
   getQueryParameter: ({
     state,
     facet
-  }, key, ifnull) => getQueryParameter({
+  }, key, ifnull) => getQueryParameter$1({
     state,
     facet,
-    context: Context.facets
+    context: Context$1.facets
   }, key, ifnull),
-  getRenderableFilters,
-  getResults,
+  getRenderableFilters: getRenderableFilters$1,
+  getResults: getResults$1,
   getTabFacets,
   getTabsAndFacets,
   getTotalCount,
   getSearchTabs,
-  getSearchTerm,
+  getSearchTerm: getSearchTerm$1,
   getSearchTotalCount,
   getSelectedFilters
 }; // 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),
-  getFilters: (state, listing = '') => getFilters(state, listing, Context.listings),
-  getFiltersToLoad: (state, listing = '') => getFiltersToLoad(state, listing, Context.listings),
-  getListing,
-  getIsLoaded: state => getIsLoaded(state, Context.listings),
-  getIsLoading: state => getIsLoading(state, Context.listings),
-  getPageIndex: (state, listing = '') => getPageIndex(state, listing, Context.listings),
-  getPaging: (state, listing = '') => getPaging(state, listing, Context.listings),
-  getPageIsLoading: (state, listing = '') => getPageIsLoading(state, listing, Context.listings),
-  getPagesLoaded: (state, listing = '') => getPagesLoaded(state, listing, Context.listings),
-  getQueryParams: (state, listing = '') => getQueryParams(state, listing, Context.listings),
+  getFeaturedResults: (state, listing = '') => getFeaturedResults$1(state, listing, Context$1.listings),
+  getFilters: (state, listing = '') => getFilters(state, listing, Context$1.listings),
+  getFiltersToLoad: (state, listing = '') => getFiltersToLoad(state, listing, Context$1.listings),
+  getListing: getListing$1,
+  getIsLoaded: state => getIsLoaded(state, Context$1.listings),
+  getIsLoading: state => getIsLoading$1(state, Context$1.listings),
+  getPageIndex: (state, listing = '') => getPageIndex$1(state, listing, Context$1.listings),
+  getPaging: (state, listing = '') => getPaging$1(state, listing, Context$1.listings),
+  getPageIsLoading: (state, listing = '') => getPageIsLoading$1(state, listing, Context$1.listings),
+  getPagesLoaded: (state, listing = '') => getPagesLoaded(state, listing, Context$1.listings),
+  getQueryParams: (state, listing = '') => getQueryParams(state, listing, Context$1.listings),
   getQueryParameter: ({
     state,
     facet
-  }, key, ifnull) => getQueryParameter({
+  }, key, ifnull) => getQueryParameter$1({
     state,
     facet,
-    context: Context.listings
+    context: Context$1.listings
   }, key, ifnull),
-  getRenderableFilters: (state, listing = '') => getRenderableFilters(state, listing, Context.listings),
-  getResults: (state, listing = '') => getResults(state, listing, Context.listings),
-  getSearchTerm,
-  getTotalCount: (state, listing = '') => getTotalCount(state, listing, Context.listings),
-  getSelectedFilters: (state, listing = '') => getSelectedFilters(state, listing, Context.listings)
+  getRenderableFilters: (state, listing = '') => getRenderableFilters$1(state, listing, Context$1.listings),
+  getResults: (state, listing = '') => getResults$1(state, listing, Context$1.listings),
+  getSearchTerm: getSearchTerm$1,
+  getTotalCount: (state, listing = '') => getTotalCount(state, listing, Context$1.listings),
+  getSelectedFilters: (state, listing = '') => getSelectedFilters(state, listing, Context$1.listings)
 };
 const selectCurrentPath = state => getImmutableOrJS(state, ['routing', 'currentPath']);
+const selectCurrentProject = state => getImmutableOrJS(state, ['routing', 'currentProject']);
 const selectVersionStatus = state => getImmutableOrJS(state, ['version', 'contensisVersionStatus']);
 
 var selectors = /*#__PURE__*/Object.freeze({
   __proto__: null,
   getSearchContext: getSearchContext,
-  getCurrent: getCurrent,
+  getCurrent: getCurrent$1,
   getCurrentFacet: getCurrentFacet,
   getCurrentListing: getCurrentListing,
   getCurrentTab: getCurrentTab,
@@ -431,27 +433,27 @@ var selectors = /*#__PURE__*/Object.freeze({
   getTabFacets: getTabFacets,
   getFacetTitles: getFacetTitles,
   getFacet: getFacet,
-  getListing: getListing,
+  getListing: getListing$1,
   getFilters: getFilters,
-  getRenderableFilters: getRenderableFilters,
+  getRenderableFilters: getRenderableFilters$1,
   getFiltersToLoad: getFiltersToLoad,
   getSelectedFilters: getSelectedFilters,
-  getResults: getResults,
+  getResults: getResults$1,
   getIsInternalPaging: getIsInternalPaging,
   getIsLoaded: getIsLoaded,
-  getIsLoading: getIsLoading,
+  getIsLoading: getIsLoading$1,
   getIsSsr: getIsSsr,
-  getFeaturedResults: getFeaturedResults,
-  getPaging: getPaging,
-  getPageIndex: getPageIndex,
+  getFeaturedResults: getFeaturedResults$1,
+  getPaging: getPaging$1,
+  getPageIndex: getPageIndex$1,
   getPrevPageIndex: getPrevPageIndex,
-  getPageIsLoading: getPageIsLoading,
+  getPageIsLoading: getPageIsLoading$1,
   getPagesLoaded: getPagesLoaded,
   getTotalCount: getTotalCount,
-  getSearchTerm: getSearchTerm,
+  getSearchTerm: getSearchTerm$1,
   getSearchTabs: getSearchTabs,
   getQueryParams: getQueryParams,
-  getQueryParameter: getQueryParameter,
+  getQueryParameter: getQueryParameter$1,
   getCustomApi: getCustomApi,
   getCustomEnv: getCustomEnv,
   getTabsAndFacets: getTabsAndFacets,
@@ -460,12 +462,12 @@ var selectors = /*#__PURE__*/Object.freeze({
   selectFacets: selectFacets,
   selectListing: selectListing,
   selectCurrentPath: selectCurrentPath,
+  selectCurrentProject: selectCurrentProject,
   selectVersionStatus: selectVersionStatus
 });
 
 // eslint-disable-next-line import/default
 
-/* eslint-disable @typescript-eslint/naming-convention */
 const withSearch = mappers => SearchComponent => {
   const Wrapper = props => {
     return /*#__PURE__*/React.createElement(SearchComponent, props);
@@ -476,22 +478,22 @@ const withSearch = mappers => SearchComponent => {
   const mapStateToProps = state => {
     return {
       currentFacet: getCurrentFacet(state),
-      currentPageIndex: getPageIndex(state),
+      currentPageIndex: getPageIndex$1(state),
       currentTabIndex: getCurrentTab(state),
       facet: getFacet(state),
       facets: getTabFacets(state),
       facetsTotalCount: getFacetsTotalCount(state),
       facetTitles: getFacetTitles(state),
-      featuredResults: getFeaturedResults(state),
-      filters: getRenderableFilters(state),
-      isLoading: getIsLoading(state),
-      paging: getPaging(state),
-      pageIsLoading: getPageIsLoading(state),
-      results: getResults(state),
+      featuredResults: getFeaturedResults$1(state),
+      filters: getRenderableFilters$1(state),
+      isLoading: getIsLoading$1(state),
+      paging: getPaging$1(state),
+      pageIsLoading: getPageIsLoading$1(state),
+      results: getResults$1(state),
       resultsInfo: (mappers === null || mappers === void 0 ? void 0 : mappers.resultsInfo) && mappers.resultsInfo(state),
-      searchTerm: getSearchTerm(state),
+      searchTerm: getSearchTerm$1(state),
       searchTotalCount: getSearchTotalCount(state),
-      sortOrder: getQueryParameter({
+      sortOrder: getQueryParameter$1({
         state
       }, 'dynamicOrderBy', []),
       tabsAndFacets: getTabsAndFacets(state),
@@ -500,16 +502,16 @@ const withSearch = mappers => SearchComponent => {
   };
 
   const mapDispatchToProps = {
-    clearFilters: () => withMappers(clearFilters(), mappers),
-    updateCurrentFacet: facet => withMappers(updateCurrentFacet(facet), mappers),
-    updateCurrentTab: id => withMappers(updateCurrentTab(id), mappers),
-    updatePageIndex: pageIndex => withMappers(updatePageIndex(pageIndex), mappers),
-    updateSearchTerm: term => withMappers(updateSearchTerm(term), mappers),
-    updateSelectedFilters: (filter, key) => withMappers(updateSelectedFilters(filter, key), mappers),
-    updateSortOrder: orderBy => withMappers(updateSortOrder(orderBy), mappers)
+    clearFilters: () => withMappers(clearFilters$1(), mappers),
+    updateCurrentFacet: facet => withMappers(updateCurrentFacet$1(facet), mappers),
+    updateCurrentTab: id => withMappers(updateCurrentTab$1(id), mappers),
+    updatePageIndex: pageIndex => withMappers(updatePageIndex$1(pageIndex), mappers),
+    updateSearchTerm: term => withMappers(updateSearchTerm$1(term), mappers),
+    updateSelectedFilters: (filter, key, isUnknownItem = false) => withMappers(updateSelectedFilters(filter, key, isUnknownItem), mappers),
+    updateSortOrder: orderBy => withMappers(updateSortOrder$1(orderBy), mappers)
   };
   const connector = connect(mapStateToProps, mapDispatchToProps);
-  return connector(toJS(Wrapper));
+  return connector(toJS$1(Wrapper));
 };
 
 /* eslint-disable @typescript-eslint/naming-convention */
@@ -552,14 +554,14 @@ const withListing = mappers => ListingComponent => {
   };
 
   const mapDispatchToProps = {
-    clearFilters: () => withMappers(clearFilters(), mappers),
-    updateCurrentFacet: facet => withMappers(updateCurrentFacet(facet), mappers),
-    updatePageIndex: pageIndex => withMappers(updatePageIndex(pageIndex), mappers),
-    updateSearchTerm: term => withMappers(updateSearchTerm(term), mappers),
-    updateSelectedFilters: (filter, key) => withMappers(updateSelectedFilters(filter, key), mappers),
-    updateSortOrder: orderBy => withMappers(updateSortOrder(orderBy), mappers)
+    clearFilters: () => withMappers(clearFilters$1(), mappers),
+    updateCurrentFacet: facet => withMappers(updateCurrentFacet$1(facet), mappers),
+    updatePageIndex: pageIndex => withMappers(updatePageIndex$1(pageIndex), mappers),
+    updateSearchTerm: term => withMappers(updateSearchTerm$1(term), mappers),
+    updateSelectedFilters: (filter, key, isUnknownItem = false) => withMappers(updateSelectedFilters(filter, key, isUnknownItem), mappers),
+    updateSortOrder: orderBy => withMappers(updateSortOrder$1(orderBy), mappers)
   };
-  return connect(mapStateToProps, mapDispatchToProps)(toJS(Wrapper));
+  return connect(mapStateToProps, mapDispatchToProps)(toJS$1(Wrapper));
 };
 
 const getClientConfig = (project, env) => {
@@ -768,7 +770,7 @@ const extractQuotedPhrases = searchTerm => {
   return (searchTerm.match(pattern) || []).map(match => match.replace(/"/g, ''));
 };
 const buildUrl = (route, params) => {
-  const qs = queryString.stringify(params);
+  const qs = stringify(params);
   const path = qs ? `${route}?${qs}` : route;
   return path;
 };
@@ -849,7 +851,7 @@ const fieldExpression = (field, value, operator = 'equalTo', weight) => {
     // to generate expressions that are combined with an 'or' operator
     return [Op.or(...field.map(fieldId => fieldExpression(fieldId, value, operator, weight)).flat())];
   if (operator === 'between') return between(field, value);
-  if (Array.isArray(value)) return equalToOrIn(field, value, operator);else return !weight ? [Op[operator](field, value, undefined, undefined)] : [Op[operator](field, value, undefined, undefined).weight(weight)];
+  if (Array.isArray(value)) return equalToOrIn(field, value, operator);else return !weight ? equalToOrIn(field, value, operator) : [equalToOrIn(field, value, operator)[0].weight(weight)];
 };
 const contentTypeIdExpression = (contentTypeIds, webpageTemplates, assetTypes) => {
   const expressions = [];
@@ -873,8 +875,17 @@ const contentTypeIdExpression = (contentTypeIds, webpageTemplates, assetTypes) =
 const filterExpressions = filters => {
   if (!filters) return [];
   const expressions = [];
-  filters.map(param => {
-    expressions.push(...fieldExpression(param.key, param.value, param.operator || 'in'));
+  filters.map(selectedFilter => {
+    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
+    // 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'));
   });
   return expressions;
 };
@@ -891,8 +902,8 @@ const dataFormatExpression = (contentTypeIds, dataFormat = DataFormats.entry) =>
     const withExpr = fieldExpression(Fields.sys.contentTypeId, withContentTypeIds)[0];
     const notExpr = Op.not(fieldExpression(Fields.sys.contentTypeId, notContentTypeIds)[0]);
     andExpr.add(dataFormatExpr);
-    if (withContentTypeIds.length > 0) andExpr.add(withExpr);
-    if (notContentTypeIds.length > 0) andExpr.add(notExpr);
+    if (withContentTypeIds.length > 0 && withExpr) andExpr.add(withExpr);
+    if (notContentTypeIds.length > 0 && notExpr) andExpr.add(notExpr);
     return [andExpr];
   }
 
@@ -948,19 +959,45 @@ const equalToOrIn = (field, value, operator = 'equalTo') => {
   if (value.length === 0) return [];
 
   if (Array.isArray(value)) {
-    if (value.length === 1) return [Op[operator](field, value[0], undefined, undefined)];
-    return [Op.in(field, ...value)];
+    if (operator === 'equalTo') return [Op.in(field, ...value)];
+    return [Op.or(...value.map(innerValue => {
+      switch (operator) {
+        case 'between':
+        case 'distanceWithin':
+          // Not implemented
+          return Op.equalTo(field, innerValue);
+
+        case 'freeText':
+          // TODO: Potentially needs further implementation of new options
+          return Op[operator](field, innerValue, false, undefined);
+
+        default:
+          return Op[operator](field, innerValue);
+      }
+    }))];
   }
 
-  return [];
+  switch (operator) {
+    case 'between':
+    case 'distanceWithin':
+      // Not implemented
+      return [Op.equalTo(field, value)];
+
+    case 'freeText':
+      // TODO: Potentially needs further implementation of new options
+      return [Op[operator](field, value, false, undefined)];
+
+    default:
+      return [Op[operator](field, value)];
+  }
 };
 
 const between = (field, value) => {
   const handle = betweenValue => {
-    const valArr = betweenValue.split('-');
+    const valArr = betweenValue.split('--');
 
     if (valArr.length > 1) {
-      const [minimum, maximum = null] = betweenValue.split('-');
+      const [minimum, maximum] = valArr;
       return Op.between(field, minimum, maximum);
     } else {
       // eslint-disable-next-line no-console
@@ -970,10 +1007,9 @@ const between = (field, value) => {
   };
 
   if (value.length === 0) return [];
-  if (Array.isArray(value)) return [Op.or(...value.map(handle).filter(bc => bc !== false))]; // const valArr = value.split('-');
-
+  if (Array.isArray(value)) return [Op.or(...value.map(handle).filter(bc => bc !== false))];
   const op = handle(value);
-  return op ? [op] : []; // valArr.length > 1 ? [Op.between(field, ...value.split('-'))] : [];
+  return op ? [op] : [];
 };
 /**
  * Accept HTTP style objects and map them to
@@ -1016,7 +1052,7 @@ const customWhereExpressions = where => {
             // the second property inside the clause
 
             if (notIdx === 1) {
-              expression = Op.not(Op[innerOperator](innerField, innerValue));
+              expression = innerOperator === 'between' ? Op.not(Op[innerOperator](innerField, innerValue[0], innerValue[1])) : Op.not(Op[innerOperator](innerField, innerValue));
             }
           });
         }
@@ -1028,8 +1064,9 @@ const customWhereExpressions = where => {
 
       if (idx === 1 && // operator !== 'and' &&
       // operator !== 'or' &&
-      operator !== 'between' && operator !== 'distanceWithin') {
-        expression = operator === 'freeText' || operator === 'contains' ? Op[operator](field, value) : operator === 'in' ? Op[operator](field, ...value) : Op[operator](field, value);
+      // operator !== 'between' &&
+      operator !== 'distanceWithin') {
+        expression = 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]) : Op[operator](field, value);
         if (typeof weight === 'number') expression = expression.weight(weight);
       }
     });
@@ -1142,7 +1179,7 @@ const searchUriTemplate = {
     facet,
     pageIndex
   }) => {
-    const currentFacet = getSearchContext(state) !== Context.listings && (facet || getCurrentFacet(state));
+    const currentFacet = getSearchContext(state) !== Context$1.listings && (facet || getCurrentFacet(state));
     const currentPath = selectCurrentPath(state) || '/search';
     const newPath = currentFacet ? `${currentPath}/${currentFacet}` : currentPath;
     if (pageIndex) return `${newPath}/${pageIndex + 1}`;
@@ -1159,20 +1196,16 @@ const searchUriTemplate = {
 
     const stateFilters = term ? {} : Object.fromEntries(Object.entries(getSelectedFilters(state, facet, searchContext, 'js')).map(([key, f]) => [key, f === null || f === void 0 ? void 0 : f.join(',')]));
     const currentSearch = !term && getImmutableOrJS(state, ['routing', 'location', 'search']);
-    const currentQs = removeEmptyAttributes(queryString.parse(currentSearch));
+    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
-    // to build the new Qs.
+    const searchTerm = getSearchTerm$1(state); // Merge the stateFilters with any current qs to build the new qs
 
     const mergedSearch = removeEmptyAttributes({ ...merge(currentQs, stateFilters),
       term: searchTerm
     });
-    return queryString.stringify(mergedSearch);
+    return stringify(mergedSearch);
   },
-  hash: {
-    $path: 'state',
-    $formatting: state => getImmutableOrJS(state, ['routing', 'location', 'hash'], '').replace('#', '')
-  }
+  hash: state => getImmutableOrJS(state, ['routing', 'location', 'hash'], '').replace('#', '')
 };
 
 const mapStateToSearchUri = params => mapJson(params, searchUriTemplate);
@@ -1317,14 +1350,15 @@ const filterTemplate = {
 const filterExpressionMapper = {
   // Expression type: so we can identify how to build the query
   expressionType: ({
-    filter
-  }) => filter.contentTypeId ? FilterExpressionTypes.contentType : FilterExpressionTypes.field,
+    contentTypeId
+  }) => contentTypeId ? FilterExpressionTypes.contentType : FilterExpressionTypes.field,
   // Key: so we can target the query to a specific field
-  key: 'filter.fieldId',
+  key: 'fieldId',
   // Value: so we can filter a specific field by an array of values
   // e.g. taxonomy key or contentTypeId array
-  value: 'selectedValue',
-  operator: 'filter.fieldOperator'
+  values: 'selectedValues',
+  fieldOperator: 'fieldOperator',
+  logicOperator: 'logicOperator'
 };
 
 const mapFilterToFilterExpression = filter => mapJson(filter, filterExpressionMapper);
@@ -1334,18 +1368,15 @@ const mapFiltersToFilterExpression = (filters, selectedFilters) => {
   const filterExpressions = []; // Iterate through the keys in selectedFilters and locate
   // the items that are selected and queryable
 
-  Object.entries(selectedFilters).map(([fkey, selectedValue]) => {
+  Object.entries(selectedFilters).map(([fkey, selectedValues]) => {
     const filter = filters[fkey];
 
-    if (selectedValue && filter) {
-      const selectedItems = filter.items && filter.items.filter(itm => itm.isSelected) || []; // Where we have a value for a selectedFilter
+    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,
-        selectedItems,
-        selectedValue
+      const expr = mapFilterToFilterExpression({ ...filter,
+        selectedValues
       });
       filterExpressions.push(expr);
     }
@@ -1354,10 +1385,10 @@ const mapFiltersToFilterExpression = (filters, selectedFilters) => {
 };
 
 const queryParamsTemplate = {
-  assetTypes: root => getQueryParameter(root, 'assetTypes', []),
-  contentTypeIds: root => getQueryParameter(root, 'contentTypeIds', []),
-  customWhere: root => getQueryParameter(root, 'customWhere', []),
-  dynamicOrderBy: root => getQueryParameter(root, 'dynamicOrderBy', []),
+  assetTypes: root => getQueryParameter$1(root, 'assetTypes', []),
+  contentTypeIds: root => getQueryParameter$1(root, 'contentTypeIds', []),
+  customWhere: root => getQueryParameter$1(root, 'customWhere', []),
+  dynamicOrderBy: root => getQueryParameter$1(root, 'dynamicOrderBy', []),
   env: ({
     state,
     facet,
@@ -1372,8 +1403,8 @@ const queryParamsTemplate = {
     if (excludeIds) return Array.isArray(excludeIds) ? excludeIds : excludeIds.split(',').map(id => id.trim());
     return null;
   },
-  featuredResults: root => getQueryParameter(root, 'featuredResults', null),
-  fields: root => getQueryParameter(root, 'fields', []),
+  featuredResults: root => getQueryParameter$1(root, 'featuredResults', null),
+  fields: root => getQueryParameter$1(root, 'fields', []),
   filters: ({
     state,
     facet,
@@ -1385,28 +1416,28 @@ const queryParamsTemplate = {
     const filterParams = mapFiltersToFilterExpression(stateFilters, selectedFilters);
     return filterParams;
   },
-  includeInSearchFields: root => getQueryParameter(root, 'includeInSearch', []),
+  includeInSearchFields: root => getQueryParameter$1(root, 'includeInSearch', []),
   internalPageIndex: ({
     action,
     state
-  }) => getPageIndex(state, '', action.context),
-  internalPaging: root => getQueryParameter(root, 'internalPaging', false),
+  }) => getPageIndex$1(state, '', action.context),
+  internalPaging: root => getQueryParameter$1(root, 'internalPaging', false),
   languages: ({
     action
   }) => action.defaultLang ? [action.defaultLang] : [],
-  linkDepth: root => getQueryParameter(root, 'linkDepth', 0),
-  loadMorePaging: root => getQueryParameter(root, 'loadMorePaging', false),
-  orderBy: root => getQueryParameter(root, 'orderBy', []),
+  linkDepth: root => getQueryParameter$1(root, 'linkDepth', 0),
+  loadMorePaging: root => getQueryParameter$1(root, 'loadMorePaging', false),
+  orderBy: root => getQueryParameter$1(root, 'orderBy', []),
   pageIndex: root => {
     const {
       action,
       state
     } = root;
-    if (getQueryParameter(root, 'internalPaging', false)) return 0;
+    if (getQueryParameter$1(root, 'internalPaging', false)) return 0;
     if (action.type === UPDATE_PAGE_INDEX) return action.params.pageIndex;
-    return !action.preload ? getPageIndex(state, '', action.context) : 0;
+    return !action.preload ? getPageIndex$1(state, action.facet, action.context) : 0;
   },
-  pageSize: root => getQueryParameter(root, 'pageSize'),
+  pageSize: root => getQueryParameter$1(root, 'pageSize'),
   pagesLoaded: ({
     state,
     facet,
@@ -1424,9 +1455,9 @@ const queryParamsTemplate = {
   }) => {
     var _getFacet;
 
-    return (_getFacet = getFacet(state, facet, context)) === null || _getFacet === void 0 ? void 0 : _getFacet.projectId;
+    return ((_getFacet = getFacet(state, facet, context)) === null || _getFacet === void 0 ? void 0 : _getFacet.projectId) || selectCurrentProject(state);
   },
-  searchTerm: root => root.context !== Context.minilist || getQueryParameter(root, 'useSearchTerm', false) ? getSearchTerm(root.state) : '',
+  searchTerm: root => root.context !== Context$1.minilist || getQueryParameter$1(root, 'useSearchTerm', false) ? getSearchTerm$1(root.state) : '',
   selectedFilters: ({
     state,
     facet,
@@ -1436,11 +1467,11 @@ const queryParamsTemplate = {
     state
   }) => selectVersionStatus(state),
   weightedSearchFields: root => {
-    const wsf = getQueryParameter(root, 'weightedSearchFields', []);
+    const wsf = getQueryParameter$1(root, 'weightedSearchFields', []);
     const deduped = wsf.filter((v, i, a) => a.findIndex(t => t.fieldId === v.fieldId) === i);
     return deduped; // return wsf;
   },
-  webpageTemplates: root => getQueryParameter(root, 'webpageTemplates', [])
+  webpageTemplates: root => getQueryParameter$1(root, 'webpageTemplates', [])
 };
 
 const mapStateToQueryParams = sourceJson => mapJson(sourceJson, queryParamsTemplate);
@@ -1486,10 +1517,10 @@ const runSearch = (action, state, queryParams) => {
   const facetIsLoaded = defaultLang ? false : getIsLoaded(state, context, facet);
   const stateParams = { ...getQueryParams(ogState, facet, context)
   };
-  stateParams.pageIndex = getPageIndex(ogState, facet, context);
-  stateParams.searchTerm = getSearchTerm(ogState);
+  stateParams.pageIndex = getPageIndex$1(ogState, facet, context);
+  stateParams.searchTerm = getSearchTerm$1(ogState);
 
-  if (context === Context.facets && ssr || // context === Context.minilist ||
+  if (context === Context$1.facets && ssr || // context === Context.minilist ||
   preload || !facetIsLoaded || filterParamsChanged(action) || defaultLang) {
     willRun = true;
   } else {
@@ -1538,9 +1569,10 @@ const filterParamsChanged = (action, state) => {
 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);
-  stateParams.pageIndex = getPageIndex(action.ogState || state, action.facet, action.context);
-  stateParams.searchTerm = getSearchTerm(action.ogState || state);
+  const stateParams = { ...getQueryParams(action.ogState || state, action.facet, action.context),
+    pageIndex: getPageIndex$1(action.ogState || state, action.facet, action.context),
+    searchTerm: getSearchTerm$1(action.ogState || state)
+  };
   console.log(stateParams, queryParams);
   console.log('getSelectedFilters', getSelectedFilters(action.ogState || state, action.facet, action.context, 'js'), 'params', action.params);
 };
@@ -1570,9 +1602,9 @@ const mapEntriesToFilterItems = entries => {
   });
 };
 
-const searchSagas = [takeEvery(CLEAR_FILTERS, clearFilters$1), takeEvery(DO_SEARCH, doSearch), takeEvery(SET_ROUTE_FILTERS, loadFilters), takeEvery(SET_SEARCH_ENTRIES, preloadOtherFacets), takeEvery(UPDATE_CURRENT_FACET, updateCurrentFacet$1), takeEvery(UPDATE_CURRENT_TAB, updateCurrentTab$1), takeEvery(UPDATE_PAGE_INDEX, updatePageIndex$1), takeEvery(UPDATE_SEARCH_TERM, updateSearchTerm$1), takeEvery(UPDATE_SORT_ORDER, updateSortOrder$1), takeEvery(UPDATE_SELECTED_FILTERS, applySearchFilter)];
+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_SEARCH_TERM, updateSearchTerm), takeEvery(UPDATE_SORT_ORDER, updateSortOrder), takeEvery(UPDATE_SELECTED_FILTERS, applySearchFilter)];
 
-const toJS$1 = obj => obj && 'toJS' in obj && typeof obj.toJS === 'function' ? obj.toJS() : obj;
+const toJS = obj => obj && 'toJS' in obj && typeof obj.toJS === 'function' ? obj.toJS() : obj;
 
 function* setRouteFilters(action) {
   const {
@@ -1582,8 +1614,8 @@ function* setRouteFilters(action) {
     defaultLang,
     debug
   } = action;
-  const context = listingType ? Context.listings : Context.facets;
-  const state = toJS$1(yield select());
+  const context = listingType ? Context$1.listings : Context$1.facets;
+  const state = toJS(yield select());
   const ssr = getIsSsr(state); // Get current facet from params or state
 
   let currentFacet = params && params.facet || listingType; // Pick the default facet from initialState
@@ -1605,15 +1637,21 @@ function* setRouteFilters(action) {
     ssr,
     debug
   };
-  yield put(nextAction); // Using call instead of triggering from the put
+  yield put(nextAction); // 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
   // to allow this exported saga to continue during SSR
 
   yield call(ensureSearch, { ...nextAction,
-    ogState: state
+    ogState
   });
 }
 function* doSearch(action) {
-  const state = toJS$1(yield select());
+  var _action$params;
+
+  const state = toJS(yield select());
 
   if (action.config) {
     // If the action contains a config object, we can add this to the
@@ -1625,12 +1663,20 @@ function* doSearch(action) {
 
   const nextAction = { ...action,
     type: SET_SEARCH_FILTERS,
-    ssr: getIsSsr(state)
+    ssr: getIsSsr(state),
+    facet: action.facet || ((_action$params = action.params) === null || _action$params === void 0 ? void 0 : _action$params.facet)
   };
-  yield put(nextAction);
-  yield call(ensureSearch, { ...nextAction,
-    ogState: state
-  });
+
+  if (nextAction.facet) {
+    yield put(nextAction); // keep track of this state ref for comparing changes to params later
+
+    const ogState = {
+      search: state.search
+    };
+    yield call(ensureSearch, { ...nextAction,
+      ogState
+    });
+  }
 }
 
 function* loadFilters(action) {
@@ -1728,7 +1774,9 @@ function* ensureSearch(action) {
   try {
     const state = yield select();
     const nextAction = { ...action,
-      ogState: action.ogState || state
+      ogState: action.ogState || {
+        search: state.search
+      }
     };
     const [queryParams, runSearch] = generateQueryParams(nextAction, state);
     if (debug && (debug === true || debug.executeSearch)) debugExecuteSearch(nextAction, state);
@@ -1746,9 +1794,9 @@ function* ensureSearch(action) {
         debug
       });
     }
-  } catch (error$1) {
+  } catch (error) {
     // eslint-disable-next-line import/namespace
-    error(...['Error running search saga:', error$1, error$1.stack]);
+    log.error(...['Error running search saga:', error, error.stack]);
   }
 }
 
@@ -1791,15 +1839,15 @@ function* executeSearch(action) {
       action,
       featuredResult,
       pageIndex: queryParams.internalPaging && queryParams.internalPageIndex || queryParams.pageIndex,
-      prevResults: getResults(state, facet, action.context, 'js'),
+      prevResults: getResults$1(state, facet, action.context, 'js'),
       result,
       state
     };
     const nextAction = mapJson(createStateFrom, facetTemplate);
     yield put(nextAction);
-  } catch (error$1) {
+  } catch (error) {
     // eslint-disable-next-line import/namespace
-    error(...['Error running search saga:', error$1, error$1.stack]);
+    log.error(...['Error running search saga:', error, error.stack]);
   }
 }
 
@@ -1813,7 +1861,7 @@ function* preloadOtherFacets(action) {
   const state = yield select();
   const currentFacet = getCurrentFacet(state);
 
-  if (!preload && facet === currentFacet && context !== Context.listings) {
+  if (!preload && facet === currentFacet && context !== Context$1.listings) {
     const allFacets = getFacets(state, 'js');
     const otherFacets = Object.keys(allFacets).filter(f => f !== currentFacet);
     yield all(otherFacets.map((preloadFacet = '') => {
@@ -1833,7 +1881,7 @@ function* preloadOtherFacets(action) {
   }
 }
 
-function* updateCurrentTab$1(action) {
+function* updateCurrentTab(action) {
   const {
     id,
     mappers
@@ -1852,10 +1900,10 @@ function* updateCurrentTab$1(action) {
 
 
   if (!nextFacet) nextFacet = Object.entries(facets).filter(([, f]) => f.tabId === id)[0][0];
-  yield put(withMappers(updateCurrentFacet(nextFacet), mappers));
+  yield put(withMappers(updateCurrentFacet$1(nextFacet), mappers));
 }
 
-function* clearFilters$1(action) {
+function* clearFilters(action) {
   const {
     mappers
   } = action;
@@ -1863,12 +1911,12 @@ function* clearFilters$1(action) {
   yield put(navigate(uri));
 }
 
-function* updateCurrentFacet$1(action) {
+function* updateCurrentFacet(action) {
   const {
     facet,
     mappers
   } = action;
-  const pageIndex = yield select(getPageIndex, facet);
+  const pageIndex = yield select(getPageIndex$1, facet);
   const uri = yield buildUri({
     facet,
     pageIndex
@@ -1876,7 +1924,7 @@ function* updateCurrentFacet$1(action) {
   yield put(navigate(uri));
 }
 
-function* updateSearchTerm$1(action) {
+function* updateSearchTerm(action) {
   const {
     term,
     mappers
@@ -1887,7 +1935,7 @@ function* updateSearchTerm$1(action) {
   yield put(navigate(uri));
 }
 
-function* updateSortOrder$1(action) {
+function* updateSortOrder(action) {
   const {
     orderBy,
     facet,
@@ -1900,7 +1948,7 @@ function* updateSortOrder$1(action) {
   yield put(navigate(uri));
 }
 
-function* updatePageIndex$1(action) {
+function* updatePageIndex(action) {
   const {
     pageIndex,
     mappers
@@ -1926,7 +1974,7 @@ function* buildUri({
   term
 }, mappers) {
   const state = yield select();
-  const mapUri = mappers && mappers.navigate || mapStateToSearchUri;
+  const mapUri = (mappers === null || mappers === void 0 ? void 0 : mappers.navigate) || mapStateToSearchUri;
   const uri = mapUri({
     state,
     facet,
@@ -1938,13 +1986,97 @@ function* buildUri({
   return `${uri.path}${uri.search && `?${uri.search}` || ''}${uri.hash && `#${uri.hash}` || ''}`;
 }
 
+var defaultMappers = {
+  results: entries => entries,
+  navigate: mapStateToSearchUri
+};
+
+const {
+  getCurrent,
+  getFeaturedResults,
+  getIsLoading,
+  getListing,
+  getPageIndex,
+  getPageIsLoading,
+  getPaging,
+  getQueryParameter,
+  getRenderableFilters,
+  getResults,
+  getSearchTerm
+} = selectListing;
+
+const makeSelectListingProps = () => createSelector(state => state, (_, mappers) => mappers, (state, mappers) => ({
+  currentListing: getCurrent(state),
+  currentPageIndex: getPageIndex(state),
+  listing: getListing(state),
+  featured: getFeaturedResults(state),
+  filters: getRenderableFilters(state),
+  isLoading: getIsLoading(state),
+  pageIsLoading: getPageIsLoading(state),
+  paging: getPaging(state),
+  results: getResults(state),
+  resultsInfo: mappers && typeof mappers.resultsInfo === 'function' && mappers.resultsInfo(state),
+  searchTerm: getSearchTerm(state),
+  sortOrder: getQueryParameter({
+    state
+  }, 'dynamicOrderBy', [])
+}));
+
+const useListing = ({
+  mappers
+} = {
+  id: ''
+}) => {
+  const dispatch = useDispatch();
+  const m = mappers || defaultMappers;
+  const selectListingProps = useMemo(makeSelectListingProps, [m]);
+  const dispatchProps = {
+    clearFilters: () => dispatch(withMappers(clearFilters$1(), m)),
+    updateCurrentFacet: facet => dispatch(withMappers(updateCurrentFacet$1(facet), m)),
+    updatePageIndex: pageIndex => dispatch(withMappers(updatePageIndex$1(pageIndex), m)),
+    updateSearchTerm: term => dispatch(withMappers(updateSearchTerm$1(term), m)),
+    updateSelectedFilters: (filter, key, isUnknownItem = false) => dispatch(withMappers(updateSelectedFilters(filter, key, isUnknownItem), m)),
+    updateSortOrder: orderBy => dispatch(withMappers(updateSortOrder$1(orderBy), m))
+  };
+  const {
+    currentListing,
+    currentPageIndex,
+    featured,
+    filters,
+    isLoading,
+    listing,
+    paging,
+    pageIsLoading,
+    results,
+    resultsInfo,
+    searchTerm,
+    sortOrder
+  } = useSelector(state => selectListingProps(state, m));
+  return {
+    currentListing,
+    currentPageIndex,
+    featured,
+    filters,
+    isLoading,
+    listing,
+    pageIsLoading,
+    paging,
+    results,
+    resultsInfo,
+    searchTerm,
+    sortOrder,
+    title: listing.title,
+    ...dispatchProps
+  };
+};
+
 const makeSelectMinilistProps = () => createSelector(state => state, (_, id) => id, (state, id) => ({
-  facet: getFacet(state, id, Context.minilist, 'js'),
-  filters: getFilters(state, id, Context.minilist, 'js'),
-  isLoading: getIsLoading(state, Context.minilist, id),
-  pagingInfo: getPaging(state, id, Context.minilist, 'js'),
-  results: getResults(state, id, Context.minilist, 'js'),
-  searchTerm: getSearchTerm(state)
+  facet: getFacet(state, id, Context$1.minilist, 'js'),
+  filters: getFilters(state, id, Context$1.minilist, 'js'),
+  isLoading: getIsLoading$1(state, Context$1.minilist, id),
+  pagingInfo: getPaging$1(state, id, Context$1.minilist, 'js'),
+  results: getResults$1(state, id, Context$1.minilist, 'js'),
+  searchTerm: getSearchTerm$1(state)
 }));
 
 const useMinilist = ({
@@ -1981,7 +2113,7 @@ const useMinilist = ({
     if (id && (mapper || mappers && mappers.results)) {
       dispatch(triggerSearch({
         config,
-        context: Context.minilist,
+        context: Context$1.minilist,
         defaultLang,
         facet: id,
         mapper,
@@ -1995,7 +2127,7 @@ const useMinilist = ({
   return {
     filters,
     isLoading,
-    pagingInfo,
+    paging: pagingInfo,
     results,
     searchTerm,
     title: facet.title
@@ -2179,7 +2311,10 @@ const generateFiltersState = ({
   // the search results during SSR without needing to fetch the filters first
 
 
-  Object.entries(filterParams).map(([paramName = '', paramValue]) => typeof paramValue === 'string' && paramValue.split(',').map(pVal => filters = addFilterItem(filters, paramName, pVal)));
+  Object.entries(filterParams).map(([paramName = '', paramValue]) => {
+    if (typeof paramValue === 'string') return paramValue.split(',').map(pVal => filters = addFilterItem(filters, paramName, pVal));
+    if (typeof paramValue === 'boolean') filters = addFilterItem(filters, paramName, paramValue);
+  });
   return Object.fromEntries(filters);
 };
 
@@ -2196,9 +2331,9 @@ var reducers = (config => {
   // Add facets from SearchConfig to initialState
   const initState = { ...initialState,
     tabs: config.tabs,
-    facets: generateSearchFacets(Context.facets, config),
-    listings: generateSearchFacets(Context.listings, config),
-    minilist: generateSearchFacets(Context.minilist, config)
+    facets: generateSearchFacets(Context$1.facets, config),
+    listings: generateSearchFacets(Context$1.listings, config),
+    minilist: generateSearchFacets(Context$1.minilist, config)
   };
   return produce((state = initState, action) => {
     const context = state.context;
@@ -2208,7 +2343,7 @@ var reducers = (config => {
       case APPLY_CONFIG:
         {
           state = addConfigToState(state, action);
-          return;
+          return state;
         }
 
       case CLEAR_FILTERS:
@@ -2325,7 +2460,7 @@ var reducers = (config => {
           }));
           state.context = context;
           state[context] = nextFacets;
-          state[action.context === Context.facets ? 'currentFacet' : 'currentListing'] = facet;
+          state[action.context === Context$1.facets ? 'currentFacet' : 'currentListing'] = facet;
           state.term = term;
           state.tabs[tabId].currentFacet = facet;
           state[context][facet].pagingInfo.pageIndex = Number(pageIndex) - 1 || (state[context][facet].queryParams.loadMorePaging ? state[context][facet].pagingInfo.pageIndex || 0 : 0);
@@ -2358,9 +2493,9 @@ var reducers = (config => {
             isCurrentFacet: true
           }, state);
           const term = action === null || action === void 0 ? void 0 : (_action$params = action.params) === null || _action$params === void 0 ? void 0 : _action$params.term;
-          const useSearchTerm = state[action.context || Context.minilist][action.facet].queryParams.useSearchTerm || false;
-          state[action.context || Context.minilist][action.facet].filters = filters;
-          state[action.context || Context.minilist][action.facet].queryParams.excludeIds = action.excludeIds;
+          const useSearchTerm = state[action.context || Context$1.minilist][action.facet].queryParams.useSearchTerm || false;
+          state[action.context || Context$1.minilist][action.facet].filters = filters;
+          state[action.context || Context$1.minilist][action.facet].queryParams.excludeIds = action.excludeIds;
           state.term = useSearchTerm ? term : state.term;
           state.config.ssr = typeof window === 'undefined';
           return;
@@ -2392,13 +2527,22 @@ var reducers = (config => {
         {
           const {
             filter,
-            key
+            key,
+            isUnknownItem
           } = action;
           const isSingleSelect = state[context][current].filters[filter].isSingleSelect || false;
           const isGrouped = state[context][current].filters[filter].isGrouped || false;
           const currentItems = state[context][current].filters[filter].items;
           if (isGrouped) state[context] = resetFacets(state, context);
           state[context][current] = resetFacet(state[context][current]);
+
+          if (isUnknownItem && (currentItems === null || currentItems === void 0 ? void 0 : currentItems.findIndex(item => (item === null || item === void 0 ? void 0 : item.key) === key)) === -1) {
+            currentItems === null || currentItems === void 0 ? void 0 : currentItems.push({
+              key,
+              isSelected: false
+            });
+          }
+
           state[context][current].filters[filter].items = currentItems === null || currentItems === void 0 ? void 0 : currentItems.map(item => {
             if (item.key === key) {
               return { ...item,
@@ -2432,12 +2576,11 @@ var reducers = (config => {
   }, initState);
 });
 
-// eslint-disable-next-line @typescript-eslint/naming-convention
-const Context$1 = {
+const Context = {
   facets: 'facets',
   listings: 'listings',
   minilist: 'minilist'
 };
 
-export { Context$1 as Context, actions, doSearch, queries, reducers as reducer, searchSagas as sagas, schema, selectors, setRouteFilters, types, useMinilist, withListing, withSearch };
+export { Context, actions, doSearch, queries, reducers as reducer, searchSagas as sagas, schema, selectors, setRouteFilters, types, useListing, useMinilist, withListing, withSearch };
 //# sourceMappingURL=search.js.map