@dhis2/analytics 28.0.4 → 28.1.0

package/build/es/modules/response/event/__tests__/default.spec.js

@@ -0,0 +1,75 @@
+import { VALUE_TYPE_NUMBER } from '../../../valueTypes.js';
+import { getDimensions, getItems, getRows, getPrefixedValue, getUnique, getValuesUniqueSortedAsc } from '../default.js';
+import { PREFIX_SEPARATOR } from '../response.js';
+const testId = 'Zj7UnCAulEk.qrur9Dvnyt5';
+describe('default', () => {
+  // applyDefaultHandler is tested by response.spec.js
+
+  describe('getUnique', () => {
+    it('removes duplicate string numbers', () => {
+      const arr = ['2', '10', '2', '01', '1', '-1', '-1', '1', '10'];
+      expect(getUnique(arr)).toEqual(['2', '10', '01', '1', '-1']);
+    });
+    it('treats "01" and "1" as different strings', () => {
+      const arr = ['01', '1', '01'];
+      expect(getUnique(arr)).toEqual(['01', '1']);
+    });
+    it('handles empty array', () => {
+      expect(getUnique([])).toEqual([]);
+    });
+    it('preserves order of first occurrence', () => {
+      const arr = ['2', '1', '2', '1'];
+      expect(getUnique(arr)).toEqual(['2', '1']);
+    });
+  });
+  describe('getValuesUniqueSortedAsc', () => {
+    it('sorts string numbers numerically', () => {
+      expect(getValuesUniqueSortedAsc(['1', '10', '-1', '5', '5', '3'], VALUE_TYPE_NUMBER)).toEqual(['-1', '1', '3', '5', '10']);
+    });
+    it('sorts non-numeric strings as strings', () => {
+      expect(getValuesUniqueSortedAsc(['1995-04-18 13:54:00.0', '1991-12-03 12:02:00.0', '1992-01-05 12:51:00.0', '1991-05-21 14:46:00.0', '1998-03-01 11:21:00.0', '1991-09-02 10:21:00.0', '1992-01-04 12:02:00.0', '1991-12-02 12:01:00.0', '1990-01-25 14:51:00.0', '1991-05-22 14:47:00.0'])).toEqual(['1990-01-25 14:51:00.0', '1991-05-21 14:46:00.0', '1991-05-22 14:47:00.0', '1991-09-02 10:21:00.0', '1991-12-02 12:01:00.0', '1991-12-03 12:02:00.0', '1992-01-04 12:02:00.0', '1992-01-05 12:51:00.0', '1995-04-18 13:54:00.0', '1998-03-01 11:21:00.0']);
+    });
+  });
+  describe('getPrefixedValue', () => {
+    it('returns prefix and value separated by a colon', () => {
+      expect(getPrefixedValue('123', 'id')).toBe(`id${PREFIX_SEPARATOR}123`);
+    });
+  });
+  describe('getItems', () => {
+    it('returns an object with prefixed keys and correct names', () => {
+      expect(getItems(['1', '2'], testId)).toEqual({
+        [testId + `${PREFIX_SEPARATOR}1`]: {
+          name: '1'
+        },
+        [testId + `${PREFIX_SEPARATOR}2`]: {
+          name: '2'
+        }
+      });
+    });
+    it('uses the formatter if one is provided', () => {
+      expect(getItems(['world'], 'hello', {
+        itemFormatter: str => str.toUpperCase()
+      })).toEqual({
+        [`hello${PREFIX_SEPARATOR}world`]: {
+          name: 'WORLD'
+        }
+      });
+    });
+  });
+  describe('getDimensions', () => {
+    it('returns an object with dimensionId as key and correctly prefixed values', () => {
+      expect(getDimensions(['1', '2'], testId)).toEqual({
+        [testId]: [testId + `${PREFIX_SEPARATOR}1`, testId + `${PREFIX_SEPARATOR}2`]
+      });
+    });
+  });
+  describe('getRows', () => {
+    it('prefixes value at headerIndex for each row', () => {
+      const rows = [['a', '1', 'x'], ['b', '2', 'y']];
+      expect(getRows(rows, 1, testId)).toEqual([['a', `${testId}${PREFIX_SEPARATOR}1`, 'x'], ['b', `${testId}${PREFIX_SEPARATOR}2`, 'y']]);
+    });
+    it('handles empty rows array', () => {
+      expect(getRows([], 1, 'a')).toEqual([]);
+    });
+  });
+});

