@dhis2/analytics 26.2.0-alpha.2 → 26.2.0-cumulative-values-alpha.1

package/build/es/components/RichText/Editor.bk/convertCtrlKey.js

@@ -0,0 +1,80 @@
+const state = {
+  boldMode: false,
+  italicMode: false,
+  element: null
+};
+const markerMap = {
+  italic: '_',
+  bold: '*'
+};
+const trim = str => {
+  const leftSpaces = /^\s+/;
+  const rightSpaces = /\s+$/;
+  return str.replace(leftSpaces, '').replace(rightSpaces, '');
+};
+const toggleMode = mode => {
+  const prop = `${mode}Mode`;
+  state[prop] = !state[prop];
+};
+const insertMarkers = (mode, cb) => {
+  const {
+    selectionStart: start,
+    selectionEnd: end,
+    value
+  } = state.element;
+  const marker = markerMap[mode] || null;
+  if (!marker || !cb || start < 0) {
+    return;
+  }
+  toggleMode(mode);
+  let newValue;
+  let caretPos = end + 1;
+  const padMarkers = text => {
+    // is caret between two markers (i.e., "**" or "__")? Then do not add padding
+    if (start === end && value.length && start > 0) {
+      if (value[start - 1] === markerMap.bold && value[start] === markerMap.bold || value[start - 1] === markerMap.italic && value[start] === markerMap.italic) {
+        return text;
+      }
+    }
+    if (value.length && start > 0 && value[start - 1] !== ' ') {
+      text = ` ${text}`;
+      ++caretPos;
+    }
+    if (value.length && end !== value.length && value[end] !== ' ') {
+      text = `${text} `;
+    }
+    return text;
+  };
+  if (start === end) {
+    //no text
+    const valueArr = value.split('');
+    valueArr.splice(start, 0, padMarkers(`${marker}${marker}`));
+    newValue = valueArr.join('');
+  } else {
+    const text = value.slice(start, end);
+    const trimmedText = trim(text);
+
+    // adjust caretPos based on trimmed text selection
+    caretPos = caretPos - (text.length - trimmedText.length) + 1;
+    newValue = [value.slice(0, start), padMarkers(`${marker}${trimmedText}${marker}`), value.slice(end)].join('');
+    toggleMode(mode);
+  }
+  cb(newValue, caretPos);
+};
+const convertCtrlKey = (event, cb) => {
+  const {
+    key,
+    ctrlKey,
+    metaKey
+  } = event;
+  const element = event.target;
+  state.element = element;
+  if (key === 'b' && (ctrlKey || metaKey)) {
+    event.preventDefault();
+    insertMarkers('bold', cb);
+  } else if (key === 'i' && (ctrlKey || metaKey)) {
+    event.preventDefault();
+    insertMarkers('italic', cb);
+  }
+};
+export default convertCtrlKey;

package/build/es/components/RichText/Parser.bk/MdParser.js

