@dhis2/analytics 29.2.1 → 29.3.0

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

@@ -1,9 +1,9 @@
 import _JSXStyle from "styled-jsx/style";
 function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
 import { getNowInCalendar } from '@dhis2/multi-calendar-dates';
-import { IconInfo16, TabBar, Tab, Transfer } from '@dhis2/ui';
+import { IconInfo16, NoticeBox, TabBar, Tab, Transfer } from '@dhis2/ui';
 import PropTypes from 'prop-types';
-import React, { useState } from 'react';
+import React, { useRef, useState, useMemo } from 'react';
 import PeriodIcon from '../../assets/DimensionItemIcons/PeriodIcon.js'; //TODO: Reimplement the icon.js
 import i18n from '../../locales/index.js';
 import { TRANSFER_HEIGHT, TRANSFER_OPTIONS_WIDTH, TRANSFER_SELECTED_WIDTH } from '../../modules/dimensionSelectorHelper.js';
@@ -11,9 +11,10 @@ import styles from '../styles/DimensionSelector.style.js';
 import { TransferOption } from '../TransferOption.js';
 import FixedPeriodFilter from './FixedPeriodFilter.js';
 import RelativePeriodFilter from './RelativePeriodFilter.js';
-import { getFixedPeriodsOptionsById } from './utils/fixedPeriods.js';
-import { MONTHLY, QUARTERLY } from './utils/index.js';
-import { getRelativePeriodsOptionsById } from './utils/relativePeriods.js';
+import { applyDisplayLabelOverrides, applyFixedPeriodTypeDisplayLabels, filterEnabledFixedPeriodTypes, filterEnabledRelativePeriodTypes } from './utils/enabledPeriodTypes.js';
+import { getFixedPeriodsOptions } from './utils/fixedPeriods.js';
+import { MONTHLY, QUARTERLY, filterPeriodTypesById } from './utils/index.js';
+import { getRelativePeriodsOptions } from './utils/relativePeriods.js';
 const RightHeader = ({
   infoBoxMessage
 }) => /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("p", {
@@ -44,10 +45,52 @@ const PeriodTransfer = ({
   excludedPeriodTypes = EXCLUDED_PERIOD_TYPES_PROP_DEFAULT,
   periodsSettings = PERIODS_SETTINGS_PROP_DEFAULT,
   infoBoxMessage,
-  height = TRANSFER_HEIGHT
+  height = TRANSFER_HEIGHT,
+  enabledPeriodTypesData = null,
+  supportsEnabledPeriodTypes = false
 }) => {
-  const defaultRelativePeriodType = excludedPeriodTypes.includes(MONTHLY) ? getRelativePeriodsOptionsById(QUARTERLY) : getRelativePeriodsOptionsById(MONTHLY);
-  const defaultFixedPeriodType = excludedPeriodTypes.includes(MONTHLY) ? getFixedPeriodsOptionsById(QUARTERLY, periodsSettings) : getFixedPeriodsOptionsById(MONTHLY, periodsSettings);
+  const {
+    filteredFixedOptions,
+    filteredRelativeOptions
+  } = useMemo(() => {
+    if (supportsEnabledPeriodTypes && enabledPeriodTypesData) {
+      const {
+        enabledTypes,
+        financialYearStart,
+        financialYearDisplayLabel,
+        weeklyDisplayLabel,
+        metaData
+      } = enabledPeriodTypesData;
+      const filteredFixed = applyFixedPeriodTypeDisplayLabels(filterEnabledFixedPeriodTypes(getFixedPeriodsOptions(periodsSettings), enabledTypes), enabledTypes);
+      const filteredRelative = applyDisplayLabelOverrides(filterEnabledRelativePeriodTypes(getRelativePeriodsOptions(), enabledTypes, financialYearStart), {
+        financialYearDisplayLabel,
+        weeklyDisplayLabel,
+        metaData
+      });
+      return {
+        filteredFixedOptions: filteredFixed,
+        filteredRelativeOptions: filteredRelative
+      };
+    } else {
+      const allFixed = getFixedPeriodsOptions(periodsSettings);
+      const allRelative = getRelativePeriodsOptions();
+      return {
+        filteredFixedOptions: filterPeriodTypesById(allFixed, excludedPeriodTypes),
+        filteredRelativeOptions: 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 === MONTHLY) || filteredRelativeOptions.find(opt => opt.id === QUARTERLY) || filteredRelativeOptions[0];
+  })();
+  const defaultFixedPeriodType = filteredFixedOptions.find(opt => opt.id === MONTHLY) || filteredFixedOptions.find(opt => opt.id === QUARTERLY) || filteredFixedOptions[0];
   const now = 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
@@ -57,15 +100,52 @@ const PeriodTransfer = ({
     filterFuturePeriods: false,
     reversePeriods: false
   });
-  const [allPeriods, setAllPeriods] = useState(defaultRelativePeriodType.getPeriods());
+  const [userPeriods, setUserPeriods] = useState(null);
   const [isRelative, setIsRelative] = useState(true);
   const [relativeFilter, setRelativeFilter] = useState({
-    periodType: defaultRelativePeriodType.id
+    periodType: (defaultRelativePeriodType === null || defaultRelativePeriodType === void 0 ? void 0 : defaultRelativePeriodType.id) || ''
   });
   const [fixedFilter, setFixedFilter] = 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 = useRef(effectiveRelativeFilterType);
+  const prevEffectiveFixedRef = 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 = 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;
@@ -73,9 +153,15 @@ const PeriodTransfer = ({
   const onIsRelativeClick = state => {
     if (state !== isRelative) {
       setIsRelative(state);
-      setAllPeriods(state ? getRelativePeriodsOptionsById(relativeFilter.periodType).getPeriods() : getFixedPeriodsOptionsById(fixedFilter.periodType, periodsSettings).getPeriods(fixedPeriodConfig(Number(fixedFilter.year))));
+      setUserPeriods(null);
     }
   };
+  if (enabledPeriodTypesData !== null && enabledPeriodTypesData !== void 0 && enabledPeriodTypesData.noEnabledTypes) {
+    return /*#__PURE__*/React.createElement(NoticeBox, {
+      warning: true,
+      title: i18n.t('No period types available')
+    }, i18n.t('No period types are enabled in the system. Please contact your system administrator.'));
+  }
   const renderLeftHeader = () => /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(TabBar, null, /*#__PURE__*/React.createElement(Tab, {
     selected: isRelative,
     onClick: () => onIsRelativeClick(true),
@@ -87,17 +173,18 @@ const PeriodTransfer = ({
   }, i18n.t('Fixed periods'))), /*#__PURE__*/React.createElement("div", {
     className: `jsx-${styles.__hash}` + " " + "filterContainer"
   }, isRelative ? /*#__PURE__*/React.createElement(RelativePeriodFilter, {
-    currentFilter: relativeFilter.periodType,
+    currentFilter: effectiveRelativeFilterType,
     onSelectFilter: filter => {
       setRelativeFilter({
         periodType: filter
       });
-      setAllPeriods(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.createElement(FixedPeriodFilter, {
-    currentPeriodType: fixedFilter.periodType,
+    currentPeriodType: effectiveFixedFilterType,
     currentYear: fixedFilter.year,
     onSelectPeriodType: periodType => {
       onSelectFixedPeriods({
@@ -112,14 +199,15 @@ const PeriodTransfer = ({
       });
     },
     dataTest: `${dataTest}-fixed-period-filter`,
-    excludedPeriodTypes: excludedPeriodTypes
+    availableOptions: filteredFixedOptions
   })), /*#__PURE__*/React.createElement(_JSXStyle, {
     id: styles.__hash
   }, styles));
   const onSelectFixedPeriods = filter => {
     setFixedFilter(filter);
     if (filter.year.match(/[0-9]{4}/)) {
-      setAllPeriods(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.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("p", {
@@ -174,6 +262,13 @@ const PeriodTransfer = ({
 PeriodTransfer.propTypes = {
   onSelect: PropTypes.func.isRequired,
   dataTest: PropTypes.string,
+  enabledPeriodTypesData: PropTypes.shape({
+    analysisRelativePeriod: PropTypes.string,
+    enabledTypes: PropTypes.array,
+    financialYearDisplayLabel: PropTypes.string,
+    financialYearStart: PropTypes.string,
+    noEnabledTypes: PropTypes.bool
+  }),
   excludedPeriodTypes: PropTypes.arrayOf(PropTypes.string),
   height: PropTypes.string,
   infoBoxMessage: PropTypes.string,
@@ -186,6 +281,7 @@ PeriodTransfer.propTypes = {
     id: PropTypes.string,
     isActive: PropTypes.bool,
     name: PropTypes.string
-  }))
+  })),
+  supportsEnabledPeriodTypes: PropTypes.bool
 };
 export default PeriodTransfer;

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

@@ -4,13 +4,11 @@ import PropTypes from 'prop-types';
 import React from 'react';
 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 = ({
   currentFilter,
   onSelectFilter,
   dataTest,
-  excludedPeriodTypes
+  availableOptions
 }) => /*#__PURE__*/React.createElement("div", {
   "data-test": dataTest,
   className: `jsx-${styles.__hash}` + " " + "leftSection"
@@ -23,7 +21,7 @@ const RelativePeriodFilter = ({
   selected: currentFilter,
   className: "filterElement",
   dataTest: `${dataTest}-period-type`
-}, filterPeriodTypesById(getRelativePeriodsOptions(), excludedPeriodTypes).map(option => /*#__PURE__*/React.createElement(SingleSelectOption, {
+}, availableOptions.map(option => /*#__PURE__*/React.createElement(SingleSelectOption, {
   key: option.id,
   value: option.id,
   label: option.name,
@@ -32,9 +30,9 @@ const RelativePeriodFilter = ({
   id: styles.__hash
 }, styles));
 RelativePeriodFilter.propTypes = {
+  availableOptions: PropTypes.array.isRequired,
   currentFilter: PropTypes.string.isRequired,
   onSelectFilter: PropTypes.func.isRequired,
-  dataTest: PropTypes.string,
-  excludedPeriodTypes: PropTypes.arrayOf(PropTypes.string)
+  dataTest: PropTypes.string
 };
 export default RelativePeriodFilter;

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

@@ -4,14 +4,27 @@ import React from 'react';
 import PeriodDimension from '../PeriodDimension.js';
 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/es/components/PeriodDimension/__tests__/fixedPeriods.spec.js

@@ -6,7 +6,7 @@ describe('fixedPeriods utils', () => {
   describe('getOptions', () => {
     it('should return a list of available period ranges', () => {
       const periodIds = 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/es/components/PeriodDimension/__tests__/utils.spec.js

@@ -6,7 +6,7 @@ describe('utils', () => {
     it('should filter fixed periods', () => {
       const excludedPeriodTypes = ['DAILY', 'WEEKLY', 'WEEKLYSAT', 'MONTHLY', 'FYOCT'];
       const periodIds = filterPeriodTypesById(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/es/components/PeriodDimension/useDataOutputPeriodTypes.js

@@ -0,0 +1,147 @@
+import { useConfig, useDataQuery } from '@dhis2/app-runtime';
+import { useEffect, useMemo } from '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
+  } = useConfig();
+  const supportsEnabledPeriodTypes = serverVersion.minor >= 43;
+  const {
+    data: v43Data,
+    error: v43Error,
+    refetch: v43Refetch
+  } = useDataQuery(v43Query, {
+    lazy: true
+  });
+  useEffect(() => {
+    if (supportsEnabledPeriodTypes) {
+      v43Refetch();
+    }
+  }, [supportsEnabledPeriodTypes, v43Refetch]);
+  const enabledPeriodTypesData = 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
+  };
+};
+export { useDataOutputPeriodTypes };

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

@@ -0,0 +1,168 @@
+// Mapping from server period type names to multi-calendar-dates constants
+export const SERVER_PT_TO_MULTI_CALENDAR_PT = {
+  Daily: 'DAILY',
+  Weekly: 'WEEKLY',
+  WeeklyWednesday: 'WEEKLYWED',
+  WeeklyThursday: 'WEEKLYTHU',
+  WeeklyFriday: 'WEEKLYFRI',
+  WeeklySaturday: 'WEEKLYSAT',
+  WeeklySunday: 'WEEKLYSUN',
+  BiWeekly: 'BIWEEKLY',
+  Monthly: 'MONTHLY',
+  BiMonthly: 'BIMONTHLY',
+  Quarterly: 'QUARTERLY',
+  QuarterlyNov: 'QUARTERLYNOV',
+  SixMonthly: 'SIXMONTHLY',
+  SixMonthlyApril: 'SIXMONTHLYAPR',
+  SixMonthlyNov: 'SIXMONTHLYNOV',
+  Yearly: 'YEARLY',
+  FinancialFeb: 'FYFEB',
+  FinancialApril: 'FYAPR',
+  FinancialJuly: 'FYJUL',
+  FinancialAug: 'FYAUG',
+  FinancialSep: 'FYSEP',
+  FinancialOct: 'FYOCT',
+  FinancialNov: 'FYNOV'
+};
+
+// Mapping from relative period categories to their corresponding fixed period types
+export const RP_CATEGORY_TO_FP_DEPENDENCIES = {
+  DAILY: ['Daily'],
+  WEEKLY: ['Weekly', 'WeeklyWednesday', 'WeeklyThursday', 'WeeklyFriday', 'WeeklySaturday', 'WeeklySunday'],
+  BIWEEKLY: ['BiWeekly'],
+  MONTHLY: ['Monthly'],
+  BIMONTHLY: ['BiMonthly'],
+  QUARTERLY: ['Quarterly', 'QuarterlyNov'],
+  SIXMONTHLY: ['SixMonthly', 'SixMonthlyApril', 'SixMonthlyNov'],
+  YEARLY: ['Yearly']
+};
+
+/**
+ * Filter fixed period types based on enabled server period types
+ * @param {Array} allFixedPeriodOptions - All available fixed period options
+ * @param {Array} enabledServerPeriodTypes - Enabled period types from server
+ * @returns {Array} Filtered fixed period options
+ */
+export const filterEnabledFixedPeriodTypes = (allFixedPeriodOptions, enabledServerPeriodTypes) => {
+  if (!enabledServerPeriodTypes || enabledServerPeriodTypes.length === 0) {
+    return [];
+  }
+  const enabledServerPtNames = new Set(enabledServerPeriodTypes.map(pt => pt.name));
+  const enabledMultiCalendarPts = new Set();
+
+  // Map server PT names to multi-calendar-dates constants
+  enabledServerPtNames.forEach(serverPtName => {
+    const multiCalendarPt = SERVER_PT_TO_MULTI_CALENDAR_PT[serverPtName];
+    if (multiCalendarPt) {
+      enabledMultiCalendarPts.add(multiCalendarPt);
+    }
+  });
+
+  // Filter fixed period options to only include enabled ones
+  return allFixedPeriodOptions.filter(option => enabledMultiCalendarPts.has(option.id));
+};
+
+/**
+ * Apply displayLabel overrides to fixed period type names
+ * v43-only: in v44 the API provides these names directly
+ */
+export const applyFixedPeriodTypeDisplayLabels = (filteredFixedOptions, enabledServerPeriodTypes) => {
+  if (!enabledServerPeriodTypes) {
+    return filteredFixedOptions;
+  }
+  const displayLabelMap = new Map();
+  enabledServerPeriodTypes.forEach(pt => {
+    if (pt.displayLabel) {
+      const multiCalendarPt = SERVER_PT_TO_MULTI_CALENDAR_PT[pt.name];
+      if (multiCalendarPt) {
+        displayLabelMap.set(multiCalendarPt, pt.displayLabel);
+      }
+    }
+  });
+  if (displayLabelMap.size === 0) {
+    return filteredFixedOptions;
+  }
+  return filteredFixedOptions.map(option => {
+    const displayLabel = displayLabelMap.get(option.id);
+    return displayLabel ? {
+      ...option,
+      name: displayLabel
+    } : option;
+  });
+};
+
+/**
+ * Filter relative period categories based on enabled server period types
+ * @param {Array} allRelativePeriodOptions - All available relative period options
+ * @param {Array} enabledServerPeriodTypes - Enabled period types from server
+ * @param {string|null} financialYearStart - Financial year start setting (if enabled)
+ * @returns {Array} Filtered relative period options
+ */
+/**
+ * Apply metaData name overrides to a list of periods
+ * v43-only: in v44 the API provides these names directly
+ */
+export const applyPeriodNameOverrides = (periods, metaData) => {
+  if (!metaData) {
+    return periods;
+  }
+  return periods.map(period => metaData[period.id] ? {
+    ...period,
+    name: metaData[period.id].name
+  } : period);
+};
+
+/**
+ * Apply display label overrides to relative period options
+ * v43-only: in v44 the API provides these names directly
+ */
+export const applyDisplayLabelOverrides = (filteredRelativeOptions, {
+  financialYearDisplayLabel,
+  weeklyDisplayLabel,
+  metaData
+}) => {
+  const overrides = {};
+  if (financialYearDisplayLabel) {
+    overrides['FINANCIAL'] = {
+      name: financialYearDisplayLabel
+    };
+  }
+  if (weeklyDisplayLabel) {
+    overrides['WEEKLY'] = {
+      name: weeklyDisplayLabel
+    };
+  }
+  if (Object.keys(overrides).length === 0) {
+    return filteredRelativeOptions;
+  }
+  return filteredRelativeOptions.map(option => {
+    const override = overrides[option.id];
+    if (!override) {
+      return option;
+    }
+    return {
+      ...option,
+      name: override.name,
+      getPeriods: () => applyPeriodNameOverrides(option.getPeriods(), metaData)
+    };
+  });
+};
+export const filterEnabledRelativePeriodTypes = (allRelativePeriodOptions, enabledServerPeriodTypes, financialYearStart = null) => {
+  if (!enabledServerPeriodTypes || enabledServerPeriodTypes.length === 0) {
+    return [];
+  }
+  const enabledServerPtNames = new Set(enabledServerPeriodTypes.map(pt => pt.name));
+  return allRelativePeriodOptions.filter(option => {
+    // Special handling for financial years
+    if (option.id === 'FINANCIAL') {
+      return financialYearStart !== null;
+    }
+
+    // Check if any of the required FP dependencies are enabled
+    const requiredFpTypes = RP_CATEGORY_TO_FP_DEPENDENCIES[option.id];
+    if (!requiredFpTypes) {
+      return true; // Show if no dependency mapping (shouldn't happen)
+    }
+    return requiredFpTypes.some(fpType => enabledServerPtNames.has(fpType));
+  });
+};