@sis-cc/dotstatsuite-components 15.0.21 → 16.1.0

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);
+};

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

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getFlagsAndNotes = 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 getFlagsAndNotes = exports.getFlagsAndNotes = function getFlagsAndNotes(attributesValues, customAttributes) {
+  var flagsIds = R.propOr([], 'flags', customAttributes);
+  var notesIds = R.propOr([], 'notes', customAttributes);
+
+  return R.addIndex(R.reduce)(function (acc, id, index) {
+    if (!R.has(id, attributesValues)) {
+      return acc;
+    }
+    var attr = R.prop(id, attributesValues);
+    if (R.isNil(attr.value)) {
+      return acc;
+    }
+    return R.append(index < flagsIds.length ? R.assoc('code', R.path(['value', 'id'], attr), attr) : attr, acc);
+  }, [], R.concat(flagsIds, notesIds));
+};

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

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getIndexedCombinationsByDisplay = undefined;
+
+var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
+
+var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
+
+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 getIndexedCombinationsByDisplay = exports.getIndexedCombinationsByDisplay = function getIndexedCombinationsByDisplay(layout, combinations) {
+  var layoutIds = R.pipe(R.map(R.pluck('id')), R.values, R.unnest, R.indexBy(R.identity))(layout);
+
+  var _R$partition = R.partition(function (comb) {
+    return R.has(comb.id, layoutIds);
+  }, combinations),
+      _R$partition2 = (0, _slicedToArray3.default)(_R$partition, 2),
+      combsInLayout = _R$partition2[0],
+      combsInCells = _R$partition2[1];
+
+  return { cells: combsInCells, layout: combsInLayout };
+};

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

@@ -0,0 +1,93 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLayout = 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);
+
+var _dotstatsuiteSdmxjs = require('@sis-cc/dotstatsuite-sdmxjs');
+
+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 getLayout = exports.getLayout = function getLayout(layoutIds, dimensions, combinations, isTimeInverted, fixedDimensions) {
+  var indexedDimensions = R.pipe(R.indexBy(R.prop('id')), R.map(function (d) {
+    return (0, _dotstatsuiteSdmxjs.isTimePeriodDimension)(d) && isTimeInverted ? R.assoc('isInverted', true, d) : d;
+  }))(dimensions);
+  var indexedFixedDimsValues = R.reduce(function (acc, dim) {
+    var value = R.head(dim.values);
+    return !dim.display || !value.display ? acc : R.assoc(dim.id, R.head(dim.values), acc);
+  }, {}, fixedDimensions);
+  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 layout = { header: [], sections: [], rows: [] };
+  R.forEach(function (comb) {
+    if (R.isEmpty(comb.relationship)) {
+      return;
+    }
+
+    var _R$partition = R.partition(function (id) {
+      return R.has(id, indexedHeaderIds);
+    }, comb.relationship),
+        _R$partition2 = (0, _slicedToArray3.default)(_R$partition, 2),
+        idsInHeader = _R$partition2[0],
+        rest = _R$partition2[1];
+
+    if (R.isEmpty(rest)) {
+      layout = R.over(R.lensProp('header'), R.append((0, _extends3.default)({}, comb, {
+        dimensions: (0, _utils.trimedProps)(comb.concepts, indexedDimensions),
+        fixedDimValues: R.pick(comb.concepts, indexedFixedDimsValues)
+      })))(layout);
+    } else if (!R.isEmpty(idsInHeader)) {
+      return;
+    } else {
+      var idsNotInSections = R.reject(function (id) {
+        return R.has(id, indexedSectionsIds);
+      }, comb.relationship);
+      if (R.isEmpty(idsNotInSections)) {
+        layout = R.over(R.lensProp('sections'), R.append((0, _extends3.default)({}, comb, {
+          dimensions: (0, _utils.trimedProps)(comb.concepts, indexedDimensions),
+          fixedDimValues: R.pick(comb.concepts, indexedFixedDimsValues)
+        })))(layout);
+      } else {
+        var idsNotInRows = R.reject(function (id) {
+          return R.has(id, indexedRowsIds);
+        }, comb.relationship);
+        if (R.isEmpty(idsNotInRows)) {
+          layout = R.over(R.lensProp('rows'), R.append((0, _extends3.default)({}, comb, {
+            dimensions: R.pipe(R.omit(layoutIds.sections), function (o) {
+              return (0, _utils.trimedProps)(comb.concepts, o);
+            })(indexedDimensions),
+            fixedDimValues: R.pick(comb.concepts, indexedFixedDimsValues)
+          })))(layout);
+        }
+      }
+    }
+  }, combinations);
+  return R.mapObjIndexed(function (combs, key) {
+    var conceptIds = R.pipe(R.pluck('concepts'), R.unnest, R.indexBy(R.identity))(combs);
+    var rest = R.reduce(function (acc, id) {
+      if (R.has(id, conceptIds)) {
+        return acc;
+      }
+      return R.append(R.prop(id, indexedDimensions), acc);
+    }, [], layoutIds[key]);
+    return R.concat(rest, combs);
+  }, layout);
+};

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

