@dhis2/analytics 28.0.5 → 28.1.0

package/build/es/__demo__/data/event/yesonly.visualization.json

@@ -0,0 +1,161 @@
+{
+    "name": "Yesonly",
+    "created": "2025-07-02T10:36:16.893",
+    "lastUpdated": "2025-07-02T10:36:16.893",
+    "translations": [],
+    "createdBy": {
+        "id": "xE7jOejl9FI",
+        "code": null,
+        "name": "John Traore",
+        "displayName": "John Traore",
+        "username": "admin"
+    },
+    "favorites": [],
+    "lastUpdatedBy": {
+        "id": "xE7jOejl9FI",
+        "code": null,
+        "name": "John Traore",
+        "displayName": "John Traore",
+        "username": "admin"
+    },
+    "sharing": {
+        "owner": "xE7jOejl9FI",
+        "external": false,
+        "users": {},
+        "userGroups": {},
+        "public": "rw------"
+    },
+    "regressionType": "NONE",
+    "displayDensity": "NORMAL",
+    "fontSize": "NORMAL",
+    "sortOrder": 0,
+    "topLimit": 0,
+    "hideEmptyRows": false,
+    "showHierarchy": false,
+    "completedOnly": false,
+    "skipRounding": false,
+    "dataDimensionItems": [],
+    "dataElementGroupSetDimensions": [],
+    "organisationUnitGroupSetDimensions": [],
+    "categoryDimensions": [],
+    "categoryOptionGroupSetDimensions": [],
+    "attributeDimensions": [],
+    "dataElementDimensions": [
+        {
+            "dataElement": {
+                "name": "E2E - Yes only",
+                "id": "hwG20Dyj6RK"
+            }
+        }
+    ],
+    "programIndicatorDimensions": [],
+    "subscribers": [],
+    "digitGroupSeparator": "SPACE",
+    "hideEmptyRowItems": "NONE",
+    "hideLegend": false,
+    "noSpaceBetweenColumns": false,
+    "cumulativeValues": false,
+    "percentStackedValues": false,
+    "showData": false,
+    "colTotals": true,
+    "rowTotals": true,
+    "rowSubTotals": true,
+    "colSubTotals": true,
+    "hideTitle": false,
+    "hideSubtitle": false,
+    "showDimensionLabels": true,
+    "interpretations": [],
+    "program": {
+        "enrollmentDateLabel": "Enrollment date (e2e)",
+        "incidentDateLabel": "Incident date (e2e)",
+        "id": "J1QQtmzqhJz",
+        "name": "E2E program"
+    },
+    "programStage": {
+        "executionDateLabel": "Event date (e2e)",
+        "id": "jfuXZB3A1ko",
+        "name": "Stage 1 - Repeatable"
+    },
+    "dataType": "AGGREGATED_VALUES",
+    "outputType": "EVENT",
+    "collapseDataDimensions": false,
+    "hideNaData": false,
+    "simpleDimensions": [
+        {
+            "parent": "COLUMN",
+            "dimension": "ou",
+            "values": [
+                "ImspTQPwCqd"
+            ]
+        }
+    ],
+    "legacy": true,
+    "type": "PIVOT_TABLE",
+    "filters": [],
+    "parentGraphMap": {
+        "ImspTQPwCqd": ""
+    },
+    "columns": [
+        {
+            "items": [
+                {
+                    "dimensionItemType": "ORGANISATION_UNIT",
+                    "name": "Sierra Leone",
+                    "id": "ImspTQPwCqd"
+                }
+            ],
+            "dimension": "ou"
+        },
+        {
+            "items": [
+                {
+                    "dimensionItemType": "PERIOD",
+                    "id": "LAST_12_MONTHS",
+                    "name": "LAST_12_MONTHS"
+                }
+            ],
+            "dimension": "pe"
+        }
+    ],
+    "rows": [
+        {
+            "items": [],
+            "programStage": {
+                "id": "jfuXZB3A1ko"
+            },
+            "dimension": "jfuXZB3A1ko.hwG20Dyj6RK"
+        }
+    ],
+    "displayName": "Yesonly",
+    "access": {
+        "manage": true,
+        "externalize": true,
+        "write": true,
+        "read": true,
+        "update": true,
+        "delete": true
+    },
+    "user": {
+        "id": "xE7jOejl9FI",
+        "code": null,
+        "name": "John Traore",
+        "displayName": "John Traore",
+        "username": "admin"
+    },
+    "favorite": false,
+    "subscribed": false,
+    "metaData": {
+        "hwG20Dyj6RK": {
+            "uid": "hwG20Dyj6RK",
+            "name": "E2E - Yes only"
+        },
+        "ImspTQPwCqd": {
+            "uid": "ImspTQPwCqd",
+            "code": "OU_525",
+            "name": "Sierra Leone"
+        }
+    },
+    "displayFormName": "Yesonly",
+    "id": "qySyY2zmjrO",
+    "attributeValues": []
+}

