@hisptz/dhis2-analytics 1.0.10 → 1.0.11

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

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getOuLevelAndGroupText = void 0;
+var _dimensionGetItems = require("./layout/dimensionGetItems.js");
+var _dimensionIs = require("./layout/dimensionIs.js");
+var _ouIdHelper = require("./ouIdHelper");
+var _predefinedDimensions = require("../constants/predefinedDimensions");
+var _d2I18n = _interopRequireDefault(require("@dhis2/d2-i18n"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const getOuLevelAndGroupText = (filter, metaData) => {
+  if (!(0, _dimensionIs.dimensionIs)(_predefinedDimensions.DIMENSION_ID_ORGUNIT)) {
+    return '';
+  }
+  const items = (0, _dimensionGetItems.dimensionGetItems)(filter);
+  const hasOuLevel = items.some(item => _ouIdHelper.ouIdHelper.hasLevelPrefix(item.id));
+  const hasOuGroup = items.some(item => _ouIdHelper.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(' - ');
+};
+exports.getOuLevelAndGroupText = getOuLevelAndGroupText;
+const getLevelAndGroupText = (items, metaData, isLevel) => {
+  const getNameFromMetadata = id => metaData.items[id] ? metaData.items[id].name : id;
+  const dynamicOuItems = items.filter(item => isLevel ? _ouIdHelper.ouIdHelper.hasLevelPrefix(item.id) : _ouIdHelper.ouIdHelper.hasGroupPrefix(item.id));
+  const lastItem = dynamicOuItems.length > 1 ? dynamicOuItems.pop() : null;
+  const dynamicOuNames = dynamicOuItems.map(item => getNameFromMetadata(_ouIdHelper.ouIdHelper.removePrefix(item.id))).join(', ');
+  let allDynamicOuNames;
+  if (lastItem) {
+    const lastOuName = getNameFromMetadata(_ouIdHelper.ouIdHelper.removePrefix(lastItem.id));
+    allDynamicOuNames = _d2I18n.default.t('{{dynamicOuNames}} and {{lastOuName}}', {
+      dynamicOuNames,
+      lastOuName
+    });
+  } else {
+    allDynamicOuNames = dynamicOuNames;
+  }
+  const staticOuNames = items.filter(item => !_ouIdHelper.ouIdHelper.hasGroupPrefix(item.id) && !_ouIdHelper.ouIdHelper.hasLevelPrefix(item.id)).map(item => getNameFromMetadata(item.id)).join(', ');
+  let ouLevelAndGroupText = '';
+  if (!staticOuNames) {
+    if (isLevel) {
+      ouLevelAndGroupText = _d2I18n.default.t('{{allDynamicOuNames}} levels', {
+        allDynamicOuNames
+      });
+    } else {
+      ouLevelAndGroupText = _d2I18n.default.t('{{allDynamicOuNames}} groups', {
+        allDynamicOuNames
+      });
+    }
+  } else {
+    if (isLevel) {
+      ouLevelAndGroupText = _d2I18n.default.t('{{allDynamicOuNames}} levels in {{staticOuNames}}', {
+        allDynamicOuNames,
+        staticOuNames
+      });
+    } else {
+      ouLevelAndGroupText = _d2I18n.default.t('{{allDynamicOuNames}} groups in {{staticOuNames}}', {
+        allDynamicOuNames,
+        staticOuNames
+      });
+    }
+  }
+  return ouLevelAndGroupText;
+};

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

@@ -0,0 +1,322 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clipPartitionedAxis = exports.applyLegendSet = void 0;
+exports.getFilterText = getFilterText;
+exports.renderValue = exports.parseValue = exports.measureTextWithWrapping = exports.getHeaderForDisplay = void 0;
+var _getOuLevelAndGroupText = require("./getOuLevelAndGroupText");
+var _dimensionGetItems = require("./layout/dimensionGetItems");
+var _dimensionIs = require("./layout/dimensionIs");
+var _ouIdHelper = require("./ouIdHelper");
+var _predefinedDimensions = require("../constants/predefinedDimensions");
+var _pivotTable = require("../constants/pivotTable");
+var _valueTypes = require("../constants/valueTypes");
+var _ui = require("@dhis2/ui");
+var _legend = require("./legend");
+var _isColorBright = require("./isColorBright.js");
+// @ts-nocheck
+
+const parseValue = valueString => {
+  const parsedValue = parseFloat(valueString);
+  if (isNaN(parsedValue)) {
+    return valueString;
+  }
+  return parsedValue;
+};
+exports.parseValue = parseValue;
+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;
+};
+const measureTextWithWrapping = (text, _ref) => {
+  let {
+    fontSize = 11,
+    maxWidth = _pivotTable.CLIPPED_CELL_MAX_SIZE,
+    justifyBuffer = _pivotTable.WRAPPED_TEXT_JUSTIFY_BUFFER,
+    lineHeight = _pivotTable.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?
+  };
+};
+exports.measureTextWithWrapping = measureTextWithWrapping;
+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);
+};
+const renderValue = (value, valueType, visualization) => {
+  if (!(0, _valueTypes.isNumericValueType)(valueType) || value === undefined) {
+    return String(value).replace(/[^\S\n]+/, ' ');
+  }
+  if (visualization.numberType === _pivotTable.NUMBER_TYPE_ROW_PERCENTAGE || visualization.numberType === _pivotTable.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));
+  }
+};
+exports.renderValue = renderValue;
+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.LEGEND_DISPLAY_STRATEGY_BY_DATA_ITEM:
+      if (dxDimension && dxDimension.legendSet) {
+        legendSetId = dxDimension.legendSet;
+      }
+      break;
+    case _legend.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.LEGEND_DISPLAY_STYLE_TEXT:
+      style.color = legendColor;
+      break;
+    case _legend.LEGEND_DISPLAY_STYLE_FILL:
+    default:
+      style.backgroundColor = legendColor;
+      if ((0, _isColorBright.isColorBright)(legendColor)) {
+        style.color = _ui.colors.grey900;
+      } else {
+        style.color = _ui.colors.white;
+      }
+      break;
+  }
+  return style;
+};
+const applyLegendSet = (value, dxDimension, engine) => {
+  if (isNaN(value) || !engine.legendSets) {
+    return {};
+  }
+  const legendSet = getLegendSet(engine, dxDimension);
+  if (!legendSet) {
+    return {};
+  }
+  const legendColor = (0, _legend.getColorByValueFromLegendSet)(legendSet, value);
+  if (!legendColor) {
+    return {};
+  }
+  return buildStyleObject(legendColor, engine);
+};
+exports.applyLegendSet = applyLegendSet;
+function getFilterText(filters, metaData) {
+  if (!Array.isArray(filters) || !filters.length) {
+    return '';
+  }
+  const titleFragments = [];
+  let i;
+  let l;
+  filters.forEach(filter => {
+    const items = (0, _dimensionGetItems.dimensionGetItems)(filter);
+    if ((0, _dimensionIs.dimensionIs)(filter, _predefinedDimensions.DIMENSION_ID_ORGUNIT) && items.some(_ref2 => {
+      let {
+        id
+      } = _ref2;
+      return _ouIdHelper.ouIdHelper.hasGroupPrefix(id) || _ouIdHelper.ouIdHelper.hasLevelPrefix(id);
+    })) {
+      titleFragments.push((0, _getOuLevelAndGroupText.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;
+};
+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
+  };
+};
+exports.getHeaderForDisplay = getHeaderForDisplay;
+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
+  };
+};
+exports.clipPartitionedAxis = clipPartitionedAxis;

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

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isColorBright = void 0;
+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;
+};
+const isColorBright = color => {
+  if (isHex(color)) {
+    color = hexToRgb(color);
+  }
+  return calculateColorBrightness(color) > 125;
+};
+exports.isColorBright = isColorBright;

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

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DIMENSION_PROP_REPETITION = exports.DIMENSION_PROP_PROGRAM_STAGE = exports.DIMENSION_PROP_LEGEND_SET = exports.DIMENSION_PROP_ITEMS = exports.DIMENSION_PROP_ID = exports.DIMENSION_PROP_FILTER = exports.DIMENSION_PROPS = exports.DIMENSION = void 0;
+var _isObject = _interopRequireDefault(require("lodash/isObject"));
+var _isString = _interopRequireDefault(require("lodash/isString"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// Dimension
+
+const DIMENSION = {
+  isValid: dimension => (0, _isObject.default)(dimension)
+};
+
+// Props
+exports.DIMENSION = DIMENSION;
+const DIMENSION_PROP_ID = {
+  name: 'dimension',
+  defaultValue: '',
+  required: true,
+  isValid: prop => (0, _isString.default)(prop)
+};
+exports.DIMENSION_PROP_ID = DIMENSION_PROP_ID;
+const DIMENSION_PROP_ITEMS = {
+  name: 'items',
+  defaultValue: [],
+  required: false,
+  isValid: prop => Array.isArray(prop)
+};
+exports.DIMENSION_PROP_ITEMS = DIMENSION_PROP_ITEMS;
+const DIMENSION_PROP_FILTER = {
+  name: 'filter',
+  defaultValue: [],
+  required: false,
+  isValid: prop => (0, _isString.default)(prop)
+};
+exports.DIMENSION_PROP_FILTER = DIMENSION_PROP_FILTER;
+const DIMENSION_PROP_LEGEND_SET = {
+  name: 'legendSet',
+  defaultValue: [],
+  required: false,
+  isValid: prop => (0, _isString.default)(prop)
+};
+exports.DIMENSION_PROP_LEGEND_SET = DIMENSION_PROP_LEGEND_SET;
+const DIMENSION_PROP_PROGRAM_STAGE = {
+  name: 'programStage',
+  defaultValue: {},
+  required: false,
+  isValid: prop => (0, _isObject.default)(prop)
+};
+exports.DIMENSION_PROP_PROGRAM_STAGE = DIMENSION_PROP_PROGRAM_STAGE;
+const DIMENSION_PROP_REPETITION = {
+  name: 'repetition',
+  defaultValue: [],
+  required: false,
+  isValid: prop => Array.isArray(prop)
+};
+exports.DIMENSION_PROP_REPETITION = DIMENSION_PROP_REPETITION;
+const DIMENSION_PROPS = [DIMENSION_PROP_ID, DIMENSION_PROP_ITEMS, DIMENSION_PROP_FILTER, DIMENSION_PROP_LEGEND_SET, DIMENSION_PROP_PROGRAM_STAGE, DIMENSION_PROP_REPETITION];
+exports.DIMENSION_PROPS = DIMENSION_PROPS;

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dimensionGetId = void 0;
+var _dimension = require("./dimension");
+const dimensionGetId = dimension => {
+  var _dimension$DIMENSION_;
+  return (_dimension$DIMENSION_ = dimension[_dimension.DIMENSION_PROP_PROGRAM_STAGE.name]) !== null && _dimension$DIMENSION_ !== void 0 && _dimension$DIMENSION_.id ? `${dimension[_dimension.DIMENSION_PROP_PROGRAM_STAGE.name].id}.${dimension[_dimension.DIMENSION_PROP_ID.name]}` : dimension[_dimension.DIMENSION_PROP_ID.name];
+};
+exports.dimensionGetId = dimensionGetId;

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dimensionGetItems = void 0;
+var _dimension = require("./dimension");
+var _dimensionIsValid = require("./dimensionIsValid");
+const dimensionGetItems = dimension => (0, _dimensionIsValid.dimensionIsValid)(dimension, {
+  requireItems: true
+}) ? dimension[_dimension.DIMENSION_PROP_ITEMS.name] : _dimension.DIMENSION_PROP_ITEMS.defaultValue;
+exports.dimensionGetItems = dimensionGetItems;

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

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dimensionIs = void 0;
+var _dimension = require("./dimension");
+const dimensionIs = (dimension, dimensionId) => dimension[_dimension.DIMENSION_PROP_ID.name] === dimensionId;
+exports.dimensionIs = dimensionIs;

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

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dimensionIsEmpty = void 0;
+var _dimension = require("./dimension");
+const dimensionIsEmpty = dimension => !(_dimension.DIMENSION.isValid(dimension) && _dimension.DIMENSION_PROP_ITEMS.isValid(dimension[_dimension.DIMENSION_PROP_ITEMS.name]) && dimension[_dimension.DIMENSION_PROP_ITEMS.name].length);
+exports.dimensionIsEmpty = dimensionIsEmpty;

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

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dimensionIsValid = void 0;
+var _dimension = require("./dimension");
+var _dimensionIsEmpty = require("./dimensionIsEmpty");
+const dimensionIsValid = function (dimension) {
+  let {
+    requireItems
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  if (!_dimension.DIMENSION.isValid(dimension)) {
+    return false;
+  }
+  const requiredProps = _dimension.DIMENSION_PROPS.filter(prop => prop.required);
+  if (!requiredProps.every(prop => prop.isValid(dimension[prop.name]))) {
+    return false;
+  }
+  if (requireItems === true && (0, _dimensionIsEmpty.dimensionIsEmpty)(dimension)) {
+    return false;
+  }
+  return true;
+};
+exports.dimensionIsValid = dimensionIsValid;

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

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLegendSetByDisplayStrategy = exports.getLegendByValueFromLegendSet = exports.getColorByValueFromLegendSet = exports.LEGEND_DISPLAY_STYLE_TEXT = exports.LEGEND_DISPLAY_STYLE_FILL = exports.LEGEND_DISPLAY_STRATEGY_FIXED = exports.LEGEND_DISPLAY_STRATEGY_BY_DATA_ITEM = void 0;
+const LEGEND_DISPLAY_STRATEGY_BY_DATA_ITEM = 'BY_DATA_ITEM';
+exports.LEGEND_DISPLAY_STRATEGY_BY_DATA_ITEM = LEGEND_DISPLAY_STRATEGY_BY_DATA_ITEM;
+const LEGEND_DISPLAY_STRATEGY_FIXED = 'FIXED';
+exports.LEGEND_DISPLAY_STRATEGY_FIXED = LEGEND_DISPLAY_STRATEGY_FIXED;
+const LEGEND_DISPLAY_STYLE_FILL = 'FILL';
+exports.LEGEND_DISPLAY_STYLE_FILL = LEGEND_DISPLAY_STYLE_FILL;
+const LEGEND_DISPLAY_STYLE_TEXT = 'TEXT';
+exports.LEGEND_DISPLAY_STYLE_TEXT = LEGEND_DISPLAY_STYLE_TEXT;
+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;
+};
+exports.getLegendByValueFromLegendSet = getLegendByValueFromLegendSet;
+const getColorByValueFromLegendSet = (legendSet, value) => {
+  const legend = getLegendByValueFromLegendSet(legendSet, value);
+  return legend && legend.color;
+};
+exports.getColorByValueFromLegendSet = getColorByValueFromLegendSet;
+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;
+  }
+};
+exports.getLegendSetByDisplayStrategy = getLegendSetByDisplayStrategy;

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

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ouIdHelper = exports.USER_ORG_UNIT_GRANDCHILDREN = exports.USER_ORG_UNIT_CHILDREN = exports.USER_ORG_UNIT = void 0;
+const LEVEL_ID_PREFIX = 'LEVEL';
+const GROUP_ID_PREFIX = 'OU_GROUP';
+const USER_ORG_UNIT = 'USER_ORGUNIT';
+exports.USER_ORG_UNIT = USER_ORG_UNIT;
+const USER_ORG_UNIT_CHILDREN = 'USER_ORGUNIT_CHILDREN';
+exports.USER_ORG_UNIT_CHILDREN = USER_ORG_UNIT_CHILDREN;
+const USER_ORG_UNIT_GRANDCHILDREN = 'USER_ORGUNIT_GRANDCHILDREN';
+exports.USER_ORG_UNIT_GRANDCHILDREN = USER_ORG_UNIT_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));
+const ouIdHelper = Object.freeze({
+  addLevelPrefix: id => `${LEVEL_ID_PREFIX}-${removePrefix(id)}`,
+  addGroupPrefix: id => `${GROUP_ID_PREFIX}-${removePrefix(id)}`,
+  removePrefix,
+  hasGroupPrefix,
+  hasLevelPrefix
+});
+exports.ouIdHelper = ouIdHelper;

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

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

package/build/cjs/index.js

@@ -46,4 +46,15 @@ Object.keys(_SingleValueContainer).forEach(function (key) {
       return _SingleValueContainer[key];
     }
   });
+});
+var _PivotTable = require("./components/PivotTable");
+Object.keys(_PivotTable).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _PivotTable[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _PivotTable[key];
+    }
+  });
 });