@blaze-cms/react-page-builder 0.124.0-alpha.3 → 0.124.0-alpha.30

package/src/components/SearchFilter/SearchFilter/SearchFilter.js

@@ -1,4 +1,4 @@
-import React, { useState, useEffect, useReducer } from 'react';
+import React, { useState, useEffect } from 'react';
 import PropTypes from 'prop-types';
 import classnames from 'classnames';
 import debounce from 'lodash.debounce';
@@ -14,21 +14,6 @@ import ResetDesktopForm from './ResetDesktopForm';
 import MobileFormToolbar from './MobileFormToolbar';
 import { SEARCH, REFINE, MORE_FILTERS_CLASSES } from '../constants';
 
-const reducer = (state, action) => {
-  const { newValues, type, shouldSearch = true } = action;
-
-  switch (type) {
-    case 'update':
-      return { ...state, ...newValues, shouldSearch };
-    case 'resetSearch':
-      return { ...state, shouldSearch: false };
-    case 'reset':
-      return { ...newValues, shouldSearch };
-    default:
-      throw new Error();
-  }
-};
-
 const SearchFilter = ({
   searchFilterRef,
   data,
@@ -40,27 +25,33 @@ const SearchFilter = ({
   isCollapsedOnResponsive,
   displaySearchFilter,
   setDisplaySearchFilter,
-  initialFilterValues,
   groupAfterDesktop,
-  groupAfterMobile
+  groupAfterMobile,
+  filterValues,
+  setAppliedFilters
 }) => {
   const [moreFiltersMobileCollapsed, setMoreFiltersMobileCollapsed] = useState(true);
   const [moreFiltersDesktopCollapsed, setMoreFiltersDesktopCollapsed] = useState(true);
-  const [filterValues, dispatch] = useReducer(reducer, initialFilterValues);
 
-  const handleSubmit = debounce(newValues => {
+  const doSubmit = (newValues = filterValues) => {
     const newQuery = buildQuery(newValues, filters);
     handleSearch(newQuery);
+    setMoreFiltersDesktopCollapsed(true);
+    setMoreFiltersMobileCollapsed(true);
+  };
+
+  const handleSubmit = debounce(newValues => {
+    doSubmit(newValues);
   }, 200);
 
   useEffect(
     () => {
       if (filterValues.shouldSearch) {
         handleSubmit(filterValues);
-        dispatch({ type: 'resetSearch' });
+        setAppliedFilters({ type: 'resetSearch' });
       }
     },
-    [filterValues, handleSubmit]
+    [filterValues, handleSubmit, setAppliedFilters]
   );
 
   const formClass = classnames('filter__form filter__form--initial', {
@@ -79,12 +70,12 @@ const SearchFilter = ({
 
   const handleReset = () => {
     const newValues = getInitialFilterValues(data, filters, {});
-
-    dispatch({ newValues, type: 'reset' });
+    setAppliedFilters({ newValues, type: 'reset' });
   };
 
   const updateFilterValues = (newValues, shouldSubmit) => {
-    dispatch({ newValues, shouldSearch: shouldSubmit, type: 'update' });
+    const newAppliedFilters = { ...filterValues, ...newValues };
+    setAppliedFilters({ newValues: newAppliedFilters, shouldSearch: shouldSubmit, type: 'update' });
   };
 
   const shouldGroup = !!(groupAfterDesktop || groupAfterMobile);
@@ -99,8 +90,7 @@ const SearchFilter = ({
         id={formId}
         onSubmit={e => {
           e.preventDefault();
-          const newQuery = buildQuery(filterValues, filters);
-          handleSearch(newQuery);
+          doSubmit();
         }}>
         {displaySearchFilter && (
           <CloseMobileForm handleClose={() => setDisplaySearchFilter(false)} />
@@ -136,6 +126,7 @@ const SearchFilter = ({
 
                 {!!groupAfterMobile && (
                   <button
+                    data-testId="search-filter-mobile-toggler"
                     className={moreFiltersMobileTogglerClass}
                     type="button"
                     onClick={() => setMoreFiltersMobileCollapsed(!moreFiltersMobileCollapsed)}>
@@ -160,6 +151,7 @@ const SearchFilter = ({
 
                     {!!groupAfterDesktop && (
                       <button
+                        data-testId="search-filter-desktop-toggler"
                         className={moreFiltersDesktopTogglerClass}
                         type="button"
                         onClick={() =>
@@ -241,7 +233,8 @@ SearchFilter.propTypes = {
   isCollapsedOnResponsive: PropTypes.bool.isRequired,
   groupAfterDesktop: PropTypes.number.isRequired,
   groupAfterMobile: PropTypes.number.isRequired,
-  initialFilterValues: PropTypes.object.isRequired
+  filterValues: PropTypes.object.isRequired,
+  setAppliedFilters: PropTypes.func.isRequired
 };
 
 export default SearchFilter;

package/src/components/SearchFilter/SearchFilterContainer.js

@@ -1,4 +1,4 @@
-import React, { useState, useRef } from 'react';
+import React, { useState, useRef, useReducer } from 'react';
 import { useRouter } from 'next/router';
 import { useQuery } from '@apollo/client';
 import PropTypes from 'prop-types';
@@ -6,11 +6,31 @@ import { parseUrl, stringify } from 'query-string';
 import SearchFilter from './SearchFilter';
 import { withTitle } from '../../HOC';
 import { getSearchPublishedContent } from '../../application/query';
-import { buildNewQuery, buildRawQueryStringified, getInitialFilterValues } from './helpers';
+import {
+  buildNewQuery,
+  buildRawQueryStringified,
+  getInitialFilterValues,
+  buildFiltersQuery
+} from './helpers';
 import { getEntityData } from '../../helpers';
 import { RAW_RESULTS, RANGE, CHECKBOX_SELECT } from './constants';
 import { SCROLL_OFFSET } from '../../constants';
 
+const reducer = (state, action) => {
+  const { newValues, type, shouldSearch = true } = action;
+
+  switch (type) {
+    case 'update':
+      return { ...state, ...newValues, shouldSearch };
+    case 'resetSearch':
+      return { ...state, shouldSearch: false };
+    case 'reset':
+      return { ...newValues, shouldSearch };
+    default:
+      throw new Error();
+  }
+};
+
 const SearchFilterContainer = ({
   entity,
   url,
@@ -18,25 +38,27 @@ const SearchFilterContainer = ({
   name,
   isCollapsedOnResponsive,
   groupAfterMobile,
-  groupAfterDesktop
+  groupAfterDesktop,
+  filterBy,
+  filterByProperty,
+  shouldAddFilters
 }) => {
   const router = useRouter();
+  const { asPath } = router;
   const searchFilterRef = useRef(null);
   const [key, setKey] = useState(`filter-${name}`);
   const [displaySearchFilter, setDisplaySearchFilter] = useState(false);
+  const [filterValues, dispatch] = useReducer(reducer, null);
   const hasUrl = !!url;
   const {
     url: currentUrl,
     query: { sort, sortby },
     query
-  } = parseUrl(router.asPath);
+  } = parseUrl(asPath);
   const sortValues = sort && sortby ? stringify({ sort, sortby }) : '';
   const baseQuery = sortValues ? `${currentUrl}?${sortValues}` : currentUrl;
 
   const action = getSearchPublishedContent(RAW_RESULTS);
-
-  let rawQueryStringified = '';
-
   const checkboxSelectValues = [];
   const rangeValues = [];
 
@@ -50,21 +72,32 @@ const SearchFilterContainer = ({
 
   const { docType } = getEntityData(entity);
 
-  rawQueryStringified = buildRawQueryStringified(checkboxSelectValues, rangeValues, docType);
+  const filtersQuery = shouldAddFilters
+    ? buildFiltersQuery(filterValues || query, filterBy, filterByProperty)
+    : [];
+
+  const rawQueryStringified = buildRawQueryStringified(
+    checkboxSelectValues,
+    rangeValues,
+    docType,
+    filtersQuery
+  );
 
-  const { data, error, loading } = useQuery(action, {
+  const { data, error } = useQuery(action, {
     variables: { rawQueryStringified, limit: 0 }, // we only want aggs so limit=0 for no search results
     skip: !rawQueryStringified
   });
 
-  if (loading) return null;
   if (error) return error.message;
   if (!filters.length) return null;
 
-  const { searchPublishedContent: { rawResults: { aggregations: filterData = {} } = {} } = {} } =
+  const { searchPublishedContent: { rawResults: { aggregations: filterData } = {} } = {} } =
     data || {};
 
-  const initialFilterValues = getInitialFilterValues(filterData, filters, query);
+  if (!filterValues && filterData) {
+    const initialFilterValues = getInitialFilterValues(filterData, filters, query);
+    dispatch({ newValues: initialFilterValues, shouldSearch: false, type: 'update' });
+  }
 
   const handleSearch = newQuery => {
     setDisplaySearchFilter(false);
@@ -93,17 +126,19 @@ const SearchFilterContainer = ({
       window.scrollTo(0, 0);
     }
   };
+  if (!filterValues) return '';
 
   return (
     <SearchFilter
       key={key}
+      setAppliedFilters={dispatch}
       searchFilterRef={searchFilterRef}
       data={filterData}
       filters={filters}
       hasUrl={hasUrl}
       entity={entity}
       handleSearch={handleSearch}
-      initialFilterValues={initialFilterValues}
+      filterValues={filterValues}
       name={name}
       isCollapsedOnResponsive={isCollapsedOnResponsive}
       displaySearchFilter={displaySearchFilter}
@@ -121,7 +156,10 @@ SearchFilterContainer.propTypes = {
   name: PropTypes.string.isRequired,
   isCollapsedOnResponsive: PropTypes.bool,
   groupAfterMobile: PropTypes.number,
-  groupAfterDesktop: PropTypes.number
+  groupAfterDesktop: PropTypes.number,
+  filterBy: PropTypes.array,
+  filterByProperty: PropTypes.array,
+  shouldAddFilters: PropTypes.bool
 };
 
 SearchFilterContainer.defaultProps = {
@@ -130,7 +168,10 @@ SearchFilterContainer.defaultProps = {
   entity: '',
   isCollapsedOnResponsive: true,
   groupAfterMobile: 0,
-  groupAfterDesktop: 0
+  groupAfterDesktop: 0,
+  filterBy: [],
+  filterByProperty: [],
+  shouldAddFilters: false
 };
 
 export default withTitle(SearchFilterContainer);

package/src/components/SearchFilter/components/Checkbox.js

@@ -7,7 +7,15 @@ import { withTitle } from '../../../HOC';
 import { decodeValue } from '../helpers';
 import { LIMIT_MIN, LIMIT_MAX, MORE, LESS } from '../constants';
 
-const Checkbox = ({ data, prop, updateFilterValues, filterValues, label, shouldSearch }) => {
+const Checkbox = ({
+  data,
+  prop,
+  updateFilterValues,
+  filterValues,
+  label,
+  shouldSearch,
+  displayFilterCount
+}) => {
   const [checkboxLimit, setCheckboxLimit] = useState(null);
 
   const handleCheckboxOptions = () => {
@@ -35,7 +43,10 @@ const Checkbox = ({ data, prop, updateFilterValues, filterValues, label, shouldS
   const multiple = [];
 
   const sortedValues = data[prop].buckets
-    .map(({ key }) => key)
+    .map(({ key, doc_count: count }) => {
+      const optionLabel = displayFilterCount ? `${key} (${count})` : key;
+      return [key, optionLabel, !count];
+    })
     .filter(Boolean)
     .sort();
 
@@ -43,11 +54,12 @@ const Checkbox = ({ data, prop, updateFilterValues, filterValues, label, shouldS
     (value, i) =>
       i < checkboxLimit[prop] &&
       multiple.push({
-        label: upperFirst(value),
-        value,
+        label: upperFirst(value[1]),
+        value: value[0],
         name: prop,
-        checked: checkboxQueryParams.includes(value),
-        id: value
+        checked: checkboxQueryParams.includes(value[0]),
+        id: value[0],
+        disabled: value[2]
       })
   );
 
@@ -95,12 +107,14 @@ Checkbox.propTypes = {
   filterValues: PropTypes.object.isRequired,
   updateFilterValues: PropTypes.func.isRequired,
   shouldSearch: PropTypes.bool,
-  label: PropTypes.string
+  label: PropTypes.string,
+  displayFilterCount: PropTypes.bool
 };
 
 Checkbox.defaultProps = {
   shouldSearch: false,
-  label: ''
+  label: '',
+  displayFilterCount: false
 };
 
 export default withTitle(Checkbox);

package/src/components/SearchFilter/components/Select.js

@@ -11,17 +11,21 @@ const SelectFilter = ({
   updateFilterValues,
   filterValues,
   shouldSearch,
-  displayLabelAsPlaceholder
+  displayLabelAsPlaceholder,
+  displayFilterCount
 }) => {
   const filterValue = filterValues[prop] || '';
-
-  const options = data[prop].buckets
-    .map(bucket => bucket.key)
+  const disabledOptions = [];
+  const { buckets = [] } = data[prop] || {};
+  const options = buckets
+    .map(({ key, doc_count: count }) => {
+      if (!count) disabledOptions.push(key);
+      const optionLabel = displayFilterCount ? `${key} (${count})` : key;
+      return [key, optionLabel];
+    })
     .filter(Boolean)
     .sort();
 
-  const optionsJoined = options;
-
   const labelText = label || prop;
   let labelToUse = labelText;
   let defaultTextValue = DEFAULT_OPTION;
@@ -36,14 +40,14 @@ const SelectFilter = ({
       value={filterValue}
       id={prop}
       data-testid={`filter-${prop}`}
-      options={optionsJoined}
+      options={options}
       defaultTextValue={defaultTextValue}
       onChange={({ value }) => {
         let valueToUse = value;
         if (value === defaultTextValue) valueToUse = '';
-
         updateFilterValues({ [prop]: valueToUse }, shouldSearch);
       }}
+      disabled={disabledOptions}
     />
   );
 };
@@ -51,17 +55,20 @@ const SelectFilter = ({
 SelectFilter.propTypes = {
   data: PropTypes.object.isRequired,
   prop: PropTypes.string.isRequired,
-  filterValues: PropTypes.object.isRequired,
+  filterValues: PropTypes.object,
   updateFilterValues: PropTypes.func.isRequired,
   shouldSearch: PropTypes.bool,
   label: PropTypes.string,
-  displayLabelAsPlaceholder: PropTypes.bool
+  displayLabelAsPlaceholder: PropTypes.bool,
+  displayFilterCount: PropTypes.bool
 };
 
 SelectFilter.defaultProps = {
+  filterValues: {},
   shouldSearch: false,
   label: '',
-  displayLabelAsPlaceholder: false
+  displayLabelAsPlaceholder: false,
+  displayFilterCount: false
 };
 
 export default withTitle(SelectFilter);

package/src/components/SearchFilter/components/TextSearch.js

@@ -5,7 +5,7 @@ import { MdSearch } from 'react-icons/md';
 import { withTitle } from '../../../HOC';
 import { SEARCH_TERM } from '../constants';
 
-const TextSearch = ({ label, searchValue, updateFilterValues, handleSubmit, filterValues }) => (
+const TextSearch = ({ label, searchValue, updateFilterValues }) => (
   <div className="search">
     <div className="search__wrapper">
       <div className="form-field form-field--input form-field--search">
@@ -34,10 +34,8 @@ const TextSearch = ({ label, searchValue, updateFilterValues, handleSubmit, filt
 );
 
 TextSearch.propTypes = {
-  filterValues: PropTypes.object.isRequired,
   searchValue: PropTypes.string.isRequired,
   updateFilterValues: PropTypes.func.isRequired,
-  handleSubmit: PropTypes.func.isRequired,
   label: PropTypes.string
 };
 

package/src/components/SearchFilter/constants.js

@@ -2,7 +2,7 @@ const CHECKBOX = 'checkbox';
 const SELECT = 'select';
 const TEXT_SEARCH = 'text-search';
 const SEARCH_TERM = 'search_term';
-const SIZE = 50;
+const SIZE = process.env.BLAZE_PB_SEARCH_FILETER_AGG_SIZE || 500;
 const KEYWORD = 'keyword';
 const RAW_RESULTS = 'rawResults';
 const DEFAULT_OPTION = 'Any';

package/src/components/SearchFilter/helpers/build-filters-query.js

@@ -0,0 +1,40 @@
+const builFilterObject = (key, value, filters) => {
+  const isArray = Array.isArray(value);
+  if (!isArray) {
+    const singleFilterObj = { match: { [key]: value } };
+    filters.push(singleFilterObj);
+    return;
+  }
+
+  value.forEach(filterValue => {
+    filters.push({ match: { [key]: filterValue } });
+  });
+};
+const buildFiltersQuery = (query, filterBy, filterByProperty) => {
+  const mustFilters = [];
+  Object.keys(query).forEach(queryKey => {
+    if (queryKey === 'search_term' || queryKey === 'shouldSearch') return;
+    if (!queryKey || !query[queryKey]) return;
+    const queryValue = query[queryKey];
+    const queryKeyword = `${queryKey}.keyword`;
+    builFilterObject(queryKeyword, queryValue, mustFilters);
+  });
+
+  if (filterByProperty && filterByProperty.length) {
+    filterByProperty &&
+      filterByProperty.forEach(filterByPropOption => {
+        const [filterByPropKey] = filterByPropOption.split('/');
+        filterBy.forEach(filterByOption => {
+          if (filterByOption.indexOf(filterByPropKey) === -1) return;
+          const [, filteryByValue] = filterByOption.split('/');
+          const filterByKeyword = `${filterByPropKey}.keyword`;
+          if (!filteryByValue) return;
+          mustFilters.push({ match: { [filterByKeyword]: filteryByValue } });
+        });
+      });
+  }
+
+  return mustFilters;
+};
+
+export default buildFiltersQuery;

package/src/components/SearchFilter/helpers/build-raw-query-stringified.js

@@ -1,6 +1,6 @@
 import { KEYWORD, SIZE } from '../constants';
 
-const buildRawQueryStringified = (checkboxSelectValues, rangeValues, entity) => {
+const buildRawQueryStringified = (checkboxSelectValues, rangeValues, entity, mustFilters) => {
   if (!checkboxSelectValues.length && !rangeValues.length) return '';
 
   const aggs = {};
@@ -36,6 +36,7 @@ const buildRawQueryStringified = (checkboxSelectValues, rangeValues, entity) =>
                 }
               }
             ],
+            must: mustFilters,
             minimum_should_match: 1
           }
         }

package/src/components/SearchFilter/helpers/get-initial-filter-values.js

@@ -3,6 +3,7 @@ import getFilterValueFromQuery from './get-filter-value-from-query';
 
 const getInitialFilterValues = (filterData, filters, query) => {
   const filterValues = {};
+
   Object.keys(filterData).forEach(key => {
     const filterProps =
       filters.find(({ propsToDisplay }) => propsToDisplay.find(prop => key === prop)) || {};

package/src/components/SearchFilter/helpers/index.js

@@ -13,6 +13,7 @@ import isDeviceDesktop from './is-device-desktop';
 import getInitialFilterValues from './get-initial-filter-values';
 import getFilterValueFromQuery from './get-filter-value-from-query';
 import buildQuery from './build-query';
+import buildFiltersQuery from './build-filters-query';
 
 export {
   buildQuery,
@@ -30,5 +31,6 @@ export {
   getSelectOptions,
   isDeviceDesktop,
   getInitialFilterValues,
-  getFilterValueFromQuery
+  getFilterValueFromQuery,
+  buildFiltersQuery
 };

package/src/components/index.js

@@ -18,7 +18,7 @@ export default {
   video: dynamic(() => import(/* webpackChunkName: "blazePbVideo" */ './Video')),
   wrapper: dynamic(() => import(/* webpackChunkName: "blazePbWrapper" */ './Wrapper')),
   searchcontent: dynamic(() =>
-    import(/* webpackChunkName: "blazePbSearchFilter" */ './SearchContent')
+    import(/* webpackChunkName: "blazePbSearchFilter" */ './SearchContent/SearchContent')
   ),
   searchfilter: dynamic(() =>
     import(/* webpackChunkName: "blazePbSearchFilter" */ './SearchFilter')
@@ -42,5 +42,11 @@ export default {
     import(/* webpackChunkName: "blazePbPasswordResetRequest" */ './PasswordResetRequest')
   ),
   breadcrumb: dynamic(() => import(/* webpackChunkName: "blazePbBreadcrumb" */ './Breadcrumb')),
+  itemlistbutton: dynamic(() =>
+    import(/* webpackChunkName: "blazePbItemListButton" */ './ItemListButton')
+  ),
+  itemlistcounter: dynamic(() =>
+    import(/* webpackChunkName: "blazePbItemListCounter" */ './ItemListCounter')
+  ),
   backtotop: dynamic(() => import(/* webpackChunkName: "blazePbBackToTop" */ './BackToTop'))
 };

package/src/constants/index.js

@@ -209,6 +209,8 @@ const DATA_SUMMARY_EMAIL_REGEX = /^([a-z0-9_\.\+-]+)@([\da-z\.-]+)\.([a-z\.]{2,6
 const DATA_SUMMARY_URL_REGEX = /(https?:\/\/)?(www\.)?[-a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)/;
 const DATA_SUMMARY_TEL_REGEX = /^\+{0,1}[0-9\(\)\.\- \/]{7,}$/; // note: very loose phone number match not for validation
 
+const LIST_ITEM_LOCAL_KEY = 'blaze_item_list_';
+
 export {
   BANNER_LOADING,
   BANNER_EMPTY,
@@ -320,5 +322,6 @@ export {
   TARGET_BLANK,
   DATA_SUMMARY_EMAIL_REGEX,
   DATA_SUMMARY_URL_REGEX,
-  DATA_SUMMARY_TEL_REGEX
+  DATA_SUMMARY_TEL_REGEX,
+  LIST_ITEM_LOCAL_KEY
 };

package/src/helpers/build-props-query.js

@@ -22,23 +22,24 @@ const buildPropsQuery = (data, extraProps = [], cardOptions = null) => {
   const basicProps = uniqueProps
     .filter(prop => prop && !prop.includes('.'))
     .filter((prop, i, arr) => arr.indexOf(prop) === i);
-  const complexProps = buildComplexProps(shouldAddCategoryProps, uniqueProps);
-
+  const complexProps = buildComplexProps(shouldAddCategoryProps, uniqueProps, data);
   return [...basicProps, ...complexProps].join(',');
 };
 
-const buildComplexProps = (shouldAddCategoryProps, props) =>
+const buildComplexProps = (shouldAddCategoryProps, props, { getEntitySchema: { relations } }) =>
   props
     .filter(prop => prop && prop.includes('.'))
     .map(nested => nested.split('.')[0])
     .filter((prop, i, arr) => arr.indexOf(prop) === i)
     .map(base => {
+      const matchingRelation = relations.find(({ localField }) => localField === base);
       const nestedProps = props
         .filter(
           (extraProp, i, arr) =>
             extraProp && extraProp.startsWith(`${base}.`) && arr.indexOf(extraProp) === i
         )
         .map(nested => nested.split('.')[1]);
+      if (matchingRelation && !nestedProps.includes('id')) nestedProps.push('id');
 
       const jointNestedProps = nestedProps.join(',');
       if (base === 'category' && shouldAddCategoryProps)
@@ -70,6 +71,8 @@ const getTypeBaseProps = (data, cardOptions, extraPropsHaveCategory) => {
   typeBasedProps.push(...getCategoyProps(shouldAddCategoryProps, hasCategory, hasPreheader));
   typeBasedProps.push(...getContentProps(isContent));
 
+  if (properties.url || dynamicProperties.url) typeBasedProps.push('url');
+
   if (displayThumbnail && relations.find(({ localField }) => localField === 'image')) {
     typeBasedProps.push('image.id', 'image.url', 'image.data');
   }

package/src/helpers/build-raw-query.js

@@ -62,6 +62,7 @@ const buildRawQuery = (
 
   if (itemsToDisplay && itemsToDisplay.length) {
     const itemsToDisplayIds = getItemsToDisplayIds(itemsToDisplay);
+
     query.bool.must.push({ ids: { values: itemsToDisplayIds } });
     if (shouldApplySort) {
       return {

package/src/helpers/get-item-list-data.js

@@ -0,0 +1,6 @@
+const getItemListData = data => {
+  if (data && data.getItemList && data.getItemList.listItems) return data.getItemList.listItems;
+  return [];
+};
+
+export default getItemListData;

package/src/helpers/get-item-list-id.js

@@ -0,0 +1,11 @@
+import { LIST_ITEM_LOCAL_KEY } from '../constants';
+
+const getItemListId = (listName, queryId) => {
+  if (queryId) return queryId;
+  if (!listName || typeof localStorage === 'undefined') return '';
+
+  const localListName = `${LIST_ITEM_LOCAL_KEY}${listName}`;
+  return localStorage.getItem(localListName) || '';
+};
+
+export default getItemListId;

package/src/helpers/get-item-list-ids.js

@@ -0,0 +1,10 @@
+import getItemListData from './get-item-list-data';
+
+const getItemListIds = data => {
+  const itemListElements = getItemListData(data);
+  return itemListElements.length
+    ? itemListElements.map(({ itemId }) => ({ displayItems: [itemId] }))
+    : null;
+};
+
+export default getItemListIds;

package/src/helpers/index.js

@@ -51,3 +51,6 @@ export { default as getParsedPropValues } from './get-parsed-prop-values';
 export { default as getSanitizedPropValues } from './get-sanitized-prop-values';
 export { default as appendImages } from './append-images';
 export { default as parseTextBlock } from './parse-TextBlock';
+export { default as getItemListId } from './get-item-list-id';
+export { default as getItemListIds } from './get-item-list-ids';
+export { default as getItemListData } from './get-item-list-data';

package/tests/helpers/mocks.js

@@ -1521,13 +1521,13 @@ const RAW_QUERY_ALL_SEARCH_VALUE_DIFFERENT_OPERATOR_TEXT_CHECKBOX_HAS_OR_OPERATO
 };
 
 const RAW_QUERY_STRINGIFIED =
-  '{"aggs":{"tags.name":{"terms":{"field":"tags.name.keyword","size":50}},"category.name"' +
-  ':{"terms":{"field":"category.name.keyword","size":50}}},"size":0,"query":{"bool":{"filter":{"bool"' +
+  '{"aggs":{"tags.name":{"terms":{"field":"tags.name.keyword","size":500}},"category.name"' +
+  ':{"terms":{"field":"category.name.keyword","size":500}}},"size":0,"query":{"bool":{"filter":{"bool"' +
   ':{"should":[{"match":{"docType":"published_page"}}],"minimum_should_match":1}}}}}';
 
 const RAW_QUERY_STRINGIFIED_WITH_RANGE =
-  '{"aggs":{"tags.name":{"terms":{"field":"tags.name.keyword","size":50}},"category.name":{"' +
-  'terms":{"field":"category.name.keyword","size":50}},"price":{"stats":{"field":"price"}},"length":' +
+  '{"aggs":{"tags.name":{"terms":{"field":"tags.name.keyword","size":500}},"category.name":{"' +
+  'terms":{"field":"category.name.keyword","size":500}},"price":{"stats":{"field":"price"}},"length":' +
   '{"stats":{"field":"length"}}},"size":0,"query":{"bool":{"filter":{"bool":{"should":[{"match":' +
   '{"docType":"published_page"}}],"minimum_should_match":1}}}}}';