@sis-cc/dotstatsuite-components 17.12.6 → 17.13.0

package/lib/rules2/src/table/{refineLayoutSize.js → refineLayoutSize2.js}

@@ -5,17 +5,17 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.refineLayoutSize = exports.truncateHeader = exports.truncateSectionRows = exports.refineHeader = exports.refineSections = exports.getCuratedCells = undefined;
 
-var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
+var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
 
-var _defineProperty3 = _interopRequireDefault(_defineProperty2);
+var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
 
-var _extends4 = require('babel-runtime/helpers/extends');
+var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
 
-var _extends5 = _interopRequireDefault(_extends4);
+var _defineProperty3 = _interopRequireDefault(_defineProperty2);
 
-var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
+var _extends3 = require('babel-runtime/helpers/extends');
 
-var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
+var _extends4 = _interopRequireDefault(_extends3);
 
 var _ramda = require('ramda');
 
@@ -62,9 +62,9 @@ var getCuratedCells = exports.getCuratedCells = function getCuratedCells(_ref) {
 
 var refineSections = exports.refineSections = function refineSections(sections, extractedKeys, curatedObs) {
   return R.pipe(R.map(function (section) {
-    var sectionKey = toKey(R.head(section) || []);
-    return R.over(R.lensIndex(1), R.filter(function (rowData) {
-      var rowKey = toKey(rowData);
+    var sectionKey = toKey(R.propOr([], 'indexes', R.head(section)));
+    return R.over(R.lensIndex(1), R.filter(function (row) {
+      var rowKey = toKey(R.prop('indexes', row));
       return R.pipe(R.path([sectionKey, rowKey]), R.omit(extractedKeys), R.isEmpty, R.not)(curatedObs);
     }))(section);
   }), R.filter(R.pipe(R.nth(1), R.isEmpty, R.not)))(sections);
@@ -73,7 +73,7 @@ var refineSections = exports.refineSections = function refineSections(sections,
 var refineHeader = exports.refineHeader = function refineHeader(header, extractedKeys, curatedObs) {
   return R.filter( // extracted : { [sectionKey]: [...rowKeys] }
   function (header) {
-    var headerKey = toKey(header);
+    var headerKey = toKey(R.prop('indexes', header));
     return R.pipe(R.prop(headerKey), function (sections) {
       return R.pickBy(function (rows, section) {
         return R.pipe(R.omit(R.propOr([], section, extractedKeys)), R.isEmpty, R.not)(rows);
@@ -82,6 +82,12 @@ var refineHeader = exports.refineHeader = function refineHeader(header, extracte
   })(header);
 };
 
+var getSerieLinesCount = function getSerieLinesCount(serie) {
+  var missingParents = R.propOr([], 'missingParents', serie);
+  var missingParentsRowsCount = R.pipe(R.flatten, R.length)(missingParents);
+  return missingParentsRowsCount + 1;
+};
+
 var truncateSectionRows = exports.truncateSectionRows = function truncateSectionRows(n, sectionsData) {
   var truncated = sectionsData;
   var extractedKeys = {};
@@ -90,33 +96,40 @@ var truncateSectionRows = exports.truncateSectionRows = function truncateSection
     var lastSection = R.last(truncated);
     var rows = lastSection[1];
     var rowsLength = R.length(rows);
-    var sectionKey = toKey(R.head(lastSection));
-    if (rowsLength > _n) {
-      var _R$splitAt = R.splitAt(R.negate(_n), rows),
-          _R$splitAt2 = (0, _slicedToArray3.default)(_R$splitAt, 2),
-          rest = _R$splitAt2[0],
-          extracted = _R$splitAt2[1];
-
-      var updatedSection = R.set(R.lensIndex(1), rest)(lastSection);
-      truncated = R.set(R.lensIndex(-1), updatedSection)(truncated);
-      extractedKeys = (0, _extends5.default)({}, extractedKeys, (0, _defineProperty3.default)({}, sectionKey, R.map(toKey, extracted)));
-      _n = 0;
-    } else {
+    var truncatedRowsCount = 0;
+    while (_n > 0 && truncatedRowsCount !== rowsLength) {
+      var rowsCount = getSerieLinesCount(R.nth(-1 * truncatedRowsCount, rows));
+      _n = _n - rowsCount;
+      truncatedRowsCount++;
+    }
+    var sectionKey = R.pipe(R.head, R.prop('indexes'), toKey)(lastSection);
+    extractedKeys = (0, _extends4.default)({}, extractedKeys, (0, _defineProperty3.default)({}, sectionKey, R.pipe(R.takeLast(truncatedRowsCount), R.map(function (r) {
+      return toKey(R.prop('indexes', r));
+    }))(rows)));
+    if (_n > 0) {
       truncated = R.dropLast(1, truncated);
-      extractedKeys = (0, _extends5.default)({}, extractedKeys, (0, _defineProperty3.default)({}, sectionKey, R.map(toKey, rows)));
-      _n = _n - rowsLength;
+    } else {
+      truncated = R.over(R.lensIndex(-1), R.over(R.lensIndex(1), R.dropLast(truncatedRowsCount)))(truncated);
     }
   }
   return { truncated: truncated, extractedKeys: extractedKeys };
 };
 
 var truncateHeader = exports.truncateHeader = function truncateHeader(n, headerData) {
-  var _R$splitAt3 = R.splitAt(R.negate(n))(headerData),
-      _R$splitAt4 = (0, _slicedToArray3.default)(_R$splitAt3, 2),
-      truncated = _R$splitAt4[0],
-      extracted = _R$splitAt4[1];
+  var _truncated$extractedK = { truncated: headerData, extractedKeys: [] },
+      truncated = _truncated$extractedK.truncated,
+      extractedKeys = _truncated$extractedK.extractedKeys;
 
-  return { truncated: truncated, extractedKeys: R.map(toKey, extracted) };
+  var _n = n;
+  while (_n > 0) {
+    var lastHeader = R.last(truncated);
+    var columnsCount = getSerieLinesCount(lastHeader);
+    var extractedKey = toKey(R.prop('indexes', lastHeader));
+    extractedKeys = R.append(extractedKey, extractedKeys);
+    truncated = R.dropLast(1, truncated);
+    _n = _n - columnsCount;
+  }
+  return { truncated: truncated, extractedKeys: extractedKeys };
 };
 
 var truncateLayout = function truncateLayout(isVertical) {
@@ -153,11 +166,14 @@ var refineLayoutSize = exports.refineLayoutSize = function refineLayoutSize(_ref
 
     //number of dimensions in header
     var headerDimCount = R.pipe(R.head, // first column
-    R.when(R.isNil, R.always([])), R.length // number of dims
+    R.when(R.isNil, R.always({})), R.propOr([], 'indexes'), R.length // number of dims
     )(header);
 
     //number of columns for values
-    var headerValuesCount = R.pipe(R.length, R.when(R.equals(0), R.always(1)))(header);
+    var headerValuesCount = R.pipe(R.reduce(function (acc, header) {
+      var columnsCount = getSerieLinesCount(header);
+      return acc + columnsCount;
+    }, 0), R.when(R.equals(0), R.always(1)))(header);
 
     //total of cells in header
     var headerCellsCount = headerDimCount * (headerValuesCount + 1);
@@ -166,19 +182,22 @@ var refineLayoutSize = exports.refineLayoutSize = function refineLayoutSize(_ref
     var rowDimCount = R.pipe(R.head, // firstSection
     R.last, // rows,
     R.head, // first row
-    R.length)(sections);
+    R.propOr([], 'indexes'), R.length)(sections);
 
     // number of cells in a row
     var rowCellsCount = rowDimCount + headerValuesCount + 1;
 
     // number of rows
-    var rowsCount = R.pipe(R.map(R.last), R.unnest, R.length, R.add(1))(sections);
+    var rowsCount = R.pipe(R.map(R.last), R.unnest, R.reduce(function (acc, row) {
+      var rowsCount = getSerieLinesCount(row);
+      return acc + rowsCount;
+    }, 1))(sections);
 
     // total of cells in all rows
     var rowsCellsCount = rowCellsCount * rowsCount;
 
     // number of sections cells
-    var sectionsCellsCount = R.ifElse(R.pipe(R.head, R.head, R.length, R.equals(0)), R.always(0), R.length)(sections);
+    var sectionsCellsCount = R.ifElse(R.pipe(R.head, R.head, R.propOr([], 'indexes'), R.length, R.equals(0)), R.always(0), R.length)(sections);
 
     var total = rowsCellsCount + sectionsCellsCount + headerCellsCount;
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sis-cc/dotstatsuite-components",
   "description": "Set components based on React.",
-  "version": "17.12.6",
+  "version": "17.13.0",
   "main": "lib/index.js",
   "author": "OECD",
   "license": "MIT",

package/src/rules2/src/{hierarchiseDimensionWithAdvancedHierarchy.js → hierarchiseDimensionWithAdvancedHierarchy2.js}

@@ -60,25 +60,27 @@ export const hierarchiseDimensionWithAdvancedHierarchy = (dimension, _hierarchy)
   const indexed = R.indexBy(R.prop('id'), dimension.values);
   const hierarchy = refinePartialHierarchy(_hierarchy, indexed);
 
-  let rest = indexed;
-  const getChildren = (parents, hier) => R.pipe(
-    ids => {
-      rest = R.omit(ids, rest);
-      return R.props(ids, indexed)
-    },
-    R.filter(R.identity),
-    R.map(
-      (val) => {
-        const _val = {
-          ...val,
-          parent: R.last(parents),
-          parents
-        };
-        const children = getChildren(R.append(val.id, parents), hier);
-        return R.prepend(_val, children);
-      },
-    )
-  )(R.propOr([], R.isEmpty(parents) ? '#ROOT' : R.join('.', parents), hier));
+  const rest = R.pipe(
+    R.values,
+    R.unnest,
+    R.flip(R.omit)(indexed),
+    R.values,
+  )(hierarchy);
+  let index = R.length(rest) - 1;
+  const getChildren = ({ parentsIndexes, parentId }) => {
+    const childrenIds = R.propOr([], parentId, hierarchy);
+    const children = R.reduce((acc, childId) => {
+      if (!R.has(childId, indexed)) {
+        return acc;
+      }
+      index = index + 1;
+      const child = { ...R.prop(childId, indexed), __indexPosition: index, parents: parentsIndexes, parent: R.isEmpty(parentsIndexes) ? undefined : R.pipe(R.split('.'), R.last)(parentId) };
+      const descendants = getChildren({ parentsIndexes: R.append(index, parentsIndexes), parentId: R.isEmpty(parentsIndexes) ? child.id : `${parentId}.${child.id}` });
+      return R.append(R.prepend(child, descendants), acc);
+    }, [], childrenIds);
+
+    return children;
+  }
 
   return R.set(
     R.lensProp('values'),
@@ -90,12 +92,11 @@ export const hierarchiseDimensionWithAdvancedHierarchy = (dimension, _hierarchy)
           return values;
         }
         const sortedRest = R.pipe(
-          R.values,
-          R.map(val => ({ ...val, parent: undefined, parents: [] })),
-          R.sortBy(R.prop('__indexPosition'))
+          R.sortBy(R.prop('__indexPosition')),
+          R.addIndex(R.map)((val, ind) => ({ ...val, __indexPosition: ind, parent: undefined, parents: [] })),
         )(rest);
         return R.concat(sortedRest, values);
       }
-    )([], hierarchy)
+    )({ parentsIndexes: [], parentId: '#ROOT' })
   )(dimension);
 };

package/src/rules2/src/{hierarchiseDimensionWithNativeHierarchy.js → hierarchiseDimensionWithNativeHierarchy2.js}

@@ -1,28 +1,31 @@
-import * as R from 'ramda';
-
-export const hierarchiseDimensionWithNativeHierarchy = (dimension) => {
-  const values = R.sortBy(R.prop('__indexPosition'), dimension.values || []);
-  const indexed = R.indexBy(R.prop('id'), values);
-  const grouped = R.groupBy(val => val.parent && R.has(val.parent, indexed) ? val.parent : '#ROOT', values);
-
-  const getChildren = (parents) => {
-    const childs = R.propOr([], R.defaultTo('#ROOT', R.last(parents)), grouped);
-    return R.reduce(
-      (acc, child) => {
-        const refined = R.pipe(
-          R.assoc('parents', parents),
-          R.assoc('parent', R.last(parents)),
-        )(child);
-        const children = getChildren(R.append(child.id, parents));
-        return R.concat(acc, R.prepend(refined, children));
-      },
-      [],
-      childs
-    );
-  }
-
-  return R.set(
-    R.lensProp('values'),
-    getChildren([])
-  )(dimension);
-};
+import * as R from 'ramda';
+
+export const hierarchiseDimensionWithNativeHierarchy = (dimension) => {
+  const values = R.sortBy(R.prop('__indexPosition'), dimension.values || []);
+  const indexed = R.indexBy(R.prop('id'), values);
+  const grouped = R.groupBy(val => val.parent && R.has(val.parent, indexed) ? val.parent : '#ROOT', values);
+
+  let index = -1;
+  const getChildren = ({ parentsIndexes, parentId }) => {
+    const childs = R.propOr([], parentId, grouped);
+    return R.reduce(
+      (acc, child) => {
+        index = index + 1;
+        const refined = R.pipe(
+          R.assoc('__indexPosition', index),
+          R.assoc('parents', parentsIndexes),
+          R.assoc('parent', R.isEmpty(parentsIndexes) ? undefined : parentId),
+        )(child);
+        const children = getChildren({ parentsIndexes: R.append(index, parentsIndexes), parentId: child.id });
+        return R.concat(acc, R.prepend(refined, children));
+      },
+      [],
+      childs
+    );
+  }
+
+  return R.set(
+    R.lensProp('values'),
+    getChildren({ parentsIndexes: [], parentId: '#ROOT' })
+  )(dimension);
+};

package/src/rules2/src/index.js

@@ -11,11 +11,10 @@ export { getMSDInformations } from './getMSDInformations';
 export { getNotDisplayedIds } from './getNotDisplayedIds';
 export { getHCodelistsRefs, getHCodelistsRefsInData } from './getHCodelistsRefsInData';
 export { parseHierarchicalCodelist } from './parseHierarchicalCodelist';
-export { refinePartialHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy';
 export { getMetadataCoordinates } from './getMetadataCoordinates';
 export { duplicateObs } from './duplicateObservations';
-export { hierarchiseDimensionWithAdvancedHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy';
-export { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy';
+export { refinePartialHierarchy, hierarchiseDimensionWithAdvancedHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy2';
+export { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy2';
 export { getDimensionValuesIndexes } from './getDimensionValuesIndexes';
 export { getCombinationDefinitions } from './getCombinationDefinitions';
 export { refineDimensions } from './refineDimensions';
@@ -34,9 +33,9 @@ export { getHeaderCombinations } from './getHeaderCombinations';
 export { getHeaderCoordinates } from './getHeaderCoordinates';
 export { getLayout } from './table/getLayout';
 export { getSortedLayoutIndexes } from './table/getSortedLayoutIndexes';
-export { refineLayoutSize } from './table/refineLayoutSize';
+export { refineLayoutSize } from './table/refineLayoutSize2';
 export { getFlagsAndNotes } from './table/getFlagsAndNotes';
-export { getLayoutData } from './table/getLayoutData';
+export { getLayoutData } from './table/getLayoutData2';
 export { getCellsAttributesIds } from './table/getCellsAttributesIds';
 export { getCellsMetadataCoordinates } from './table/getCellsMetadataCoordinates';
 export { getIndexedCombinationsByDisplay } from './table/getIndexedCombinationsByDisplay';
@@ -46,3 +45,4 @@ export { prepareData } from './prepareData';
 export { getTableProps } from './table/getTableProps';
 export { getTableLabelAccessor } from './table/getTableLabelAccessor';
 export { parseValueHierarchy } from './table/parseValueHierarchy';
+export { parseLayoutIndexesHierarchies } from './table/parseSeriesIndexesHierarchies';

package/src/rules2/src/prepareData.js

@@ -11,8 +11,8 @@ import { getMetadataCoordinates } from './getMetadataCoordinates';
 import { getAttributesSeries } from './getAttributesSeries';
 import { getManyValuesDimensions } from './getManyValuesDimensions';
 import { getOneValueDimensions } from './getOneValueDimensions';
-import { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy';
-import { hierarchiseDimensionWithAdvancedHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy';
+import { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy2';
+import { hierarchiseDimensionWithAdvancedHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy2';
 import { getDataflowAttributes } from './getDataflowAttributes';
 import { getHeaderTitle } from './getHeaderTitle';
 import { getHeaderSubtitle } from './getHeaderSubtitle';

package/src/rules2/src/refineDimensions.js

@@ -5,15 +5,12 @@ export const refineDimensions = (dimensions=[], dataquery='') => {
 
   return R.addIndex(R.map)((dim, index) => {
     const selection = R.nth(index, selectionIds);
-    if (R.isNil(selection) || R.length(selection) === 0 || R.isEmpty(R.head(selection))) {
-      return { ...dim, header: R.length(dim.values || []) <= 1 };
-    }
     const values = R.map(val => {
-      if (R.includes(val.id, selection)) {
-        return val;
+      if (R.includes(val.id, selection || []) || R.isNil(selection) || R.length(selection) === 0 || R.isEmpty(R.head(selection))) {
+        return R.assoc('isSelected', true, val);
       }
       return R.assoc('empty', true, val);
     }, dim.values || []);
-    return { ...dim, values, header: R.length(values) <= 1 || R.length(selection) === 1 };
+    return { ...dim, values, header: R.length(values) <= 1 || (R.length(selection) === 1 && !R.isEmpty(R.head(selection))) };
   }, dimensions);
 };

package/src/rules2/src/table/getLayoutData2.js

@@ -0,0 +1,175 @@
+import * as R from 'ramda';
+import { getFlagsAndNotes } from './getFlagsAndNotes';
+import { getLayoutCoordinatesValidator } from '../utils';
+
+const getValueData = (index, dimension, parentsIndexes) => ({
+	dimension: R.pick(['id', 'name', '__index'], dimension),
+	value: {
+		...R.pipe(R.pathOr({}, ['values', index]), R.pick(['id', 'name']))(dimension),
+		parents: parentsIndexes
+	}
+});
+
+const addCoordinatesToKey = (key, dimensionId, valueId) =>
+	`${key}${R.isEmpty(key) ? '' : ':'}${dimensionId}=${valueId}`;
+
+const simpleValueDataSetter = (valueData, datas = []) => R.append(valueData, datas);
+
+const combinedValueDataSetter = (valueData, datas = []) =>
+	R.over(R.lensIndex(-1), d => ({ ...d, values: R.append(R.prop('value', valueData), d.values) }), datas);
+
+const addValueToSerieData = (dataSetter) => (index, parentsIndexes, dimension, serieData) => {
+	const valueData = getValueData(index, dimension, parentsIndexes);
+	const valueId = R.path(['value', 'id'], valueData);
+	return ({
+		...serieData,
+		data: dataSetter(valueData, R.prop('data', serieData)),
+		coordinates: R.assoc(dimension.id, valueId, R.prop('coordinates', serieData)),
+		key: addCoordinatesToKey(R.prop('key', serieData), R.prop('id', dimension), valueId)
+	});
+};
+
+const addSimpleValueToSerieData = addValueToSerieData(simpleValueDataSetter);
+
+const addCombinedValueToSerieData = addValueToSerieData(combinedValueDataSetter);
+
+const getHasAdvancedAttributes = (attrValues, customAttributes) => R.pipe(
+    R.omit(R.concat(customAttributes.flags || [], customAttributes.notes || [])),
+    R.isEmpty,
+    R.not
+  )(attrValues);
+
+const getCoordinates = (indexes, topCoordinates, definition) => R.addIndex(R.reduce)((acc, entry, index) => {
+	if (R.has('dimensions', entry)) {
+		return R.addIndex(R.reduce)((_acc, dim, _index) => {
+			const valInd = R.path([index, _index], indexes);
+			return R.assoc(dim.id, R.path(['values', valInd, 'id'], dim), _acc)
+		}, acc, entry.dimensions);
+	}
+	const valInd = R.nth(index, indexes);
+	return R.assoc(entry.id, R.path(['values', valInd, 'id'], entry), acc);
+}, topCoordinates, definition);
+
+const getAttributesSeries = (validator, attributesSeries) => R.reduce((acc, attrs) => {
+	const attr = R.head(R.values(attrs));
+	const coordinates = R.propOr({}, 'coordinates', attr);
+	const isValid = validator(coordinates);
+	if (!isValid && !attr.isObs) {
+		return acc;
+	}
+	return ({ ...acc, ...attrs });
+}, {}, R.values(attributesSeries));
+
+const combineConcepts = (combDimValues, definition, attrValues) => R.over(
+	R.lensProp('data'),
+	R.over(R.lensIndex(-1), data => ({
+		...data,
+		values: R.reduce((acc, conceptId) => {
+			if (R.has(conceptId, combDimValues)) {
+				return R.append(R.prop(conceptId, combDimValues), acc);
+			}
+			if (R.has(conceptId, definition.fixedDimValues || {})) {
+				return R.append(R.prop(conceptId, definition.fixedDimValues), acc);
+			}
+			if (R.has(conceptId, attrValues)) {
+				const value = R.path([conceptId, 'value'], attrValues);
+				return R.append(value, acc);
+			}
+			return acc;
+		}, [], definition.concepts)
+	})));
+
+const getSerieFlagsAndSideProps = (coordinates, validator, attributesValues, customAttributes, metadataCoordinates) => {
+	const layoutAttrValues = R.reject(R.prop('isObs'), attributesValues);
+  const flags = getFlagsAndNotes(layoutAttrValues, customAttributes);
+  const hasMetadata = !R.isNil(R.find(validator, metadataCoordinates));
+  const hasAdvancedAttributes = getHasAdvancedAttributes(layoutAttrValues, customAttributes);
+  const sideProps = hasMetadata || hasAdvancedAttributes
+    ? { hasMetadata, hasAdvancedAttributes, coordinates } : null;
+	return { flags, sideProps };
+};
+
+export const getSerieDatas = (serie, definition, topCoordinates, attributesSeries, customAttributes, metadataCoordinates) => {
+	const lines = [];
+
+	const serieCoordinates = getCoordinates(serie.indexes, topCoordinates, definition);
+	const coordinatesValidator = getLayoutCoordinatesValidator(serieCoordinates, topCoordinates);
+	let attributesValues = getAttributesSeries(coordinatesValidator, attributesSeries);
+
+	const addMissingParentsLines = dataSetter => (missingParentsIndexes, parentsIndexes, dim, serieData) => R.reduce(
+		(parents, index) => {
+			const missingParentData = addValueToSerieData(dataSetter)(index, parents, dim, serieData);
+			lines.push(R.assoc('isEmpty', true, missingParentData));
+			return R.append(index, parents);
+		}, parentsIndexes, missingParentsIndexes
+	);
+
+	const addSimpleMissingParentsLines = addMissingParentsLines(simpleValueDataSetter);
+	const addCombinedMissingParentsLines = addMissingParentsLines(combinedValueDataSetter);
+
+	const serieData = R.addIndex(R.reduce)(
+		(onGoingSerie, entry, index) => {
+			if (R.has('dimensions', entry)) {
+				const combValuesIndexes = R.pathOr([], ['indexes', index], serie);
+				const combParentsIndexes = R.pathOr([], ['parentsIndexes', index], serie);
+				const combMissingParentsIndexes = R.pathOr([], ['missingIndexes', index], serie);
+				let combDimValues = {};
+				const res = R.addIndex(R.reduce)((combSerie, dimension, dimIndex) => {
+					const valueIndex = Math.abs(R.nth(dimIndex, combValuesIndexes));
+					const _parentsIndexes = R.nth(dimIndex, combParentsIndexes) || [];
+					const missingParentsIndexes = R.nth(dimIndex, combMissingParentsIndexes) || [];
+					const parentsIndexes = addCombinedMissingParentsLines(missingParentsIndexes, _parentsIndexes, dimension, combSerie);
+					const next = addCombinedValueToSerieData(valueIndex, parentsIndexes, dimension, combSerie);
+					const value = R.pipe(R.prop('data'), R.last, R.prop('values'), R.last)(next);
+					combDimValues = R.assoc(dimension.id, value, combDimValues);
+					return next;
+				},
+				R.over(
+					R.lensProp('data'),
+					R.append({ dimension: R.pick(['id', 'name'], entry), values: [] })
+				)(onGoingSerie),
+				R.propOr([], 'dimensions', entry));
+
+				const combined = combineConcepts(combDimValues, entry, attributesValues)(res);
+				attributesValues = R.omit(entry.concepts, attributesValues);
+				return combined;
+			}
+
+			const valueIndex = Math.abs(R.path(['indexes', index], serie));
+			const _parentsIndexes = R.pathOr([], ['parentsIndexes', index], serie);
+			const missingParentsIndexes = R.pathOr([], ['missingIndexes', index], serie);
+			const parentsIndexes = addSimpleMissingParentsLines(missingParentsIndexes, _parentsIndexes, entry, onGoingSerie);
+			return addSimpleValueToSerieData(valueIndex, parentsIndexes, entry, onGoingSerie);
+		},
+		{ data: [], coordinates: {}, key: '', sideProps: null, flags: [] },
+		definition,
+	);
+	const { flags, sideProps } = getSerieFlagsAndSideProps(serieCoordinates, coordinatesValidator, attributesValues, customAttributes, metadataCoordinates);
+	lines.push({ ...serieData, flags, sideProps });
+	return lines;
+};
+
+export const getLayoutData = (layoutIndexes, layout, { metadataCoordinates, attributesSeries, customAttributes, topCoordinates={} }) => {
+  const { header, sections, ...rest } = layoutIndexes;
+
+  const headerData = R.reduce((acc, serie) => {
+  	const datas = getSerieDatas(serie, layout.header, topCoordinates, attributesSeries, customAttributes, metadataCoordinates);
+  	return R.concat(acc, datas);
+  }, [], header);
+
+  const sectionsData = R.map(
+  	([sectionSerie, rowsSeries]) => {
+  		const sectionData = getSerieDatas(sectionSerie, layout.sections, topCoordinates, attributesSeries, customAttributes, metadataCoordinates);
+  		return [
+  			R.last(sectionData),
+  			 R.reduce((acc, serie) => {
+  				const datas = getSerieDatas(serie, layout.rows, sectionData.coordinates, attributesSeries, customAttributes, metadataCoordinates);
+  				return R.concat(acc, datas);
+  			}, [], rowsSeries)
+  		];
+  	},
+  	sections
+  );
+
+  return ({ headerData, sectionsData, ...rest });
+};

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

@@ -1,8 +1,8 @@
-import * as R from 'ramda';
 import { getLayout } from './getLayout';
 import { getSortedLayoutIndexes } from './getSortedLayoutIndexes';
-import { refineLayoutSize } from './refineLayoutSize';
-import { getLayoutData } from './getLayoutData';
+import { parseLayoutIndexesHierarchies } from './parseSeriesIndexesHierarchies';
+import { refineLayoutSize } from './refineLayoutSize2';
+import { getLayoutData } from './getLayoutData2';
 import { getCellsAttributesIds } from './getCellsAttributesIds';
 import { getIndexedCombinationsByDisplay } from './getIndexedCombinationsByDisplay';
 import { getCells } from './getCells';
@@ -24,7 +24,11 @@ export const getTableProps = ({ data, layoutIds, customAttributes, limit, isTime
   const seriesCombinations = getSeriesCombinations(combinations, oneValueDimensions);
   const layout = getLayout(layoutIds, dimensions, seriesCombinations, isTimeInverted);
   const layoutIndexes = getSortedLayoutIndexes(layout, observations);
-  const refinedLayoutIndexes = refineLayoutSize({ layout, observations, limit })(layoutIndexes);
+  const enhancedLayoutIndexes = parseLayoutIndexesHierarchies(
+    layoutIndexes,
+    layout,
+  );
+  const refinedLayoutIndexes = refineLayoutSize({ layout, observations, limit })(enhancedLayoutIndexes);
   const layoutData = getLayoutData(refinedLayoutIndexes, layout, { metadataCoordinates, attributesSeries, customAttributes, topCoordinates: header.coordinates });
 
   const cellsAttributesIds = getCellsAttributesIds(layoutIds, attributes);

package/src/rules2/src/table/parseSeriesIndexesHierarchies.js

@@ -0,0 +1,62 @@
+import * as R from 'ramda';
+
+const parseSerieIndexesHierarchies = (serieIndexes, previousSerie, dimensions, isSameSerie = true) => {
+	return R.addIndex(R.reduce)((acc, _valueIndex, dimensionIndex) => {
+		if (R.is(Array, _valueIndex)) {
+      const previous = R.isEmpty(previousSerie) ? {} : {
+        indexes: R.nth(dimensionIndex, previousSerie.indexes || []),
+        parentsIndexes: R.nth(dimensionIndex, previousSerie.parentsIndexes || []),
+        missingIndexes: R.nth(dimensionIndex, previousSerie.missingIndexes || []),
+        registeredIndexes: R.nth(dimensionIndex, previousSerie.registeredIndexes || []),
+      };
+			const parsed = parseSerieIndexesHierarchies(_valueIndex, previous, R.pathOr([], [dimensionIndex, 'dimensions'], dimensions), acc.isSameSerie);
+			return ({
+      	parentsIndexes: R.append(parsed.parentsIndexes, acc.parentsIndexes),
+      	missingIndexes: R.append(parsed.missingIndexes, acc.missingIndexes),
+      	registeredIndexes: R.append(parsed.registeredIndexes, acc.registeredIndexes),
+        isSameSerie: parsed.isSameSerie
+    	});
+		}
+    const valueIndex = Math.abs(_valueIndex);
+    const _parentsIndexes = R.pathOr([], [dimensionIndex, 'values', valueIndex, 'parents'], dimensions);
+    const previousIndex = acc.isSameSerie ? R.pathOr(-1, ['indexes', dimensionIndex], previousSerie) : -1;
+    const previousRegisteredIndexes = acc.isSameSerie ? R.pathOr(new Set(), ['registeredIndexes', dimensionIndex], previousSerie) : new Set();
+    const registeredIndexes = new Set(previousRegisteredIndexes);
+    const [parentsIndexes, missingParentsIndexes] = R.reduce((_acc, ind) => {
+      if (previousRegisteredIndexes.has(ind)) {
+        return R.over(R.lensIndex(0), R.append(ind), _acc);
+      }
+      else if  (ind > previousIndex && R.pathOr(false, [dimensionIndex, 'values', ind, 'isSelected'], dimensions)) {
+        registeredIndexes.add(ind);
+        return R.over(R.lensIndex(1), R.append(ind), _acc);
+      }
+      return _acc;
+    }, [[], []], _parentsIndexes);
+    registeredIndexes.add(valueIndex);
+    return ({
+      parentsIndexes: R.append(parentsIndexes, acc.parentsIndexes),
+      missingIndexes: R.append(missingParentsIndexes, acc.missingIndexes),
+      registeredIndexes: R.append(registeredIndexes, acc.registeredIndexes),
+      isSameSerie: acc.isSameSerie && valueIndex === previousIndex
+    });
+  }, { parentsIndexes: [], missingIndexes: [], registeredIndexes: [], isSameSerie }, serieIndexes);
+};
+
+export const parseSeriesIndexesHierarchies = (seriesIndexes, dimensions) => R.reduce((acc, serieIndexes) => {
+	const previousSerie = R.last(acc) || {};
+	const { parentsIndexes, missingIndexes, registeredIndexes } = parseSerieIndexesHierarchies(serieIndexes, previousSerie, dimensions);
+	return R.append({ indexes: serieIndexes, parentsIndexes, missingIndexes, registeredIndexes }, acc);
+}, [], seriesIndexes);
+
+export const parseLayoutIndexesHierarchies = (layoutIndexes, layout) => {
+  const header = parseSeriesIndexesHierarchies(layoutIndexes.header, layout.header);
+  const sections = R.map(
+    ([sectionIndexes, rowsIndexes]) => ([
+      { indexes: sectionIndexes, parentsIndexes: [], missingIndexes: [] },
+      parseSeriesIndexesHierarchies(rowsIndexes, layout.rows)
+    ]),
+    layoutIndexes.sections
+  );
+
+  return ({ header, sections });
+};