@hisptz/dhis2-analytics 1.0.10 → 1.0.11

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

@@ -0,0 +1,63 @@
+import { dimensionGetItems } from './layout/dimensionGetItems.js';
+import { dimensionIs } from './layout/dimensionIs.js';
+import { ouIdHelper } from './ouIdHelper';
+import { DIMENSION_ID_ORGUNIT } from '../constants/predefinedDimensions';
+import i18n from '@dhis2/d2-i18n';
+export const getOuLevelAndGroupText = (filter, metaData) => {
+  if (!dimensionIs(DIMENSION_ID_ORGUNIT)) {
+    return '';
+  }
+  const items = dimensionGetItems(filter);
+  const hasOuLevel = items.some(item => ouIdHelper.hasLevelPrefix(item.id));
+  const hasOuGroup = items.some(item => ouIdHelper.hasGroupPrefix(item.id));
+  const filterFragments = [];
+  if (hasOuGroup) {
+    filterFragments.push(getLevelAndGroupText(items, metaData, false));
+  }
+  if (hasOuLevel) {
+    filterFragments.push(getLevelAndGroupText(items, metaData, true));
+  }
+  return filterFragments.join(' - ');
+};
+const getLevelAndGroupText = (items, metaData, isLevel) => {
+  const getNameFromMetadata = id => metaData.items[id] ? metaData.items[id].name : id;
+  const dynamicOuItems = items.filter(item => isLevel ? ouIdHelper.hasLevelPrefix(item.id) : ouIdHelper.hasGroupPrefix(item.id));
+  const lastItem = dynamicOuItems.length > 1 ? dynamicOuItems.pop() : null;
+  const dynamicOuNames = dynamicOuItems.map(item => getNameFromMetadata(ouIdHelper.removePrefix(item.id))).join(', ');
+  let allDynamicOuNames;
+  if (lastItem) {
+    const lastOuName = getNameFromMetadata(ouIdHelper.removePrefix(lastItem.id));
+    allDynamicOuNames = i18n.t('{{dynamicOuNames}} and {{lastOuName}}', {
+      dynamicOuNames,
+      lastOuName
+    });
+  } else {
+    allDynamicOuNames = dynamicOuNames;
+  }
+  const staticOuNames = items.filter(item => !ouIdHelper.hasGroupPrefix(item.id) && !ouIdHelper.hasLevelPrefix(item.id)).map(item => getNameFromMetadata(item.id)).join(', ');
+  let ouLevelAndGroupText = '';
+  if (!staticOuNames) {
+    if (isLevel) {
+      ouLevelAndGroupText = i18n.t('{{allDynamicOuNames}} levels', {
+        allDynamicOuNames
+      });
+    } else {
+      ouLevelAndGroupText = i18n.t('{{allDynamicOuNames}} groups', {
+        allDynamicOuNames
+      });
+    }
+  } else {
+    if (isLevel) {
+      ouLevelAndGroupText = i18n.t('{{allDynamicOuNames}} levels in {{staticOuNames}}', {
+        allDynamicOuNames,
+        staticOuNames
+      });
+    } else {
+      ouLevelAndGroupText = i18n.t('{{allDynamicOuNames}} groups in {{staticOuNames}}', {
+        allDynamicOuNames,
+        staticOuNames
+      });
+    }
+  }
+  return ouLevelAndGroupText;
+};

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

