@dhis2/analytics 24.10.1 → 25.0.0

package/build/cjs/modules/__tests__/expressions.spec.js

@@ -0,0 +1,139 @@
+"use strict";
+
+var _expressions = require("../expressions.js");
+
+const invalidTestExpressions = [{
+  message: 'Formula is empty. Add items to the formula from the lists on the left.',
+  expressions: ['']
+}, // {
+//     message: 'Consecutive math operators',
+//     expressions: ['5+-', '5+++', '4+9-*', '5++9'],
+// },
+{
+  message: 'Consecutive data elements',
+  expressions: ['#{cYeuwXTCPkU}#{Jtf34kNZhzP}']
+}, {
+  message: 'Starts or ends with a math operator',
+  expressions: ['+', '+1', '1-2/', '*((#{cYeuwXTCPkU}*#{Jtf34kNZhzP})))']
+}, {
+  message: 'Empty parentheses',
+  expressions: ['#{cYeuwXTCPkU}*()']
+}, {
+  message: 'Missing left parenthesis (',
+  expressions: [')', '5)', '((#{cYeuwXTCPkU}*#{P3jJH5Tu5VC.S34ULMcHMca})))']
+}, {
+  message: 'Missing right parenthesis )',
+  expressions: ['(', '(5', '((#{cYeuwXTCPkU}*#{Jtf34kNZhzP})']
+}];
+const validTestExpressions = ['5+9', '((#{cYeuwXTCPkU}*#{Jtf34kNZhzP}))#{iKGjnOOaPlE}', '#{P3jJH5Tu5VC.S34ULMcHMca}*#{Jtf34kNZhzP}', '(5)+9', '(5+9)', '10/-5'];
+describe('validateExpression', () => {
+  invalidTestExpressions.forEach(_ref => {
+    let {
+      expressions,
+      message
+    } = _ref;
+    expressions.forEach(exp => {
+      test("Fails: ".concat(message), () => {
+        expect((0, _expressions.validateExpression)(exp)).toEqual({
+          status: _expressions.INVALID_EXPRESSION,
+          message
+        });
+      });
+    });
+  });
+  validTestExpressions.forEach(exp => {
+    test("Passes validation: ".concat(exp), () => {
+      expect((0, _expressions.validateExpression)(exp)).toEqual(undefined);
+    });
+  });
+});
+describe('parseArrayToExpression', () => {
+  test('exp 1', () => {
+    const expressionArray = [{
+      label: 'abc123',
+      value: '#{abc123}',
+      type: _expressions.EXPRESSION_TYPE_DATA
+    }, {
+      label: '+',
+      value: '+',
+      type: _expressions.EXPRESSION_TYPE_OPERATOR
+    }, {
+      label: 'def456.xyz999',
+      value: '#{def456.xyz999}',
+      type: _expressions.EXPRESSION_TYPE_DATA
+    }, {
+      label: '/',
+      value: '/',
+      type: _expressions.EXPRESSION_TYPE_OPERATOR
+    }, {
+      label: '10',
+      value: '10',
+      type: _expressions.EXPRESSION_TYPE_NUMBER
+    }];
+    const expected = '#{abc123}+#{def456.xyz999}/10';
+    expect((0, _expressions.parseArrayToExpression)(expressionArray)).toEqual(expected);
+  });
+});
+describe('parseExpressionToArray', () => {
+  test('exp 1', () => {
+    const expression = '#{abc123}/10*99';
+    const expected = [{
+      label: 'abc123',
+      value: '#{abc123}',
+      type: _expressions.EXPRESSION_TYPE_DATA
+    }, {
+      label: '/',
+      value: '/',
+      type: _expressions.EXPRESSION_TYPE_OPERATOR
+    }, {
+      label: '10',
+      value: '10',
+      type: _expressions.EXPRESSION_TYPE_NUMBER
+    }, {
+      label: '×',
+      value: '*',
+      type: _expressions.EXPRESSION_TYPE_OPERATOR
+    }, {
+      label: '99',
+      value: '99',
+      type: _expressions.EXPRESSION_TYPE_NUMBER
+    }];
+    expect((0, _expressions.parseExpressionToArray)(expression)).toEqual(expected);
+  });
+});
+describe('getItemIdsFromExpression', () => {
+  test('exp 1', () => {
+    const expression = '#{abc123}/10*99';
+    const expected = ['abc123'];
+    expect((0, _expressions.getItemIdsFromExpression)(expression)).toEqual(expected);
+  });
+  test('exp 2', () => {
+    const expression = '#{abc123}/10*#{def456}';
+    const expected = ['abc123', 'def456'];
+    expect((0, _expressions.getItemIdsFromExpression)(expression)).toEqual(expected);
+  });
+  test('exp 3', () => {
+    const expression = '#{abc123}/10*#{def456.xyz999}';
+    const expected = ['abc123', 'def456.xyz999'];
+    expect((0, _expressions.getItemIdsFromExpression)(expression)).toEqual(expected);
+  });
+  test('exp 4', () => {
+    const expression = '#{abc123}/10*#{def456.xyz999}+#{ghi789}';
+    const expected = ['abc123', 'def456.xyz999', 'ghi789'];
+    expect((0, _expressions.getItemIdsFromExpression)(expression)).toEqual(expected);
+  });
+  test('exp 5', () => {
+    const expression = '#{abc123}/10*#{def456.xyz999}+#{ghi789}+#{jkl000}';
+    const expected = ['abc123', 'def456.xyz999', 'ghi789', 'jkl000'];
+    expect((0, _expressions.getItemIdsFromExpression)(expression)).toEqual(expected);
+  });
+  test('exp 6', () => {
+    const expression = '5/10';
+    const expected = [];
+    expect((0, _expressions.getItemIdsFromExpression)(expression)).toEqual(expected);
+  });
+  test('exp 6', () => {
+    const expected = [];
+    expect((0, _expressions.getItemIdsFromExpression)()).toEqual(expected);
+  });
+});

