@dhis2/analytics 29.2.0 → 29.3.0

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

@@ -10,20 +10,16 @@ var _propTypes = _interopRequireDefault(require("prop-types"));
 var _react = _interopRequireDefault(require("react"));
 var _index = _interopRequireDefault(require("../../locales/index.js"));
 var _PeriodFilterStyle = _interopRequireDefault(require("./styles/PeriodFilter.style.js"));
-var _fixedPeriods = require("./utils/fixedPeriods.js");
-var _index2 = require("./utils/index.js");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const EXCLUDED_PERIOD_TYPES_PROP_DEFAULT = [];
 const FixedPeriodFilter = ({
-  allowedPeriodTypes,
-  excludedPeriodTypes = EXCLUDED_PERIOD_TYPES_PROP_DEFAULT,
+  availableOptions,
   currentPeriodType,
   currentYear,
   onSelectPeriodType,
   onSelectYear,
   dataTest
 }) => {
-  const onlyAllowedTypeIsSelected = Array.isArray(allowedPeriodTypes) && allowedPeriodTypes.length === 1 && allowedPeriodTypes[0] === currentPeriodType;
+  const onlyAllowedTypeIsSelected = availableOptions.length === 1 && availableOptions[0].id === currentPeriodType;
   return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement("div", {
     "data-test": dataTest,
     className: `jsx-${_PeriodFilterStyle.default.__hash}` + " " + "leftSection"
@@ -37,7 +33,7 @@ const FixedPeriodFilter = ({
     disabled: onlyAllowedTypeIsSelected,
     className: "filterElement",
     dataTest: `${dataTest}-period-type`
-  }, (allowedPeriodTypes ? (0, _fixedPeriods.getFixedPeriodsOptions)().filter(option => allowedPeriodTypes.some(type => type === option.id)) : (0, _index2.filterPeriodTypesById)((0, _fixedPeriods.getFixedPeriodsOptions)(), excludedPeriodTypes)).map(option => /*#__PURE__*/_react.default.createElement(_ui.SingleSelectOption, {
+  }, availableOptions.map(option => /*#__PURE__*/_react.default.createElement(_ui.SingleSelectOption, {
     key: option.id,
     value: option.id,
     label: option.name,
@@ -60,12 +56,11 @@ const FixedPeriodFilter = ({
   }, _PeriodFilterStyle.default));
 };
 FixedPeriodFilter.propTypes = {
+  availableOptions: _propTypes.default.array.isRequired,
   currentPeriodType: _propTypes.default.string.isRequired,
   currentYear: _propTypes.default.string.isRequired,
   onSelectPeriodType: _propTypes.default.func.isRequired,
   onSelectYear: _propTypes.default.func.isRequired,
-  allowedPeriodTypes: _propTypes.default.arrayOf(_propTypes.default.string),
-  dataTest: _propTypes.default.string,
-  excludedPeriodTypes: _propTypes.default.arrayOf(_propTypes.default.string)
+  dataTest: _propTypes.default.string
 };
 var _default = exports.default = FixedPeriodFilter;

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

@@ -69,13 +69,15 @@ class FixedPeriodSelect extends _react.Component {
     });
   }
   render() {
+    const allOptions = (0, _fixedPeriods.getFixedPeriodsOptions)();
+    const availableOptions = this.props.allowedPeriodTypes ? allOptions.filter(option => this.props.allowedPeriodTypes.includes(option.id)) : allOptions;
     return /*#__PURE__*/_react.default.createElement("div", {
       "data-test": this.props.dataTest,
       className: `jsx-${_FixedPeriodSelectStyle.default.__hash}` + " " + (this.props.className || "")
     }, /*#__PURE__*/_react.default.createElement("div", {
       className: `jsx-${_FixedPeriodSelectStyle.default.__hash}` + " " + "row"
     }, /*#__PURE__*/_react.default.createElement(_FixedPeriodFilter.default, {
-      allowedPeriodTypes: this.props.allowedPeriodTypes,
+      availableOptions: availableOptions,
       currentPeriodType: this.state.periodType,
       currentYear: this.state.year,
       onSelectPeriodType: this.onSelectPeriodType,

package/build/cjs/components/PeriodDimension/PeriodDimension.js

@@ -9,6 +9,8 @@ var _propTypes = _interopRequireDefault(require("prop-types"));
 var _react = _interopRequireDefault(require("react"));
 var _predefinedDimensions = require("../../modules/predefinedDimensions.js");
 var _PeriodTransfer = _interopRequireDefault(require("./PeriodTransfer.js"));
+var _useDataOutputPeriodTypes = require("./useDataOutputPeriodTypes.js");
+var _enabledPeriodTypes = require("./utils/enabledPeriodTypes.js");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const userSettingsQuery = {
   userSettings: {
@@ -27,10 +29,15 @@ const PeriodDimension = ({
   infoBoxMessage,
   height
 }) => {
+  const config = (0, _appRuntime.useConfig)();
   const {
     systemInfo
-  } = (0, _appRuntime.useConfig)();
-  const result = (0, _appRuntime.useDataQuery)(userSettingsQuery);
+  } = config;
+  const userSettingsResult = (0, _appRuntime.useDataQuery)(userSettingsQuery);
+  const {
+    supportsEnabledPeriodTypes,
+    enabledPeriodTypesData
+  } = (0, _useDataOutputPeriodTypes.useDataOutputPeriodTypes)();
   const {
     calendar = 'gregory'
   } = systemInfo;
@@ -40,7 +47,7 @@ const PeriodDimension = ({
         keyUiLocale: locale
       } = {}
     } = {}
-  } = result;
+  } = userSettingsResult;
   const periodsSettings = {
     calendar,
     locale
@@ -51,15 +58,18 @@ const PeriodDimension = ({
       items: periods
     });
   };
+  const selectedPeriodsWithCustomDisplayNames = (0, _enabledPeriodTypes.applyPeriodNameOverrides)(selectedPeriods, enabledPeriodTypesData === null || enabledPeriodTypesData === void 0 ? void 0 : enabledPeriodTypesData.metaData);
   return /*#__PURE__*/_react.default.createElement(_PeriodTransfer.default, {
     onSelect: selectPeriods,
-    selectedItems: selectedPeriods,
+    selectedItems: selectedPeriodsWithCustomDisplayNames,
     infoBoxMessage: infoBoxMessage,
     rightFooter: rightFooter,
     dataTest: 'period-dimension',
     excludedPeriodTypes: excludedPeriodTypes,
     periodsSettings: periodsSettings,
-    height: height
+    height: height,
+    enabledPeriodTypesData: enabledPeriodTypesData,
+    supportsEnabledPeriodTypes: supportsEnabledPeriodTypes
   });
 };
 PeriodDimension.propTypes = {

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

@@ -16,6 +16,7 @@ var _DimensionSelectorStyle = _interopRequireDefault(require("../styles/Dimensio
 var _TransferOption = require("../TransferOption.js");
 var _FixedPeriodFilter = _interopRequireDefault(require("./FixedPeriodFilter.js"));
 var _RelativePeriodFilter = _interopRequireDefault(require("./RelativePeriodFilter.js"));
+var _enabledPeriodTypes = require("./utils/enabledPeriodTypes.js");
 var _fixedPeriods = require("./utils/fixedPeriods.js");
 var _index2 = require("./utils/index.js");
 var _relativePeriods = require("./utils/relativePeriods.js");
@@ -52,10 +53,52 @@ const PeriodTransfer = ({
   excludedPeriodTypes = EXCLUDED_PERIOD_TYPES_PROP_DEFAULT,
   periodsSettings = PERIODS_SETTINGS_PROP_DEFAULT,
   infoBoxMessage,
-  height = _dimensionSelectorHelper.TRANSFER_HEIGHT
+  height = _dimensionSelectorHelper.TRANSFER_HEIGHT,
+  enabledPeriodTypesData = null,
+  supportsEnabledPeriodTypes = false
 }) => {
-  const defaultRelativePeriodType = excludedPeriodTypes.includes(_index2.MONTHLY) ? (0, _relativePeriods.getRelativePeriodsOptionsById)(_index2.QUARTERLY) : (0, _relativePeriods.getRelativePeriodsOptionsById)(_index2.MONTHLY);
-  const defaultFixedPeriodType = excludedPeriodTypes.includes(_index2.MONTHLY) ? (0, _fixedPeriods.getFixedPeriodsOptionsById)(_index2.QUARTERLY, periodsSettings) : (0, _fixedPeriods.getFixedPeriodsOptionsById)(_index2.MONTHLY, periodsSettings);
+  const {
+    filteredFixedOptions,
+    filteredRelativeOptions
+  } = (0, _react.useMemo)(() => {
+    if (supportsEnabledPeriodTypes && enabledPeriodTypesData) {
+      const {
+        enabledTypes,
+        financialYearStart,
+        financialYearDisplayLabel,
+        weeklyDisplayLabel,
+        metaData
+      } = enabledPeriodTypesData;
+      const filteredFixed = (0, _enabledPeriodTypes.applyFixedPeriodTypeDisplayLabels)((0, _enabledPeriodTypes.filterEnabledFixedPeriodTypes)((0, _fixedPeriods.getFixedPeriodsOptions)(periodsSettings), enabledTypes), enabledTypes);
+      const filteredRelative = (0, _enabledPeriodTypes.applyDisplayLabelOverrides)((0, _enabledPeriodTypes.filterEnabledRelativePeriodTypes)((0, _relativePeriods.getRelativePeriodsOptions)(), enabledTypes, financialYearStart), {
+        financialYearDisplayLabel,
+        weeklyDisplayLabel,
+        metaData
+      });
+      return {
+        filteredFixedOptions: filteredFixed,
+        filteredRelativeOptions: filteredRelative
+      };
+    } else {
+      const allFixed = (0, _fixedPeriods.getFixedPeriodsOptions)(periodsSettings);
+      const allRelative = (0, _relativePeriods.getRelativePeriodsOptions)();
+      return {
+        filteredFixedOptions: (0, _index2.filterPeriodTypesById)(allFixed, excludedPeriodTypes),
+        filteredRelativeOptions: (0, _index2.filterPeriodTypesById)(allRelative, excludedPeriodTypes)
+      };
+    }
+  }, [supportsEnabledPeriodTypes, enabledPeriodTypesData, excludedPeriodTypes, periodsSettings]);
+  const analysisRelativePeriod = enabledPeriodTypesData === null || enabledPeriodTypesData === void 0 ? void 0 : enabledPeriodTypesData.analysisRelativePeriod;
+  const defaultRelativePeriodType = (() => {
+    if (analysisRelativePeriod) {
+      const match = filteredRelativeOptions.find(opt => opt.getPeriods().some(p => p.id === analysisRelativePeriod));
+      if (match) {
+        return match;
+      }
+    }
+    return filteredRelativeOptions.find(opt => opt.id === _index2.MONTHLY) || filteredRelativeOptions.find(opt => opt.id === _index2.QUARTERLY) || filteredRelativeOptions[0];
+  })();
+  const defaultFixedPeriodType = filteredFixedOptions.find(opt => opt.id === _index2.MONTHLY) || filteredFixedOptions.find(opt => opt.id === _index2.QUARTERLY) || filteredFixedOptions[0];
   const now = (0, _multiCalendarDates.getNowInCalendar)(periodsSettings.calendar);
   // use ".eraYear" rather than ".year" because in Ethiopian calendar, eraYear is what our users expect to see (for other calendars, it doesn't matter)
   // there is still a pending decision in Temporal regarding which era to use by default: https://github.com/js-temporal/temporal-polyfill/blob/9350ee7dd0d29f329fc097debf923a517c32f813/lib/calendar.ts#L1964
@@ -65,15 +108,52 @@ const PeriodTransfer = ({
     filterFuturePeriods: false,
     reversePeriods: false
   });
-  const [allPeriods, setAllPeriods] = (0, _react.useState)(defaultRelativePeriodType.getPeriods());
+  const [userPeriods, setUserPeriods] = (0, _react.useState)(null);
   const [isRelative, setIsRelative] = (0, _react.useState)(true);
   const [relativeFilter, setRelativeFilter] = (0, _react.useState)({
-    periodType: defaultRelativePeriodType.id
+    periodType: (defaultRelativePeriodType === null || defaultRelativePeriodType === void 0 ? void 0 : defaultRelativePeriodType.id) || ''
   });
   const [fixedFilter, setFixedFilter] = (0, _react.useState)({
-    periodType: defaultFixedPeriodType.id,
+    periodType: (defaultFixedPeriodType === null || defaultFixedPeriodType === void 0 ? void 0 : defaultFixedPeriodType.id) || '',
     year: defaultFixedPeriodYear.toString()
   });
+  const effectiveRelativeFilterType = filteredRelativeOptions.some(opt => opt.id === relativeFilter.periodType) ? relativeFilter.periodType : (defaultRelativePeriodType === null || defaultRelativePeriodType === void 0 ? void 0 : defaultRelativePeriodType.id) || '';
+  const effectiveFixedFilterType = filteredFixedOptions.some(opt => opt.id === fixedFilter.periodType) ? fixedFilter.periodType : (defaultFixedPeriodType === null || defaultFixedPeriodType === void 0 ? void 0 : defaultFixedPeriodType.id) || '';
+  const prevEffectiveRelativeRef = (0, _react.useRef)(effectiveRelativeFilterType);
+  const prevEffectiveFixedRef = (0, _react.useRef)(effectiveFixedFilterType);
+  if (prevEffectiveRelativeRef.current !== effectiveRelativeFilterType) {
+    prevEffectiveRelativeRef.current = effectiveRelativeFilterType;
+    if (relativeFilter.periodType !== effectiveRelativeFilterType) {
+      setRelativeFilter({
+        periodType: effectiveRelativeFilterType
+      });
+    }
+    if (isRelative) {
+      setUserPeriods(null);
+    }
+  }
+  if (prevEffectiveFixedRef.current !== effectiveFixedFilterType) {
+    prevEffectiveFixedRef.current = effectiveFixedFilterType;
+    if (fixedFilter.periodType !== effectiveFixedFilterType) {
+      setFixedFilter(prev => ({
+        ...prev,
+        periodType: effectiveFixedFilterType
+      }));
+    }
+    if (!isRelative) {
+      setUserPeriods(null);
+    }
+  }
+  const derivedPeriods = (0, _react.useMemo)(() => {
+    if (isRelative) {
+      const opt = filteredRelativeOptions.find(o => o.id === effectiveRelativeFilterType);
+      return (opt === null || opt === void 0 ? void 0 : opt.getPeriods()) || [];
+    } else {
+      const opt = filteredFixedOptions.find(o => o.id === effectiveFixedFilterType);
+      return (opt === null || opt === void 0 ? void 0 : opt.getPeriods(fixedPeriodConfig(Number(fixedFilter.year)))) || [];
+    }
+  }, [isRelative, effectiveRelativeFilterType, effectiveFixedFilterType, filteredRelativeOptions, filteredFixedOptions, fixedFilter.year]);
+  const allPeriods = userPeriods !== null && userPeriods !== void 0 ? userPeriods : derivedPeriods;
   const isActive = value => {
     const item = selectedItems.find(item => item.id === value);
     return !item || item.isActive;
@@ -81,9 +161,15 @@ const PeriodTransfer = ({
   const onIsRelativeClick = state => {
     if (state !== isRelative) {
       setIsRelative(state);
-      setAllPeriods(state ? (0, _relativePeriods.getRelativePeriodsOptionsById)(relativeFilter.periodType).getPeriods() : (0, _fixedPeriods.getFixedPeriodsOptionsById)(fixedFilter.periodType, periodsSettings).getPeriods(fixedPeriodConfig(Number(fixedFilter.year))));
+      setUserPeriods(null);
     }
   };
+  if (enabledPeriodTypesData !== null && enabledPeriodTypesData !== void 0 && enabledPeriodTypesData.noEnabledTypes) {
+    return /*#__PURE__*/_react.default.createElement(_ui.NoticeBox, {
+      warning: true,
+      title: _index.default.t('No period types available')
+    }, _index.default.t('No period types are enabled in the system. Please contact your system administrator.'));
+  }
   const renderLeftHeader = () => /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement(_ui.TabBar, null, /*#__PURE__*/_react.default.createElement(_ui.Tab, {
     selected: isRelative,
     onClick: () => onIsRelativeClick(true),
@@ -95,17 +181,18 @@ const PeriodTransfer = ({
   }, _index.default.t('Fixed periods'))), /*#__PURE__*/_react.default.createElement("div", {
     className: `jsx-${_DimensionSelectorStyle.default.__hash}` + " " + "filterContainer"
   }, isRelative ? /*#__PURE__*/_react.default.createElement(_RelativePeriodFilter.default, {
-    currentFilter: relativeFilter.periodType,
+    currentFilter: effectiveRelativeFilterType,
     onSelectFilter: filter => {
       setRelativeFilter({
         periodType: filter
       });
-      setAllPeriods((0, _relativePeriods.getRelativePeriodsOptionsById)(filter).getPeriods());
+      const selectedOption = filteredRelativeOptions.find(opt => opt.id === filter);
+      setUserPeriods((selectedOption === null || selectedOption === void 0 ? void 0 : selectedOption.getPeriods()) || []);
     },
     dataTest: `${dataTest}-relative-period-filter`,
-    excludedPeriodTypes: excludedPeriodTypes
+    availableOptions: filteredRelativeOptions
   }) : /*#__PURE__*/_react.default.createElement(_FixedPeriodFilter.default, {
-    currentPeriodType: fixedFilter.periodType,
+    currentPeriodType: effectiveFixedFilterType,
     currentYear: fixedFilter.year,
     onSelectPeriodType: periodType => {
       onSelectFixedPeriods({
@@ -120,14 +207,15 @@ const PeriodTransfer = ({
       });
     },
     dataTest: `${dataTest}-fixed-period-filter`,
-    excludedPeriodTypes: excludedPeriodTypes
+    availableOptions: filteredFixedOptions
   })), /*#__PURE__*/_react.default.createElement(_style.default, {
     id: _DimensionSelectorStyle.default.__hash
   }, _DimensionSelectorStyle.default));
   const onSelectFixedPeriods = filter => {
     setFixedFilter(filter);
     if (filter.year.match(/[0-9]{4}/)) {
-      setAllPeriods((0, _fixedPeriods.getFixedPeriodsOptionsById)(filter.periodType, periodsSettings).getPeriods(fixedPeriodConfig(Number(filter.year)), periodsSettings));
+      const selectedOption = filteredFixedOptions.find(opt => opt.id === filter.periodType);
+      setUserPeriods((selectedOption === null || selectedOption === void 0 ? void 0 : selectedOption.getPeriods(fixedPeriodConfig(Number(filter.year)))) || []);
     }
   };
   const renderEmptySelection = () => /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement("p", {
@@ -182,6 +270,13 @@ const PeriodTransfer = ({
 PeriodTransfer.propTypes = {
   onSelect: _propTypes.default.func.isRequired,
   dataTest: _propTypes.default.string,
+  enabledPeriodTypesData: _propTypes.default.shape({
+    analysisRelativePeriod: _propTypes.default.string,
+    enabledTypes: _propTypes.default.array,
+    financialYearDisplayLabel: _propTypes.default.string,
+    financialYearStart: _propTypes.default.string,
+    noEnabledTypes: _propTypes.default.bool
+  }),
   excludedPeriodTypes: _propTypes.default.arrayOf(_propTypes.default.string),
   height: _propTypes.default.string,
   infoBoxMessage: _propTypes.default.string,
@@ -194,6 +289,7 @@ PeriodTransfer.propTypes = {
     id: _propTypes.default.string,
     isActive: _propTypes.default.bool,
     name: _propTypes.default.string
-  }))
+  })),
+  supportsEnabledPeriodTypes: _propTypes.default.bool
 };
 var _default = exports.default = PeriodTransfer;

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

@@ -10,14 +10,12 @@ var _propTypes = _interopRequireDefault(require("prop-types"));
 var _react = _interopRequireDefault(require("react"));
 var _index = _interopRequireDefault(require("../../locales/index.js"));
 var _PeriodFilterStyle = _interopRequireDefault(require("./styles/PeriodFilter.style.js"));
-var _index2 = require("./utils/index.js");
-var _relativePeriods = require("./utils/relativePeriods.js");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const RelativePeriodFilter = ({
   currentFilter,
   onSelectFilter,
   dataTest,
-  excludedPeriodTypes
+  availableOptions
 }) => /*#__PURE__*/_react.default.createElement("div", {
   "data-test": dataTest,
   className: `jsx-${_PeriodFilterStyle.default.__hash}` + " " + "leftSection"
@@ -30,7 +28,7 @@ const RelativePeriodFilter = ({
   selected: currentFilter,
   className: "filterElement",
   dataTest: `${dataTest}-period-type`
-}, (0, _index2.filterPeriodTypesById)((0, _relativePeriods.getRelativePeriodsOptions)(), excludedPeriodTypes).map(option => /*#__PURE__*/_react.default.createElement(_ui.SingleSelectOption, {
+}, availableOptions.map(option => /*#__PURE__*/_react.default.createElement(_ui.SingleSelectOption, {
   key: option.id,
   value: option.id,
   label: option.name,
@@ -39,9 +37,9 @@ const RelativePeriodFilter = ({
   id: _PeriodFilterStyle.default.__hash
 }, _PeriodFilterStyle.default));
 RelativePeriodFilter.propTypes = {
+  availableOptions: _propTypes.default.array.isRequired,
   currentFilter: _propTypes.default.string.isRequired,
   onSelectFilter: _propTypes.default.func.isRequired,
-  dataTest: _propTypes.default.string,
-  excludedPeriodTypes: _propTypes.default.arrayOf(_propTypes.default.string)
+  dataTest: _propTypes.default.string
 };
 var _default = exports.default = RelativePeriodFilter;

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

@@ -7,14 +7,27 @@ var _PeriodDimension = _interopRequireDefault(require("../PeriodDimension.js"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 jest.mock('@dhis2/app-runtime', () => ({
   useConfig: () => ({
-    systemInfo: {}
+    systemInfo: {},
+    serverVersion: {
+      minor: 42
+    }
   }),
-  useDataQuery: () => ({
-    data: {
-      userSettings: {
-        keyUiLocale: 'en'
-      }
+  useDataQuery: jest.fn().mockImplementation((_query, options) => {
+    if (options !== null && options !== void 0 && options.lazy) {
+      return {
+        data: null,
+        error: undefined,
+        loading: false,
+        refetch: jest.fn()
+      };
     }
+    return {
+      data: {
+        userSettings: {
+          keyUiLocale: 'en'
+        }
+      }
+    };
   })
 }));
 global.ResizeObserver = jest.fn().mockImplementation(() => ({

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

@@ -8,7 +8,7 @@ describe('fixedPeriods utils', () => {
   describe('getOptions', () => {
     it('should return a list of available period ranges', () => {
       const periodIds = (0, _fixedPeriods.getFixedPeriodsOptions)().map(option => option.id);
-      expect(periodIds).toEqual(['DAILY', 'WEEKLY', 'WEEKLYWED', 'WEEKLYTHU', 'WEEKLYSAT', 'WEEKLYSUN', 'BIWEEKLY', 'MONTHLY', 'BIMONTHLY', 'QUARTERLY', 'SIXMONTHLY', 'SIXMONTHLYAPR', 'YEARLY', 'FYNOV', 'FYOCT', 'FYJUL', 'FYAPR']);
+      expect(periodIds).toEqual(['DAILY', 'WEEKLY', 'WEEKLYWED', 'WEEKLYTHU', 'WEEKLYSAT', 'WEEKLYSUN', 'BIWEEKLY', 'MONTHLY', 'BIMONTHLY', 'QUARTERLY', 'SIXMONTHLY', 'SIXMONTHLYAPR', 'YEARLY', 'FYFEB', 'FYAPR', 'FYJUL', 'FYAUG', 'FYSEP', 'FYOCT', 'FYNOV']);
     });
   });
   describe('Daily period generator', () => {

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

@@ -8,7 +8,7 @@ describe('utils', () => {
     it('should filter fixed periods', () => {
       const excludedPeriodTypes = ['DAILY', 'WEEKLY', 'WEEKLYSAT', 'MONTHLY', 'FYOCT'];
       const periodIds = (0, _index.filterPeriodTypesById)((0, _fixedPeriods.getFixedPeriodsOptions)(), excludedPeriodTypes).map(option => option.id);
-      expect(periodIds).toEqual(['WEEKLYWED', 'WEEKLYTHU', 'WEEKLYSUN', 'BIWEEKLY', 'BIMONTHLY', 'QUARTERLY', 'SIXMONTHLY', 'SIXMONTHLYAPR', 'YEARLY', 'FYNOV', 'FYJUL', 'FYAPR']);
+      expect(periodIds).toEqual(['WEEKLYWED', 'WEEKLYTHU', 'WEEKLYSUN', 'BIWEEKLY', 'BIMONTHLY', 'QUARTERLY', 'SIXMONTHLY', 'SIXMONTHLYAPR', 'YEARLY', 'FYFEB', 'FYAPR', 'FYJUL', 'FYAUG', 'FYSEP', 'FYNOV']);
     });
     it('should filter relative periods', () => {
       const excludedPeriodTypes = ['MONTHLY', 'BIMONTHLY'];

package/build/cjs/components/PeriodDimension/useDataOutputPeriodTypes.js

@@ -0,0 +1,153 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useDataOutputPeriodTypes = void 0;
+var _appRuntime = require("@dhis2/app-runtime");
+var _react = require("react");
+const v43Query = {
+  enabledPeriodTypes: {
+    resource: 'configuration/dataOutputPeriodTypes'
+  },
+  // v43-only: analyticsFinancialYearStart is removed in v44
+  financialYearStart: {
+    resource: 'systemSettings/analyticsFinancialYearStart'
+  },
+  analysisRelativePeriod: {
+    resource: 'systemSettings/keyAnalysisRelativePeriod'
+  },
+  // v43-only: analyticsWeeklyStart is removed in v44
+  weeklyStart: {
+    resource: 'systemSettings/analyticsWeeklyStart'
+  }
+};
+
+// v43-only: analyticsFinancialYearStart is removed in v44
+const FY_SETTING_TO_SERVER_PT = {
+  FINANCIAL_YEAR_APRIL: 'FinancialApril',
+  FINANCIAL_YEAR_JULY: 'FinancialJuly',
+  FINANCIAL_YEAR_SEPTEMBER: 'FinancialSep',
+  FINANCIAL_YEAR_OCTOBER: 'FinancialOct',
+  FINANCIAL_YEAR_NOVEMBER: 'FinancialNov'
+};
+
+// v43-only: analyticsWeeklyStart is removed in v44
+const WEEKLY_START_TO_SERVER_PT = {
+  WEEKLY: 'Weekly',
+  WEEKLY_WEDNESDAY: 'WeeklyWednesday',
+  WEEKLY_THURSDAY: 'WeeklyThursday',
+  WEEKLY_FRIDAY: 'WeeklyFriday',
+  WEEKLY_SATURDAY: 'WeeklySaturday',
+  WEEKLY_SUNDAY: 'WeeklySunday'
+};
+const useDataOutputPeriodTypes = () => {
+  const {
+    serverVersion
+  } = (0, _appRuntime.useConfig)();
+  const supportsEnabledPeriodTypes = serverVersion.minor >= 43;
+  const {
+    data: v43Data,
+    error: v43Error,
+    refetch: v43Refetch
+  } = (0, _appRuntime.useDataQuery)(v43Query, {
+    lazy: true
+  });
+  (0, _react.useEffect)(() => {
+    if (supportsEnabledPeriodTypes) {
+      v43Refetch();
+    }
+  }, [supportsEnabledPeriodTypes, v43Refetch]);
+  const enabledPeriodTypesData = (0, _react.useMemo)(() => {
+    var _v43Data$financialYea, _v43Data$weeklyStart, _v43Data$analysisRela;
+    if (!supportsEnabledPeriodTypes) {
+      return null;
+    }
+    if (v43Error || !(v43Data !== null && v43Data !== void 0 && v43Data.enabledPeriodTypes)) {
+      return null;
+    }
+    const enabledTypes = v43Data.enabledPeriodTypes;
+    if (!enabledTypes || enabledTypes.length === 0) {
+      return {
+        enabledTypes: [],
+        financialYearStart: null,
+        analysisRelativePeriod: null,
+        noEnabledTypes: true
+      };
+    }
+
+    // v43-only: financial year logic goes away in v44
+    let financialYearStart = null;
+    let financialYearDisplayLabel = null;
+    if ((_v43Data$financialYea = v43Data.financialYearStart) !== null && _v43Data$financialYea !== void 0 && _v43Data$financialYea.analyticsFinancialYearStart) {
+      const fyStartValue = v43Data.financialYearStart.analyticsFinancialYearStart;
+      const mappedFyPt = FY_SETTING_TO_SERVER_PT[fyStartValue];
+      const matchingPt = enabledTypes.find(pt => pt.name === mappedFyPt);
+      if (matchingPt) {
+        financialYearStart = fyStartValue;
+        if (matchingPt.displayLabel) {
+          financialYearDisplayLabel = matchingPt.displayLabel;
+        }
+      }
+    }
+
+    // v43-only: weekly start logic goes away in v44
+    let weeklyDisplayLabel = null;
+    if ((_v43Data$weeklyStart = v43Data.weeklyStart) !== null && _v43Data$weeklyStart !== void 0 && _v43Data$weeklyStart.analyticsWeeklyStart) {
+      const weeklyStartValue = v43Data.weeklyStart.analyticsWeeklyStart;
+      const mappedWeeklyPt = WEEKLY_START_TO_SERVER_PT[weeklyStartValue];
+      const matchingWeeklyPt = enabledTypes.find(pt => pt.name === mappedWeeklyPt);
+      if (matchingWeeklyPt !== null && matchingWeeklyPt !== void 0 && matchingWeeklyPt.displayLabel) {
+        weeklyDisplayLabel = matchingWeeklyPt.displayLabel;
+      }
+    }
+    const analysisRelativePeriod = ((_v43Data$analysisRela = v43Data.analysisRelativePeriod) === null || _v43Data$analysisRela === void 0 ? void 0 : _v43Data$analysisRela.keyAnalysisRelativePeriod) || null;
+    const metaData = {
+      ...(financialYearDisplayLabel && {
+        THIS_FINANCIAL_YEAR: {
+          name: `This ${financialYearDisplayLabel}`
+        },
+        LAST_FINANCIAL_YEAR: {
+          name: `Last ${financialYearDisplayLabel}`
+        },
+        LAST_5_FINANCIAL_YEARS: {
+          name: `Last 5 ${financialYearDisplayLabel}`
+        }
+      }),
+      ...(weeklyDisplayLabel && {
+        THIS_WEEK: {
+          name: `This ${weeklyDisplayLabel}`
+        },
+        LAST_WEEK: {
+          name: `Last ${weeklyDisplayLabel}`
+        },
+        LAST_4_WEEKS: {
+          name: `Last 4 ${weeklyDisplayLabel}`
+        },
+        LAST_12_WEEKS: {
+          name: `Last 12 ${weeklyDisplayLabel}`
+        },
+        LAST_52_WEEKS: {
+          name: `Last 52 ${weeklyDisplayLabel}`
+        },
+        WEEKS_THIS_YEAR: {
+          name: `${weeklyDisplayLabel} this year`
+        }
+      })
+    };
+    return {
+      enabledTypes,
+      financialYearStart,
+      financialYearDisplayLabel,
+      weeklyDisplayLabel,
+      analysisRelativePeriod,
+      metaData,
+      noEnabledTypes: false
+    };
+  }, [supportsEnabledPeriodTypes, v43Data, v43Error]);
+  return {
+    supportsEnabledPeriodTypes,
+    enabledPeriodTypesData
+  };
+};
+exports.useDataOutputPeriodTypes = useDataOutputPeriodTypes;