@@ -0,0 +1,202 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLayoutData = undefined;
+
+var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');
+
+var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
+
+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);
+
+var _getFlagsAndNotes = require('./getFlagsAndNotes');
+
+var _hasCellMetadata = require('../hasCellMetadata');
+
+var _getCombinationDimensionsData = require('./getCombinationDimensionsData');
+
+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; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var getSubLayoutData = function getSubLayoutData(series, _definition, _ref) {
+  var metadataCoordinates = _ref.metadataCoordinates,
+      attributesSeries = _ref.attributesSeries,
+      customAttributes = _ref.customAttributes;
+
+  var getHasAdvancedAttributes = function getHasAdvancedAttributes(attrValues) {
+    return R.pipe(R.omit(R.concat(customAttributes.flags, customAttributes.notes)), R.isEmpty, R.not)(attrValues);
+  };
+
+  var combinationConceptIds = R.reduce(function (acc, def) {
+    var concepts = R.propOr([], 'concepts', def);
+    if (R.isEmpty(concepts)) {
+      return acc;
+    }
+    return R.concat(acc, concepts);
+  }, [], _definition);
+
+  var definition = R.map( //used for parseValueHierarchy ...
+  function (entry) {
+    if (R.has('dimensions', entry)) {
+      return (0, _extends3.default)({}, entry, {
+        dimensions: R.map(function (dim) {
+          return R.assoc('indexedValues', R.indexBy(R.prop('id'), dim.values || []), dim);
+        }, entry.dimensions)
+      });
+    }
+    return R.assoc('indexedValues', R.indexBy(R.prop('id'), entry.values || []), entry);
+  }, _definition);
+
+  var _R$reduce = R.reduce(function (acc, serie) {
+    var data = [];
+    var next = [];
+    var sameSerie = true;
+    var i = 0;
+    var hasAdvancedAttributes = false;
+    var coordinates = {};
+    var ids = [];
+    while (i < serie.length) {
+      var entry = serie[i];
+      if (R.is(Array, entry)) {
+        var combination = definition[i];
+        var previousDimValues = R.nth(i, acc.previous);
+        var combData = (0, _getCombinationDimensionsData.getCombinationDimensionsData)(entry, combination, previousDimValues, sameSerie);
+        data = R.append({
+          dimension: R.pick(['id', 'name'], combination),
+          dimValues: combData.dimValues
+        }, data);
+        next = R.append(combData.dimValues, next);
+        hasAdvancedAttributes = !hasAdvancedAttributes ? combData.hasAdvancedAttributes : true;
+        sameSerie = combData.sameSerie;
+        coordinates = (0, _extends3.default)({}, coordinates, combData.coordinates);
+        ids = R.concat(ids, combData.ids);
+      } else {
+        var dimension = definition[i];
+        var value = R.nth(Math.abs(entry), dimension.values || []);
+        var previousValue = R.nth(i, acc.previous) || {};
+        coordinates = R.assoc(dimension.id, value.id, coordinates);
+        ids = R.append(dimension.id + '=' + value.id, ids);
+        if (value.id === R.prop('id', previousValue || {}) && sameSerie) {
+          next = R.append(previousValue, next);
+          data = R.append({
+            dimension: R.pick(['id', 'name', '__index'], dimension),
+            value: previousValue
+          }, data);
+        } else {
+          hasAdvancedAttributes = !hasAdvancedAttributes ? value.hasAdvancedAttributes : true;
+          var parsedValue = (0, _parseValueHierarchy.parseValueHierarchy)(value, sameSerie ? previousValue || {} : {}, dimension.indexedValues);
+          next = R.append(parsedValue, next);
+          data = R.append({
+            dimension: R.pick(['id', 'name', '__index'], dimension),
+            value: parsedValue
+          }, data);
+          if (!R.isNil(acc.previous)) {
+            sameSerie = false;
+          }
+        }
+      }
+      i++;
+    }
+
+    var attributesValues = R.reduce(function (acc, key) {
+      var splitKey = R.split(':', key);
+      var isValid = R.all(function (entry) {
+        var _R$split = R.split('=', entry),
+            _R$split2 = (0, _slicedToArray3.default)(_R$split, 2),
+            d = _R$split2[0],
+            v = _R$split2[1];
+
+        return R.propEq(d, v, coordinates);
+      }, splitKey);
+      return isValid ? (0, _extends3.default)({}, acc, R.length(splitKey) === 1 ? R.pick(combinationConceptIds, R.prop(key, attributesSeries)) : R.prop(key, attributesSeries)) : acc;
+    }, {}, R.keys(attributesSeries));
+
+    data = R.addIndex(R.map)(function (entry, ind) {
+      if (!R.has('dimValues', entry)) {
+        return entry;
+      }
+      var dimValues = entry.dimValues,
+          dimension = entry.dimension;
+
+      var def = R.nth(ind, definition);
+      var fixedDimValues = R.propOr([], 'fixedDimValues', def);
+      var values = R.reduce(function (_acc, id) {
+        if (R.has(id, dimValues)) {
+          return R.append(R.prop(id, dimValues), _acc);
+        }
+        if (R.has(id, fixedDimValues)) {
+          return R.append(R.prop(id, fixedDimValues), _acc);
+        }
+        if (!R.has(id, attributesValues)) {
+          return _acc;
+        }
+        return R.append(R.path([id, 'value'], attributesValues), _acc);
+      }, [], def.concepts);
+      return { dimension: dimension, values: values };
+    }, data);
+
+    var layoutAttrValues = R.pipe(R.omit(combinationConceptIds), R.reject(R.prop('isObs')))(attributesValues);
+
+    var flags = (0, _getFlagsAndNotes.getFlagsAndNotes)(layoutAttrValues, customAttributes);
+    var hasMetadata = (0, _hasCellMetadata.hasCellMetadata)(metadataCoordinates, coordinates);
+
+    if (!hasAdvancedAttributes) {
+      hasAdvancedAttributes = getHasAdvancedAttributes(layoutAttrValues);
+    }
+
+    var sideProps = hasMetadata || hasAdvancedAttributes ? { hasMetadata: hasMetadata, hasAdvancedAttributes: hasAdvancedAttributes, coordinates: coordinates } : null;
+
+    return {
+      res: R.append({ data: data, key: R.join(':', ids), flags: flags, sideProps: sideProps }, acc.res),
+      previous: next
+    };
+  }, { res: [], previous: [] }, series),
+      res = _R$reduce.res;
+
+  return res;
+};
+
+var getLayoutData = function getLayoutData(layoutIndexes, layout, _ref2) {
+  var metadataCoordinates = _ref2.metadataCoordinates,
+      attributesSeries = _ref2.attributesSeries,
+      customAttributes = _ref2.customAttributes;
+  var header = layoutIndexes.header,
+      sections = layoutIndexes.sections,
+      rest = (0, _objectWithoutProperties3.default)(layoutIndexes, ['header', 'sections']);
+
+  var opts = { metadataCoordinates: metadataCoordinates, attributesSeries: attributesSeries, customAttributes: customAttributes };
+  var headerData = getSubLayoutData(header, layout.header, opts);
+  var sectionsData = R.pipe(R.transpose, function (_ref3) {
+    var _ref4 = (0, _slicedToArray3.default)(_ref3, 2),
+        sections = _ref4[0],
+        sectionsRows = _ref4[1];
+
+    if (R.isNil(sections)) {
+      return [];
+    }
+    var _sectionsData = getSubLayoutData(sections, layout.sections, opts);
+    var rowsData = R.map(function (rows) {
+      return getSubLayoutData(rows, layout.rows, opts);
+    }, sectionsRows);
+
+    return R.transpose([_sectionsData, rowsData]);
+  })(sections);
+
+  return (0, _extends3.default)({ headerData: headerData, sectionsData: sectionsData }, rest);
+};
+exports.getLayoutData = getLayoutData;