@@ -0,0 +1,99 @@
+import MarkdownIt from 'markdown-it';
+const emojiDb = {
+  ':-)': '\u{1F642}',
+  ':)': '\u{1F642}',
+  ':-(': '\u{1F641}',
+  ':(': '\u{1F641}',
+  ':+1': '\u{1F44D}',
+  ':-1': '\u{1F44E}'
+};
+const codes = {
+  bold: {
+    name: 'bold',
+    char: '*',
+    domEl: 'strong',
+    encodedChar: 0x2a,
+    // see https://regex101.com/r/evswdV/8 for explanation of regexp
+    regexString: '\\B\\*((?!\\s)[^*]+(?:\\b|[^*\\s]))\\*\\B',
+    contentFn: val => val
+  },
+  italic: {
+    name: 'italic',
+    char: '_',
+    domEl: 'em',
+    encodedChar: 0x5f,
+    // see https://regex101.com/r/p6LpjK/6 for explanation of regexp
+    regexString: '\\b_((?!\\s)[^_]+(?:\\B|[^_\\s]))_\\b',
+    contentFn: val => val
+  },
+  emoji: {
+    name: 'emoji',
+    char: ':',
+    domEl: 'span',
+    encodedChar: 0x3a,
+    regexString: '^(:-\\)|:\\)|:\\(|:-\\(|:\\+1|:-1)',
+    contentFn: val => emojiDb[val]
+  }
+};
+let md;
+let linksInText;
+const markerIsInLinkText = pos => linksInText.some(link => pos >= link.index && pos <= link.lastIndex);
+const parse = code => (state, silent) => {
+  if (silent) {
+    return false;
+  }
+  const start = state.pos;
+
+  // skip parsing emphasis if marker is within a link
+  if (markerIsInLinkText(start)) {
+    return false;
+  }
+  const marker = state.src.charCodeAt(start);
+
+  // marker character: "_", "*", ":"
+  if (marker !== codes[code].encodedChar) {
+    return false;
+  }
+  const MARKER_REGEX = new RegExp(codes[code].regexString);
+  const token = state.src.slice(start);
+  if (MARKER_REGEX.test(token)) {
+    const markerMatch = token.match(MARKER_REGEX);
+
+    // skip parsing sections where the marker is not at the start of the token
+    if (markerMatch.index !== 0) {
+      return false;
+    }
+    const text = markerMatch[1];
+    state.push(`${codes[code].domEl}_open`, codes[code].domEl, 1);
+    const t = state.push('text', '', 0);
+    t.content = codes[code].contentFn(text);
+    state.push(`${codes.bold.domEl}_close`, codes[code].domEl, -1);
+    state.pos += markerMatch[0].length;
+    return true;
+  }
+  return false;
+};
+class MdParser {
+  constructor() {
+    // disable all rules, enable autolink for URLs and email addresses
+    md = new MarkdownIt('zero', {
+      linkify: true
+    });
+
+    // *bold* -> <strong>bold</strong>
+    md.inline.ruler.push('strong', parse(codes.bold.name));
+
+    // _italic_ -> <em>italic</em>
+    md.inline.ruler.push('italic', parse(codes.italic.name));
+
+    // :-) :) :-( :( :+1 :-1 -> <span>[unicode]</span>
+    md.inline.ruler.push('emoji', parse(codes.emoji.name));
+    md.enable(['link', 'linkify', 'strong', 'italic', 'emoji']);
+    return this;
+  }
+  render(text) {
+    linksInText = md.linkify.match(text) || [];
+    return md.renderInline(text);
+  }
+}
+export default MdParser;

package/build/es/components/RichText/Parser.bk/Parser.js

@@ -0,0 +1,24 @@
+import PropTypes from 'prop-types';
+import React, { useMemo } from 'react';
+import MdParserClass from './MdParser.js';
+const Parser = _ref => {
+  let {
+    children,
+    style
+  } = _ref;
+  const MdParser = useMemo(() => new MdParserClass(), []);
+  return children ? /*#__PURE__*/React.createElement("p", {
+    style: style,
+    dangerouslySetInnerHTML: {
+      __html: MdParser.render(children)
+    }
+  }) : null;
+};
+Parser.defaultProps = {
+  style: null
+};
+Parser.propTypes = {
+  children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),
+  style: PropTypes.object
+};
+export default Parser;

package/build/es/components/RichText/Parser.bk/__tests__/MdParser.spec.js

