@dhis2/analytics 28.0.3 → 28.0.5

package/build/es/components/OrgUnitDimension/__tests__/OrgUnitDimension.spec.js

@@ -1,55 +1,89 @@
-import { shallow } from 'enzyme';
+import { CustomDataProvider } from '@dhis2/app-runtime';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
 import React from 'react';
 import OrgUnitDimension from '../OrgUnitDimension.js';
-describe('The OrgUnitDimension component', () => {
-  let props;
-  let shallowOrgUnitDimension;
-  const getWrapper = () => {
-    if (!shallowOrgUnitDimension) {
-      shallowOrgUnitDimension = shallow(/*#__PURE__*/React.createElement(OrgUnitDimension, props));
-    }
-    return shallowOrgUnitDimension;
+jest.mock('@dhis2-ui/organisation-unit-tree', () => {
+  const lib = jest.requireActual('@dhis2-ui/organisation-unit-tree');
+  return {
+    ...lib,
+    OrganisationUnitTree: () => /*#__PURE__*/React.createElement("div", null, "Org unit tree component mock")
   };
-  beforeEach(() => {
-    props = {
-      roots: [],
-      selected: [],
-      onSelect: jest.fn(),
-      hideGroupSelect: false,
-      hideLevelSelect: false,
-      hideUserOrgUnits: false,
-      warning: ''
-    };
-    shallowOrgUnitDimension = undefined;
-  });
-  it('matches the snapshot', () => {
-    const wrapper = getWrapper();
-    expect(wrapper).toMatchSnapshot();
+});
+describe('OrgUnitDimension', () => {
+  const onSelect = jest.fn();
+  const props = {
+    roots: [],
+    selected: [],
+    onSelect: onSelect,
+    hideGroupSelect: false,
+    hideLevelSelect: false,
+    hideUserOrgUnits: false,
+    warning: ''
+  };
+  const renderOrgUnitDimension = props => render(/*#__PURE__*/React.createElement(CustomDataProvider, {
+    data: {
+      organisationUnitLevels: {
+        organisationUnitLevels: []
+      },
+      organisationUnitGroups: {
+        organisationUnitGroups: []
+      }
+    }
+  }, /*#__PURE__*/React.createElement(OrgUnitDimension, props)));
+  beforeEach(() => onSelect.mockClear());
+  test('OrgUnitDimension is rendered correctly', async () => {
+    renderOrgUnitDimension(props);
+
+    // wait for the component to be loaded, here done by testing that the OrganisationUnitTree component is loaded
+    // avoid the act warning due to the snapshot being taken before async code is run
+    await screen.findByText('Org unit tree component mock');
+
+    // the top user org unit checkboxes are rendered
+    expect(screen.getByLabelText('User organisation unit')).toBeInTheDocument();
+    expect(screen.getByLabelText('User sub-units')).toBeInTheDocument();
+    expect(screen.getByLabelText('User sub-x2-units')).toBeInTheDocument();
+
+    // the OrganisationUnitTree component is rendered
+    expect(screen.getByText('Org unit tree component mock')).toBeInTheDocument();
+
+    // the level selector is rendered
+    expect(screen.getByText('Select a level')).toBeInTheDocument();
+
+    // the group selector is rendered
+    expect(screen.getByText('Select a group')).toBeInTheDocument();
+
+    // the Deselect all button is rendered
+    expect(screen.getByRole('button', {
+      name: 'Deselect all'
+    })).toBeInTheDocument();
   });
-  it('calls onSelect when an organisation unit is selected', () => {
-    const wrapper = getWrapper();
-    const orgUnitTree = wrapper.find('OrganisationUnitTree');
-    const testOrgUnit = {
-      id: 'testId',
-      path: '/testPath',
-      displayName: 'Test Org Unit',
-      checked: true
-    };
-    orgUnitTree.props().onChange(testOrgUnit);
-    expect(props.onSelect).toHaveBeenCalledWith({
+  test('OrgUnitDimension calls onSelect when an organisation unit is selected', async () => {
+    const user = userEvent.setup();
+    renderOrgUnitDimension(props);
+    await user.click(screen.getByText('User organisation unit'));
+    expect(onSelect).toHaveBeenCalledWith({
       dimensionId: 'ou',
       items: [{
-        id: 'testId',
-        path: '/testPath',
-        name: 'Test Org Unit'
+        id: 'USER_ORGUNIT',
+        displayName: 'User organisation unit'
       }]
     });
   });
-  it('calls onSelect with an empty array when selection is cleared', () => {
-    const wrapper = getWrapper();
-    const deselectButton = wrapper.find('Button[onClick]');
-    deselectButton.simulate('click');
-    expect(props.onSelect).toHaveBeenCalledWith({
+  test('OrgUnitDimension calls onSelect with an empty array when selection is cleared', async () => {
+    const user = userEvent.setup();
+    renderOrgUnitDimension({
+      ...props,
+      // make some selection to enable the deselect all button
+      selected: [{
+        id: 'USER_ORGUNIT_CHILDREN',
+        name: 'User sub-units'
+      }]
+    });
+    await user.click(screen.getByRole('button', {
+      name: 'Deselect all'
+    }));
+    expect(onSelect).toHaveBeenLastCalledWith({
       dimensionId: 'ou',
       items: []
     });

package/build/es/components/PeriodDimension/FixedPeriodFilter.js

@@ -6,27 +6,25 @@ import i18n from '../../locales/index.js';
 import styles from './styles/PeriodFilter.style.js';
 import { getFixedPeriodsOptions } from './utils/fixedPeriods.js';
 import { filterPeriodTypesById } from './utils/index.js';
-const FixedPeriodFilter = _ref => {
-  let {
-    allowedPeriodTypes,
-    excludedPeriodTypes,
-    currentPeriodType,
-    currentYear,
-    onSelectPeriodType,
-    onSelectYear,
-    dataTest
-  } = _ref;
+const EXCLUDED_PERIOD_TYPES_PROP_DEFAULT = [];
+const FixedPeriodFilter = ({
+  allowedPeriodTypes,
+  excludedPeriodTypes = EXCLUDED_PERIOD_TYPES_PROP_DEFAULT,
+  currentPeriodType,
+  currentYear,
+  onSelectPeriodType,
+  onSelectYear,
+  dataTest
+}) => {
   const onlyAllowedTypeIsSelected = Array.isArray(allowedPeriodTypes) && allowedPeriodTypes.length === 1 && allowedPeriodTypes[0] === currentPeriodType;
   return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
+    "data-test": dataTest,
     className: `jsx-${styles.__hash}` + " " + "leftSection"
   }, /*#__PURE__*/React.createElement(SingleSelectField, {
     label: i18n.t('Period type'),
-    onChange: _ref2 => {
-      let {
-        selected
-      } = _ref2;
-      return onSelectPeriodType(selected);
-    },
+    onChange: ({
+      selected
+    }) => onSelectPeriodType(selected),
     dense: true,
     selected: currentPeriodType,
     disabled: onlyAllowedTypeIsSelected,
@@ -45,21 +43,15 @@ const FixedPeriodFilter = _ref => {
     type: "number",
     placeholder: i18n.t('Select year'),
     value: currentYear,
-    onChange: _ref3 => {
-      let {
-        value
-      } = _ref3;
-      return onSelectYear(value);
-    },
+    onChange: ({
+      value
+    }) => onSelectYear(value),
     dense: true,
     dataTest: `${dataTest}-year`
   })), /*#__PURE__*/React.createElement(_JSXStyle, {
     id: styles.__hash
   }, styles));
 };
-FixedPeriodFilter.defaultProps = {
-  excludedPeriodTypes: []
-};
 FixedPeriodFilter.propTypes = {
   currentPeriodType: PropTypes.string.isRequired,
   currentYear: PropTypes.string.isRequired,

package/build/es/components/PeriodDimension/FixedPeriodSelect.js

@@ -10,8 +10,8 @@ import FixedPeriodFilter from './FixedPeriodFilter.js';
 import styles from './styles/FixedPeriodSelect.style.js';
 import { parsePeriodCode, getFixedPeriodsOptionsById as getPeriodById, getYearOffsetFromNow } from './utils/fixedPeriods.js';
 class FixedPeriodSelect extends Component {
-  constructor() {
-    super(...arguments);
+  constructor(...args) {
+    super(...args);
     _defineProperty(this, "state", {
       periodType: '',
       year: '',
@@ -31,24 +31,19 @@ class FixedPeriodSelect extends Component {
       });
       this.props.onChange();
     });
-    _defineProperty(this, "onSelectPeriod", (_ref, event) => {
-      let {
-        selected: periodId
-      } = _ref;
-      const period = this.state.options.find(_ref2 => {
-        let {
-          id
-        } = _ref2;
-        return id === periodId;
-      });
+    _defineProperty(this, "onSelectPeriod", ({
+      selected: periodId
+    }, event) => {
+      const period = this.state.options.find(({
+        id
+      }) => id === periodId);
       this.props.onChange(period, event);
     });
   }
-  static getDerivedStateFromProps(_ref3) {
-    let {
-      value,
-      allowedPeriodTypes
-    } = _ref3;
+  static getDerivedStateFromProps({
+    value,
+    allowedPeriodTypes
+  }) {
     const period = parsePeriodCode(value, allowedPeriodTypes);
     if (!period) {
       return null;
@@ -91,10 +86,10 @@ class FixedPeriodSelect extends Component {
     }, styles));
   }
 }
-FixedPeriodSelect.defaultProps = {
+_defineProperty(FixedPeriodSelect, "defaultProps", {
   dataTest: 'dhis2-analytics-fixedperiodselect',
   value: ''
-};
+});
 FixedPeriodSelect.propTypes = {
   onChange: PropTypes.func.isRequired,
   allowedPeriodTypes: PropTypes.arrayOf(PropTypes.string),

package/build/es/components/PeriodDimension/PeriodDimension.js

@@ -11,15 +11,15 @@ const userSettingsQuery = {
     }
   }
 };
-const PeriodDimension = _ref => {
-  let {
-    onSelect,
-    selectedPeriods,
-    rightFooter,
-    excludedPeriodTypes,
-    infoBoxMessage,
-    height
-  } = _ref;
+const SELECTED_PERIODS_PROP_DEFAULT = [];
+const PeriodDimension = ({
+  onSelect,
+  selectedPeriods = SELECTED_PERIODS_PROP_DEFAULT,
+  rightFooter,
+  excludedPeriodTypes,
+  infoBoxMessage,
+  height
+}) => {
   const {
     systemInfo
   } = useConfig();
@@ -63,7 +63,4 @@ PeriodDimension.propTypes = {
   rightFooter: PropTypes.node,
   selectedPeriods: PropTypes.array
 };
-PeriodDimension.defaultProps = {
-  selectedPeriods: []
-};
 export default PeriodDimension;

package/build/es/components/PeriodDimension/PeriodTransfer.js

@@ -14,36 +14,38 @@ import RelativePeriodFilter from './RelativePeriodFilter.js';
 import { getFixedPeriodsOptionsById } from './utils/fixedPeriods.js';
 import { MONTHLY, QUARTERLY } from './utils/index.js';
 import { getRelativePeriodsOptionsById } from './utils/relativePeriods.js';
-const RightHeader = _ref => {
-  let {
-    infoBoxMessage
-  } = _ref;
-  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("p", {
-    className: `jsx-${styles.__hash}` + " " + "rightHeader"
-  }, i18n.t('Selected Periods')), infoBoxMessage && /*#__PURE__*/React.createElement("div", {
-    className: `jsx-${styles.__hash}` + " " + "info-container"
-  }, /*#__PURE__*/React.createElement("div", {
-    className: `jsx-${styles.__hash}`
-  }, /*#__PURE__*/React.createElement(IconInfo16, null)), /*#__PURE__*/React.createElement("span", {
-    className: `jsx-${styles.__hash}` + " " + "info-text"
-  }, infoBoxMessage)), /*#__PURE__*/React.createElement(_JSXStyle, {
-    id: styles.__hash
-  }, styles));
-};
+const RightHeader = ({
+  infoBoxMessage
+}) => /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("p", {
+  className: `jsx-${styles.__hash}` + " " + "rightHeader"
+}, i18n.t('Selected Periods')), infoBoxMessage && /*#__PURE__*/React.createElement("div", {
+  className: `jsx-${styles.__hash}` + " " + "info-container"
+}, /*#__PURE__*/React.createElement("div", {
+  className: `jsx-${styles.__hash}`
+}, /*#__PURE__*/React.createElement(IconInfo16, null)), /*#__PURE__*/React.createElement("span", {
+  className: `jsx-${styles.__hash}` + " " + "info-text"
+}, infoBoxMessage)), /*#__PURE__*/React.createElement(_JSXStyle, {
+  id: styles.__hash
+}, styles));
 RightHeader.propTypes = {
   infoBoxMessage: PropTypes.string
 };
-const PeriodTransfer = _ref2 => {
-  let {
-    onSelect,
-    dataTest,
-    selectedItems,
-    rightFooter,
-    excludedPeriodTypes,
-    periodsSettings,
-    infoBoxMessage,
-    height = TRANSFER_HEIGHT
-  } = _ref2;
+const SELECTED_ITEMS_PROP_DEFAULT = [];
+const EXCLUDED_PERIOD_TYPES_PROP_DEFAULT = [];
+const PERIODS_SETTINGS_PROP_DEFAULT = {
+  calendar: 'gregory',
+  locale: 'en'
+};
+const PeriodTransfer = ({
+  onSelect,
+  dataTest,
+  selectedItems = SELECTED_ITEMS_PROP_DEFAULT,
+  rightFooter,
+  excludedPeriodTypes = EXCLUDED_PERIOD_TYPES_PROP_DEFAULT,
+  periodsSettings = PERIODS_SETTINGS_PROP_DEFAULT,
+  infoBoxMessage,
+  height = TRANSFER_HEIGHT
+}) => {
   const defaultRelativePeriodType = excludedPeriodTypes.includes(MONTHLY) ? getRelativePeriodsOptionsById(QUARTERLY) : getRelativePeriodsOptionsById(MONTHLY);
   const defaultFixedPeriodType = excludedPeriodTypes.includes(MONTHLY) ? getFixedPeriodsOptionsById(QUARTERLY, periodsSettings) : getFixedPeriodsOptionsById(MONTHLY, periodsSettings);
   const now = getNowInCalendar(periodsSettings.calendar);
@@ -126,10 +128,9 @@ const PeriodTransfer = _ref2 => {
     id: styles.__hash
   }, styles));
   return /*#__PURE__*/React.createElement(Transfer, {
-    onChange: _ref3 => {
-      let {
-        selected
-      } = _ref3;
+    onChange: ({
+      selected
+    }) => {
       const formattedItems = selected.map(id => {
         const matchingItem = [...allPeriods, ...selectedItems].find(item => item.id === id);
         return {
@@ -151,39 +152,25 @@ const PeriodTransfer = _ref2 => {
       infoBoxMessage: infoBoxMessage
     }),
     rightFooter: rightFooter,
-    options: [...allPeriods, ...selectedItems].map(_ref4 => {
-      let {
-        id,
-        name
-      } = _ref4;
-      return {
-        label: name,
-        value: id
-      };
-    }),
-    renderOption: _ref5 => {
-      let {
-        value,
-        ...props
-      } = _ref5;
-      return /*#__PURE__*/React.createElement(TransferOption, _extends({}, props, {
-        value: value,
-        active: isActive(value),
-        icon: PeriodIcon,
-        dataTest: `${dataTest}-transfer-option`
-      }));
-    },
+    options: [...allPeriods, ...selectedItems].map(({
+      id,
+      name
+    }) => ({
+      label: name,
+      value: id
+    })),
+    renderOption: ({
+      value,
+      ...props
+    }) => /*#__PURE__*/React.createElement(TransferOption, _extends({}, props, {
+      value: value,
+      active: isActive(value),
+      icon: PeriodIcon,
+      dataTest: `${dataTest}-transfer-option`
+    })),
     dataTest: `${dataTest}-transfer`
   });
 };
-PeriodTransfer.defaultProps = {
-  selectedItems: [],
-  excludedPeriodTypes: [],
-  periodsSettings: {
-    calendar: 'gregory',
-    locale: 'en'
-  }
-};
 PeriodTransfer.propTypes = {
   onSelect: PropTypes.func.isRequired,
   dataTest: PropTypes.string,

package/build/es/components/PeriodDimension/RelativePeriodFilter.js

@@ -6,36 +6,31 @@ import i18n from '../../locales/index.js';
 import styles from './styles/PeriodFilter.style.js';
 import { filterPeriodTypesById } from './utils/index.js';
 import { getRelativePeriodsOptions } from './utils/relativePeriods.js';
-const RelativePeriodFilter = _ref => {
-  let {
-    currentFilter,
-    onSelectFilter,
-    dataTest,
-    excludedPeriodTypes
-  } = _ref;
-  return /*#__PURE__*/React.createElement("div", {
-    className: `jsx-${styles.__hash}` + " " + "leftSection"
-  }, /*#__PURE__*/React.createElement(SingleSelectField, {
-    label: i18n.t('Period type'),
-    onChange: _ref2 => {
-      let {
-        selected
-      } = _ref2;
-      return onSelectFilter(selected);
-    },
-    dense: true,
-    selected: currentFilter,
-    className: "filterElement",
-    dataTest: dataTest
-  }, filterPeriodTypesById(getRelativePeriodsOptions(), excludedPeriodTypes).map(option => /*#__PURE__*/React.createElement(SingleSelectOption, {
-    key: option.id,
-    value: option.id,
-    label: option.name,
-    dataTest: `${dataTest}-option-${option.id}`
-  }))), /*#__PURE__*/React.createElement(_JSXStyle, {
-    id: styles.__hash
-  }, styles));
-};
+const RelativePeriodFilter = ({
+  currentFilter,
+  onSelectFilter,
+  dataTest,
+  excludedPeriodTypes
+}) => /*#__PURE__*/React.createElement("div", {
+  "data-test": dataTest,
+  className: `jsx-${styles.__hash}` + " " + "leftSection"
+}, /*#__PURE__*/React.createElement(SingleSelectField, {
+  label: i18n.t('Period type'),
+  onChange: ({
+    selected
+  }) => onSelectFilter(selected),
+  dense: true,
+  selected: currentFilter,
+  className: "filterElement",
+  dataTest: `${dataTest}-period-type`
+}, filterPeriodTypesById(getRelativePeriodsOptions(), excludedPeriodTypes).map(option => /*#__PURE__*/React.createElement(SingleSelectOption, {
+  key: option.id,
+  value: option.id,
+  label: option.name,
+  dataTest: `${dataTest}-period-type-option-${option.id}`
+}))), /*#__PURE__*/React.createElement(_JSXStyle, {
+  id: styles.__hash
+}, styles));
 RelativePeriodFilter.propTypes = {
   currentFilter: PropTypes.string.isRequired,
   onSelectFilter: PropTypes.func.isRequired,

package/build/es/components/PeriodDimension/__tests__/FixedPeriodSingleSelect.spec.js

@@ -1,24 +1,17 @@
-import { shallow } from 'enzyme';
+import { render, screen } from '@testing-library/react';
 import React from 'react';
 import FixedPeriodSelect from '../FixedPeriodSelect.js';
-describe('The Fixed Period Single Select component', () => {
-  let props;
-  let shallowFixedPeriodSelect;
-  const getWrapper = () => {
-    if (!shallowFixedPeriodSelect) {
-      shallowFixedPeriodSelect = shallow(/*#__PURE__*/React.createElement(FixedPeriodSelect, props));
-    }
-    return shallowFixedPeriodSelect;
+test('FixedPeriodSelect renders correctly', () => {
+  const props = {
+    value: '201405',
+    onChange: () => {}
   };
-  beforeEach(() => {
-    props = {
-      value: '201405',
-      onChange: () => {}
-    };
-    shallowFixedPeriodSelect = undefined;
-  });
-  it('matches the snapshot', () => {
-    const wrapper = getWrapper();
-    expect(wrapper).toMatchSnapshot();
-  });
+  render(/*#__PURE__*/React.createElement(FixedPeriodSelect, props));
+  expect(screen.getByTestId('dhis2-analytics-fixedperiodselect')).toBeInTheDocument();
+  expect(screen.getByText('Period type')).toBeInTheDocument();
+  expect(screen.getByText('Monthly')).toBeInTheDocument();
+  expect(screen.getByText('Year')).toBeInTheDocument();
+  const yearSelectEl = screen.getByPlaceholderText('Select year');
+  expect(yearSelectEl).toBeInTheDocument();
+  expect(yearSelectEl.value).toEqual('2014');
 });

package/build/es/components/PeriodDimension/__tests__/PeriodDimension.spec.js

@@ -1,4 +1,5 @@
-import { shallow } from 'enzyme';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
 import React from 'react';
 import PeriodDimension from '../PeriodDimension.js';
 jest.mock('@dhis2/app-runtime', () => ({
@@ -13,26 +14,29 @@ jest.mock('@dhis2/app-runtime', () => ({
     }
   })
 }));
+global.ResizeObserver = jest.fn().mockImplementation(() => ({
+  observe: jest.fn(),
+  unobserve: jest.fn(),
+  disconnect: jest.fn()
+}));
 afterEach(jest.clearAllMocks);
-describe('The Period Dimension component', () => {
-  let props;
-  let shallowPeriodDimension;
-  const getWrapper = () => {
-    if (!shallowPeriodDimension) {
-      shallowPeriodDimension = shallow(/*#__PURE__*/React.createElement(PeriodDimension, props));
-    }
-    return shallowPeriodDimension;
-  };
-  beforeEach(() => {
-    props = {
-      selectedPeriods: [],
-      onSelect: jest.fn(),
-      rightFooter: /*#__PURE__*/React.createElement(React.Fragment, null)
-    };
-    shallowPeriodDimension = undefined;
-  });
-  it('matches the snapshot', () => {
-    const wrapper = getWrapper();
-    expect(wrapper).toMatchSnapshot();
-  });
+const props = {
+  selectedPeriods: [],
+  onSelect: jest.fn(),
+  rightFooter: /*#__PURE__*/React.createElement(React.Fragment, null)
+};
+test('PeriodDimension renders the tabs for relative/fixed with relative pre-selected', () => {
+  render(/*#__PURE__*/React.createElement(PeriodDimension, props));
+  expect(screen.getByText('Relative periods')).toBeInTheDocument();
+  expect(screen.getByTestId('period-dimension-relative-period-filter')).toBeInTheDocument();
+  expect(screen.getByText('Fixed periods')).toBeInTheDocument();
+});
+test('PeriodDimension can toggle between relative and fixed period tab', async () => {
+  const user = userEvent.setup();
+  render(/*#__PURE__*/React.createElement(PeriodDimension, props));
+  expect(screen.getByText('Relative periods')).toBeInTheDocument();
+  const fixedPeriodButton = screen.getByText('Fixed periods');
+  expect(fixedPeriodButton).toBeInTheDocument();
+  await user.click(fixedPeriodButton);
+  expect(screen.getByTestId('period-dimension-fixed-period-filter')).toBeInTheDocument();
 });

package/build/es/components/PeriodDimension/utils/fixedPeriods.js

@@ -37,13 +37,12 @@ export const PERIOD_TYPE_REGEX = {
   // YYYY"July"
   [FYAPR]: /^([0-9]{4})April$/ // YYYY"April"
 };
-const getPeriods = _ref => {
-  let {
-    periodType,
-    config,
-    fnFilter,
-    periodSettings = {}
-  } = _ref;
+const getPeriods = ({
+  periodType,
+  config,
+  fnFilter,
+  periodSettings = {}
+}) => {
   const offset = parseInt(config.offset, 10);
   const isFilter = config.filterFuturePeriods;
   const isReverse = periodType.match(/^FY|YEARLY/) ? true : config.reversePeriods;

package/build/es/components/PeriodDimension/utils/index.js

@@ -17,8 +17,4 @@ export const FYNOV = 'FYNOV';
 export const FYOCT = 'FYOCT';
 export const FYJUL = 'FYJUL';
 export const FYAPR = 'FYAPR';
-export const filterPeriodTypesById = function () {
-  let allPeriodTypes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-  let excludedPeriodTypes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-  return allPeriodTypes.filter(period => !excludedPeriodTypes.includes(period.id));
-};
+export const filterPeriodTypesById = (allPeriodTypes = [], excludedPeriodTypes = []) => allPeriodTypes.filter(period => !excludedPeriodTypes.includes(period.id));

package/build/es/components/PivotTable/PivotTable.js

@@ -8,14 +8,13 @@ import { PivotTableBody } from './PivotTableBody.js';
 import { PivotTableContainer } from './PivotTableContainer.js';
 import { Provider } from './PivotTableEngineContext.js';
 import { PivotTableHead } from './PivotTableHead.js';
-const PivotTable = _ref => {
-  let {
-    visualization,
-    data,
-    legendSets,
-    renderCounter,
-    onToggleContextualMenu
-  } = _ref;
+const PivotTable = ({
+  visualization,
+  data,
+  legendSets,
+  renderCounter,
+  onToggleContextualMenu
+}) => {
   const containerRef = useRef(undefined);
   const {
     width,