package/lib/{rules/src/table/factories → rules2/src/table}/getSortedLayoutIndexes.js

@@ -21,45 +21,62 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-/*
-
-const layout = {
-  header: [
-    { ...dim, values: [] } // values already sorted regarding order annotation
-  ],
-  rows: [],
-  sections: []
-};
-
-const observations = {
-  [obsKey]: {
-    ...obs,
-    orderedDimIndexes: [sortedValIndex]
-  }
-}
-
+/*
+  const layout = {
+    header: [
+      { id, __index },
+      { id: COMB, dimensions: [{ id, __index }] }
+    ],
+    sections: [],
+    rows: []
+  }
+
 */
 
-var getLayoutPivots = function getLayoutPivots(layout) {
-  return R.mapObjIndexed(function (dimensions) {
-    return R.props(R.pluck('__index', dimensions));
-  })(layout);
+var getLayoutPivots = function getLayoutPivots(layoutEntry) {
+  var valIndexGetter = function valIndexGetter(d) {
+    return R.pipe(R.nth(R.prop('__index', d)), function (ind) {
+      return d.isInverted ? R.negate(ind) : ind;
+    });
+  };
+  return function (indexes) {
+    return R.map(R.ifElse(R.has('dimensions'), function (c) {
+      return R.map(function (d) {
+        return valIndexGetter(d)(indexes);
+      }, R.prop('dimensions', c));
+    }, function (d) {
+      return valIndexGetter(d)(indexes);
+    }), layoutEntry);
+  };
 };
 
-var comparator = function comparator(size) {
-  return function (a, b) {
-    var i = 0;
-    while (a[i] === b[i] && i < size) {
-      i++;
+var comparator = function comparator(a, b) {
+  var size = R.length(a);
+  var i = 0;
+  while (i < size) {
+    if (R.is(Array, a[i])) {
+      var _a = a[i];
+      var _b = b[i];
+      var _size = R.length(_a);
+      var j = 0;
+      while (_a[j] === _b[j] && j < _size) {
+        j++;
+      }
+      if (_a[j] !== _b[j]) {
+        return _a[j] - _b[j];
+      }
+    } else if (a[i] !== b[i]) {
+      return a[i] - b[i];
     }
-    return a[i] - b[i];
-  };
+    i++;
+  }
+  return a[i] - b[i];
 };
 
 // simple call to ramda uniq method is very slow regarding performance
 var uniqIndexes = function uniqIndexes(indexes) {
   return R.pipe(R.reduce(function (acc, i) {
-    var key = R.join(':', i);
+    var key = R.join(':', R.unnest(i));
     if (R.has(key, acc.keys)) {
       return acc;
     }
@@ -73,25 +90,22 @@ var uniqIndexes = function uniqIndexes(indexes) {
 var getSortedLayoutIndexes = exports.getSortedLayoutIndexes = function getSortedLayoutIndexes(layout, observations) {
   var dimIndexes = R.pipe(R.values, R.map(R.propOr([], 'orderedDimIndexes')))(observations);
 
-  var headerLength = R.length(layout.header);
+  var headerPivots = getLayoutPivots(layout.header);
+  var sectionsPivots = getLayoutPivots(R.concat(layout.sections, layout.rows));
 
   var sectionLength = R.length(layout.sections);
-  var rowLength = R.length(layout.rows);
-
-  var layoutPivots = getLayoutPivots(layout);
 
   var _R$pipe = R.pipe(R.reduce(function (acc, indexes) {
-    var headerIndexes = layoutPivots.header(indexes);
-    var sectionsIndexes = layoutPivots.sections(indexes);
-    var rowsIndexes = layoutPivots.rows(indexes);
+    var headerIndexes = headerPivots(indexes);
+    var sectionsIndexes = sectionsPivots(indexes);
 
     return {
       header: R.append(headerIndexes, acc.header),
-      sections: R.append(R.concat(sectionsIndexes, rowsIndexes), acc.sections)
+      sections: R.append(sectionsIndexes, acc.sections)
     };
   }, { header: [], sections: [] }), R.mapObjIndexed(uniqIndexes), R.evolve({
-    header: R.sort(comparator(headerLength)),
-    sections: R.sort(comparator(sectionLength + rowLength))
+    header: R.sort(comparator),
+    sections: R.sort(comparator)
   }), function (indexes) {
     return (0, _extends3.default)({}, indexes, {
       sections: R.reduce(function (acc, i) {
@@ -103,7 +117,8 @@ var getSortedLayoutIndexes = exports.getSortedLayoutIndexes = function getSorted
         var previousSecIndexes = R.pipe(R.nth(-1), function (i) {
           return R.isNil(i) ? null : R.head(i);
         })(acc);
-        if (R.equals(sectionIndexes, previousSecIndexes)) {
+        if (R.equals(R.unnest(sectionIndexes), previousSecIndexes ? R.unnest(previousSecIndexes) : null)) {
+          //perhaps a bit dirty ...
           return R.over(R.lensIndex(-1), R.over(R.lensIndex(1), R.append(rowIndexes)))(acc);
         }
 

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

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTableProps = undefined;
+
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+var _getLayout = require('./getLayout');
+
+var _getSortedLayoutIndexes = require('./getSortedLayoutIndexes');
+
+var _refineLayoutSize = require('./refineLayoutSize');
+
+var _getLayoutData = require('./getLayoutData');
+
+var _getCellsAttributesIds = require('./getCellsAttributesIds');
+
+var _getIndexedCombinationsByDisplay = require('./getIndexedCombinationsByDisplay');
+
+var _getCells = require('./getCells');
+
+var _getCuratedCells = require('./getCuratedCells');
+
+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 getTableProps = exports.getTableProps = function getTableProps(_ref) {
+  var data = _ref.data,
+      layoutIds = _ref.layoutIds,
+      customAttributes = _ref.customAttributes,
+      limit = _ref.limit,
+      isTimeInverted = _ref.isTimeInverted;
+  var observations = data.observations,
+      dimensions = data.dimensions,
+      combinations = data.combinations,
+      oneValueDimensions = data.oneValueDimensions,
+      attributesSeries = data.attributesSeries,
+      metadataCoordinates = data.metadataCoordinates,
+      attributes = data.attributes;
+
+
+  var seriesCombinations = R.filter(R.prop('series'), combinations);
+  var layout = (0, _getLayout.getLayout)(layoutIds, dimensions, seriesCombinations, isTimeInverted, oneValueDimensions);
+  var layoutIndexes = (0, _getSortedLayoutIndexes.getSortedLayoutIndexes)(layout, observations);
+  var refinedLayoutIndexes = (0, _refineLayoutSize.refineLayoutSize)({ layout: layout, observations: observations, limit: limit })(layoutIndexes);
+  var layoutData = (0, _getLayoutData.getLayoutData)(refinedLayoutIndexes, layout, { metadataCoordinates: metadataCoordinates, attributesSeries: attributesSeries, customAttributes: customAttributes });
+
+  var cellsAttributesIds = (0, _getCellsAttributesIds.getCellsAttributesIds)(layoutIds, attributes);
+  var indexedCombinations = (0, _getIndexedCombinationsByDisplay.getIndexedCombinationsByDisplay)(layout, seriesCombinations);
+  var cells = (0, _getCells.getCells)(customAttributes, cellsAttributesIds, indexedCombinations, attributesSeries, metadataCoordinates)(observations);
+
+  return (0, _extends3.default)({}, layoutData, {
+    cells: (0, _getCuratedCells.getCuratedCells)(cells, layout)
+  });
+};

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

@@ -0,0 +1,55 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseValueHierarchy = undefined;
+
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
+var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
+
+var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
+
+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 parseValueHierarchy = exports.parseValueHierarchy = function parseValueHierarchy(value, previousValue, indexedValues) {
+  var parentsIds = R.propOr([], 'parents', value);
+  if (R.isEmpty(parentsIds)) {
+    return value;
+  }
+  var _previousParentsIds = R.propOr([], 'parentsIds', previousValue);
+  var previousParentsIds = R.isNil(previousValue) ? [] : R.append(R.prop('id', previousValue), _previousParentsIds);
+
+  var _R$addIndex = R.addIndex(R.splitWhen)(function (val, ind) {
+    return R.nth(ind, previousParentsIds) !== val;
+  }, parentsIds),
+      _R$addIndex2 = (0, _slicedToArray3.default)(_R$addIndex, 2),
+      presentIds = _R$addIndex2[0],
+      missingIds = _R$addIndex2[1];
+  //console.log({ presentIds, missingIds });
+
+
+  var _previousParents = R.propOr([], 'parents', previousValue);
+  var previousParents = R.isNil(previousValue) ? [] : R.append(R.pick(['id', 'name'], previousValue), _previousParents);
+  //console.log('previousParents', previousParents);
+  var parents = R.takeWhile(function (p) {
+    return R.includes(p.id, presentIds);
+  }, previousParents);
+  var missingParents = R.concat(R.includes(R.prop('id', previousValue), presentIds) ? [] : R.takeWhile(function (p) {
+    return R.includes(p.id, presentIds);
+  }, R.propOr([], 'missingParents', previousValue)), R.props(missingIds, indexedValues));
+  return (0, _extends3.default)({}, value, {
+    parents: parents,
+    parentsIds: parentsIds,
+    missingParents: missingParents
+  });
+};