@sis-cc/dotstatsuite-components 15.0.20 → 16.0.0

package/lib/rules2/src/index.js

@@ -115,56 +115,224 @@ Object.defineProperty(exports, 'getMetadataCoordinates', {
   }
 });
 
-var _getAdvancedAttributes = require('./getAdvancedAttributes');
+var _duplicateObservations = require('./duplicateObservations');
 
-Object.defineProperty(exports, 'getDataflowAdvancedAttributes', {
+Object.defineProperty(exports, 'duplicateObs', {
   enumerable: true,
   get: function get() {
-    return _getAdvancedAttributes.getDataflowAdvancedAttributes;
+    return _duplicateObservations.duplicateObs;
   }
 });
-Object.defineProperty(exports, 'getObservationsAdvancedAttributes', {
+Object.defineProperty(exports, 'hierarchiseDimensionWithAdvancedHierarchy', {
   enumerable: true,
   get: function get() {
-    return _getAdvancedAttributes.getObservationsAdvancedAttributes;
+    return _hierarchiseDimensionWithAdvancedHierarchy.hierarchiseDimensionWithAdvancedHierarchy;
   }
 });
-Object.defineProperty(exports, 'getSeriesAdvancedAttributes', {
+
+var _hierarchiseDimensionWithNativeHierarchy = require('./hierarchiseDimensionWithNativeHierarchy');
+
+Object.defineProperty(exports, 'hierarchiseDimensionWithNativeHierarchy', {
   enumerable: true,
   get: function get() {
-    return _getAdvancedAttributes.getSeriesAdvancedAttributes;
+    return _hierarchiseDimensionWithNativeHierarchy.hierarchiseDimensionWithNativeHierarchy;
   }
 });
 
-var _duplicateObservations = require('./duplicateObservations');
+var _getDimensionValuesIndexes = require('./getDimensionValuesIndexes');
 
-Object.defineProperty(exports, 'duplicateObs', {
+Object.defineProperty(exports, 'getDimensionValuesIndexes', {
   enumerable: true,
   get: function get() {
-    return _duplicateObservations.duplicateObs;
+    return _getDimensionValuesIndexes.getDimensionValuesIndexes;
   }
 });
-Object.defineProperty(exports, 'hierarchiseDimensionWithAdvancedHierarchy', {
+
+var _getCombinationDefinitions = require('./getCombinationDefinitions');
+
+Object.defineProperty(exports, 'getCombinationDefinitions', {
   enumerable: true,
   get: function get() {
-    return _hierarchiseDimensionWithAdvancedHierarchy.hierarchiseDimensionWithAdvancedHierarchy;
+    return _getCombinationDefinitions.getCombinationDefinitions;
   }
 });
 
-var _hierarchiseDimensionWithNativeHierarchy = require('./hierarchiseDimensionWithNativeHierarchy');
+var _parseAttributes = require('./parseAttributes');
 
-Object.defineProperty(exports, 'hierarchiseDimensionWithNativeHierarchy', {
+Object.defineProperty(exports, 'parseAttributes', {
   enumerable: true,
   get: function get() {
-    return _hierarchiseDimensionWithNativeHierarchy.hierarchiseDimensionWithNativeHierarchy;
+    return _parseAttributes.parseAttributes;
   }
 });
 
-var _getDimensionValuesIndexes = require('./getDimensionValuesIndexes');
+var _parseCombinations = require('./parseCombinations');
 
-Object.defineProperty(exports, 'getDimensionValuesIndexes', {
+Object.defineProperty(exports, 'parseCombinations', {
   enumerable: true,
   get: function get() {
-    return _getDimensionValuesIndexes.getDimensionValuesIndexes;
+    return _parseCombinations.parseCombinations;
+  }
+});
+
+var _refineAttributes = require('./refineAttributes');
+
+Object.defineProperty(exports, 'refineAttributes', {
+  enumerable: true,
+  get: function get() {
+    return _refineAttributes.refineAttributes;
+  }
+});
+
+var _enhanceObservations = require('./enhanceObservations');
+
+Object.defineProperty(exports, 'enhanceObservations', {
+  enumerable: true,
+  get: function get() {
+    return _enhanceObservations.enhanceObservations;
+  }
+});
+
+var _getAttributesSeries = require('./getAttributesSeries');
+
+Object.defineProperty(exports, 'getAttributesSeries', {
+  enumerable: true,
+  get: function get() {
+    return _getAttributesSeries.getAttributesSeries;
+  }
+});
+
+var _getManyValuesDimensions = require('./getManyValuesDimensions');
+
+Object.defineProperty(exports, 'getManyValuesDimensions', {
+  enumerable: true,
+  get: function get() {
+    return _getManyValuesDimensions.getManyValuesDimensions;
+  }
+});
+
+var _getOneValueDimensions = require('./getOneValueDimensions');
+
+Object.defineProperty(exports, 'getOneValueDimensions', {
+  enumerable: true,
+  get: function get() {
+    return _getOneValueDimensions.getOneValueDimensions;
+  }
+});
+
+var _getHeaderSubtitle = require('./getHeaderSubtitle');
+
+Object.defineProperty(exports, 'getHeaderSubtitle', {
+  enumerable: true,
+  get: function get() {
+    return _getHeaderSubtitle.getHeaderSubtitle;
+  }
+});
+
+var _getHeaderCombinations = require('./getHeaderCombinations');
+
+Object.defineProperty(exports, 'getHeaderCombinations', {
+  enumerable: true,
+  get: function get() {
+    return _getHeaderCombinations.getHeaderCombinations;
+  }
+});
+
+var _getLayout = require('./table/getLayout');
+
+Object.defineProperty(exports, 'getLayout', {
+  enumerable: true,
+  get: function get() {
+    return _getLayout.getLayout;
+  }
+});
+
+var _getSortedLayoutIndexes = require('./table/getSortedLayoutIndexes');
+
+Object.defineProperty(exports, 'getSortedLayoutIndexes', {
+  enumerable: true,
+  get: function get() {
+    return _getSortedLayoutIndexes.getSortedLayoutIndexes;
+  }
+});
+
+var _refineLayoutSize = require('./table/refineLayoutSize');
+
+Object.defineProperty(exports, 'refineLayoutSize', {
+  enumerable: true,
+  get: function get() {
+    return _refineLayoutSize.refineLayoutSize;
+  }
+});
+
+var _getFlagsAndNotes = require('./table/getFlagsAndNotes');
+
+Object.defineProperty(exports, 'getFlagsAndNotes', {
+  enumerable: true,
+  get: function get() {
+    return _getFlagsAndNotes.getFlagsAndNotes;
+  }
+});
+
+var _getLayoutData = require('./table/getLayoutData');
+
+Object.defineProperty(exports, 'getLayoutData', {
+  enumerable: true,
+  get: function get() {
+    return _getLayoutData.getLayoutData;
+  }
+});
+
+var _getCellsAttributesIds = require('./table/getCellsAttributesIds');
+
+Object.defineProperty(exports, 'getCellsAttributesIds', {
+  enumerable: true,
+  get: function get() {
+    return _getCellsAttributesIds.getCellsAttributesIds;
+  }
+});
+
+var _getIndexedCombinationsByDisplay = require('./table/getIndexedCombinationsByDisplay');
+
+Object.defineProperty(exports, 'getIndexedCombinationsByDisplay', {
+  enumerable: true,
+  get: function get() {
+    return _getIndexedCombinationsByDisplay.getIndexedCombinationsByDisplay;
+  }
+});
+
+var _getCells = require('./table/getCells');
+
+Object.defineProperty(exports, 'getCells', {
+  enumerable: true,
+  get: function get() {
+    return _getCells.getCells;
+  }
+});
+
+var _getCuratedCells = require('./table/getCuratedCells');
+
+Object.defineProperty(exports, 'getCuratedCells', {
+  enumerable: true,
+  get: function get() {
+    return _getCuratedCells.getCuratedCells;
+  }
+});
+
+var _prepareData = require('./prepareData');
+
+Object.defineProperty(exports, 'prepareData', {
+  enumerable: true,
+  get: function get() {
+    return _prepareData.prepareData;
+  }
+});
+
+var _getTableProps = require('./table/getTableProps');
+
+Object.defineProperty(exports, 'getTableProps', {
+  enumerable: true,
+  get: function get() {
+    return _getTableProps.getTableProps;
   }
 });

package/lib/rules2/src/parseAttributes.js

@@ -0,0 +1,50 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseAttributes = undefined;
+
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+var _constants = require('./constants');
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var parseAttributes = exports.parseAttributes = function parseAttributes(attributes, dimensions, customAttributes) {
+  var indexedDimensions = R.indexBy(R.prop('id'), dimensions);
+  return R.addIndex(R.map)(function (attr, index) {
+    var res = R.assoc('index', index, attr);
+    if (R.isEmpty(attr.values || []) || !R.propOr(true, 'display', attr) || attr.id === _constants.REPORTING_YEAR_START_DAY || attr.id === _constants.REPYEARSTART) {
+      return R.assoc('display', false, res);
+    }
+    if (R.propEq('id', customAttributes.prefscale, attr)) {
+      return R.assoc('prefscale', true, res);
+    }
+    if (R.propEq('id', customAttributes.decimals, attr)) {
+      return R.assoc('decimals', true, res);
+    }
+    if (R.hasPath(['relationship', 'none'], attr) || R.hasPath(['relationship', 'dataflow'], attr)) {
+      return (0, _extends3.default)({}, res, { header: true, relationship: [] });
+    }
+    if (R.hasPath(['relationship', 'primaryMeasure'], attr) || R.hasPath(['relationship', 'observation'], attr)) {
+      return (0, _extends3.default)({}, res, { series: true, relationship: [] });
+    }
+    var seriesDimensions = R.pipe(R.pathOr([], ['relationship', 'dimensions']), R.filter(function (id) {
+      var values = R.path([id, 'values'], indexedDimensions);
+      return R.length(values) > 1;
+    }))(attr);
+    if (R.length(seriesDimensions) > 0) {
+      return (0, _extends3.default)({}, res, { series: true, relationship: seriesDimensions });
+    }
+    return (0, _extends3.default)({}, res, { header: true, relationship: R.prop('dimensions', attr.relationship || []) });
+  }, attributes);
+};

package/lib/rules2/src/parseCombinations.js

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseCombinations = undefined;
+
+var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
+
+var _defineProperty3 = _interopRequireDefault(_defineProperty2);
+
+var _extends3 = require('babel-runtime/helpers/extends');
+
+var _extends4 = _interopRequireDefault(_extends3);
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var parseCombinations = exports.parseCombinations = function parseCombinations(combinations, parsedAttributes, dimensions) {
+  var indexedDimensions = R.indexBy(R.prop('id'), dimensions);
+  var indexedAttributes = R.indexBy(R.prop('id'), parsedAttributes);
+
+  return R.map(function (comb) {
+    var relationship = [];
+    var ids = {};
+    var seriesConcepts = R.filter(function (concept) {
+      if (R.has(concept, ids)) {
+        return false;
+      }
+      if (R.has(concept, indexedDimensions)) {
+        var values = R.path([concept, 'values'], indexedDimensions);
+        relationship = R.length(values) > 1 ? R.append(concept, relationship) : relationship;
+        ids = (0, _extends4.default)({}, ids, (0, _defineProperty3.default)({}, concept, concept));
+        return R.length(values) > 1;
+      }
+      var attribute = R.prop(concept, indexedAttributes);
+      relationship = attribute.series ? R.pipe(R.reject(function (id) {
+        return R.has(id, ids);
+      }), R.concat(relationship))(attribute.relationship) : relationship;
+      ids = attribute.series ? (0, _extends4.default)({}, ids, R.indexBy(R.identity, attribute.relationship)) : ids;
+      return true;
+    }, comb.concepts);
+
+    if (R.isEmpty(seriesConcepts) || R.isEmpty(relationship)) {
+      return (0, _extends4.default)({}, comb, { header: true });
+    }
+    return (0, _extends4.default)({}, comb, { series: true, relationship: relationship });
+  }, combinations);
+};

package/lib/rules2/src/prepareData.js

@@ -0,0 +1,74 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.prepareData = undefined;
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+var _src = require('../../rules/src');
+
+var _enhanceObservations = require('./enhanceObservations');
+
+var _parseAttributes = require('./parseAttributes');
+
+var _getCombinationDefinitions = require('./getCombinationDefinitions');
+
+var _parseCombinations = require('./parseCombinations');
+
+var _refineAttributes = require('./refineAttributes');
+
+var _duplicateObservations = require('./duplicateObservations');
+
+var _getMetadataCoordinates = require('./getMetadataCoordinates');
+
+var _getAttributesSeries = require('./getAttributesSeries');
+
+var _getManyValuesDimensions = require('./getManyValuesDimensions');
+
+var _getOneValueDimensions = require('./getOneValueDimensions');
+
+var _hierarchiseDimensionWithNativeHierarchy = require('./hierarchiseDimensionWithNativeHierarchy');
+
+var _hierarchiseDimensionWithAdvancedHierarchy = require('./hierarchiseDimensionWithAdvancedHierarchy');
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+var prepareData = exports.prepareData = function prepareData(sdmxJson, customAttributes, locale, hierarchies) {
+  var dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
+  var attributes = R.pathOr([], ['data', 'structure', 'attributes', 'observation'], sdmxJson);
+  var annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
+  var observations = (0, _src.getObservations)(sdmxJson);
+  var combinations = (0, _getCombinationDefinitions.getCombinationDefinitions)(annotations, locale);
+  var metadataCoordinates = (0, _getMetadataCoordinates.getMetadataCoordinates)(sdmxJson);
+
+  var parsedAttributes = (0, _parseAttributes.parseAttributes)(attributes, dimensions, customAttributes);
+  var parsedCombinations = (0, _parseCombinations.parseCombinations)(combinations, parsedAttributes, dimensions);
+  var seriesCombinations = R.filter(R.prop('series'), parsedCombinations);
+  var refinedAttributes = (0, _refineAttributes.refineAttributes)(parsedAttributes, seriesCombinations);
+
+  var enhancedObservations = (0, _enhanceObservations.enhanceObservations)(dimensions, observations, refinedAttributes, { customAttributes: customAttributes });
+  var attributesSeries = (0, _getAttributesSeries.getAttributesSeries)(enhancedObservations);
+  var manyValuesDimensions = (0, _getManyValuesDimensions.getManyValuesDimensions)(dimensions, attributesSeries, customAttributes, seriesCombinations);
+  var oneValueDimensions = (0, _getOneValueDimensions.getOneValueDimensions)(dimensions, parsedAttributes);
+  var hierarchisedDimensions = R.map(function (dim) {
+    if (R.isEmpty(R.propOr({}, dim.id, hierarchies))) {
+      return (0, _hierarchiseDimensionWithNativeHierarchy.hierarchiseDimensionWithNativeHierarchy)(dim);
+    }
+    return (0, _hierarchiseDimensionWithAdvancedHierarchy.hierarchiseDimensionWithAdvancedHierarchy)(dim, R.prop(dim.id, hierarchies));
+  }, manyValuesDimensions);
+  var duplicatedObservations = (0, _duplicateObservations.duplicateObs)(R.values(hierarchisedDimensions), enhancedObservations);
+
+  return {
+    observations: duplicatedObservations,
+    dimensions: hierarchisedDimensions,
+    combinations: parsedCombinations,
+    oneValueDimensions: oneValueDimensions,
+    attributesSeries: attributesSeries,
+    metadataCoordinates: metadataCoordinates,
+    attributes: refinedAttributes
+  };
+};

package/lib/{rules/src/table/preparators/getAttributeValue.js → rules2/src/refineAttributes.js}

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getAttributeValue = undefined;
+exports.refineAttributes = undefined;
 
 var _extends2 = require('babel-runtime/helpers/extends');
 
@@ -17,14 +17,16 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var getAttributeValue = exports.getAttributeValue = function getAttributeValue(attribute, valueIndex) {
-  var value = R.pipe(R.propOr([], 'values'), R.nth(valueIndex))(attribute);
-
-  if (R.isNil(value)) {
-    return null;
-  }
-
-  return (0, _extends3.default)({}, R.pick(['id', 'name'], attribute), {
-    value: R.pick(['id', 'name'], value)
-  });
+var refineAttributes = exports.refineAttributes = function refineAttributes(parsedAttributes, seriesCombinations) {
+  var indexedRelationships = R.reduce(function (acc, comb) {
+    return R.reduce(function (_acc, concept) {
+      return R.assoc(concept, comb.relationship, _acc);
+    }, acc, comb.concepts);
+  }, {}, seriesCombinations);
+  return R.map(function (attr) {
+    if (R.has(attr.id, indexedRelationships)) {
+      return (0, _extends3.default)({}, attr, { series: true, relationship: R.prop(attr.id, indexedRelationships) });
+    }
+    return attr;
+  }, parsedAttributes);
 };

package/lib/rules2/src/table/getCells.js

@@ -0,0 +1,74 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCells = exports.getCellCombinedAttributes = exports.getCellRelevantAttributes = undefined;
+
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+var _getFlagsAndNotes = require('./getFlagsAndNotes');
+
+var _hasCellMetadata = require('../hasCellMetadata');
+
+var _utils = require('../utils');
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var getCellRelevantAttributes = exports.getCellRelevantAttributes = function getCellRelevantAttributes(attributes, attributesSeries, cellAttributeIds) {
+  return R.filter(function (attr) {
+    if (R.has(attr.id, cellAttributeIds)) {
+      return true;
+    }
+    var attrInSerie = R.path([attr.serieKey, attr.id], attributesSeries);
+    return R.isNil(attrInSerie);
+  }, attributes);
+};
+
+var getCellCombinedAttributes = exports.getCellCombinedAttributes = function getCellCombinedAttributes(attributes, combinations) {
+  return R.reduce(function (acc, comb) {
+    var values = (0, _utils.trimedProps)(comb.concepts, attributes);
+    if (R.isEmpty(values)) {
+      return acc;
+    }
+    return R.append((0, _extends3.default)({}, R.pick(['id', 'name'], comb), { values: R.pluck('value', values) }), acc);
+  }, [], combinations);
+};
+
+// combinations = { cells, layout };
+var getCells = exports.getCells = function getCells(customAttributes, cellsAttributesId, combinations, attributesSeries, metadataCoordinates) {
+  return function (observations) {
+    var attributesInLayoutCombination = R.pipe(R.propOr([], 'layout'), R.pluck('concepts'), R.unnest)(combinations);
+
+    var attributesInCellsCombination = R.pipe(R.propOr([], 'cells'), R.pluck('concepts'), R.unnest)(combinations);
+
+    var _customAttributes = R.over(R.lensProp('notes'), function (notes) {
+      return R.concat(notes || [], attributesInLayoutCombination);
+    })(customAttributes);
+
+    return R.mapObjIndexed(function (obs) {
+      var relevantAttributes = getCellRelevantAttributes(obs.attributes, attributesSeries, cellsAttributesId);
+      var flagsAndNotes = (0, _getFlagsAndNotes.getFlagsAndNotes)(relevantAttributes, _customAttributes);
+      var combinedAttributes = getCellCombinedAttributes(relevantAttributes, combinations.cells || []);
+
+      var hasAdvancedAttributes = R.pipe(R.omit(R.unnest([_customAttributes.flags || [], _customAttributes.notes || [], attributesInCellsCombination])), R.isEmpty, R.not)(relevantAttributes);
+
+      var hasMetadata = (0, _hasCellMetadata.hasCellMetadata)(metadataCoordinates, obs.indexedDimValIds);
+
+      return (0, _extends3.default)({}, R.pick(['indexedDimValIds', 'key'], obs), {
+        flags: R.concat(flagsAndNotes, combinedAttributes),
+        sideProps: hasAdvancedAttributes || hasMetadata ? { hasAdvancedAttributes: hasAdvancedAttributes, hasMetadata: hasMetadata, coordinates: obs.indexedDimValIds } : null,
+        intValue: R.is(Number, obs.value) ? obs.value : null,
+        value: obs.formattedValue
+      });
+    }, observations);
+  };
+};

package/lib/rules2/src/table/getCellsAttributesIds.js

@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCellsAttributesIds = undefined;
+
+var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
+
+var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
+
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var getCellsAttributesIds = exports.getCellsAttributesIds = function getCellsAttributesIds(layoutIds, attributes) {
+  return R.reduce(function (acc, attr) {
+    if (!attr.series) {
+      return acc;
+    }
+    if (R.isEmpty(attr.relationship || [])) {
+      return R.assoc(attr.id, attr.id, acc);
+    }
+    var indexedHeaderIds = R.indexBy(R.identity, layoutIds.header);
+    var indexedSectionsIds = R.indexBy(R.identity, layoutIds.sections);
+    var indexedRowsIds = (0, _extends3.default)({}, indexedSectionsIds, R.indexBy(R.identity, layoutIds.rows));
+
+    var _R$partition = R.partition(function (id) {
+      return R.has(id, indexedHeaderIds);
+    }, attr.relationship),
+        _R$partition2 = (0, _slicedToArray3.default)(_R$partition, 2),
+        idsInHeader = _R$partition2[0],
+        rest = _R$partition2[1];
+
+    if (R.isEmpty(rest)) {
+      return acc;
+    } else if (!R.isEmpty(idsInHeader)) {
+      return R.assoc(attr.id, attr.id, acc);
+    } else {
+      var idsNotInSections = R.reject(function (id) {
+        return R.has(id, indexedSectionsIds);
+      }, attr.relationship);
+      if (R.isEmpty(idsNotInSections)) {
+        return acc;
+      }
+      var idsNotInRows = R.reject(function (id) {
+        return R.has(id, indexedRowsIds);
+      }, idsNotInSections);
+      if (R.isEmpty(idsNotInRows)) {
+        return acc;
+      }
+    }
+    return R.assoc(attr.id, attr.id, acc);
+  }, {}, attributes);
+};

package/lib/rules2/src/table/getCombinationDimensionsData.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCombinationDimensionsData = undefined;
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+var _parseValueHierarchy = require('./parseValueHierarchy');
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+var getCombinationDimensionsData = exports.getCombinationDimensionsData = function getCombinationDimensionsData(indexes, combination, previous, sameSerie) {
+  var coordinates = {};
+  var ids = [];
+  var _sameSerie = sameSerie;
+  var hasAdvancedAttributes = false;
+
+  var _combination$dimensio = combination.dimensions,
+      dimensions = _combination$dimensio === undefined ? [] : _combination$dimensio;
+
+  var dimValues = R.addIndex(R.reduce)(function (acc, valIndex, dimIndex) {
+    var dimension = R.nth(dimIndex, dimensions);
+    var value = R.nth(Math.abs(valIndex), R.propOr([], 'values', dimension));
+    hasAdvancedAttributes = !hasAdvancedAttributes ? value.hasAdvancedAttributes : true;
+    if (!value) {
+      return acc;
+    }
+    coordinates = R.assoc(dimension.id, value.id, coordinates);
+    ids = R.append(dimension.id + '=' + value.id, ids);
+    var previousValue = R.propOr({}, dimension.id, previous);
+    if (value.id === R.prop('id', previousValue || {}) && _sameSerie) {
+      return R.assoc(dimension.id, previousValue, acc);
+    } else {
+      var parsedValue = (0, _parseValueHierarchy.parseValueHierarchy)(value, _sameSerie ? previousValue || {} : {}, dimension.indexedValues);
+      if (!R.isNil(previous)) {
+        _sameSerie = false;
+      }
+      return R.assoc(dimension.id, parsedValue, acc);
+    }
+  }, {}, indexes);
+
+  return { dimValues: dimValues, coordinates: coordinates, ids: ids, sameSerie: _sameSerie, hasAdvancedAttributes: hasAdvancedAttributes };
+};

package/lib/rules2/src/table/getCuratedCells.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCuratedCells = undefined;
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+var getCuratedCells = exports.getCuratedCells = function getCuratedCells(cells, layout) {
+  var layoutIds = R.map(R.pipe(R.map(function (entry) {
+    return R.has('dimensions', entry) ? R.pluck('id', entry.dimensions || []) : entry.id;
+  }), R.unnest))(layout);
+  return R.pipe(R.values, R.reduce(function (acc, cell) {
+    var keys = R.map(R.pipe(R.map(function (dim) {
+      var val = R.prop(dim, cell.indexedDimValIds);
+      return dim + '=' + val;
+    }), R.join(':')), layoutIds);
+
+    return R.over(R.lensPath(R.props(['header', 'sections', 'rows'], keys)), function (cells) {
+      return R.isNil(cells) ? [cell] : R.append(cell, cells);
+    }, acc);
+  }, {}))(cells);
+};