@@ -0,0 +1,309 @@
+// @ts-nocheck
+
+import { getOuLevelAndGroupText } from './getOuLevelAndGroupText';
+import { dimensionGetItems } from './layout/dimensionGetItems';
+import { dimensionIs } from './layout/dimensionIs';
+import { ouIdHelper } from './ouIdHelper';
+import { DIMENSION_ID_ORGUNIT } from '../constants/predefinedDimensions';
+import { CLIPPED_CELL_MAX_SIZE, NUMBER_TYPE_COLUMN_PERCENTAGE, NUMBER_TYPE_ROW_PERCENTAGE, WRAPPED_TEXT_JUSTIFY_BUFFER, WRAPPED_TEXT_LINE_HEIGHT } from '../constants/pivotTable';
+import { isNumericValueType } from '../constants/valueTypes';
+import { colors } from '@dhis2/ui';
+import { getColorByValueFromLegendSet, LEGEND_DISPLAY_STRATEGY_BY_DATA_ITEM, LEGEND_DISPLAY_STRATEGY_FIXED, LEGEND_DISPLAY_STYLE_FILL, LEGEND_DISPLAY_STYLE_TEXT } from './legend';
+import { isColorBright } from './isColorBright.js';
+export const parseValue = valueString => {
+  const parsedValue = parseFloat(valueString);
+  if (isNaN(parsedValue)) {
+    return valueString;
+  }
+  return parsedValue;
+};
+let canvas;
+const getContext = fontSize => {
+  if (!canvas) {
+    canvas = document.createElement('canvas');
+  }
+  const ctx = canvas.getContext('2d');
+  ctx.font = `${fontSize}px Roboto, Arial, sans-serif`;
+  return ctx;
+};
+const measureText = function (text) {
+  let fontSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 11;
+  const ctx = getContext(fontSize);
+  const textMetrics = ctx.measureText(text);
+  return textMetrics.width;
+};
+export const measureTextWithWrapping = (text, _ref) => {
+  let {
+    fontSize = 11,
+    maxWidth = CLIPPED_CELL_MAX_SIZE,
+    justifyBuffer = WRAPPED_TEXT_JUSTIFY_BUFFER,
+    lineHeight = WRAPPED_TEXT_LINE_HEIGHT
+  } = _ref;
+  if (!text) {
+    return {
+      width: 0,
+      height: 0
+    };
+  }
+  // Multiple consecutive linebreaks are combined into one
+  const paragraphs = String(text).split(/\n/);
+  const lines = [];
+  let currentLine = '';
+  let currentLineWidth = 0;
+  let maxLineWidth = 0;
+  while (paragraphs.length) {
+    var _paragraphs$shift$spl, _paragraphs$shift;
+    // Currently, all different whitespace types are ignored and assumed to be just a space
+    const words = (_paragraphs$shift$spl = (_paragraphs$shift = paragraphs.shift()) === null || _paragraphs$shift === void 0 ? void 0 : _paragraphs$shift.split(/\s+/)) !== null && _paragraphs$shift$spl !== void 0 ? _paragraphs$shift$spl : [];
+    while (words.length) {
+      const nextWord = (currentLineWidth === 0 ? '' : ' ') + words.shift();
+      const nextWordWidth = measureText(nextWord, fontSize);
+      if (maxWidth && currentLineWidth + nextWordWidth > maxWidth) {
+        if (currentLineWidth <= maxWidth - justifyBuffer) {
+          // Wrapping this word would cause an unnaturally short line
+          // For now we allow the cell to expand to fit this word
+          // In the future, we might intelligently hyphenate the word
+          // TODO: if splitting words how would we localize hyphens?
+          // Do nothing, keep the word on this line
+        } else {
+          maxLineWidth = Math.max(currentLineWidth, maxLineWidth);
+          lines.push(currentLine);
+          currentLine = '';
+          currentLineWidth = 0;
+          words.unshift(nextWord.substring(1)); // Get rid of the extra space
+          continue;
+        }
+      }
+      currentLine += nextWord;
+      currentLineWidth += nextWordWidth;
+    }
+    if (currentLineWidth > 0) {
+      maxLineWidth = Math.max(currentLineWidth, maxLineWidth);
+      lines.push(currentLine);
+    }
+  }
+  return {
+    normalizedText: lines.join('\n'),
+    width: maxLineWidth,
+    height: lines.length * fontSize * lineHeight // TODO: use lineHeight=1 for last line?
+  };
+};
+
+const trimTrailingZeros = stringValue => stringValue.replace(/\.?0+$/, '');
+const decimalSeparator = '.';
+const separateDigitGroups = (stringValue, decimalSeparator) => {
+  const isNegative = stringValue[0] === '-';
+  const [integer, remainder] = stringValue.replace(/^-/, '').split('.');
+  const groups = [];
+  for (let i = integer.length; i > 0; i -= 3) {
+    groups.unshift(integer.substring(i - 3, i));
+  }
+  if (isNegative) {
+    groups[0] = '-' + groups[0];
+  }
+  if (remainder) {
+    const trimmedRemainder = trimTrailingZeros(remainder);
+    if (trimmedRemainder.length) {
+      groups[groups.length - 1] += decimalSeparator + remainder;
+    }
+  }
+  return groups;
+};
+const getSeparator = visualization => {
+  switch (visualization.digitGroupSeparator) {
+    case 'SPACE':
+      return ' ';
+    case 'COMMA':
+      return ',';
+    case 'NONE':
+    default:
+      return '';
+  }
+};
+const toFixedPrecisionString = (value, skipRounding) => {
+  if (typeof value !== 'number') {
+    // Values returned from the server should keep their string representation
+    return value;
+  }
+  const precision = skipRounding ? 10 : value > -1 && value < 1 ? 2 : 1;
+  return value.toFixed(precision);
+};
+export const renderValue = (value, valueType, visualization) => {
+  if (!isNumericValueType(valueType) || value === undefined) {
+    return String(value).replace(/[^\S\n]+/, ' ');
+  }
+  if (visualization.numberType === NUMBER_TYPE_ROW_PERCENTAGE || visualization.numberType === NUMBER_TYPE_COLUMN_PERCENTAGE) {
+    const stringValue = trimTrailingZeros(toFixedPrecisionString(value * 100, visualization.skipRounding));
+    return separateDigitGroups(stringValue, decimalSeparator).join(getSeparator(visualization)) + '%';
+  } else {
+    const stringValue = toFixedPrecisionString(value, visualization.skipRounding);
+    return separateDigitGroups(stringValue, decimalSeparator).join(getSeparator(visualization));
+  }
+};
+const getLegendSet = (engine, dxDimension) => {
+  var _engine$visualization, _engine$visualization2, _engine$visualization3;
+  let legendSetId;
+  switch ((_engine$visualization = engine.visualization.legend) === null || _engine$visualization === void 0 ? void 0 : _engine$visualization.strategy) {
+    case LEGEND_DISPLAY_STRATEGY_BY_DATA_ITEM:
+      if (dxDimension && dxDimension.legendSet) {
+        legendSetId = dxDimension.legendSet;
+      }
+      break;
+    case LEGEND_DISPLAY_STRATEGY_FIXED:
+    default:
+      legendSetId = (_engine$visualization2 = engine.visualization.legend) === null || _engine$visualization2 === void 0 ? void 0 : (_engine$visualization3 = _engine$visualization2.set) === null || _engine$visualization3 === void 0 ? void 0 : _engine$visualization3.id;
+      break;
+  }
+  return engine.legendSets[legendSetId];
+};
+const buildStyleObject = (legendColor, engine) => {
+  var _engine$visualization4;
+  const style = {};
+  switch ((_engine$visualization4 = engine.visualization.legend) === null || _engine$visualization4 === void 0 ? void 0 : _engine$visualization4.style) {
+    case LEGEND_DISPLAY_STYLE_TEXT:
+      style.color = legendColor;
+      break;
+    case LEGEND_DISPLAY_STYLE_FILL:
+    default:
+      style.backgroundColor = legendColor;
+      if (isColorBright(legendColor)) {
+        style.color = colors.grey900;
+      } else {
+        style.color = colors.white;
+      }
+      break;
+  }
+  return style;
+};
+export const applyLegendSet = (value, dxDimension, engine) => {
+  if (isNaN(value) || !engine.legendSets) {
+    return {};
+  }
+  const legendSet = getLegendSet(engine, dxDimension);
+  if (!legendSet) {
+    return {};
+  }
+  const legendColor = getColorByValueFromLegendSet(legendSet, value);
+  if (!legendColor) {
+    return {};
+  }
+  return buildStyleObject(legendColor, engine);
+};
+export function getFilterText(filters, metaData) {
+  if (!Array.isArray(filters) || !filters.length) {
+    return '';
+  }
+  const titleFragments = [];
+  let i;
+  let l;
+  filters.forEach(filter => {
+    const items = dimensionGetItems(filter);
+    if (dimensionIs(filter, DIMENSION_ID_ORGUNIT) && items.some(_ref2 => {
+      let {
+        id
+      } = _ref2;
+      return ouIdHelper.hasGroupPrefix(id) || ouIdHelper.hasLevelPrefix(id);
+    })) {
+      titleFragments.push(getOuLevelAndGroupText(filter, metaData));
+    } else {
+      const filterItems = metaData.dimensions[filter.dimension];
+      if (Array.isArray(filterItems)) {
+        l = filterItems.length;
+        let id;
+        const sectionParts = [];
+        for (i = 0; i < l; i++) {
+          id = filterItems[i];
+
+          // if the value is present in items take the name to show from there
+          if (metaData.items[id]) {
+            sectionParts.push(metaData.items[id].name);
+          }
+          // otherwise use the values directly
+          // this is a temporary fix to avoid app crashing when using filters with data items in EV
+          else {
+            sectionParts.push(metaData.items[filter.dimension].name + ': ' + filterItems.join(', '));
+            break;
+          }
+        }
+        titleFragments.push(sectionParts.join(', '));
+      }
+    }
+  });
+  return titleFragments.join(' - ');
+}
+const headerStacksAreEqual = (a, b, limit) => {
+  for (let i = 0; i <= limit; ++i) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+export const getHeaderForDisplay = _ref3 => {
+  let {
+    start,
+    count,
+    index,
+    dimensionLevel,
+    getHeader,
+    showHierarchy
+  } = _ref3;
+  const header = getHeader(index);
+  const showHeader = index === start || !headerStacksAreEqual(header, getHeader(index - 1), dimensionLevel);
+  if (!showHeader) {
+    return null;
+  }
+  let span = 1;
+  for (let i = index + 1; i < start + count; ++i) {
+    if (!headerStacksAreEqual(getHeader(i), header, dimensionLevel)) {
+      break;
+    }
+    ++span;
+  }
+  const currentHeader = header[dimensionLevel];
+  const includesHierarchy = showHierarchy && (currentHeader === null || currentHeader === void 0 ? void 0 : currentHeader.hierarchy);
+  const label = includesHierarchy ? currentHeader.hierarchy.join(' / ') : currentHeader === null || currentHeader === void 0 ? void 0 : currentHeader.name;
+  return {
+    span,
+    label,
+    includesHierarchy
+  };
+};
+export const clipPartitionedAxis = _ref4 => {
+  let {
+    partitionSize,
+    partitions,
+    axisMap,
+    widthMap,
+    viewportWidth,
+    viewportPosition,
+    totalWidth
+  } = _ref4;
+  const partition = Math.floor(viewportPosition / partitionSize);
+  if (partitions[partition] === undefined) {
+    return {
+      indices: [0],
+      pre: 0,
+      post: 0
+    };
+  }
+  let start = partitions[partition] - partitions[0];
+  while (start < axisMap.length && widthMap[axisMap[start]].pre < viewportPosition) {
+    ++start;
+  }
+  start = start === 0 ? start : start - 1;
+  const pre = widthMap[axisMap[start]].pre;
+  const indices = [];
+  let end = start;
+  while (end < axisMap.length && widthMap[axisMap[end]].pre < viewportPosition + viewportWidth) {
+    indices.push(end);
+    ++end;
+  }
+  end = end === 0 ? end : end - 1;
+  const post = totalWidth - (widthMap[axisMap[end]].pre + widthMap[axisMap[end]].size);
+  return {
+    indices,
+    pre,
+    post
+  };
+};

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

@@ -0,0 +1,22 @@
+const calculateColorBrightness = function (rgb) {
+  if (!rgb) {
+    return 0;
+  }
+  return Math.round((parseInt(rgb[0]) * 299 + parseInt(rgb[1]) * 587 + parseInt(rgb[2]) * 114) / 1000);
+};
+const isHex = color => {
+  return typeof color === 'string' && color.charAt(0) === '#';
+};
+const hexToRgb = hex => {
+  let result;
+  if (typeof hex === "string") {
+    result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  }
+  return result ? [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16)] : null;
+};
+export const isColorBright = color => {
+  if (isHex(color)) {
+    color = hexToRgb(color);
+  }
+  return calculateColorBrightness(color) > 125;
+};