package/build/es/modules/response/event/__tests__/optionSet.spec.js

@@ -0,0 +1,32 @@
+import responseHideNa from '../../../../__demo__/data/event/optionset.data.hidena.json';
+import responseOrg from '../../../../__demo__/data/event/optionset.data.org.json';
+import { getOptionCodeIdMap, getOptionIdRows } from '../optionSet.js';
+const testOptionCodeIdMap1 = {
+  ONE: 'optionId1',
+  TWO: 'optionId2'
+};
+const testOptionCodeIdMap2 = {
+  ONE: 'optionId3',
+  TWO: 'optionId4'
+};
+describe('optionSet', () => {
+  // applyOptionSetHandler is tested by response.spec.js
+
+  describe('getOptionCodeIdMap', () => {
+    it('should create an option code:id object', () => {
+      const testId = responseHideNa.headers[0].name;
+      const testOptionIds = responseHideNa.metaData.dimensions[testId];
+      const testOptionItems = responseHideNa.metaData.items;
+      expect(getOptionCodeIdMap(testOptionIds, testOptionItems)).toEqual(testOptionCodeIdMap1);
+    });
+  });
+
+  // Test the solution for two option sets with shared option codes
+  describe('getOptionIdRows', () => {
+    it('should replace option codes with ids in the right index', () => {
+      const optionSet1Rows = getOptionIdRows(responseOrg.rows, testOptionCodeIdMap1, 0);
+      const optionSet1And2Rows = getOptionIdRows(optionSet1Rows, testOptionCodeIdMap2, 1);
+      expect(optionSet1And2Rows).toEqual(responseHideNa.rows);
+    });
+  });
+});

package/build/es/modules/response/event/__tests__/response.spec.js