package/build/es/components/DataDimension/ItemSelector/ItemSelector.js

@@ -343,28 +343,25 @@ const ItemSelector = ({
       infoBoxMessage: infoBoxMessage
     }),
     rightFooter: rightFooter,
-    renderOption: props => {
-      // console.log('renderOption', props)
-      return /*#__PURE__*/React.createElement(TransferOption
-      /* eslint-disable react/prop-types */, _extends({}, props, {
-        active: isActive(props.value),
-        showingInfo: (infoDataItem === null || infoDataItem === void 0 ? void 0 : infoDataItem.id) === props.value,
-        icon: getIcon(props.type),
-        dataItemType: props.type,
-        dimensionType: getDimensionType({
-          type: props.type,
-          expression: props.expression
-        }),
-        dataTest: `${dataTest}-transfer-option`,
-        itemsRef: itemsRef,
-        onEditClick: () => onEditClick(props),
-        onInfoClick: () => setInfoDataItem({
-          id: props.value,
-          type: props.type
-        })
-        /* eslint-enable react/prop-types */
-      }));
-    },
+    renderOption: props => /*#__PURE__*/React.createElement(TransferOption
+    /* eslint-disable react/prop-types */, _extends({}, props, {
+      active: isActive(props.value),
+      showingInfo: (infoDataItem === null || infoDataItem === void 0 ? void 0 : infoDataItem.id) === props.value,
+      icon: getIcon(props.type),
+      dataItemType: props.type,
+      dimensionType: getDimensionType({
+        type: props.type,
+        expression: props.expression
+      }),
+      dataTest: `${dataTest}-transfer-option`,
+      itemsRef: itemsRef,
+      onEditClick: () => onEditClick(props),
+      onInfoClick: () => setInfoDataItem({
+        id: props.value,
+        type: props.type
+      })
+      /* eslint-enable react/prop-types */
+    })),
     dataTest: `${dataTest}-transfer`
   }), currentCalculation && supportsEDI && /*#__PURE__*/React.createElement(CalculationModal, {
     calculation: currentCalculation,

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

@@ -52,6 +52,9 @@ export const PivotTableColumnHeaderCell = ({
         className: `jsx-${cellStyle.__hash}` + " " + "column-header-inner"
       }, /*#__PURE__*/React.createElement("span", {
         "data-test": "visualization-column-header",
+        style: {
+          ...header.style
+        },
         className: `jsx-${cellStyle.__hash}` + " " + "column-header-label"
       }, header.label), isSortable ? /*#__PURE__*/React.createElement(PivotTableSortIcon, {
         index: index,

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

@@ -30,7 +30,8 @@ export const PivotTableRowHeaderCell = ({
         height,
         left: rowLevel > 0 ?
         // calculate the width of all row header cells on the left of current cell
-        engine.adaptiveClippingController.columns.headerSizes.slice(0, rowLevel).reduce((width, acc) => acc += width, 0) : 0
+        engine.adaptiveClippingController.columns.headerSizes.slice(0, rowLevel).reduce((width, acc) => acc += width, 0) : 0,
+        ...header.style
       },
       dataTest: "visualization-row-header"
     }, header.label)

package/build/es/index.js

@@ -129,6 +129,10 @@ export { HIDE_EMPTY_ROW_ITEMS_BEFORE_FIRST, HIDE_EMPTY_ROW_ITEMS_AFTER_LAST, HID
 
 export { renderValue as formatValue } from './modules/renderValue.js';
 
+// Modules: response
+
+export { transformResponse as transformEventAggregateResponse } from './modules/response/event/response.js';
+
 // Utils: colorSets
 export { COLOR_SET_DEFAULT, COLOR_SET_BASIC, COLOR_SET_EXTENDED, COLOR_SET_BRIGHT, COLOR_SET_DARK, COLOR_SET_GRAY, COLOR_SET_COLOR_BLIND, COLOR_SET_PATTERNS, colorSets } from './visualizations/util/colors/colorSets.js';
 

package/build/es/locales/en/translations.json

@@ -410,6 +410,7 @@
     "Data": "Data",
     "Organisation unit": "Organisation unit",
     "Assigned Categories": "Assigned Categories",
+    "No value": "No value",
     "Text": "Text",
     "Long text": "Long text",
     "Multi text": "Multi text",

package/build/es/modules/pivotTable/AdaptiveClippingController.js

@@ -74,7 +74,8 @@ export class AdaptiveClippingController {
           if (isColumn) {
             var _axis$sizes$index;
             const headerSize = this.measureText(label, {
-              maxWidth: isLeafHeader ? Math.max(CLIPPED_CELL_MIN_SIZE, ((_axis$sizes$index = axis.sizes[index]) === null || _axis$sizes$index === void 0 ? void 0 : _axis$sizes$index.size) || 0) : 0
+              maxWidth: isLeafHeader ? Math.max(CLIPPED_CELL_MIN_SIZE, ((_axis$sizes$index = axis.sizes[index]) === null || _axis$sizes$index === void 0 ? void 0 : _axis$sizes$index.size) || 0) : 0,
+              ...header.style
             });
             this.addSize({
               row: -headerStack.length + level,

package/build/es/modules/pivotTable/getHeaderForDisplay.js

@@ -32,6 +32,9 @@ export const getHeaderForDisplay = ({
   return {
     span,
     label,
-    includesHierarchy
+    includesHierarchy,
+    ...(currentHeader.style ? {
+      style: currentHeader.style
+    } : {})
   };
 };

package/build/es/modules/pivotTable/measureText.js

@@ -1,15 +1,15 @@
 import { CLIPPED_CELL_MAX_SIZE, WRAPPED_TEXT_JUSTIFY_BUFFER, WRAPPED_TEXT_LINE_HEIGHT } from './pivotTableConstants.js';
 let canvas;
-const getContext = fontSize => {
+const getContext = (fontSize = 11, fontFamily = 'Roboto, Arial, sans-serif') => {
   if (!canvas) {
     canvas = document.createElement('canvas');
   }
   const ctx = canvas.getContext('2d');
-  ctx.font = `${fontSize}px Roboto, Arial, sans-serif`;
+  ctx.font = `${fontSize}px ${fontFamily}`;
   return ctx;
 };
-const measureText = (text, fontSize = 11) => {
-  const ctx = getContext(fontSize);
+const measureText = (text, fontSize, fontFamily) => {
+  const ctx = getContext(fontSize, fontFamily);
   const textMetrics = ctx.measureText(text);
   return textMetrics.width;
 };
@@ -17,7 +17,8 @@ export const measureTextWithWrapping = (text, {
   fontSize = 11,
   maxWidth = CLIPPED_CELL_MAX_SIZE,
   justifyBuffer = WRAPPED_TEXT_JUSTIFY_BUFFER,
-  lineHeight = WRAPPED_TEXT_LINE_HEIGHT
+  lineHeight = WRAPPED_TEXT_LINE_HEIGHT,
+  fontFamily
 }) => {
   if (!text) {
     return {
@@ -36,7 +37,7 @@ export const measureTextWithWrapping = (text, {
     const words = paragraphs.shift().split(/\s+/);
     while (words.length) {
       const nextWord = (currentLineWidth === 0 ? '' : ' ') + words.shift();
-      const nextWordWidth = measureText(nextWord, fontSize);
+      const nextWordWidth = measureText(nextWord, fontSize, fontFamily);
       if (maxWidth && currentLineWidth + nextWordWidth > maxWidth) {
         if (currentLineWidth <= maxWidth - justifyBuffer) {
           // Wrapping this word would cause an unnaturally short line

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)
+  };
+};