package/build/cjs/modules/__tests__/hash.spec.js

@@ -0,0 +1,92 @@
+"use strict";
+
+var _dataTypes = require("../dataTypes.js");
+
+var _hash = require("../hash.js");
+
+describe('getHash', () => {
+  const textInput = 'Raymond Luxury Yacht';
+  it('accepts a string and returns a hash', () => {
+    const hash = (0, _hash.getHash)(textInput);
+    expect(typeof hash).toBe('string');
+    expect(hash).not.toBe(textInput);
+  });
+  it('is deterministic', () => {
+    expect((0, _hash.getHash)(textInput)).toBe((0, _hash.getHash)(textInput));
+  });
+  it('returns undefined for invalid input', () => {
+    const unsupportedTypes = ['', 1, true, null, undefined, {}, []];
+    unsupportedTypes.forEach(type => expect((0, _hash.getHash)(type)).toBe(undefined));
+  });
+});
+describe('getExpressionHashFromVisualization', () => {
+  const edi1 = {
+    id: 'OdiHJayrsKo',
+    dimensionItemType: _dataTypes.DIMENSION_TYPE_EXPRESSION_DIMENSION_ITEM,
+    expression: '#{abc} * 10'
+  };
+  const edi2 = {
+    id: 'Uvn6LCg7dVU',
+    dimensionItemType: _dataTypes.DIMENSION_TYPE_EXPRESSION_DIMENSION_ITEM,
+    expression: '#{abc} * 20'
+  };
+  const dxWithEdi = {
+    dimension: 'dx',
+    items: [edi1, edi2]
+  };
+  it('generates a hash (columns)', () => {
+    expect(typeof (0, _hash.getExpressionHashFromVisualization)({
+      columns: [dxWithEdi],
+      rows: [],
+      filters: []
+    })).toBe('string');
+  });
+  it('generates a hash (rows)', () => {
+    expect(typeof (0, _hash.getExpressionHashFromVisualization)({
+      columns: [],
+      rows: [dxWithEdi],
+      filters: []
+    })).toBe('string');
+  });
+  it('generates a hash (filters)', () => {
+    expect(typeof (0, _hash.getExpressionHashFromVisualization)({
+      columns: [],
+      rows: [],
+      filters: [dxWithEdi]
+    })).toBe('string');
+  });
+  it('does not generate a hash when there are no dimensions', () => {
+    expect((0, _hash.getExpressionHashFromVisualization)({
+      columns: [],
+      rows: [],
+      filters: []
+    })).toBe(undefined);
+  });
+  it('does not generate a hash when there are no EDI dimensions', () => {
+    expect((0, _hash.getExpressionHashFromVisualization)({
+      columns: [{
+        id: 'OdiHJayrsKo',
+        dimensionItemType: 'INDICATOR'
+      }],
+      rows: [],
+      filters: []
+    })).toBe(undefined);
+  });
+  it('sorts the edi objects by id before generating the hash to optimize caching', () => {
+    expect((0, _hash.getExpressionHashFromVisualization)({
+      columns: [{
+        dimension: 'dx',
+        items: [edi1, edi2]
+      }],
+      rows: [],
+      filters: []
+    })).toBe((0, _hash.getExpressionHashFromVisualization)({
+      columns: [{
+        dimension: 'dx',
+        items: [edi2, edi1]
+      }],
+      rows: [],
+      filters: []
+    }));
+  });
+});