package/build/es/components/PivotTable/utils/layout/dimension.js

@@ -0,0 +1,48 @@
+import isObject from 'lodash/isObject';
+import isString from 'lodash/isString';
+
+// Dimension
+
+export const DIMENSION = {
+  isValid: dimension => isObject(dimension)
+};
+
+// Props
+
+export const DIMENSION_PROP_ID = {
+  name: 'dimension',
+  defaultValue: '',
+  required: true,
+  isValid: prop => isString(prop)
+};
+export const DIMENSION_PROP_ITEMS = {
+  name: 'items',
+  defaultValue: [],
+  required: false,
+  isValid: prop => Array.isArray(prop)
+};
+export const DIMENSION_PROP_FILTER = {
+  name: 'filter',
+  defaultValue: [],
+  required: false,
+  isValid: prop => isString(prop)
+};
+export const DIMENSION_PROP_LEGEND_SET = {
+  name: 'legendSet',
+  defaultValue: [],
+  required: false,
+  isValid: prop => isString(prop)
+};
+export const DIMENSION_PROP_PROGRAM_STAGE = {
+  name: 'programStage',
+  defaultValue: {},
+  required: false,
+  isValid: prop => isObject(prop)
+};
+export const DIMENSION_PROP_REPETITION = {
+  name: 'repetition',
+  defaultValue: [],
+  required: false,
+  isValid: prop => Array.isArray(prop)
+};
+export const DIMENSION_PROPS = [DIMENSION_PROP_ID, DIMENSION_PROP_ITEMS, DIMENSION_PROP_FILTER, DIMENSION_PROP_LEGEND_SET, DIMENSION_PROP_PROGRAM_STAGE, DIMENSION_PROP_REPETITION];