@@ -0,0 +1,31 @@
+import MdParser from '../MdParser.js';
+const Parser = new MdParser();
+describe('MdParser class', () => {
+  it('converts text into HTML', () => {
+    const tests = [['_italic_', '<em>italic</em>'], ['*bold*', '<strong>bold</strong>'], ['* not bold because there is a space *', '* not bold because there is a space *'], ['_ not italic because there is a space _', '_ not italic because there is a space _'], [':-)', '<span>\u{1F642}</span>'], [':)', '<span>\u{1F642}</span>'], [':-(', '<span>\u{1F641}</span>'], [':(', '<span>\u{1F641}</span>'], [':+1', '<span>\u{1F44D}</span>'], [':-1', '<span>\u{1F44E}</span>'], ['mixed _italic_ *bold* and :+1', 'mixed <em>italic</em> <strong>bold</strong> and <span>\u{1F44D}</span>'], ['_italic with * inside_', '<em>italic with * inside</em>'], ['*bold with _ inside*', '<strong>bold with _ inside</strong>'],
+    // italic marker followed by : should work
+    ['_italic_:', '<em>italic</em>:'], ['_italic_: some text, *bold*: some other text', '<em>italic</em>: some text, <strong>bold</strong>: some other text'],
+    // bold marker followed by : should work
+    ['*bold*:', '<strong>bold</strong>:'], ['*bold*: some text, _italic_: some other text', '<strong>bold</strong>: some text, <em>italic</em>: some other text'],
+    // italic marker inside an italic string not allowed
+    ['_italic with _ inside_', '_italic with _ inside_'],
+    // bold marker inside a bold string not allowed
+    ['*bold with * inside*', '*bold with * inside*'], ['_multiple_ italic in the _same line_', '<em>multiple</em> italic in the <em>same line</em>'],
+    // nested italic/bold combinations not allowed
+    ['_italic with *bold* inside_', '<em>italic with *bold* inside</em>'], ['*bold with _italic_ inside*', '<strong>bold with _italic_ inside</strong>'], ['text with : and :)', 'text with : and <span>\u{1F642}</span>'], ['(parenthesis and :))', '(parenthesis and <span>\u{1F642}</span>)'], [':((parenthesis:))', '<span>\u{1F641}</span>(parenthesis<span>\u{1F642}</span>)'], [':+1+1', '<span>\u{1F44D}</span>+1'], ['-1:-1', '-1<span>\u{1F44E}</span>'],
+    // links
+    ['example.com/path', '<a href="http://example.com/path">example.com/path</a>'],
+    // not recognized links with italic marker inside not converted
+    ['example_with_underscore.com/path', 'example_with_underscore.com/path'], ['example_with_underscore.com/path_with_underscore', 'example_with_underscore.com/path_with_underscore'],
+    // markers around non-recognized links
+    ['link example_with_underscore.com/path should _not_ be converted', 'link example_with_underscore.com/path should <em>not</em> be converted'], ['link example_with_underscore.com/path should *not* be converted', 'link example_with_underscore.com/path should <strong>not</strong> be converted'],
+    // italic marker inside links not converted
+    ['example.com/path_with_underscore', '<a href="http://example.com/path_with_underscore">example.com/path_with_underscore</a>'], ['_italic_ and *bold* with a example.com/link_with_underscore', '<em>italic</em> and <strong>bold</strong> with a <a href="http://example.com/link_with_underscore">example.com/link_with_underscore</a>'], ['example.com/path with *bold* after :)', '<a href="http://example.com/path">example.com/path</a> with <strong>bold</strong> after <span>\u{1F642}</span>'], ['_before_ example.com/path_with_underscore *after* :)', '<em>before</em> <a href="http://example.com/path_with_underscore">example.com/path_with_underscore</a> <strong>after</strong> <span>\u{1F642}</span>'],
+    // italic/bold markers right after non-word characters
+    ['_If % of ART retention rate after 12 months >90(%)_: Sustain the efforts.', '<em>If % of ART retention rate after 12 months &gt;90(%)</em>: Sustain the efforts.'], ['*If % of ART retention rate after 12 months >90(%)*: Sustain the efforts.', '<strong>If % of ART retention rate after 12 months &gt;90(%)</strong>: Sustain the efforts.']];
+    tests.forEach(test => {
+      const renderedText = Parser.render(test[0]);
+      expect(renderedText).toEqual(test[1]);
+    });
+  });
+});

