@carbon/ibm-products 2.81.0-rc.0 → 2.82.0-rc.0

package/lib/components/Datagrid/Datagrid/addons/Filtering/hooks/useFilters.js

@@ -0,0 +1,479 @@
+/**
+ * Copyright IBM Corp. 2020, 2026
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../../../../../../_virtual/_rollupPluginBabelHelpers.js');
+var constants = require('../constants.js');
+var react = require('@carbon/react');
+var React = require('react');
+var OverflowCheckboxes = require('../OverflowCheckboxes.js');
+var utils = require('../utils.js');
+var FilterProvider = require('../FilterProvider.js');
+var handleCheckboxChange = require('../handleCheckboxChange.js');
+var uuidv4 = require('../../../../../../global/js/utils/uuidv4.js');
+var usePreviousValue = require('../../../../../../global/js/hooks/usePreviousValue.js');
+
+// Use same empty array every time, for benefit of useEffect() etc. dependency checking.
+const emptyArray = [];
+const useFilters = _ref => {
+  let {
+    updateMethod,
+    filters = emptyArray,
+    setAllFilters,
+    variation,
+    reactTableFiltersState,
+    onCancel,
+    panelOpen,
+    autoHideFilters,
+    isFetching
+  } = _ref;
+  const {
+    state,
+    tableId: contextTableId
+  } = React.useContext(FilterProvider.FilterContext);
+  const {
+    savedFilters
+  } = state;
+  /** State */
+  const [filtersState, setFiltersState] = React.useState(utils.getInitialStateFromFilters(filters, variation, reactTableFiltersState));
+  const [fetchingReset, setFetchingReset] = React.useState(false);
+  const [filtersObjectArray, setFiltersObjectArray] = React.useState(reactTableFiltersState);
+  const previousState = usePreviousValue.usePreviousValue({
+    panelOpen
+  });
+  const filteredItemsRef = React.useRef(undefined);
+
+  // When using batch actions we have to store the filters to then apply them later
+  const prevFiltersRef = React.useRef(JSON.stringify(filtersState));
+  const lastAppliedFilters = React.useRef(JSON.stringify(reactTableFiltersState));
+  const prevFiltersObjectArrayRef = React.useRef(JSON.stringify(filtersObjectArray));
+  const holdingPrevFiltersRef = React.useRef(undefined);
+  const holdingLastAppliedFiltersRef = React.useRef([]);
+  const holdingPrevFiltersObjectArrayRef = React.useRef([]);
+
+  /** Methods */
+  // If the user decides to cancel or click outside the flyout, it reverts back to the filters that were
+  // there when they opened the flyout
+  const revertToPreviousFilters = React.useCallback(() => {
+    setFiltersState(JSON.parse(prevFiltersRef.current));
+    setFiltersObjectArray(JSON.parse(prevFiltersObjectArrayRef.current));
+    setAllFilters(JSON.parse(lastAppliedFilters.current));
+
+    // Set the temp prev refs, these will be used to populate the prev values once the
+    // panel opens again
+    holdingPrevFiltersRef.current = JSON.parse(prevFiltersRef.current);
+    holdingLastAppliedFiltersRef.current = JSON.parse(prevFiltersObjectArrayRef.current);
+    holdingPrevFiltersObjectArrayRef.current = JSON.parse(lastAppliedFilters.current);
+  }, [setAllFilters]);
+  const reset = React.useCallback(tableId => {
+    // only reset filters if tableid of the datagrid that triggered "clear filters"
+    // matches the table id stored in its context instance
+    if (tableId === contextTableId) {
+      // When we reset we want the "initialFilters" to be an empty array
+      const resetFiltersArray = [];
+
+      // Get the initial values for the filters
+      const initialFiltersState = utils.getInitialStateFromFilters(filters, variation, resetFiltersArray);
+      const initialFiltersObjectArray = [];
+
+      // Set the state to the initial values
+      setFiltersState(initialFiltersState);
+      setFiltersObjectArray(initialFiltersObjectArray);
+      setAllFilters([]);
+
+      // Update their respective refs so everything is in sync
+      prevFiltersRef.current = JSON.stringify(initialFiltersState);
+      prevFiltersObjectArrayRef.current = JSON.stringify(initialFiltersObjectArray);
+      lastAppliedFilters.current = JSON.stringify([]);
+    }
+  }, [filters, setAllFilters, variation, contextTableId]);
+  const applyFilters = _ref2 => {
+    let {
+      column,
+      value,
+      type
+    } = _ref2;
+    // If no end date is selected return because we need the end date to do computations
+    if (type === constants.DATE && value.length > 0 && !value[1]) {
+      return;
+    }
+    const filterCopy = [...filtersObjectArray];
+    // // check if the filter already exists in the array
+    const filter = filterCopy.find(item => item.id === column);
+
+    // // if filter exists in array then update the filter's new value
+    if (filter) {
+      filter.value = value;
+    } else {
+      filterCopy.push({
+        id: column,
+        value,
+        type
+      });
+    }
+    const index = filterCopy.findIndex(_ref3 => {
+      let {
+        id
+      } = _ref3;
+      return id === column;
+    });
+    const clearCheckbox = (type === constants.CHECKBOX || type === constants.MULTISELECT) && filterCopy[index].value.every(_ref4 => {
+      let {
+        selected
+      } = _ref4;
+      return selected === false;
+    });
+    const clearDate = type === constants.DATE && value.length === 0;
+    const clearAny = (type === constants.DROPDOWN || type === constants.RADIO) && value === 'Any';
+    const clearNum = type === constants.NUMBER && value === '';
+    const shouldClear = clearCheckbox || clearDate || clearAny || clearNum;
+    if (shouldClear) {
+      filterCopy.splice(index, 1);
+    }
+    setFiltersObjectArray(filterCopy);
+    if (updateMethod === constants.INSTANT) {
+      setAllFilters(filterCopy);
+    }
+  };
+
+  /** Render the individual filter component */
+  const renderFilter = _ref5 => {
+    var _OverflowCheckboxes;
+    let {
+      type,
+      column,
+      props: components
+    } = _ref5;
+    let filter;
+    const isPanel = variation === constants.PANEL;
+    if (!type) {
+      return console.error(`type: ${type}; does not exist as a type of filter.`);
+    }
+    const renderCheckboxes = () => {
+      if (variation === constants.PANEL && filtersState[column].value.length > 10 && !autoHideFilters) {
+        return _OverflowCheckboxes || (_OverflowCheckboxes = /*#__PURE__*/React.createElement(OverflowCheckboxes.default, {
+          components: components,
+          type: type,
+          column: column,
+          setFiltersState: setFiltersState,
+          filtersState: filtersState,
+          applyFilters: applyFilters
+        }));
+      }
+      return /*#__PURE__*/React.createElement(react.FormGroup, components.FormGroup, filtersState[column].value.map(option => /*#__PURE__*/React.createElement(react.Checkbox, _rollupPluginBabelHelpers.extends({
+        key: option.id
+      }, option, {
+        onChange: (_, _ref6) => {
+          let {
+            checked
+          } = _ref6;
+          handleCheckboxChange.handleCheckboxChange({
+            checked,
+            filtersState,
+            column,
+            option,
+            setFiltersState,
+            applyFilters,
+            type
+          });
+        },
+        checked: option.selected
+      }))));
+    };
+    switch (type) {
+      case constants.DATE:
+        filter = /*#__PURE__*/React.createElement(react.DatePicker, _rollupPluginBabelHelpers.extends({}, components.DatePicker, {
+          onChange: value => {
+            setFiltersState({
+              ...filtersState,
+              [column]: {
+                value,
+                type
+              }
+            });
+            applyFilters({
+              column,
+              value,
+              type
+            });
+            components.DatePicker.onChange?.(value);
+          },
+          value: filtersState[column].value,
+          datePickerType: "range"
+        }), /*#__PURE__*/React.createElement(react.DatePickerInput, _rollupPluginBabelHelpers.extends({
+          placeholder: "mm/dd/yyyy",
+          labelText: "Start date"
+        }, components.DatePickerInput.start)), /*#__PURE__*/React.createElement(react.DatePickerInput, _rollupPluginBabelHelpers.extends({
+          placeholder: "mm/dd/yyyy",
+          labelText: "End date"
+        }, components.DatePickerInput.end)));
+        break;
+      case constants.NUMBER:
+        filter = /*#__PURE__*/React.createElement(react.NumberInput, _rollupPluginBabelHelpers.extends({
+          step: 1,
+          allowEmpty: true,
+          hideSteppers: true
+        }, components.NumberInput, {
+          onChange: event => {
+            setFiltersState({
+              ...filtersState,
+              [column]: {
+                value: event.target.value,
+                type
+              }
+            });
+            applyFilters({
+              column,
+              value: event.target.value,
+              type
+            });
+            components.NumberInput.onChange?.(event);
+          },
+          value: filtersState[column].value
+        }));
+        break;
+      case constants.CHECKBOX:
+        filter = renderCheckboxes();
+        break;
+      case constants.RADIO:
+        {
+          const {
+            name
+          } = {
+            ...components.RadioButtonGroup
+          };
+          filter = /*#__PURE__*/React.createElement(react.FormGroup, components.FormGroup, /*#__PURE__*/React.createElement(react.RadioButtonGroup, _rollupPluginBabelHelpers.extends({}, components.RadioButtonGroup, {
+            valueSelected: filtersState[column]?.value === '' ? components.DefaultRadioButton?.value ?? 'Any' : filtersState[column]?.value,
+            onChange: selected => {
+              setFiltersState({
+                ...filtersState,
+                [column]: {
+                  value: selected,
+                  type
+                }
+              });
+              applyFilters({
+                column,
+                value: selected,
+                type
+              });
+              components.RadioButtonGroup.onChange?.(selected);
+            }
+          }), /*#__PURE__*/React.createElement(react.RadioButton, _rollupPluginBabelHelpers.extends({
+            id: components?.DefaultRadioButton?.id ?? `any__${name}`,
+            labelText: components?.DefaultRadioButton?.labelText ?? 'Any',
+            value: components?.DefaultRadioButton?.value ?? 'Any'
+          }, components.DefaultRadioButton)), components.RadioButton.map(radio => /*#__PURE__*/React.createElement(react.RadioButton, _rollupPluginBabelHelpers.extends({
+            key: radio.id ?? radio.labelText ?? radio.value
+          }, radio)))));
+        }
+        break;
+      case constants.DROPDOWN:
+        filter = /*#__PURE__*/React.createElement(react.Dropdown, _rollupPluginBabelHelpers.extends({}, components.Dropdown, {
+          selectedItem: filtersState[column]?.value === '' ? 'Any' : filtersState[column]?.value,
+          items: ['Any', ...components.Dropdown.items],
+          onChange: _ref7 => {
+            let {
+              selectedItem
+            } = _ref7;
+            setFiltersState({
+              ...filtersState,
+              [column]: {
+                value: selectedItem,
+                type
+              }
+            });
+            applyFilters({
+              column,
+              value: selectedItem,
+              type
+            });
+            components.Dropdown.onChange?.(selectedItem);
+          }
+        }));
+        break;
+      case constants.MULTISELECT:
+        {
+          const isStringArray = components.MultiSelect.items.length && typeof components.MultiSelect.items[0] === 'string';
+          const selectedFilters = filtersState[column]?.value.filter(i => i.selected);
+          const filteredItems = components.MultiSelect.items.map(item => {
+            if (selectedFilters.filter(a => isStringArray ? a.id === item : a.id === item.id).length) {
+              return item;
+            }
+            return null;
+          }).filter(Boolean);
+          const isEqual = compareFilterItems(filteredItems);
+          if (!isEqual) {
+            filteredItemsRef.current = [...filteredItems];
+          }
+          const getKey = () => {
+            return isEqual ? {
+              key: uuidv4.default()
+            } : column;
+          };
+          filter = /*#__PURE__*/React.createElement(react.MultiSelect, _rollupPluginBabelHelpers.extends({}, components.MultiSelect, {
+            selectedItems: filteredItems,
+            key: getKey(),
+            onChange: _ref8 => {
+              let {
+                selectedItems
+              } = _ref8;
+              const allOptions = filtersState[column].value;
+              // Find selected items from list of options
+              const foundItems = selectedItems.map(item => {
+                if (allOptions.filter(option => isStringArray ? option.id === item : option.id === item.id)) {
+                  return allOptions.filter(option => isStringArray ? option.id === item : option.id === item.id)[0];
+                }
+                return null;
+              }).filter(Boolean);
+              filteredItemsRef.current = [...foundItems];
+
+              // Change selected state for those items that have been selected
+              allOptions.map(a => a.selected = false);
+              foundItems.map(item => {
+                const foundOriginalItem = allOptions.filter(a => isStringArray ? a === item : a.id === item.id);
+                if (foundOriginalItem && foundOriginalItem.length) {
+                  foundOriginalItem[0].selected = true;
+                }
+              });
+              if (!selectedItems.length) {
+                allOptions.map(a => a.selected = false);
+              }
+              setFiltersState({
+                ...filtersState,
+                [column]: {
+                  value: allOptions,
+                  type
+                }
+              });
+              applyFilters({
+                column,
+                value: [...filtersState[column].value],
+                type
+              });
+              components.MultiSelect?.onChange?.(selectedItems);
+            }
+          }));
+          break;
+        }
+    }
+    if (isPanel) {
+      return /*#__PURE__*/React.createElement(react.Layer, {
+        key: column
+      }, filter);
+    }
+    return /*#__PURE__*/React.createElement(React.Fragment, {
+      key: column
+    }, filter);
+  };
+  const compareFilterItems = filteredItems => {
+    const filteredItemsId = filteredItems.map(item => item.id) ?? [];
+    const previousFilteredItemsId = filteredItemsRef?.current?.map(item => item.id) ?? [];
+    const set1 = new Set(filteredItemsId);
+    const set2 = new Set(previousFilteredItemsId);
+    // Check if the sets have the same size (same number of unique elements)
+    if (set1.size !== set2.size) {
+      return false;
+    }
+    // Check if all elements in set1 are also present in set2 (using spread syntax)
+    return [...set1].every(element => set2.has(element));
+  };
+
+  /** This useEffect will properly handle the previous filters when the panel closes
+   * 1. If the panel closes we need to call the reset fn but also store the
+   * previous filters in a (new) temporary place.
+   * 2. When the panel opens again, take the values from the temporary place
+   * and populate the filter state with them
+   */
+  React.useEffect(() => {
+    if (!panelOpen && previousState?.panelOpen) {
+      revertToPreviousFilters();
+      setAllFilters(holdingLastAppliedFiltersRef.current);
+    }
+    if (panelOpen && !previousState?.panelOpen) {
+      if (holdingPrevFiltersRef.current && holdingLastAppliedFiltersRef.current && holdingPrevFiltersObjectArrayRef.current) {
+        setFiltersState(holdingPrevFiltersRef.current);
+        setFiltersObjectArray(holdingLastAppliedFiltersRef.current);
+        setAllFilters(JSON.parse(prevFiltersObjectArrayRef.current));
+      }
+    }
+  }, [panelOpen, previousState, previousState?.panelOpen, reset, setAllFilters, revertToPreviousFilters]);
+
+  // Re-applies filters if the Datagrid goes into a fetching state while panel is open
+  // and has had filters changed without applying
+  React.useEffect(() => {
+    if (isFetching && !fetchingReset) {
+      setFiltersState(JSON.parse(prevFiltersRef.current));
+      setFiltersObjectArray(JSON.parse(prevFiltersRef.current));
+      setAllFilters(JSON.parse(prevFiltersObjectArrayRef.current));
+      setFetchingReset(true);
+    }
+    if (isFetching && fetchingReset) {
+      const cleanFilters = originalFilterState => {
+        const copy = {
+          ...originalFilterState
+        };
+        const updatedFilters = savedFilters.map(f => {
+          if (Object.hasOwn(copy, f.id)) {
+            copy[f.id] = f;
+            return copy;
+          }
+          return copy;
+        });
+        return updatedFilters[0];
+      };
+      if (savedFilters && savedFilters.length) {
+        setFiltersObjectArray(savedFilters);
+        const filterStateCopy = cleanFilters(filtersState) ?? [];
+        setFiltersState(filterStateCopy);
+      }
+    }
+    if (!isFetching) {
+      setFetchingReset(false);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isFetching, reactTableFiltersState, setAllFilters, fetchingReset, savedFilters, filtersObjectArray]);
+
+  // This useEffect will update the last applied filters when the react-table filters change, this helps keeps all states in sync
+  React.useEffect(function reflectLastAppliedFiltersWhenReactTableUpdates() {
+    lastAppliedFilters.current = JSON.stringify(reactTableFiltersState);
+  }, [reactTableFiltersState, lastAppliedFilters]);
+  const cancel = () => {
+    // Reverting to previous filters only applies when using batch actions
+    if (updateMethod === constants.BATCH) {
+      revertToPreviousFilters();
+      onCancel();
+    }
+  };
+
+  /** The purpose of this function is to sync any changes in react-tables state.filters array and reflect
+      those new filter changes in the panel/flyout state. The external change is triggered if setAllFilters is called outside of the Datagrid */
+  React.useEffect(function updateStateAndFiltersToReflectExternalFilterChanges() {
+    const newFiltersState = utils.getInitialStateFromFilters(filters, variation, reactTableFiltersState);
+    setFiltersState(newFiltersState);
+    prevFiltersRef.current = JSON.stringify(newFiltersState);
+    prevFiltersObjectArrayRef.current = JSON.stringify(reactTableFiltersState);
+    setFiltersObjectArray(reactTableFiltersState);
+  }, [filters, reactTableFiltersState, variation]);
+  return {
+    filtersState,
+    setFiltersState,
+    prevFiltersObjectArrayRef,
+    prevFiltersRef,
+    revertToPreviousFilters,
+    reset,
+    renderFilter,
+    filtersObjectArray,
+    lastAppliedFilters,
+    cancel
+  };
+};
+
+exports.default = useFilters;

