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

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,31 @@ 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 hasUrl = !!url;
   const {
     url: currentUrl,
     query: { sort, sortby },
     query
-  } = parseUrl(router.asPath);
+  } = parseUrl(asPath);
+  const [filterValues, dispatch] = useReducer(
+    reducer,
+    getInitialFilterValues(null, filters, query)
+  );
+  const hasUrl = !!url;
+
   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 +76,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.dataNotSet && filterData) {
+    const initialFilterValues = getInitialFilterValues(filterData, filters, query);
+    dispatch({ newValues: initialFilterValues, shouldSearch: false, type: 'update' });
+  }
 
   const handleSearch = newQuery => {
     setDisplaySearchFilter(false);
@@ -93,17 +130,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 +160,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 +172,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,8 +7,17 @@ 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);
+  if (!data[prop]) return null;
 
   const handleCheckboxOptions = () => {
     if (checkboxLimit[prop] === LIMIT_MIN) {
@@ -35,7 +44,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 +55,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 +108,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-query.js

@@ -3,7 +3,9 @@ import parseFilterValue from './parse-filter-value';
 
 const buildQuery = (filterValues, filters) => {
   const newQuery = [];
-  const searchValue = filterValues[SEARCH_TERM];
+  const searchValue = filterValues[SEARCH_TERM]
+    ? encodeURIComponent(filterValues[SEARCH_TERM])
+    : '';
   if (searchValue) newQuery.push(`${SEARCH_TERM}=${searchValue}`);
 
   filters.forEach(({ propsToDisplay, type }) => {

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,12 +3,23 @@ import getFilterValueFromQuery from './get-filter-value-from-query';
 
 const getInitialFilterValues = (filterData, filters, query) => {
   const filterValues = {};
+  filterValues[SEARCH_TERM] = query[SEARCH_TERM] || '';
+
+  if (!filterData) {
+    filters.forEach(({ propsToDisplay: [key] }) => {
+      filterValues[key] = null;
+    });
+    filterValues.dataNotSet = true;
+    return filterValues;
+  }
+
   Object.keys(filterData).forEach(key => {
     const filterProps =
       filters.find(({ propsToDisplay }) => propsToDisplay.find(prop => key === prop)) || {};
     filterValues[key] = getFilterValueFromQuery(key, filterProps, filterData[key], query);
   });
-  filterValues[SEARCH_TERM] = query[SEARCH_TERM] || '';
+
+  filterValues.dataNotSet = false;
 
   return filterValues;
 };

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/SearchFilter/helpers/parse-filter-value.js

@@ -8,10 +8,10 @@ const parseFilterValue = (key, type, value) => {
       if (value.minValue === value.min && value.maxValue === value.max) return null;
       return `${key}=${value.minValue}-${value.maxValue}`;
     case CHECKBOX:
-      if (typeof value === 'string') return `${key}=${value}`;
-      return value.map(val => `${key}=${val}`).join('&');
+      if (typeof value === 'string') return `${key}=${encodeURIComponent(value)}`;
+      return value.map(val => `${key}=${encodeURIComponent(val)}`).join('&');
     case SELECT: {
-      const parsedValue = value.replace(/&/g, '%26');
+      const parsedValue = encodeURIComponent(value);
       return `${key}=${parsedValue}`;
     }
 

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,14 @@ export default {
     import(/* webpackChunkName: "blazePbPasswordResetRequest" */ './PasswordResetRequest')
   ),
   breadcrumb: dynamic(() => import(/* webpackChunkName: "blazePbBreadcrumb" */ './Breadcrumb')),
+  itemlistbutton: dynamic(() =>
+    import(/* webpackChunkName: "blazePbItemListButton" */ './ItemList/ItemListButton')
+  ),
+  itemlistcounter: dynamic(() =>
+    import(/* webpackChunkName: "blazePbItemListCounter" */ './ItemList/ItemListCounter')
+  ),
+  itemlistnew: dynamic(() =>
+    import(/* webpackChunkName: "blazePbItemListNew" */ './ItemList/ItemListNew')
+  ),
   backtotop: dynamic(() => import(/* webpackChunkName: "blazePbBackToTop" */ './BackToTop'))
 };

package/src/constants/index.js

@@ -17,6 +17,7 @@ const RANGE = 'range';
 const CHECKBOX = 'checkbox';
 const ELEMENT = 'element';
 const MENU_ITEM = 'menuitem';
+const SUB_MENU = 'submenu';
 const SELECT = 'select';
 const ON_CLICK = 'onClick';
 const KEYWORD = 'keyword';
@@ -303,6 +304,7 @@ export {
   MOBILE_WIDTH,
   HIDDEN,
   MENU_ITEM,
+  SUB_MENU,
   LOGIN_FORM,
   PASSWORD_REGEX,
   PASSWORD_VALIDATION_MESSAGE,

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/hooks/helpers/append-gtm-classname.js

@@ -7,6 +7,9 @@ const appendGtmClassName = (settings, childComponents) => {
       children: [, compChildren]
     }
   } = childComponents;
+
+  if (!compChildren || !Array.isArray(compChildren)) return settings;
+
   const gtmClassNames = compChildren
     .filter(
       ({

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}}}}}';
 

package/tests/unit/src/components/Button.test.js

@@ -1,5 +1,5 @@
 import React from 'react';
-import { act, render } from '@testing-library/react';
+import { act, render, fireEvent, waitFor } from '@testing-library/react';
 import '@testing-library/jest-dom/extend-expect';
 import Button from '../../../../src/components/Button';
 
@@ -20,6 +20,16 @@ const componentProps = {
   }
 };
 
+const contentToShow = 'Content to show';
+
+const seoVisivilityProps = {
+  text: 'show more',
+  afterClickText: 'show less',
+  url: '',
+  icon: '',
+  children: [<p>Content to show</p>]
+};
+
 const renderComponent = async props => {
   let renderResults;
 
@@ -68,4 +78,48 @@ describe('Button component', () => {
     const { container } = await renderComponent(logoutButton);
     expect(container.innerHTML).toBe('');
   });
+
+  it('should toggle button text and render child components for SEO visibility ', async () => {
+    const props = {
+      ...componentProps,
+      ...seoVisivilityProps,
+      childSeoVisibility: true
+    };
+    const { container, getByText } = await renderComponent(props);
+
+    const element = await waitFor(() => getByText('show more'));
+    expect(container.innerHTML).toContain(contentToShow);
+
+    fireEvent(
+      element,
+      new MouseEvent('click', {
+        bubbles: true,
+        cancelable: true
+      })
+    );
+    expect(container.innerHTML).toContain('show less');
+    expect(container.innerHTML).toContain(contentToShow);
+  });
+
+  it('should toggle button text hide child components when SEO visibility is disabled', async () => {
+    const props = {
+      ...componentProps,
+      ...seoVisivilityProps,
+      childSeoVisibility: false
+    };
+    const { container, getByText } = await renderComponent(props);
+
+    const element = await waitFor(() => getByText('show more'));
+    expect(container.innerHTML).not.toContain(contentToShow);
+
+    fireEvent(
+      element,
+      new MouseEvent('click', {
+        bubbles: true,
+        cancelable: true
+      })
+    );
+    expect(container.innerHTML).toContain('show less');
+    expect(container.innerHTML).toContain(contentToShow);
+  });
 });