package/build/es/components/RichText/Parser.bk/__tests__/Parser.spec.js

@@ -0,0 +1,38 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+import Parser from '../Parser.js';
+import '../MdParser.js';
+jest.mock('../MdParser', () => {
+  return jest.fn().mockImplementation(() => {
+    return {
+      render: () => 'converted text'
+    };
+  });
+});
+describe('RichText: Parser component', () => {
+  let richTextParser;
+  const defaultProps = {
+    style: {
+      color: 'blue'
+    }
+  };
+  const renderComponent = (props, text) => {
+    return shallow( /*#__PURE__*/React.createElement(Parser, props, text));
+  };
+  it('should have rendered a result', () => {
+    richTextParser = renderComponent({}, 'test');
+    expect(richTextParser).toHaveLength(1);
+  });
+  it('should have rendered a result with the style prop', () => {
+    richTextParser = renderComponent(defaultProps, 'test prop');
+    expect(richTextParser.props().style).toEqual(defaultProps.style);
+  });
+  it('should have rendered content', () => {
+    richTextParser = renderComponent({}, 'plain text');
+    expect(richTextParser.html()).toEqual('<p>converted text</p>');
+  });
+  it('should return null if no children is passed', () => {
+    richTextParser = renderComponent({}, undefined);
+    expect(richTextParser.html()).toBe(null);
+  });
+});

package/build/es/modules/layout/dimension.js

@@ -33,12 +33,6 @@ export const DIMENSION_PROP_LEGEND_SET = {
   required: false,
   isValid: prop => isString(prop)
 };