package/lib/components/Datagrid/Datagrid/addons/Filtering/hooks/useShouldDisableButtons.d.ts

@@ -0,0 +1,9 @@
+export default useShouldDisableButtons;
+/**
+ * Keeps track of the button disabled state
+ * @param  {string} initialValue - the initial value if the buttons should be enabled or disabled
+ * @param  {object} filtersState - the filter state from the filter panel or flyout
+ * @param  {object} prevFiltersRef - reference of the prev filterState
+ * @returns {Array} returns a tuple of the state and setter function
+ */
+declare function useShouldDisableButtons({ initialValue, filtersState, prevFiltersRef, open, }: string): any[];

package/lib/components/Datagrid/Datagrid/addons/Filtering/hooks/useShouldDisableButtons.js

@@ -0,0 +1,44 @@
+/**
+ * Copyright IBM Corp. 2020, 2026
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var deepCompareObject = require('../../../../../../global/js/utils/deepCompareObject.js');
+
+/* eslint-disable jsdoc/check-param-names */
+
+
+/**
+ * Keeps track of the button disabled state
+ * @param  {string} initialValue - the initial value if the buttons should be enabled or disabled
+ * @param  {object} filtersState - the filter state from the filter panel or flyout
+ * @param  {object} prevFiltersRef - reference of the prev filterState
+ * @returns {Array} returns a tuple of the state and setter function
+ */
+const useShouldDisableButtons = _ref => {
+  let {
+    initialValue,
+    // initially the buttons should be disabled
+    filtersState,
+    prevFiltersRef,
+    open
+  } = _ref;
+  const [shouldDisableButtons, setShouldDisableButtons] = React.useState(initialValue);
+  React.useEffect(function updateDisabledButtonsState() {
+    // prevent this effect from running when columns are being resized
+    if (!open) {
+      return;
+    }
+    setShouldDisableButtons(deepCompareObject.deepCompareObject(filtersState, JSON.parse(prevFiltersRef.current)));
+  }, [filtersState, prevFiltersRef]);
+  return [shouldDisableButtons, setShouldDisableButtons];
+};
+
+exports.default = useShouldDisableButtons;