package/build/es/components/PivotTable/utils/layout/dimensionGetId.js

@@ -0,0 +1,5 @@
+import { DIMENSION_PROP_ID, DIMENSION_PROP_PROGRAM_STAGE } from './dimension';
+export const dimensionGetId = dimension => {
+  var _dimension$DIMENSION_;
+  return (_dimension$DIMENSION_ = dimension[DIMENSION_PROP_PROGRAM_STAGE.name]) !== null && _dimension$DIMENSION_ !== void 0 && _dimension$DIMENSION_.id ? `${dimension[DIMENSION_PROP_PROGRAM_STAGE.name].id}.${dimension[DIMENSION_PROP_ID.name]}` : dimension[DIMENSION_PROP_ID.name];
+};

package/build/es/components/PivotTable/utils/layout/dimensionGetItems.js

@@ -0,0 +1,5 @@
+import { DIMENSION_PROP_ITEMS } from './dimension';
+import { dimensionIsValid } from './dimensionIsValid';
+export const dimensionGetItems = dimension => dimensionIsValid(dimension, {
+  requireItems: true
+}) ? dimension[DIMENSION_PROP_ITEMS.name] : DIMENSION_PROP_ITEMS.defaultValue;

package/build/es/components/PivotTable/utils/layout/dimensionIs.js