-export const DIMENSION_PROP_PROGRAM = {
-  name: 'program',
-  defaultValue: {},
-  required: false,
-  isValid: prop => isObject(prop)
-};
 export const DIMENSION_PROP_PROGRAM_STAGE = {
   name: 'programStage',
   defaultValue: {},
@@ -51,4 +45,4 @@ export const DIMENSION_PROP_REPETITION = {
   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, DIMENSION_PROP_PROGRAM_STAGE, DIMENSION_PROP_REPETITION];
+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/modules/layout/dimensionCreate.js

@@ -1,4 +1,4 @@
-import { DIMENSION_PROP_ID, DIMENSION_PROP_ITEMS, DIMENSION_PROP_FILTER, DIMENSION_PROP_LEGEND_SET, DIMENSION_PROP_PROGRAM, DIMENSION_PROP_PROGRAM_STAGE, DIMENSION_PROP_REPETITION } from './dimension.js';
+import { DIMENSION_PROP_ID, DIMENSION_PROP_ITEMS, DIMENSION_PROP_FILTER, DIMENSION_PROP_LEGEND_SET, DIMENSION_PROP_PROGRAM_STAGE, DIMENSION_PROP_REPETITION } from './dimension.js';
 export const dimensionCreate = function (dimensionId) {
   let itemIds = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
   let args = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
@@ -15,9 +15,6 @@ export const dimensionCreate = function (dimensionId) {
     ...(args.legendSet && {
       [DIMENSION_PROP_LEGEND_SET.name]: args.legendSet
     }),
-    ...(args.program && {
-      [DIMENSION_PROP_PROGRAM.name]: args.program
-    }),
     ...(args.programStage && {
       [DIMENSION_PROP_PROGRAM_STAGE.name]: args.programStage
     }),

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

@@ -20,7 +20,8 @@ const defaultOptions = {
   showRowSubtotals: false,
   showColumnSubtotals: false,
   fixColumnHeaders: false,
-  fixRowHeaders: false
+  fixRowHeaders: false,
+  cumulativeValues: false
 };
 const defaultVisualizationProps = {
   fontSize: FONT_SIZE_OPTION_NORMAL,
@@ -175,6 +176,9 @@ export class PivotTableEngine {
     _defineProperty(this, "data", []);
     _defineProperty(this, "rowMap", []);
     _defineProperty(this, "columnMap", []);
+    _defineProperty(this, "accumulators", {
+      rows: {}
+    });
     this.visualization = Object.assign({}, defaultVisualizationProps, visualization);
     this.legendSets = (legendSets || []).reduce((sets, set) => {
       sets[set.id] = set;
@@ -194,7 +198,8 @@ export class PivotTableEngine {
       subtitle: visualization.hideSubtitle ? undefined : visualization.subtitle,
       // turn on fixed headers only when there are dimensions
       fixColumnHeaders: this.dimensionLookup.columns.length ? visualization.fixColumnHeaders : false,
-      fixRowHeaders: this.dimensionLookup.rows.length ? visualization.fixRowHeaders : false
+      fixRowHeaders: this.dimensionLookup.rows.length ? visualization.fixRowHeaders : false,
+      cumulativeValues: visualization.cumulativeValues
     };
     this.adaptiveClippingController = new AdaptiveClippingController(this);
     const doColumnSubtotals = this.options.showColumnSubtotals && this.dimensionLookup.rows.length > 1;
@@ -218,51 +223,68 @@ export class PivotTableEngine {
       row,
       column
     });
+    const valueType = (dxDimension === null || dxDimension === void 0 ? void 0 : dxDimension.valueType) || VALUE_TYPE_TEXT;
     const headers = [...this.getRawRowHeader(row), ...this.getRawColumnHeader(column)];
     const peId = (_headers$find = headers.find(header => (header === null || header === void 0 ? void 0 : header.dimensionItemType) === DIMENSION_TYPE_PERIOD)) === null || _headers$find === void 0 ? void 0 : _headers$find.uid;
     const ouId = (_headers$find2 = headers.find(header => (header === null || header === void 0 ? void 0 : header.dimensionItemType) === DIMENSION_TYPE_ORGANISATION_UNIT)) === null || _headers$find2 === void 0 ? void 0 : _headers$find2.uid;
-    if (!this.data[row] || !this.data[row][column]) {
-      return {
-        cellType,
-        empty: true,
-        ouId,
-        peId
-      };
-    }
-    const dataRow = this.data[row][column];
-    let rawValue = cellType === CELL_TYPE_VALUE ? dataRow[this.dimensionLookup.dataHeaders.value] : dataRow.value;
-    let renderedValue = rawValue;
-    const valueType = (dxDimension === null || dxDimension === void 0 ? void 0 : dxDimension.valueType) || VALUE_TYPE_TEXT;
-    if (valueType === VALUE_TYPE_NUMBER) {
-      rawValue = parseValue(rawValue);
-      switch (this.visualization.numberType) {
-        case NUMBER_TYPE_ROW_PERCENTAGE:
-          renderedValue = rawValue / this.percentageTotals[row].value;
-          break;
-        case NUMBER_TYPE_COLUMN_PERCENTAGE:
-          renderedValue = rawValue / this.percentageTotals[column].value;
-          break;
-        default:
-          break;
-      }
-    }
-    renderedValue = renderValue(renderedValue, valueType, this.visualization);
-    return {
+    const rawCell = {
       cellType,
-      empty: false,
       valueType,
-      rawValue,
-      renderedValue,
-      dxDimension,
       ouId,
       peId
     };
+    if (!this.data[row] || !this.data[row][column]) {
+      rawCell.empty = true;
+    } else {
+      const dataRow = this.data[row][column];
+      let rawValue = cellType === CELL_TYPE_VALUE ? dataRow[this.dimensionLookup.dataHeaders.value] : dataRow.value;
+      let renderedValue = rawValue;
+      if (valueType === VALUE_TYPE_NUMBER) {
+        rawValue = parseValue(rawValue);
+        switch (this.visualization.numberType) {
+          case NUMBER_TYPE_ROW_PERCENTAGE:
+            renderedValue = rawValue / this.percentageTotals[row].value;
+            break;
+          case NUMBER_TYPE_COLUMN_PERCENTAGE:
+            renderedValue = rawValue / this.percentageTotals[column].value;
+            break;
+          default:
+            break;
+        }
+      }
+      renderedValue = renderValue(renderedValue, valueType, this.visualization);
+      rawCell.dxDimension = dxDimension;
+      rawCell.empty = false;
+      rawCell.rawValue = rawValue;
+      rawCell.renderedValue = renderedValue;
+    }
+    if (this.options.cumulativeValues) {
+      const cumulativeValue = this.getCumulative({
+        row,
+        column
+      });
+      if (cumulativeValue !== undefined && cumulativeValue !== null) {
+        // force to NUMBER for accumulated values
+        rawCell.valueType = valueType === undefined || valueType === null ? VALUE_TYPE_NUMBER : valueType;
+        rawCell.empty = false;
+        rawCell.rawValue = cumulativeValue;
+        rawCell.renderedValue = renderValue(cumulativeValue, valueType, this.visualization);
+      }
+    }
+    return rawCell;
   }
-  get(_ref4) {
+  getCumulative(_ref4) {
     let {
       row,
       column
     } = _ref4;
+    return this.accumulators.rows[row][column];
+  }
+  get(_ref5) {
+    let {
+      row,
+      column
+    } = _ref5;
     const mappedRow = this.rowMap[row],
       mappedColumn = this.columnMap[column];
     if (!mappedRow && mappedRow !== 0 || !mappedColumn && mappedColumn !== 0) {
@@ -273,11 +295,11 @@ export class PivotTableEngine {
       column: mappedColumn
     });
   }
-  getRawCellType(_ref5) {
+  getRawCellType(_ref6) {
     let {
       row,
       column
-    } = _ref5;
+    } = _ref6;
     const isRowTotal = this.doRowTotals && column === this.dataWidth - 1;
     const isColumnTotal = this.doColumnTotals && row === this.dataHeight - 1;
     if (isRowTotal || isColumnTotal) {
@@ -290,11 +312,11 @@ export class PivotTableEngine {
     }
     return CELL_TYPE_VALUE;
   }
-  getCellType(_ref6) {
+  getCellType(_ref7) {
     let {
       row,
       column
-    } = _ref6;
+    } = _ref7;
     row = this.rowMap[row];
     column = this.columnMap[column];
     return this.getRawCellType({
@@ -324,29 +346,26 @@ export class PivotTableEngine {
       return i18n.t(this.dimensionLookup.rows[rowLevel].meta.name);
     }
   }
-  getCellDxDimension(_ref7) {
+  getCellDxDimension(_ref8) {
     let {
       row,
       column
-    } = _ref7;
+    } = _ref8;
     return this.getRawCellDxDimension({
       row: this.rowMap[row],
       column: this.columnMap[column]
     });
   }
-  getRawCellDxDimension(_ref8) {
+  getRawCellDxDimension(_ref9) {
     let {
       row,
       column
-    } = _ref8;
+    } = _ref9;
     if (!this.data[row]) {
       return undefined;
     }
     const cellValue = this.data[row][column];
-    if (!cellValue) {
-      return undefined;
-    }
-    if (!Array.isArray(cellValue)) {
+    if (cellValue && !Array.isArray(cellValue)) {
       // This is a total cell
       return {
         valueType: cellValue.valueType,
@@ -373,6 +392,11 @@ export class PivotTableEngine {
       };
     }
 
+    // Empty cell
+    // The cell still needs to get the valueType to render correctly 0 and cumulative values
+    //
+    // OR
+    //
     // Data is in Filter
     // TODO : This assumes the server ignores text types, we should confirm this is the case
     return {
@@ -384,7 +408,7 @@ export class PivotTableEngine {
     return !this.data[row] || this.data[row].length === 0;
   }
   columnIsEmpty(column) {
-    return !this.adaptiveClippingController.columns.sizes[column];
+    return !this.rowMap.some(row => this.data[row][column]);
   }
   getRawColumnHeader(column) {
     if (this.doRowTotals && column === this.dataWidth - 1) {
@@ -430,12 +454,12 @@ export class PivotTableEngine {
   getRowHeader(row) {
     return this.getRawRowHeader(this.rowMap[row]);
   }
-  getDependantTotalCells(_ref9) {
+  getDependantTotalCells(_ref10) {
     var _this$dimensionLookup, _this$dimensionLookup2;
     let {
       row,
       column
-    } = _ref9;
+    } = _ref10;
     const rowSubtotalSize = ((_this$dimensionLookup = this.dimensionLookup.columns[0]) === null || _this$dimensionLookup === void 0 ? void 0 : _this$dimensionLookup.size) + 1;
     const rowSubtotal = rowSubtotalSize && this.doRowSubtotals && {
       row,
@@ -610,11 +634,11 @@ export class PivotTableEngine {
       }
     }
   }
-  finalizeTotal(_ref10) {
+  finalizeTotal(_ref11) {
     let {
       row,
       column
-    } = _ref10;
+    } = _ref11;
     if (!this.data[row]) {
       return;
     }
@@ -710,6 +734,40 @@ export class PivotTableEngine {
   resetColumnMap() {
     this.columnMap = this.options.hideEmptyColumns ? times(this.dataWidth, n => n).filter(idx => !this.columnIsEmpty(idx)) : times(this.dataWidth, n => n);
   }
+  resetAccumulators() {
+    if (this.options.cumulativeValues) {
+      this.rowMap.forEach(row => {
+        this.accumulators.rows[row] = {};
+        this.columnMap.reduce((acc, column) => {
+          const cellType = this.getRawCellType({
+            row,
+            column
+          });
+          const dxDimension = this.getRawCellDxDimension({
+            row,
+            column
+          });
+          const valueType = (dxDimension === null || dxDimension === void 0 ? void 0 : dxDimension.valueType) || VALUE_TYPE_TEXT;
+
+          // only accumulate numeric values
+          // accumulating text values does not make sense
+          if (valueType === VALUE_TYPE_NUMBER) {
+            if (this.data[row] && this.data[row][column]) {
+              const dataRow = this.data[row][column];
+              const rawValue = cellType === CELL_TYPE_VALUE ? dataRow[this.dimensionLookup.dataHeaders.value] : dataRow.value;
+              acc += parseValue(rawValue);
+            }
+            this.accumulators.rows[row][column] = acc;
+          }
+          return acc;
+        }, 0);
+      });
+    } else {
+      this.accumulators = {
+        rows: {}
+      };
+    }
+  }
   get cellPadding() {
     switch (this.visualization.displayDensity) {
       case DISPLAY_DENSITY_OPTION_COMPACT:
@@ -780,14 +838,18 @@ export class PivotTableEngine {
       }
     });
     this.finalizeTotals();
-    this.rawData.rows.forEach(dataRow => {
-      const pos = lookup(dataRow, this.dimensionLookup, this);
-      if (pos) {
-        this.adaptiveClippingController.add(pos, this.getRaw(pos).renderedValue);
-      }
-    });
     this.resetRowMap();
     this.resetColumnMap();
+    this.resetAccumulators();
+    this.rowMap.forEach(row => {
+      this.columnMap.forEach(column => {
+        const pos = {
+          row,
+          column
+        };
+        this.adaptiveClippingController.add(pos, this.getRaw(pos).renderedValue);
+      });
+    });
     this.height = this.rowMap.length;
     this.width = this.columnMap.length;
     this.adaptiveClippingController.finalize();