package/lib/components/Datagrid/Datagrid/addons/Filtering/hooks/useSubscribeToEventEmitter.d.ts

@@ -0,0 +1,7 @@
+export default useSubscribeToEventEmitter;
+/**
+ * Subscribes to the filter event emitter
+ * @param  {string} type - the type of event to call
+ * @param  {Function} callback - a callback to run when the event is dispatched
+ */
+declare function useSubscribeToEventEmitter(type: string, callback: Function): void;

package/lib/components/Datagrid/Datagrid/addons/Filtering/hooks/useSubscribeToEventEmitter.js

@@ -0,0 +1,30 @@
+/**
+ * Copyright IBM Corp. 2020, 2026
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var FilterProvider = require('../FilterProvider.js');
+
+/**
+ * Subscribes to the filter event emitter
+ * @param  {string} type - the type of event to call
+ * @param  {Function} callback - a callback to run when the event is dispatched
+ */
+const useSubscribeToEventEmitter = (type, callback) => {
+  const {
+    EventEmitter
+  } = React.useContext(FilterProvider.FilterContext);
+  React.useEffect(function subscribeToEmitter() {
+    // This event is emitted from the DatagridToolbar component when clearFilters is clicked in FilterSummary
+    EventEmitter.subscribe(type, callback);
+  });
+};
+
+exports.default = useSubscribeToEventEmitter;