package/build/cjs/modules/__tests__/parseExpression.spec.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _expressions = require("../expressions.js");
+
+test('matches numbers and operators', () => {
+  expect((0, _expressions.parseExpression)('1+2-3*4/5')).toEqual(['1', '+', '2', '-', '3', '*', '4', '/', '5']);
+});
+test('matches #{} with letters, numbers and operators', () => {
+  expect((0, _expressions.parseExpression)('#{abc123}+100-200*300/400')).toEqual(['#{abc123}', '+', '100', '-', '200', '*', '300', '/', '400']);
+});
+test('matches numbers and operators with brackets', () => {
+  expect((0, _expressions.parseExpression)('1+(2-3)*4/5')).toEqual(['1', '+', '(', '2', '-', '3', ')', '*', '4', '/', '5']);
+});
+test('matches #{} with letters, numbers and operators with brackets', () => {
+  expect((0, _expressions.parseExpression)('(100-200)+#{abc123}*300/400')).toEqual(['(', '100', '-', '200', ')', '+', '#{abc123}', '*', '300', '/', '400']);
+});
+test('matches #{} with numbers and operators with brackets', () => {
+  expect((0, _expressions.parseExpression)('#{123}+(10-200)*3000/40000')).toEqual(['#{123}', '+', '(', '10', '-', '200', ')', '*', '3000', '/', '40000']);
+});
+test('matches #{} with letters and numbers only', () => {
+  expect((0, _expressions.parseExpression)('#{abc123}')).toEqual(['#{abc123}']);
+});
+test('matches #{} with numbers only', () => {
+  expect((0, _expressions.parseExpression)('#{123}')).toEqual(['#{123}']);
+});
+test('matches #{} with letters only', () => {
+  expect((0, _expressions.parseExpression)('#{abc}')).toEqual(['#{abc}']);
+});
+test('matches #{} with no input', () => {
+  expect((0, _expressions.parseExpression)('')).toEqual([]);
+});
+test('matches multiple #{} with operators', () => {
+  expect((0, _expressions.parseExpression)('#{abc123}+#{def456}')).toEqual(['#{abc123}', '+', '#{def456}']);
+});
+test('matches multiple #{} containing dots with operators', () => {
+  expect((0, _expressions.parseExpression)('#{abc123.xyz999}+#{def456.xyz999}')).toEqual(['#{abc123.xyz999}', '+', '#{def456.xyz999}']);
+});
+test('matches multiple #{} with operators with brackets', () => {
+  expect((0, _expressions.parseExpression)('(#{abc123}/#{def456})*#{ghi789}')).toEqual(['(', '#{abc123}', '/', '#{def456}', ')', '*', '#{ghi789}']);
+});
+test('matches on decimal numbers', () => {
+  expect((0, _expressions.parseExpression)('#{abc123}*1.2/#{def456}')).toEqual(['#{abc123}', '*', '1.2', '/', '#{def456}']);
+});
+test('matches on decimal numbers with #{} containing dots', () => {
+  expect((0, _expressions.parseExpression)('1.2+#{abc123.xyz999}')).toEqual(['1.2', '+', '#{abc123.xyz999}']);
+});