@@ -0,0 +1,122 @@
+import responseBooleanHideNa from '../../../../__demo__/data/event/boolean.data.hidena.json';
+import responseBoolean from '../../../../__demo__/data/event/boolean.data.json';
+import responseBooleanOrg from '../../../../__demo__/data/event/boolean.data.org.json';
+import responseDateHideNa from '../../../../__demo__/data/event/date.data.hidena.json';
+import responseDate from '../../../../__demo__/data/event/date.data.json';
+import responseDateOrg from '../../../../__demo__/data/event/date.data.org.json';
+import responseDatetimeHideNa from '../../../../__demo__/data/event/datetime.data.hidena.json';
+import responseDatetime from '../../../../__demo__/data/event/datetime.data.json';
+import responseDatetimeOrg from '../../../../__demo__/data/event/datetime.data.org.json';
+import responseTextHideNa from '../../../../__demo__/data/event/email.data.hidena.json';
+import responseText from '../../../../__demo__/data/event/email.data.json';
+import responseTextOrg from '../../../../__demo__/data/event/email.data.org.json';
+import responseNumericHideNa from '../../../../__demo__/data/event/integer.data.hidena.json';
+import responseNumeric from '../../../../__demo__/data/event/integer.data.json';
+import responseNumericOrg from '../../../../__demo__/data/event/integer.data.org.json';
+import responseOptionSetHideNa from '../../../../__demo__/data/event/optionset.data.hidena.json';
+import responseOptionSet from '../../../../__demo__/data/event/optionset.data.json';
+import responseOptionSetOrg from '../../../../__demo__/data/event/optionset.data.org.json';
+import responseTimeHideNa from '../../../../__demo__/data/event/time.data.hidena.json';
+import responseTime from '../../../../__demo__/data/event/time.data.json';
+import responseTimeOrg from '../../../../__demo__/data/event/time.data.org.json';
+import responseYesOnlyHideNa from '../../../../__demo__/data/event/yesonly.data.hidena.json';
+import responseYesOnly from '../../../../__demo__/data/event/yesonly.data.json';
+import responseYesOnlyOrg from '../../../../__demo__/data/event/yesonly.data.org.json';
+import { VALUE_TYPE_AGE, VALUE_TYPE_BOOLEAN, VALUE_TYPE_DATE, VALUE_TYPE_DATETIME, VALUE_TYPE_PERCENTAGE, VALUE_TYPE_TRUE_ONLY } from '../../../valueTypes.js';
+import { getItemFormatterByValueType, transformResponse } from '../response.js';
+describe('response', () => {
+  describe('getItemFormatterByValueType', () => {
+    it('should return the correct formatter and format correctly', () => {
+      expect(getItemFormatterByValueType(VALUE_TYPE_BOOLEAN)('1')).toBe('Yes');
+      expect(getItemFormatterByValueType(VALUE_TYPE_BOOLEAN)('0')).toBe('No');
+      expect(getItemFormatterByValueType(VALUE_TYPE_TRUE_ONLY)('1')).toBe('Yes');
+      expect(getItemFormatterByValueType(VALUE_TYPE_AGE)('1985-01-01 00:00:00.0')).toBe('1985-01-01');
+      expect(getItemFormatterByValueType(VALUE_TYPE_DATE)('2023-01-01 00:00:00.0')).toBe('2023-01-01');
+      expect(getItemFormatterByValueType(VALUE_TYPE_DATETIME)('2023-01-01 12:00:00.0')).toBe('2023-01-01 12:00');
+      expect(getItemFormatterByValueType(VALUE_TYPE_PERCENTAGE)('50.0')).toBe('50');
+      expect(getItemFormatterByValueType('NOT_A_TYPE')).toBe(undefined);
+    });
+  });
+  describe('transformResponse', () => {
+    describe('boolean', () => {
+      it('transforms response', () => {
+        expect(transformResponse(responseBooleanOrg)).toEqual(responseBoolean);
+      });
+      it('transforms response and hides N/A data', () => {
+        expect(transformResponse(responseBooleanOrg, {
+          hideNaData: true
+        })).toEqual(responseBooleanHideNa);
+      });
+    });
+    describe('date', () => {
+      it('transforms response', () => {
+        expect(transformResponse(responseDateOrg)).toEqual(responseDate);
+      });
+      it('transforms response and hides N/A data', () => {
+        expect(transformResponse(responseDateOrg, {
+          hideNaData: true
+        })).toEqual(responseDateHideNa);
+      });
+    });
+    describe('datetime', () => {
+      it('transforms response', () => {
+        expect(transformResponse(responseDatetimeOrg)).toEqual(responseDatetime);
+      });
+      it('transforms response and hides N/A data', () => {
+        expect(transformResponse(responseDatetimeOrg, {
+          hideNaData: true
+        })).toEqual(responseDatetimeHideNa);
+      });
+    });
+    describe('numeric', () => {
+      it('transforms response', () => {
+        expect(transformResponse(responseNumericOrg)).toEqual(responseNumeric);
+      });
+      it('transforms response and hides N/A data', () => {
+        expect(transformResponse(responseNumericOrg, {
+          hideNaData: true
+        })).toEqual(responseNumericHideNa);
+      });
+    });
+    describe('option set', () => {
+      it('transforms response with non-unique codes across two option sets', () => {
+        expect(transformResponse(responseOptionSetOrg)).toEqual(responseOptionSet);
+      });
+      it('transforms response with non-unique codes across two option sets and hides N/A data', () => {
+        expect(transformResponse(responseOptionSetOrg, {
+          hideNaData: true
+        })).toEqual(responseOptionSetHideNa);
+      });
+    });
+    describe('text', () => {
+      it('transforms response', () => {
+        expect(transformResponse(responseTextOrg)).toEqual(responseText);
+      });
+      it('transforms response and hides N/A data', () => {
+        expect(transformResponse(responseTextOrg, {
+          hideNaData: true
+        })).toEqual(responseTextHideNa);
+      });
+    });
+    describe('time', () => {
+      it('transforms response', () => {
+        expect(transformResponse(responseTimeOrg)).toEqual(responseTime);
+      });
+      it('transforms response and hides N/A data', () => {
+        expect(transformResponse(responseTimeOrg, {
+          hideNaData: true
+        })).toEqual(responseTimeHideNa);
+      });
+    });
+    describe('yes only', () => {
+      it('transforms response', () => {
+        expect(transformResponse(responseYesOnlyOrg)).toEqual(responseYesOnly);
+      });
+      it('transforms response and hides N/A data', () => {
+        expect(transformResponse(responseYesOnlyOrg, {
+          hideNaData: true
+        })).toEqual(responseYesOnlyHideNa);
+      });
+    });
+  });
+});