@@ -0,0 +1,2 @@
+import { DIMENSION_PROP_ID } from './dimension';
+export const dimensionIs = (dimension, dimensionId) => dimension[DIMENSION_PROP_ID.name] === dimensionId;

package/build/es/components/PivotTable/utils/layout/dimensionIsEmpty.js

@@ -0,0 +1,2 @@
+import { DIMENSION, DIMENSION_PROP_ITEMS } from './dimension';
+export const dimensionIsEmpty = dimension => !(DIMENSION.isValid(dimension) && DIMENSION_PROP_ITEMS.isValid(dimension[DIMENSION_PROP_ITEMS.name]) && dimension[DIMENSION_PROP_ITEMS.name].length);

package/build/es/components/PivotTable/utils/layout/dimensionIsValid.js

@@ -0,0 +1,18 @@
+import { DIMENSION, DIMENSION_PROPS } from './dimension';
+import { dimensionIsEmpty } from './dimensionIsEmpty';
+export const dimensionIsValid = function (dimension) {
+  let {
+    requireItems
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  if (!DIMENSION.isValid(dimension)) {
+    return false;
+  }
+  const requiredProps = DIMENSION_PROPS.filter(prop => prop.required);
+  if (!requiredProps.every(prop => prop.isValid(dimension[prop.name]))) {
+    return false;
+  }
+  if (requireItems === true && dimensionIsEmpty(dimension)) {
+    return false;
+  }
+  return true;
+};

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

@@ -0,0 +1,27 @@
+export const LEGEND_DISPLAY_STRATEGY_BY_DATA_ITEM = 'BY_DATA_ITEM';
+export const LEGEND_DISPLAY_STRATEGY_FIXED = 'FIXED';
+export const LEGEND_DISPLAY_STYLE_FILL = 'FILL';
+export const LEGEND_DISPLAY_STYLE_TEXT = 'TEXT';
+export const getLegendByValueFromLegendSet = (legendSet, value) => {
+  var _legendSet$legends;
+  return Number.isInteger(parseInt(value)) ? legendSet === null || legendSet === void 0 ? void 0 : (_legendSet$legends = legendSet.legends) === null || _legendSet$legends === void 0 ? void 0 : _legendSet$legends.find(legend => value >= legend.startValue && value < legend.endValue // TODO: Confirm inclusive/exclusive bounds
+  ) : null;
+};
+export const getColorByValueFromLegendSet = (legendSet, value) => {
+  const legend = getLegendByValueFromLegendSet(legendSet, value);
+  return legend && legend.color;
+};
+export const getLegendSetByDisplayStrategy = _ref => {
+  let {
+    displayStrategy,
+    legendSets,
+    legendSetId
+  } = _ref;
+  if (displayStrategy === LEGEND_DISPLAY_STRATEGY_FIXED && legendSets.length) {
+    return legendSets[0];
+  } else if (displayStrategy === LEGEND_DISPLAY_STRATEGY_BY_DATA_ITEM) {
+    return legendSets.find(legendSet => legendSet.id === legendSetId);
+  } else {
+    return null;
+  }
+};

package/build/es/components/PivotTable/utils/ouIdHelper/index.js

@@ -0,0 +1,17 @@
+const LEVEL_ID_PREFIX = 'LEVEL';
+const GROUP_ID_PREFIX = 'OU_GROUP';
+export const USER_ORG_UNIT = 'USER_ORGUNIT';
+export const USER_ORG_UNIT_CHILDREN = 'USER_ORGUNIT_CHILDREN';
+export const USER_ORG_UNIT_GRANDCHILDREN = 'USER_ORGUNIT_GRANDCHILDREN';
+const hasGroupPrefix = id => id.substr(0, GROUP_ID_PREFIX.length) === GROUP_ID_PREFIX;
+const hasLevelPrefix = id => id.substr(0, LEVEL_ID_PREFIX.length) === LEVEL_ID_PREFIX;
+const stripLevelPrefix = id => hasLevelPrefix(id) ? id.substr(LEVEL_ID_PREFIX.length + 1) : id;
+const stripGroupPrefix = id => hasGroupPrefix(id) ? id.substr(GROUP_ID_PREFIX.length + 1) : id;
+const removePrefix = id => stripGroupPrefix(stripLevelPrefix(id));
+export const ouIdHelper = Object.freeze({
+  addLevelPrefix: id => `${LEVEL_ID_PREFIX}-${removePrefix(id)}`,
+  addGroupPrefix: id => `${GROUP_ID_PREFIX}-${removePrefix(id)}`,
+  removePrefix,
+  hasGroupPrefix,
+  hasLevelPrefix
+});

package/build/es/components/SingleValueContainer/SingleValueContainer.stories.js

@@ -107,7 +107,7 @@ SingleValuesWithDecimalPlaces.args = {
   }]
 };
 export default {
-  title: "Components/Single Value Container",
+  title: "Analytics/Single Value Container",
   component: SingleValueContainer,
   decorators: [SingleValueStory => {
     return /*#__PURE__*/React.createElement(SingleValueStory, null);

package/build/es/index.js

@@ -2,4 +2,5 @@ export * from "./components/Map";
 export * from "./components/CircularProgressDashboard";
 export * from "./components/ChartAnalytics";
 export * from "./components/SingleValueContainer";
+export * from "./components/PivotTable";
 export {};

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

@@ -124,5 +124,38 @@
     "Legend set is required": "Legend set is required",
     "Radius": "Radius",
     "Configure Thematic Layer": "Configure Thematic Layer",
+    "Program": "Program",
+    "Select a program": "Select a program",
+    "Indicators": "Indicators",
+    "Indicator group": "Indicator group",
+    "All groups": "All groups",
+    "Indicator": "Indicator",
+    "No indicator groups found": "No indicator groups found",
+    "Loading indicator groups": "Loading indicator groups",
+    "Data elements": "Data elements",
+    "Data element group": "Data element group",
+    "Data element": "Data element",
+    "No data element groups found": "No data element groups found",
+    "Loading data element groups": "Loading data element groups",
+    "Data sets": "Data sets",
+    "Data set": "Data set",
+    "All data sets": "All data sets",
+    "No data sets found": "No data sets found",
+    "Loading data sets": "Loading data sets",
+    "Event data items": "Event data items",
+    "All programs": "All programs",
+    "Event data item": "Event data item",
+    "No programs found": "No programs found",
+    "Loading programs": "Loading programs",
+    "Program indicators": "Program indicators",
+    "Program indicator": "Program indicator",
+    "Data": "Data",
+    "Organisation unit": "Organisation unit",
+    "Assigned Categories": "Assigned Categories",
+    "{{dynamicOuNames}} and {{lastOuName}}": "{{dynamicOuNames}} and {{lastOuName}}",
+    "{{allDynamicOuNames}} levels": "{{allDynamicOuNames}} levels",
+    "{{allDynamicOuNames}} groups": "{{allDynamicOuNames}} groups",
+    "{{allDynamicOuNames}} levels in {{staticOuNames}}": "{{allDynamicOuNames}} levels in {{staticOuNames}}",
+    "{{allDynamicOuNames}} groups in {{staticOuNames}}": "{{allDynamicOuNames}} groups in {{staticOuNames}}",
     "Loading ...": "Loading ..."
 }

package/build/types/components/PivotTable/components/AssignedCategoriesIcon/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const AssignedCategoriesIcon: () => JSX.Element;
+export default AssignedCategoriesIcon;

package/build/types/components/PivotTable/components/PivotTable.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { LegendSet } from "@hisptz/dhis2-utils";
+import { PivotTableVisualization, ToggleContextualMenuFunction } from "../interfaces";
+export interface PivotTableProps {
+    data: Record<string, any>;
+    visualization: PivotTableVisualization;
+    legendSets?: Array<LegendSet>;
+    tableProps?: Record<string, any>;
+    renderCounter?: number;
+    onToggleContextualMenu?: ToggleContextualMenuFunction;
+}
+export declare const PivotTable: React.FC<PivotTableProps>;

package/build/types/components/PivotTable/components/PivotTableBody.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { ClippingResult, ToggleContextualMenuFunction } from "../interfaces";
+export interface PivotTableBodyProps {
+    clippingResult: ClippingResult;
+    onToggleContextualMenu?: ToggleContextualMenuFunction;
+}
+export declare const PivotTableBody: ({ clippingResult, onToggleContextualMenu }: PivotTableBodyProps) => JSX.Element;

package/build/types/components/PivotTable/components/PivotTableCell.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+export interface PivotTableCellProps {
+    children: React.ReactNode;
+    classes: Array<string> | Record<string, any> | string;
+    dataTest: string;
+    isHeader: boolean;
+    style: Record<string, any>;
+    isSortable?: boolean;
+    index: number;
+    sortBy: {
+        order: number;
+        column: number;
+    };
+    onSortClick?: () => void;
+    [key: string]: any;
+}
+export declare const PivotTableCell: React.ForwardRefExoticComponent<Pick<PivotTableCellProps, keyof PivotTableCellProps> & React.RefAttributes<HTMLTableCellElement>>;

package/build/types/components/PivotTable/components/PivotTableClippedAxis.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+export interface PivotTableClippedAxisProps {
+    axisClippingResult: Record<string, any>;
+    EmptyComponent: React.JSXElementConstructor<any>;
+    ItemComponent: React.JSXElementConstructor<any>;
+}
+export declare const PivotTableClippedAxis: ({ axisClippingResult, EmptyComponent, ItemComponent, }: PivotTableClippedAxisProps) => React.ReactElement<any, string | React.JSXElementConstructor<any>>;

package/build/types/components/PivotTable/components/PivotTableColumnHeaderCell.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { ClippingResult } from "../interfaces";
+export interface PivotTableColumnHeaderCellProps {
+    clippingResult: ClippingResult;
+    index: number;
+    level: number;
+    onSortByColumn: (column: number) => void;
+    sortBy: {
+        order: number;
+        column: number;
+    } | null;
+}
+export declare const PivotTableColumnHeaderCell: ({ clippingResult, index, level, onSortByColumn, sortBy, }: PivotTableColumnHeaderCellProps) => JSX.Element | null;

package/build/types/components/PivotTable/components/PivotTableColumnHeaders.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { ClippingResult } from "../interfaces";
+export interface PivotTableColumnHeadersProps {
+    clippingResult: ClippingResult;
+    onSortByColumn: (column: number) => void;
+    sortBy: {
+        order: number;
+        column: number;
+    } | null;
+}
+export declare const PivotTableColumnHeaders: ({ clippingResult, onSortByColumn, sortBy, }: PivotTableColumnHeadersProps) => JSX.Element | null;