package/build/cjs/modules/dataTypes.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.dataTypeMap = exports.TOTALS = exports.SUB_GROUP_METRIC = exports.SUB_GROUP_DETAIL = exports.DIMENSION_TYPE_PROGRAM_INDICATOR = exports.DIMENSION_TYPE_PROGRAM_DATA_ELEMENT = exports.DIMENSION_TYPE_PROGRAM_ATTRIBUTE = exports.DIMENSION_TYPE_PERIOD = exports.DIMENSION_TYPE_ORGANISATION_UNIT_GROUP_SET = exports.DIMENSION_TYPE_ORGANISATION_UNIT = exports.DIMENSION_TYPE_INDICATOR = exports.DIMENSION_TYPE_EVENT_DATA_ITEM = exports.DIMENSION_TYPE_DATA_SET = exports.DIMENSION_TYPE_DATA_ELEMENT_OPERAND = exports.DIMENSION_TYPE_DATA_ELEMENT_GROUP_SET = exports.DIMENSION_TYPE_DATA_ELEMENT = exports.DIMENSION_TYPE_DATA = exports.DIMENSION_TYPE_CATEGORY_OPTION_GROUP_SET = exports.DIMENSION_TYPE_CATEGORY = exports.DIMENSION_TYPE_ALL = exports.DETAIL = exports.DEFAULT_DATATYPE_ID = void 0;
+exports.dataTypeMap = exports.TOTALS = exports.SUB_GROUP_METRIC = exports.SUB_GROUP_DETAIL = exports.DIMENSION_TYPE_PROGRAM_INDICATOR = exports.DIMENSION_TYPE_PROGRAM_DATA_ELEMENT = exports.DIMENSION_TYPE_PROGRAM_ATTRIBUTE = exports.DIMENSION_TYPE_PERIOD = exports.DIMENSION_TYPE_ORGANISATION_UNIT_GROUP_SET = exports.DIMENSION_TYPE_ORGANISATION_UNIT = exports.DIMENSION_TYPE_INDICATOR = exports.DIMENSION_TYPE_EXPRESSION_DIMENSION_ITEM = exports.DIMENSION_TYPE_EVENT_DATA_ITEM = exports.DIMENSION_TYPE_DATA_SET = exports.DIMENSION_TYPE_DATA_ELEMENT_OPERAND = exports.DIMENSION_TYPE_DATA_ELEMENT_GROUP_SET = exports.DIMENSION_TYPE_DATA_ELEMENT = exports.DIMENSION_TYPE_DATA = exports.DIMENSION_TYPE_CATEGORY_OPTION_GROUP_SET = exports.DIMENSION_TYPE_CATEGORY = exports.DIMENSION_TYPE_ALL = exports.DETAIL = exports.DEFAULT_DATATYPE_ID = void 0;
 exports.defaultGroupDetail = defaultGroupDetail;
 exports.defaultGroupId = defaultGroupId;
 
@@ -43,6 +43,8 @@ const DIMENSION_TYPE_ORGANISATION_UNIT = 'ORGANISATION_UNIT';
 exports.DIMENSION_TYPE_ORGANISATION_UNIT = DIMENSION_TYPE_ORGANISATION_UNIT;
 const DIMENSION_TYPE_ORGANISATION_UNIT_GROUP_SET = 'ORGANISATION_UNIT_GROUP_SET';
 exports.DIMENSION_TYPE_ORGANISATION_UNIT_GROUP_SET = DIMENSION_TYPE_ORGANISATION_UNIT_GROUP_SET;