package/lib/components/Datagrid/Datagrid/addons/Filtering/index.d.ts

@@ -0,0 +1,3 @@
+export { default as FilterFlyout } from "./FilterFlyout";
+export { default as FilterPanel } from "./FilterPanel";
+export { FilterProvider, FilterContext } from "./FilterProvider";

package/lib/components/Datagrid/Datagrid/addons/Filtering/utils.d.ts

@@ -0,0 +1 @@
+export function getInitialStateFromFilters(filters: any, variation: any, initialFilters: any): {};

package/lib/components/Datagrid/Datagrid/addons/Filtering/utils.js

@@ -0,0 +1,101 @@
+/**
+ * Copyright IBM Corp. 2020, 2026
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+var constants = require('./constants.js');
+
+const applyInitialFilters = (filterState, initialFilters) => {
+  Object.keys(filterState).forEach(key => {
+    const hasInitialFilter = initialFilters.find(filter => filter.id === key);
+    if (hasInitialFilter) {
+      filterState[key].value = hasInitialFilter.value;
+    }
+  });
+};
+
+// This functions takes the filters passed in and makes an object to track it's state
+const getInitialStateFromFilters = (filters, variation, initialFilters) => {
+  const initialFilterState = {};
+  const setInitialState = _ref => {
+    let {
+      type,
+      column,
+      props
+    } = _ref;
+    if (type === constants.CHECKBOX) {
+      initialFilterState[column] = {
+        value: props.Checkbox.map(_ref2 => {
+          let {
+            id,
+            labelText,
+            value,
+            ...rest
+          } = _ref2;
+          return {
+            id,
+            labelText,
+            value,
+            selected: false,
+            ...rest
+          };
+        }),
+        type
+      };
+    } else if (type === constants.DATE) {
+      initialFilterState[column] = {
+        value: [null, null],
+        type
+      };
+    } else if (type === constants.NUMBER) {
+      initialFilterState[column] = {
+        value: '',
+        type
+      };
+    } else if (type === constants.RADIO) {
+      initialFilterState[column] = {
+        value: '',
+        type
+      };
+    } else if (type === constants.DROPDOWN) {
+      initialFilterState[column] = {
+        value: '',
+        type
+      };
+    } else if (type === constants.MULTISELECT) {
+      initialFilterState[column] = {
+        value: props.MultiSelect.items.map(item => ({
+          id: typeof item === 'string' ? item : item.id,
+          value: typeof item === 'string' ? item : item.text,
+          selected: false
+        })),
+        type
+      };
+    }
+  };
+  if (variation === constants.FLYOUT) {
+    filters.forEach(setInitialState);
+  } else if (variation === constants.PANEL) {
+    filters.forEach(_ref3 => {
+      let {
+        filters: sections = []
+      } = _ref3;
+      sections.forEach(_ref4 => {
+        let {
+          filter
+        } = _ref4;
+        return setInitialState(filter);
+      });
+    });
+  }
+  if (initialFilters.length > 0) {
+    applyInitialFilters(initialFilterState, initialFilters);
+  }
+  return initialFilterState;
+};
+
+exports.getInitialStateFromFilters = getInitialStateFromFilters;