package/build/es/modules/response/event/default.js

@@ -0,0 +1,52 @@
+import { isBooleanValueType, isNumericValueType, VALUE_TYPE_TEXT } from '../../valueTypes.js';
+import { NA_VALUE, PREFIX_SEPARATOR } from './response.js';
+export const getUnique = array => [...new Set(array)];
+export const getValuesUniqueSortedAsc = (values, valueType = VALUE_TYPE_TEXT) => isNumericValueType(valueType) || isBooleanValueType(valueType) ? getUnique(values).map(x => [Number(x), x]).sort((a, b) => a[0] - b[0]).map(arr => arr[1]) : getUnique(values).slice().sort((a, b) => a.localeCompare(b));
+export const getPrefixedValue = (value, prefix) => `${prefix}${PREFIX_SEPARATOR}${value}`;
+export const getItems = (values, dimensionId, {
+  itemFormatter
+} = {}) => values.reduce((items, value) => {
+  items[getPrefixedValue(value, dimensionId)] = {
+    name: itemFormatter ? itemFormatter(value) : value
+  };
+  return items;
+}, {});
+export const getDimensions = (values, dimensionId) => ({
+  [dimensionId]: values.map(value => getPrefixedValue(value, dimensionId))
+});
+export const getRows = (rows, headerIndex, dimensionId) => {
+  let row;
+  let value;
+  return rows.map(r => {
+    value = r[headerIndex];
+    if (value !== NA_VALUE) {
+      row = [...r];
+      row[headerIndex] = getPrefixedValue(row[headerIndex], dimensionId);
+      return row;
+    }
+    return r;
+  });
+};
+export const applyDefaultHandler = (response, headerIndex, {
+  itemFormatter
+} = {}) => {
+  const header = response.headers[headerIndex];
+  const uniqueSortedValuesAsc = getValuesUniqueSortedAsc(response.rows.map(row => row[headerIndex]).filter(value => value !== NA_VALUE), header.valueType);
+  return {
+    ...response,
+    metaData: {
+      ...response.metaData,
+      items: {
+        ...response.metaData.items,
+        ...getItems(uniqueSortedValuesAsc, header.name, {
+          itemFormatter
+        })
+      },
+      dimensions: {
+        ...response.metaData.dimensions,
+        ...getDimensions(uniqueSortedValuesAsc, header.name)
+      }
+    },
+    rows: [...getRows(response.rows, headerIndex, header.name)]
+  };
+};

package/build/es/modules/response/event/optionSet.js