+const DIMENSION_TYPE_EXPRESSION_DIMENSION_ITEM = 'EXPRESSION_DIMENSION_ITEM';
+exports.DIMENSION_TYPE_EXPRESSION_DIMENSION_ITEM = DIMENSION_TYPE_EXPRESSION_DIMENSION_ITEM;
 const TOTALS = 'totals';
 exports.TOTALS = TOTALS;
 const DETAIL = 'detail';
@@ -120,6 +122,11 @@ const dataTypeMap = {
     getItemName: () => _index.default.t('Program indicator'),
     getGroupEmptyLabel: () => _index.default.t('No programs found'),
     getGroupLoadingLabel: () => _index.default.t('Loading programs')
+  },
+  [DIMENSION_TYPE_EXPRESSION_DIMENSION_ITEM]: {
+    id: DIMENSION_TYPE_EXPRESSION_DIMENSION_ITEM,
+    getName: () => _index.default.t('Calculations'),
+    getItemName: () => _index.default.t('Calculation')
   }
 };
 exports.dataTypeMap = dataTypeMap;

package/build/cjs/modules/dimensionListItem.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTooltipText = exports.getIcon = void 0;
+
+var _ui = require("@dhis2/ui");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _DataElementIcon = _interopRequireDefault(require("../assets/DimensionItemIcons/DataElementIcon.js"));
+
+var _GenericIcon = _interopRequireDefault(require("../assets/DimensionItemIcons/GenericIcon.js"));
+
+var _CalculationIcon = _interopRequireDefault(require("./../assets/DimensionItemIcons/CalculationIcon.js"));
+
+var _dataSets = require("./dataSets.js");
+
+var _dataTypes = require("./dataTypes.js");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const getTooltipText = _ref => {
+  var _dataTypes$type;
+
+  let {
+    type,
+    expression
+  } = _ref;
+
+  if (type === _dataTypes.DIMENSION_TYPE_EXPRESSION_DIMENSION_ITEM && expression) {
+    return _dataTypes.dataTypeMap[_dataTypes.DIMENSION_TYPE_EXPRESSION_DIMENSION_ITEM].getItemName();
+  }
+
+  switch (type) {
+    case _dataTypes.DIMENSION_TYPE_DATA_ELEMENT_OPERAND:
+      return _dataTypes.dataTypeMap[_dataTypes.DIMENSION_TYPE_DATA_ELEMENT].getItemName();
+
+    case _dataSets.REPORTING_RATE:
+      return _dataTypes.dataTypeMap[_dataTypes.DIMENSION_TYPE_DATA_SET].getItemName();
+
+    case _dataTypes.DIMENSION_TYPE_PROGRAM_DATA_ELEMENT:
+    case _dataTypes.DIMENSION_TYPE_PROGRAM_ATTRIBUTE:
+      return _dataTypes.dataTypeMap[_dataTypes.DIMENSION_TYPE_EVENT_DATA_ITEM].getItemName();
+
+    default:
+      return (_dataTypes$type = _dataTypes.dataTypeMap[type]) === null || _dataTypes$type === void 0 ? void 0 : _dataTypes$type.getItemName();
+  }
+};
+
+exports.getTooltipText = getTooltipText;
+
+const getIcon = type => {
+  switch (type) {
+    case _dataTypes.DIMENSION_TYPE_INDICATOR:
+      return /*#__PURE__*/_react.default.createElement(_ui.IconDimensionIndicator16, null);
+
+    case _dataTypes.DIMENSION_TYPE_DATA_ELEMENT_OPERAND:
+    case _dataTypes.DIMENSION_TYPE_DATA_ELEMENT:
+      return _DataElementIcon.default;
+
+    case _dataSets.REPORTING_RATE:
+      return /*#__PURE__*/_react.default.createElement(_ui.IconDimensionDataSet16, null);
+
+    case _dataTypes.DIMENSION_TYPE_EVENT_DATA_ITEM:
+    case _dataTypes.DIMENSION_TYPE_PROGRAM_DATA_ELEMENT:
+    case _dataTypes.DIMENSION_TYPE_PROGRAM_ATTRIBUTE:
+      return /*#__PURE__*/_react.default.createElement(_ui.IconDimensionEventDataItem16, null);
+
+    case _dataTypes.DIMENSION_TYPE_PROGRAM_INDICATOR:
+      return /*#__PURE__*/_react.default.createElement(_ui.IconDimensionProgramIndicator16, null);
+
+    case _dataTypes.DIMENSION_TYPE_EXPRESSION_DIMENSION_ITEM:
+      return _CalculationIcon.default;
+
+    default:
+      return _GenericIcon.default;
+  }
+};
+
+exports.getIcon = getIcon;