@@ -0,0 +1,27 @@
+import { NA_VALUE } from './response.js';
+export const getOptionCodeIdMap = (optionIds, items) => optionIds.reduce((map, optionId) => {
+  map[items[optionId].code] = optionId;
+  return map;
+}, {});
+export const getOptionIdRows = (rows, optionCodeIdMap, headerIndex) => {
+  let value;
+  let row;
+  return rows.map(r => {
+    value = r[headerIndex];
+    if (value !== NA_VALUE) {
+      row = [...r];
+      row[headerIndex] = optionCodeIdMap[value];
+      return row;
+    }
+    return r;
+  });
+};
+export const applyOptionSetHandler = (response, headerIndex) => {
+  const header = response.headers[headerIndex];
+  const optionIds = response.metaData.dimensions[header.name];
+  const optionCodeIdMap = getOptionCodeIdMap(optionIds, response.metaData.items);
+  return {
+    ...response,
+    rows: getOptionIdRows(response.rows, optionCodeIdMap, headerIndex)
+  };
+};

package/build/es/modules/response/event/response.js

@@ -0,0 +1,86 @@
+import i18n from '@dhis2/d2-i18n';
+import { DIMENSION_ID_ORGUNIT, DIMENSION_ID_PERIOD } from '../../predefinedDimensions.js';
+import { VALUE_TYPE_AGE, VALUE_TYPE_BOOLEAN, VALUE_TYPE_COORDINATE, VALUE_TYPE_DATE, VALUE_TYPE_DATETIME, VALUE_TYPE_FILE_RESOURCE, VALUE_TYPE_GEOJSON, VALUE_TYPE_IMAGE, VALUE_TYPE_MULTI_TEXT, VALUE_TYPE_PERCENTAGE, VALUE_TYPE_REFERENCE, VALUE_TYPE_TRUE_ONLY } from '../../valueTypes.js';
+import { applyDefaultHandler } from './default.js';
+import { applyOptionSetHandler } from './optionSet.js';
+export const PREFIX_SEPARATOR = '_';
+export const NA_VALUE = '';
+export const NA_VALUE_ITEM = {
+  name: i18n.t('No value'),
+  style: {
+    fontStyle: 'italic',
+    color: '#6C7787',
+    fontFamily: 'monospace',
+    letterSpacing: '-0.3px'
+  }
+};
+export const UNSUPPORTED_VALUE_TYPES = [VALUE_TYPE_COORDINATE, VALUE_TYPE_GEOJSON, VALUE_TYPE_FILE_RESOURCE, VALUE_TYPE_IMAGE, VALUE_TYPE_MULTI_TEXT, VALUE_TYPE_REFERENCE];
+export const getItemFormatterByValueType = valueType => {
+  switch (valueType) {
+    case VALUE_TYPE_AGE:
+    case VALUE_TYPE_DATE:
+      return name => name.replace(/ 00:00:00\.0$/, '');
+    case VALUE_TYPE_BOOLEAN:
+    case VALUE_TYPE_TRUE_ONLY:
+      return name => name === '1' ? i18n.t('Yes') : i18n.t('No');
+    case VALUE_TYPE_DATETIME:
+      return name => name.replace(/:00\.0$/, '');
+    case VALUE_TYPE_PERCENTAGE:
+      return name => name.endsWith('.0') ? name.slice(0, -2) : name;
+    default:
+      return undefined;
+  }
+};
+export const transformResponse = (response, {
+  hideNaData = false
+} = {}) => {
+  // Do not modify the original response
+  // Rows is mapped by the handlers
+  let transformedResponse = {
+    ...response,
+    metaData: {
+      ...response.metaData,
+      items: {
+        ...response.metaData.items
+      },
+      dimensions: {
+        ...response.metaData.dimensions
+      }
+    }
+  };
+
+  // Add index to all headers
+  // Include only headers that are "meta" and skip "pe" and "ou"
+  const metaHeaders = response.headers.map((header, index) => ({
+    ...header,
+    index
+  })).filter(header => Boolean(header.meta) && ![DIMENSION_ID_PERIOD, DIMENSION_ID_ORGUNIT].includes(header.name));
+
+  // Legendsets use uids and do not need transformation
+  // Skip unsupported value types
+  // Option set and Boolean have separate handlers
+  // All other types use default handler with specific item formatter
+  metaHeaders.forEach(header => {
+    if (!(header.legendSet || UNSUPPORTED_VALUE_TYPES.includes(header.valueType))) {
+      if (header.optionSet) {
+        transformedResponse = applyOptionSetHandler(transformedResponse, header.index);
+      } else {
+        transformedResponse = applyDefaultHandler(transformedResponse, header.index, {
+          itemFormatter: getItemFormatterByValueType(header.valueType)
+        });
+      }
+    }
+  });
+
+  // Add "No value" dimension item if "Hide NA data" option is disabled
+  // Only add if there is at least one empty value
+  if (!hideNaData) {
+    metaHeaders.forEach(header => {
+      if (response.rows.map(row => row[header.index]).includes(NA_VALUE)) {
+        transformedResponse.metaData.dimensions[header.name] = [...transformedResponse.metaData.dimensions[header.name], NA_VALUE];
+        transformedResponse.metaData.items[NA_VALUE] = NA_VALUE_ITEM;
+      }
+    });
+  }
+  return transformedResponse;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dhis2/analytics",
-    "version": "28.0.4",
+    "version": "28.1.0",
     "main": "./build/cjs/index.js",
     "module": "./build/es/index.js",
     "exports": {
@@ -42,10 +42,8 @@
         "@testing-library/dom": "^10.4.0",
         "@testing-library/jest-dom": "^6.6.3",
         "@testing-library/react": "^16.3.0",
-        "enzyme": "^3.9.0",
-        "enzyme-adapter-react-16": "^1.15.6",
+        "@testing-library/user-event": "^14.6.1",
         "fs-extra": "^10.1.0",
-        "jest-enzyme": "^7.0.2",
         "prop-types": "^15",
         "react": "^18.3.1",
         "react-dom": "^18.3.1",

package/build/cjs/components/OrgUnitDimension/__tests__/__snapshots__/OrgUnitDimension.spec.js.snap

@@ -1,89 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`The OrgUnitDimension component matches the snapshot 1`] = `
-<div
-  className="container"
->
-  <div
-    className="userOrgUnitsWrapper"
-  >
-    <Checkbox
-      checked={false}
-      dataTest="dhis2-uicore-checkbox"
-      dense={true}
-      indeterminate={false}
-      label="User organisation unit"
-      onChange={[Function]}
-    />
-    <Checkbox
-      checked={false}
-      dataTest="dhis2-uicore-checkbox"
-      dense={true}
-      indeterminate={false}
-      label="User sub-units"
-      onChange={[Function]}
-    />
-    <Checkbox
-      checked={false}
-      dataTest="dhis2-uicore-checkbox"
-      dense={true}
-      indeterminate={false}
-      label="User sub-x2-units"
-      onChange={[Function]}
-    />
-  </div>
-  <div
-    className="orgUnitTreeWrapper"
-  >
-    <OrganisationUnitTree
-      dataTest="org-unit-tree"
-      initiallyExpanded={Array []}
-      onChange={[Function]}
-      roots={Array []}
-      selected={Array []}
-    />
-  </div>
-  <div
-    className="selectsWrapper"
-  >
-    <MultiSelect
-      dataTest="org-unit-level-select"
-      dense={true}
-      loading={true}
-      onChange={[Function]}
-      placeholder="Select a level"
-      selected={Array []}
-    />
-    <MultiSelect
-      dataTest="org-unit-group-select"
-      dense={true}
-      loading={true}
-      onChange={[Function]}
-      placeholder="Select a group"
-      selected={Array []}
-    />
-  </div>
-  <div
-    className="summaryWrapper"
-  >
-    <span
-      className="summaryText"
-    >
-      Nothing selected
-    </span>
-    <div
-      className="deselectButton"
-    >
-      <Button
-        disabled={true}
-        onClick={[Function]}
-        secondary={true}
-        small={true}
-      >
-        Deselect all
-      </Button>
-    </div>
-  </div>
-  <style />
-</div>
-`;

package/build/cjs/components/PeriodDimension/__tests__/PeriodSelector.spec.js

@@ -1,29 +0,0 @@
-"use strict";
-
-var _enzyme = require("enzyme");
-var _react = _interopRequireDefault(require("react"));
-var _PeriodTransfer = _interopRequireDefault(require("../PeriodTransfer.js"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-describe('The Period Selector component', () => {
-  let props;
-  let shallowPeriodTransfer;
-  const getWrapper = () => {
-    if (!shallowPeriodTransfer) {
-      shallowPeriodTransfer = (0, _enzyme.shallow)(/*#__PURE__*/_react.default.createElement(_PeriodTransfer.default, props));
-    }
-    return shallowPeriodTransfer;
-  };
-  beforeEach(() => {
-    props = {
-      initialSelectedPeriods: [],
-      onSelect: jest.fn(),
-      rightFooter: /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null),
-      dataTest: 'period-dimension'
-    };
-    shallowPeriodTransfer = undefined;
-  });
-  it('matches the snapshot', () => {
-    const wrapper = getWrapper();
-    expect(wrapper).toMatchSnapshot();
-  });
-});

package/build/cjs/components/PeriodDimension/__tests__/__snapshots__/FixedPeriodSingleSelect.spec.js.snap

@@ -1,92 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`The Fixed Period Single Select component matches the snapshot 1`] = `
-<div
-  data-test="dhis2-analytics-fixedperiodselect"
->
-  <div
-    className="row"
-  >
-    <FixedPeriodFilter
-      currentPeriodType="MONTHLY"
-      currentYear="2014"
-      onSelectPeriodType={[Function]}
-      onSelectYear={[Function]}
-    />
-  </div>
-  <SingleSelectField
-    clearText={[Function]}
-    dataTest="dhis2-uiwidgets-singleselectfield"
-    dense={true}
-    empty={[Function]}
-    filterPlaceholder={[Function]}
-    label="Period"
-    loadingText={[Function]}
-    noMatchText={[Function]}
-    onChange={[Function]}
-    selected="201405"
-  >
-    <SingleSelectOption
-      key="201401"
-      label="January 2014"
-      value="201401"
-    />
-    <SingleSelectOption
-      key="201402"
-      label="February 2014"
-      value="201402"
-    />
-    <SingleSelectOption
-      key="201403"
-      label="March 2014"
-      value="201403"
-    />
-    <SingleSelectOption
-      key="201404"
-      label="April 2014"
-      value="201404"
-    />
-    <SingleSelectOption
-      key="201405"
-      label="May 2014"
-      value="201405"
-    />
-    <SingleSelectOption
-      key="201406"
-      label="June 2014"
-      value="201406"
-    />
-    <SingleSelectOption
-      key="201407"
-      label="July 2014"
-      value="201407"
-    />
-    <SingleSelectOption
-      key="201408"
-      label="August 2014"
-      value="201408"
-    />
-    <SingleSelectOption
-      key="201409"
-      label="September 2014"
-      value="201409"
-    />
-    <SingleSelectOption
-      key="201410"
-      label="October 2014"
-      value="201410"
-    />
-    <SingleSelectOption
-      key="201411"
-      label="November 2014"
-      value="201411"
-    />
-    <SingleSelectOption
-      key="201412"
-      label="December 2014"
-      value="201412"
-    />
-  </SingleSelectField>
-  <style />
-</div>
-`;

package/build/cjs/components/PeriodDimension/__tests__/__snapshots__/PeriodDimension.spec.js.snap

@@ -1,16 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`The Period Dimension component matches the snapshot 1`] = `
-<PeriodTransfer
-  dataTest="period-dimension"
-  onSelect={[Function]}
-  periodsSettings={
-    Object {
-      "calendar": "gregory",
-      "locale": "en",
-    }
-  }
-  rightFooter={<React.Fragment />}
-  selectedItems={Array []}
-/>
-`;