package/build/cjs/modules/expressions.js

@@ -0,0 +1,164 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateExpression = exports.parseExpressionToArray = exports.parseExpression = exports.parseArrayToExpression = exports.getOperators = exports.getItemIdsFromExpression = exports.VALID_EXPRESSION = exports.INVALID_EXPRESSION = exports.EXPRESSION_TYPE_OPERATOR = exports.EXPRESSION_TYPE_NUMBER = exports.EXPRESSION_TYPE_DATA = void 0;
+
+var _index = _interopRequireDefault(require("../locales/index.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const EXPRESSION_TYPE_NUMBER = 'EXPRESSION_TYPE_NUMBER';
+exports.EXPRESSION_TYPE_NUMBER = EXPRESSION_TYPE_NUMBER;
+const EXPRESSION_TYPE_OPERATOR = 'EXPRESSION_TYPE_OPERATOR';
+exports.EXPRESSION_TYPE_OPERATOR = EXPRESSION_TYPE_OPERATOR;
+const EXPRESSION_TYPE_DATA = 'EXPRESSION_TYPE_DATA';
+exports.EXPRESSION_TYPE_DATA = EXPRESSION_TYPE_DATA;
+const VALID_EXPRESSION = 'OK';
+exports.VALID_EXPRESSION = VALID_EXPRESSION;
+const INVALID_EXPRESSION = 'ERROR';
+exports.INVALID_EXPRESSION = INVALID_EXPRESSION;
+
+const getOperators = () => [{
+  value: '+',
+  label: '+',
+  type: EXPRESSION_TYPE_OPERATOR
+}, {
+  value: '-',
+  label: '-',
+  type: EXPRESSION_TYPE_OPERATOR
+}, {
+  value: '*',
+  label: '×',
+  type: EXPRESSION_TYPE_OPERATOR
+}, {
+  value: '/',
+  label: '/',
+  type: EXPRESSION_TYPE_OPERATOR
+}, {
+  value: '(',
+  label: '(',
+  type: EXPRESSION_TYPE_OPERATOR
+}, {
+  value: ')',
+  label: ')',
+  type: EXPRESSION_TYPE_OPERATOR
+}, {
+  value: '',
+  label: _index.default.t('Number'),
+  type: EXPRESSION_TYPE_NUMBER
+}];
+
+exports.getOperators = getOperators;
+
+const parseExpression = input => {
+  const regex = /(#{[a-zA-Z0-9#.]+}|[+\-*/()])|(\d+(\.\d+)?)/g;
+  return input.match(regex) || [];
+};
+
+exports.parseExpression = parseExpression;
+
+const parseExpressionToArray = function () {
+  let expression = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  let metadata = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  return parseExpression(expression).map(value => {
+    if (value.startsWith('#{') && value.endsWith('}')) {
+      var _metadata$find;
+
+      const id = value.slice(2, -1);
+      const label = ((_metadata$find = metadata.find(item => item.id === id)) === null || _metadata$find === void 0 ? void 0 : _metadata$find.name) || id;
+      return {
+        value,
+        label,
+        type: EXPRESSION_TYPE_DATA
+      };
+    }
+
+    if (isNaN(value)) {
+      return {
+        value,
+        label: getOperators().find(op => op.value === value).label,
+        type: EXPRESSION_TYPE_OPERATOR
+      };
+    }
+
+    return {
+      value,
+      label: value,
+      type: EXPRESSION_TYPE_NUMBER
+    };
+  }) || [];
+};
+
+exports.parseExpressionToArray = parseExpressionToArray;
+
+const parseArrayToExpression = function () {
+  let input = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return input.map(item => item.value).join('');
+};
+
+exports.parseArrayToExpression = parseArrayToExpression;
+
+const validateExpression = expression => {
+  let result;
+  const leftParenthesisCount = expression.split('(').length - 1;
+  const rightParenthesisCount = expression.split(')').length - 1;
+
+  if (!expression) {
+    // empty formula
+    result = {
+      status: INVALID_EXPRESSION,
+      message: _index.default.t('Formula is empty. Add items to the formula from the lists on the left.')
+    }; // TODO: reimplement this but allow negative values, e.g. 10 / -5
+    // } else if (/[-+/*]{2,}/.test(expression)) {
+    //     // two math operators next to each other
+    //     result = {
+    //         status: INVALID_EXPRESSION,
+    //         message: i18n.t('Consecutive math operators'),
+    //     }
+  } else if (/}#/.test(expression)) {
+    // two data elements next to each other
+    result = {
+      status: INVALID_EXPRESSION,
+      message: _index.default.t('Consecutive data elements')
+    };
+  } else if (/^[+\-*/]|[+\-*/]$/.test(expression)) {
+    // starting or ending with a math operator
+    result = {
+      status: INVALID_EXPRESSION,
+      message: _index.default.t('Starts or ends with a math operator')
+    };
+  } else if (/\(\)/.test(expression)) {
+    // contains an empty set of parentheses
+    result = {
+      status: INVALID_EXPRESSION,
+      message: _index.default.t('Empty parentheses')
+    };
+  } else if (leftParenthesisCount > rightParenthesisCount) {
+    // ( but no )
+    result = {
+      status: INVALID_EXPRESSION,
+      message: _index.default.t('Missing right parenthesis )')
+    };
+  } else if (rightParenthesisCount > leftParenthesisCount) {
+    // ) but no (
+    result = {
+      status: INVALID_EXPRESSION,
+      message: _index.default.t('Missing left parenthesis (')
+    };
+  }
+
+  return result;
+};
+
+exports.validateExpression = validateExpression;
+
+const getItemIdsFromExpression = function () {
+  let expression = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  const regex = /#{([a-zA-Z0-9#]+.*?)}/g;
+  const matches = expression.match(regex);
+  return matches ? matches.map(match => match.slice(2, -1)) : [];
+};
+
+exports.getItemIdsFromExpression = getItemIdsFromExpression;

package/build/cjs/modules/hash.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getHash = exports.getExpressionHashFromVisualization = void 0;
+
+var _sha = _interopRequireDefault(require("crypto-js/sha1"));
+
+var _dataTypes = require("./dataTypes.js");
+
+var _layoutGetAllItems2 = require("./layout/layoutGetAllItems.js");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const isValidValue = value => typeof value === 'string' && value.length;
+
+const getHash = value => isValidValue(value) ? (0, _sha.default)(value).toString() : undefined;
+
+exports.getHash = getHash;
+
+const getExpressionHashFromVisualization = visualization => {
+  var _layoutGetAllItems;
+
+  return getHash((_layoutGetAllItems = (0, _layoutGetAllItems2.layoutGetAllItems)(visualization)) === null || _layoutGetAllItems === void 0 ? void 0 : _layoutGetAllItems.filter(item => item.dimensionItemType === _dataTypes.DIMENSION_TYPE_EXPRESSION_DIMENSION_ITEM && isValidValue(item.expression)).sort((i1, i2) => i1.id < i2.id ? -1 : i1.id > i2.id ? 1 : 0).map(edi => edi.expression).join(''));
+};
+
+exports.getExpressionHashFromVisualization = getExpressionHashFromVisualization;