@sis-cc/dotstatsuite-components 17.14.0 → 17.16.0

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
 	value: true
 });
-exports.getLayoutData = exports.getSerieDatas = undefined;
+exports.getLayoutData = exports.getSerieDataWithoutMissingLines = exports.getSerieDataWithMissingLines = undefined;
 
 var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
 
@@ -30,10 +30,12 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 var getValueData = function getValueData(index, dimension, parentsIndexes) {
+	var missingParents = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
 	return {
 		dimension: R.pick(['id', 'name', '__index'], dimension),
 		value: (0, _extends3.default)({}, R.pipe(R.pathOr({}, ['values', index]), R.pick(['id', 'name']))(dimension), {
-			parents: parentsIndexes
+			parents: parentsIndexes,
+			missingParents: missingParents
 		})
 	};
 };
@@ -55,8 +57,8 @@ var combinedValueDataSetter = function combinedValueDataSetter(valueData) {
 };
 
 var addValueToSerieData = function addValueToSerieData(dataSetter) {
-	return function (index, parentsIndexes, dimension, serieData) {
-		var valueData = getValueData(index, dimension, parentsIndexes);
+	return function (index, parentsIndexes, dimension, serieData, missingParents) {
+		var valueData = getValueData(index, dimension, parentsIndexes, missingParents);
 		var valueId = R.path(['value', 'id'], valueData);
 		return (0, _extends3.default)({}, serieData, {
 			data: dataSetter(valueData, R.prop('data', serieData)),
@@ -92,7 +94,7 @@ var getAttributesSeries = function getAttributesSeries(validator, attributesSeri
 		var attr = R.head(R.values(attrs));
 		var coordinates = R.propOr({}, 'coordinates', attr);
 		var isValid = validator(coordinates);
-		if (!isValid && !attr.isObs) {
+		if (!isValid && !R.prop('isObs', attr)) {
 			return acc;
 		}
 		return (0, _extends3.default)({}, acc, attrs);
@@ -128,27 +130,8 @@ var getSerieFlagsAndSideProps = function getSerieFlagsAndSideProps(coordinates,
 	return { flags: flags, sideProps: sideProps };
 };
 
-var getSerieDatas = exports.getSerieDatas = function getSerieDatas(serie, definition, topCoordinates, attributesSeries, customAttributes, metadataCoordinates) {
-	var lines = [];
-
-	var serieCoordinates = getCoordinates(serie.indexes, topCoordinates, definition);
-	var coordinatesValidator = (0, _utils.getLayoutCoordinatesValidator)(serieCoordinates, topCoordinates);
-	var attributesValues = getAttributesSeries(coordinatesValidator, attributesSeries);
-
-	var addMissingParentsLines = function addMissingParentsLines(dataSetter) {
-		return function (missingParentsIndexes, parentsIndexes, dim, serieData) {
-			return R.reduce(function (parents, index) {
-				var missingParentData = addValueToSerieData(dataSetter)(index, parents, dim, serieData);
-				lines.push(R.assoc('isEmpty', true, missingParentData));
-				return R.append(index, parents);
-			}, parentsIndexes, missingParentsIndexes);
-		};
-	};
-
-	var addSimpleMissingParentsLines = addMissingParentsLines(simpleValueDataSetter);
-	var addCombinedMissingParentsLines = addMissingParentsLines(combinedValueDataSetter);
-
-	var serieData = R.addIndex(R.reduce)(function (onGoingSerie, entry, index) {
+var getSerieDimensionsData = function getSerieDimensionsData(serie, definition, attributesValues, missingParentsGetter) {
+	return R.addIndex(R.reduce)(function (onGoingSerie, entry, index) {
 		if (R.has('dimensions', entry)) {
 			var combValuesIndexes = R.pathOr([], ['indexes', index], serie);
 			var combParentsIndexes = R.pathOr([], ['parentsIndexes', index], serie);
@@ -158,33 +141,90 @@ var getSerieDatas = exports.getSerieDatas = function getSerieDatas(serie, defini
 				var valueIndex = Math.abs(R.nth(dimIndex, combValuesIndexes));
 				var _parentsIndexes = R.nth(dimIndex, combParentsIndexes) || [];
 				var missingParentsIndexes = R.nth(dimIndex, combMissingParentsIndexes) || [];
-				var parentsIndexes = addCombinedMissingParentsLines(missingParentsIndexes, _parentsIndexes, dimension, combSerie);
-				var next = addCombinedValueToSerieData(valueIndex, parentsIndexes, dimension, combSerie);
+
+				var _missingParentsGetter = missingParentsGetter(combinedValueDataSetter)(missingParentsIndexes, _parentsIndexes, dimension, combSerie),
+				    parentsIndexes = _missingParentsGetter.parentsIndexes,
+				    missingParents = _missingParentsGetter.missingParents;
+
+				var next = addCombinedValueToSerieData(valueIndex, parentsIndexes, dimension, combSerie, missingParents);
 				var 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));
 
-			var combined = combineConcepts(combDimValues, entry, attributesValues)(res);
-			attributesValues = R.omit(entry.concepts, attributesValues);
-			return combined;
+			var combined = combineConcepts(combDimValues, entry, onGoingSerie.attributes)(res);
+			return R.over(R.lensProp('attributes'), R.omit(entry.concepts), combined);
 		}
 
 		var valueIndex = Math.abs(R.path(['indexes', index], serie));
 		var _parentsIndexes = R.pathOr([], ['parentsIndexes', index], serie);
 		var missingParentsIndexes = R.pathOr([], ['missingIndexes', index], serie);
-		var parentsIndexes = addSimpleMissingParentsLines(missingParentsIndexes, _parentsIndexes, entry, onGoingSerie);
-		return addSimpleValueToSerieData(valueIndex, parentsIndexes, entry, onGoingSerie);
-	}, { data: [], coordinates: {}, key: '', sideProps: null, flags: [] }, definition);
 
-	var _getSerieFlagsAndSide = getSerieFlagsAndSideProps(serieCoordinates, coordinatesValidator, attributesValues, customAttributes, metadataCoordinates),
+		var _missingParentsGetter2 = missingParentsGetter(simpleValueDataSetter)(missingParentsIndexes, _parentsIndexes, entry, onGoingSerie),
+		    parentsIndexes = _missingParentsGetter2.parentsIndexes,
+		    missingParents = _missingParentsGetter2.missingParents;
+
+		return addSimpleValueToSerieData(valueIndex, parentsIndexes, entry, onGoingSerie, missingParents);
+	}, { data: [], key: '', attributes: attributesValues }, definition);
+};
+
+var getSerieDataWithMissingLines = function getSerieDataWithMissingLines(serie, definition, topCoordinates, attributesSeries, customAttributes, metadataCoordinates) {
+	var lines = [];
+
+	var serieCoordinates = getCoordinates(serie.indexes, topCoordinates, definition);
+	var coordinatesValidator = (0, _utils.getLayoutCoordinatesValidator)(serieCoordinates, topCoordinates);
+	var attributesValues = getAttributesSeries(coordinatesValidator, attributesSeries);
+
+	var getMissingParents = function getMissingParents(dataSetter) {
+		return function (missingParentsIndexes, _parentsIndexes, dim, serieData) {
+			return R.reduce(function (acc, index) {
+				var missingParentData = addValueToSerieData(dataSetter)(index, acc.parentsIndexes, dim, serieData);
+				lines.push((0, _extends3.default)({}, R.dissoc('attributes', missingParentData), { sideProps: null, flags: [], isEmpty: true }));
+				return R.over(R.lensProp('parentsIndexes'), R.append(index), acc);
+			}, { parentsIndexes: _parentsIndexes, missingParents: [] }, missingParentsIndexes);
+		};
+	};
+
+	var _getSerieDimensionsDa = getSerieDimensionsData(serie, definition, attributesValues, getMissingParents),
+	    attributes = _getSerieDimensionsDa.attributes,
+	    serieData = (0, _objectWithoutProperties3.default)(_getSerieDimensionsDa, ['attributes']);
+
+	var _getSerieFlagsAndSide = getSerieFlagsAndSideProps(serieCoordinates, coordinatesValidator, attributes, customAttributes, metadataCoordinates),
 	    flags = _getSerieFlagsAndSide.flags,
 	    sideProps = _getSerieFlagsAndSide.sideProps;
 
-	lines.push((0, _extends3.default)({}, serieData, { flags: flags, sideProps: sideProps }));
-	return lines;
+	return R.append((0, _extends3.default)({}, serieData, { flags: flags, sideProps: sideProps }), lines);
+};
+
+exports.getSerieDataWithMissingLines = getSerieDataWithMissingLines;
+var getSerieDataWithoutMissingLines = function getSerieDataWithoutMissingLines(serie, definition, topCoordinates, attributesSeries, customAttributes, metadataCoordinates) {
+	var serieCoordinates = getCoordinates(serie.indexes, topCoordinates, definition);
+	var coordinatesValidator = (0, _utils.getLayoutCoordinatesValidator)(serieCoordinates, topCoordinates);
+	var attributesValues = getAttributesSeries(coordinatesValidator, attributesSeries);
+
+	var getMissingParents = function getMissingParents() {
+		return function (missingParentsIndexes, _parentsIndexes, dim) {
+			return R.reduce(function (acc, index) {
+				return {
+					parentsIndexes: R.append(index, acc.parentsIndexes),
+					missingParents: R.append(R.prop('value', getValueData(index, dim, acc.parentsIndexes)), acc.missingParents)
+				};
+			}, { parentsIndexes: _parentsIndexes, missingParents: [] }, missingParentsIndexes);
+		};
+	};
+
+	var _getSerieDimensionsDa2 = getSerieDimensionsData(serie, definition, attributesValues, getMissingParents),
+	    attributes = _getSerieDimensionsDa2.attributes,
+	    serieData = (0, _objectWithoutProperties3.default)(_getSerieDimensionsDa2, ['attributes']);
+
+	var _getSerieFlagsAndSide2 = getSerieFlagsAndSideProps(serieCoordinates, coordinatesValidator, attributes, customAttributes, metadataCoordinates),
+	    flags = _getSerieFlagsAndSide2.flags,
+	    sideProps = _getSerieFlagsAndSide2.sideProps;
+
+	return (0, _extends3.default)({}, serieData, { flags: flags, sideProps: sideProps });
 };
 
+exports.getSerieDataWithoutMissingLines = getSerieDataWithoutMissingLines;
 var getLayoutData = function getLayoutData(layoutIndexes, layout, _ref) {
 	var metadataCoordinates = _ref.metadataCoordinates,
 	    attributesSeries = _ref.attributesSeries,
@@ -197,7 +237,7 @@ var getLayoutData = function getLayoutData(layoutIndexes, layout, _ref) {
 
 
 	var headerData = R.reduce(function (acc, serie) {
-		var datas = getSerieDatas(serie, layout.header, topCoordinates, attributesSeries, customAttributes, metadataCoordinates);
+		var datas = getSerieDataWithMissingLines(serie, layout.header, topCoordinates, attributesSeries, customAttributes, metadataCoordinates);
 		return R.concat(acc, datas);
 	}, [], header);
 
@@ -206,9 +246,9 @@ var getLayoutData = function getLayoutData(layoutIndexes, layout, _ref) {
 		    sectionSerie = _ref3[0],
 		    rowsSeries = _ref3[1];
 
-		var sectionData = getSerieDatas(sectionSerie, layout.sections, topCoordinates, attributesSeries, customAttributes, metadataCoordinates);
-		return [R.last(sectionData), R.reduce(function (acc, serie) {
-			var datas = getSerieDatas(serie, layout.rows, sectionData.coordinates, attributesSeries, customAttributes, metadataCoordinates);
+		var sectionData = getSerieDataWithoutMissingLines(sectionSerie, layout.sections, topCoordinates, attributesSeries, customAttributes, metadataCoordinates, false);
+		return [sectionData, R.reduce(function (acc, serie) {
+			var datas = getSerieDataWithMissingLines(serie, layout.rows, R.propOr(topCoordinates, 'coordinates', sectionData), attributesSeries, customAttributes, metadataCoordinates);
 			return R.concat(acc, datas);
 		}, [], rowsSeries)];
 	}, sections);

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

@@ -13,6 +13,14 @@ var _set = require('babel-runtime/core-js/set');
 
 var _set2 = _interopRequireDefault(_set);
 
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
+var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');
+
+var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
+
 var _ramda = require('ramda');
 
 var R = _interopRequireWildcard(_ramda);
@@ -21,76 +29,81 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+var registerParsedIndexes = function registerParsedIndexes(_ref, register) {
+  var isSameSerie = _ref.isSameSerie,
+      parsed = (0, _objectWithoutProperties3.default)(_ref, ['isSameSerie']);
+
+  var merged = R.mergeWith(function (a, b) {
+    return R.append(a || [], b);
+  }, parsed, register);
+  return (0, _extends3.default)({}, merged, { isSameSerie: isSameSerie });
+};
+
 var parseSerieIndexesHierarchies = function parseSerieIndexesHierarchies(serieIndexes, previousSerie, dimensions) {
-  var isSameSerie = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+  var defaultIsSameSerie = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
 
   return R.addIndex(R.reduce)(function (acc, _valueIndex, dimensionIndex) {
     if (R.is(Array, _valueIndex)) {
-      var 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 || [])
-      };
+      var previous = R.isEmpty(previousSerie) ? {} : R.map(R.nth(dimensionIndex), previousSerie);
       var 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
-      };
+      return registerParsedIndexes(parsed, acc);
     }
     var valueIndex = Math.abs(_valueIndex);
-    var _parentsIndexes = R.pathOr([], [dimensionIndex, 'values', valueIndex, 'parents'], dimensions);
+    var parents = R.pathOr([], [dimensionIndex, 'values', valueIndex, 'parents'], dimensions);
     var previousIndex = acc.isSameSerie ? R.pathOr(-1, ['indexes', dimensionIndex], previousSerie) : -1;
     var previousRegisteredIndexes = acc.isSameSerie ? R.pathOr(new _set2.default(), ['registeredIndexes', dimensionIndex], previousSerie) : new _set2.default();
     var registeredIndexes = new _set2.default(previousRegisteredIndexes);
 
-    var _R$reduce = R.reduce(function (_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);
+    var _R$reduce = R.reduce(function (_acc, i) {
+      if (previousRegisteredIndexes.has(i)) {
+        return R.over(R.lensProp('presentParentsIndexes'), function (p) {
+          return R.isNil(p) ? [i] : R.append(i, p);
+        }, _acc);
+      } else if (i > previousIndex && R.pathOr(false, [dimensionIndex, 'values', i, 'isSelected'], dimensions)) {
+        registeredIndexes.add(i);
+        return R.over(R.lensProp('missingParentsIndexes'), function (m) {
+          return R.isNil(m) ? [i] : R.append(i, m);
+        }, _acc);
       }
       return _acc;
-    }, [[], []], _parentsIndexes),
-        _R$reduce2 = (0, _slicedToArray3.default)(_R$reduce, 2),
-        parentsIndexes = _R$reduce2[0],
-        missingParentsIndexes = _R$reduce2[1];
+    }, {}, parents),
+        presentParentsIndexes = _R$reduce.presentParentsIndexes,
+        missingParentsIndexes = _R$reduce.missingParentsIndexes;
 
     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: isSameSerie }, serieIndexes);
+    return registerParsedIndexes({ parentsIndexes: presentParentsIndexes, missingIndexes: missingParentsIndexes, registeredIndexes: registeredIndexes, isSameSerie: acc.isSameSerie && valueIndex === previousIndex }, acc);
+  }, { parentsIndexes: [], missingIndexes: [], registeredIndexes: [], isSameSerie: defaultIsSameSerie }, serieIndexes);
 };
 
-var parseSeriesIndexesHierarchies = exports.parseSeriesIndexesHierarchies = function parseSeriesIndexesHierarchies(seriesIndexes, dimensions) {
+var parseSeriesIndexesHierarchies = function parseSeriesIndexesHierarchies(seriesIndexes, dimensions) {
   return R.reduce(function (acc, serieIndexes) {
     var previousSerie = R.last(acc) || {};
 
     var _parseSerieIndexesHie = parseSerieIndexesHierarchies(serieIndexes, previousSerie, dimensions),
-        parentsIndexes = _parseSerieIndexesHie.parentsIndexes,
-        missingIndexes = _parseSerieIndexesHie.missingIndexes,
-        registeredIndexes = _parseSerieIndexesHie.registeredIndexes;
+        isSameSerie = _parseSerieIndexesHie.isSameSerie,
+        parsed = (0, _objectWithoutProperties3.default)(_parseSerieIndexesHie, ['isSameSerie']);
 
-    return R.append({ indexes: serieIndexes, parentsIndexes: parentsIndexes, missingIndexes: missingIndexes, registeredIndexes: registeredIndexes }, acc);
+    return R.append(R.assoc('indexes', serieIndexes, parsed), acc);
   }, [], seriesIndexes);
 };
 
+exports.parseSeriesIndexesHierarchies = parseSeriesIndexesHierarchies;
 var parseLayoutIndexesHierarchies = exports.parseLayoutIndexesHierarchies = function parseLayoutIndexesHierarchies(layoutIndexes, layout) {
   var header = parseSeriesIndexesHierarchies(layoutIndexes.header, layout.header);
-  var sections = R.map(function (_ref) {
-    var _ref2 = (0, _slicedToArray3.default)(_ref, 2),
-        sectionIndexes = _ref2[0],
-        rowsIndexes = _ref2[1];
+  var sections = R.pipe(R.transpose, function (_ref2) {
+    var _ref3 = (0, _slicedToArray3.default)(_ref2, 2),
+        _sections = _ref3[0],
+        _sectionsRows = _ref3[1];
 
-    return [{ indexes: sectionIndexes, parentsIndexes: [], missingIndexes: [] }, parseSeriesIndexesHierarchies(rowsIndexes, layout.rows)];
-  }, layoutIndexes.sections);
+    if (R.isNil(_sections)) {
+      return [];
+    }
+    var sections = parseSeriesIndexesHierarchies(_sections, layout.sections);
+    var sectionsRows = R.map(function (rows) {
+      return parseSeriesIndexesHierarchies(rows, layout.rows);
+    }, _sectionsRows);
+    return R.transpose([sections, sectionsRows]);
+  })(layoutIndexes.sections);
 
   return { header: header, sections: sections };
 };

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

@@ -17,6 +17,10 @@ var _extends3 = require('babel-runtime/helpers/extends');
 
 var _extends4 = _interopRequireDefault(_extends3);
 
+var _set = require('babel-runtime/core-js/set');
+
+var _set2 = _interopRequireDefault(_set);
+
 var _ramda = require('ramda');
 
 var R = _interopRequireWildcard(_ramda);
@@ -27,8 +31,11 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 
 var toKey = function toKey(indexes) {
   return R.reduce(function (acc, _ind) {
-    var ind = R.is(Array, _ind) ? toKey(_ind) : Math.abs(_ind);
-    return R.isEmpty(acc) ? String(ind) : acc + ':' + ind;
+    var ind = R.is(Array, _ind) ? toKey(_ind) : String(Math.abs(_ind));
+    if (R.isEmpty(ind)) {
+      return acc;
+    }
+    return R.isEmpty(acc) ? ind : acc + ':' + ind;
   }, '', indexes);
 };
 
@@ -60,26 +67,70 @@ var getCuratedCells = exports.getCuratedCells = function getCuratedCells(_ref) {
   return indexWithPivots(pivots, observations);
 };
 
+var filterSeries = function filterSeries(series, getHasStillData) {
+  var removedMissingIndexes = [];
+  return R.reduce(function (acc, serie) {
+    var hasStillData = getHasStillData(serie);
+    var serieParentsSets = R.map(function (p) {
+      return new _set2.default(p);
+    }, R.propOr([], 'parentsIndexes', serie));
+    if (!hasStillData) {
+      removedMissingIndexes = R.addIndex(R.map)(function (mIs, ind) {
+        var filtered = R.filter(function (i) {
+          return serieParentsSets[ind].has(i);
+        }, R.nth(ind, removedMissingIndexes) || []);
+        return R.concat(filtered, mIs);
+      }, serie.missingIndexes || []);
+      return acc;
+    }
+    var _serie = R.pipe(R.over(R.lensProp('missingIndexes'), function () {
+      var missingIndexes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      return R.addIndex(R.map)(function (mIs, ind) {
+        var removed = R.nth(ind, removedMissingIndexes) || [];
+        if (R.isEmpty(removed)) {
+          return mIs;
+        }
+        var filteredRemoved = R.filter(function (i) {
+          return serieParentsSets[ind].has(i);
+        }, removed);
+        return R.concat(filteredRemoved, mIs || []);
+      }, missingIndexes);
+    }), R.over(R.lensProp('parentsIndexes'), function () {
+      var parentsIndexes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      return R.addIndex(R.map)(function (p, ind) {
+        return R.reject(function (i) {
+          return R.includes(i, R.nth(ind, removedMissingIndexes) || []);
+        }, p || []);
+      }, parentsIndexes);
+    }))(serie);
+    removedMissingIndexes = [];
+    return R.append(_serie, acc);
+  }, [], series);
+};
+
 var refineSections = exports.refineSections = function refineSections(sections, extractedKeys, curatedObs) {
   return R.pipe(R.map(function (section) {
     var sectionKey = toKey(R.propOr([], 'indexes', R.head(section)));
-    return R.over(R.lensIndex(1), R.filter(function (row) {
+    var getHasRowStillData = function getHasRowStillData(row) {
       var rowKey = toKey(R.prop('indexes', row));
       return R.pipe(R.path([sectionKey, rowKey]), R.omit(extractedKeys), R.isEmpty, R.not)(curatedObs);
-    }))(section);
+    };
+    return R.over(R.lensIndex(1), function (rows) {
+      return filterSeries(rows, getHasRowStillData);
+    })(section);
   }), R.filter(R.pipe(R.nth(1), R.isEmpty, R.not)))(sections);
 };
 
-var refineHeader = exports.refineHeader = function refineHeader(header, extractedKeys, curatedObs) {
-  return R.filter( // extracted : { [sectionKey]: [...rowKeys] }
-  function (header) {
+var refineHeader = exports.refineHeader = function refineHeader(headers, extractedKeys, curatedObs) {
+  var getHasHeaderStillData = function getHasHeaderStillData(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);
       }, sections);
     }, R.isEmpty, R.not)(curatedObs);
-  })(header);
+  };
+  return filterSeries(headers, getHasHeaderStillData);
 };
 
 var getSerieLinesCount = function getSerieLinesCount(serie) {

package/package.json

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

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

@@ -2,11 +2,12 @@ import * as R from 'ramda';
 import { getFlagsAndNotes } from './getFlagsAndNotes';
 import { getLayoutCoordinatesValidator } from '../utils';
 
-const getValueData = (index, dimension, parentsIndexes) => ({
+const getValueData = (index, dimension, parentsIndexes, missingParents = []) => ({
 	dimension: R.pick(['id', 'name', '__index'], dimension),
 	value: {
 		...R.pipe(R.pathOr({}, ['values', index]), R.pick(['id', 'name']))(dimension),
-		parents: parentsIndexes
+		parents: parentsIndexes,
+		missingParents
 	}
 });
 
@@ -18,8 +19,8 @@ const simpleValueDataSetter = (valueData, datas = []) => R.append(valueData, dat
 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 addValueToSerieData = (dataSetter) => (index, parentsIndexes, dimension, serieData, missingParents) => {
+	const valueData = getValueData(index, dimension, parentsIndexes, missingParents);
 	const valueId = R.path(['value', 'id'], valueData);
 	return ({
 		...serieData,
@@ -54,7 +55,7 @@ const getAttributesSeries = (validator, attributesSeries) => R.reduce((acc, attr
 	const attr = R.head(R.values(attrs));
 	const coordinates = R.propOr({}, 'coordinates', attr);
 	const isValid = validator(coordinates);
-	if (!isValid && !attr.isObs) {
+	if (!isValid && !R.prop('isObs', attr)) {
 		return acc;
 	}
 	return ({ ...acc, ...attrs });
@@ -89,81 +90,95 @@ const getSerieFlagsAndSideProps = (coordinates, validator, attributesValues, cus
 	return { flags, sideProps };
 };
 
-export const getSerieDatas = (serie, definition, topCoordinates, attributesSeries, customAttributes, metadataCoordinates) => {
+const getSerieDimensionsData = (serie, definition, attributesValues, missingParentsGetter) =>  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, missingParents } = missingParentsGetter(combinedValueDataSetter)(missingParentsIndexes, _parentsIndexes, dimension, combSerie);
+				const next = addCombinedValueToSerieData(valueIndex, parentsIndexes, dimension, combSerie, missingParents);
+				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, onGoingSerie.attributes)(res);
+			return  R.over(R.lensProp('attributes'), R.omit(entry.concepts), 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, missingParents } =  missingParentsGetter(simpleValueDataSetter)(missingParentsIndexes, _parentsIndexes, entry, onGoingSerie);
+		return addSimpleValueToSerieData(valueIndex, parentsIndexes, entry, onGoingSerie, missingParents);
+	},
+	{ data: [], key: '', attributes: attributesValues },
+	definition,
+);
+
+export const getSerieDataWithMissingLines = (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 attributesValues = getAttributesSeries(coordinatesValidator, attributesSeries);
 
-			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);
+	const getMissingParents = dataSetter => (missingParentsIndexes, _parentsIndexes, dim, serieData) => R.reduce(
+		(acc, index) => {
+				const missingParentData = addValueToSerieData(dataSetter)(index, acc.parentsIndexes, dim, serieData);
+				lines.push({ ...R.dissoc('attributes', missingParentData), sideProps: null, flags: [], isEmpty: true });
+			return R.over(R.lensProp('parentsIndexes'), R.append(index), acc);
 		},
-		{ data: [], coordinates: {}, key: '', sideProps: null, flags: [] },
-		definition,
-	);
-	const { flags, sideProps } = getSerieFlagsAndSideProps(serieCoordinates, coordinatesValidator, attributesValues, customAttributes, metadataCoordinates);
-	lines.push({ ...serieData, flags, sideProps });
-	return lines;
+	{ parentsIndexes: _parentsIndexes, missingParents: [] }, missingParentsIndexes);
+
+	const { attributes, ...serieData } = getSerieDimensionsData(serie, definition, attributesValues, getMissingParents);
+	const { flags, sideProps } = getSerieFlagsAndSideProps(serieCoordinates, coordinatesValidator, attributes, customAttributes, metadataCoordinates);
+	return R.append({ ...serieData, flags, sideProps }, lines);
+};
+
+export const getSerieDataWithoutMissingLines = (serie, definition, topCoordinates, attributesSeries, customAttributes, metadataCoordinates) => {
+	const serieCoordinates = getCoordinates(serie.indexes, topCoordinates, definition);
+	const coordinatesValidator = getLayoutCoordinatesValidator(serieCoordinates, topCoordinates);
+	const attributesValues = getAttributesSeries(coordinatesValidator, attributesSeries);
+
+	const getMissingParents = () => (missingParentsIndexes, _parentsIndexes, dim) => R.reduce(
+		(acc, index) => ({
+			parentsIndexes: R.append(index, acc.parentsIndexes),
+			missingParents: R.append(R.prop('value', getValueData(index, dim, acc.parentsIndexes)), acc.missingParents)
+		}),
+	{ parentsIndexes: _parentsIndexes, missingParents: [] }, missingParentsIndexes);
+
+	const { attributes, ...serieData } = getSerieDimensionsData(serie, definition, attributesValues, getMissingParents);
+	const { flags, sideProps } = getSerieFlagsAndSideProps(serieCoordinates, coordinatesValidator, attributes, customAttributes, metadataCoordinates);
+	return ({ ...serieData, flags, sideProps });
 };
 
 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);
+  	const datas = getSerieDataWithMissingLines(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);
+  		const sectionData = getSerieDataWithoutMissingLines(sectionSerie, layout.sections, topCoordinates, attributesSeries, customAttributes, metadataCoordinates, false);
   		return [
-  			R.last(sectionData),
+  			sectionData,
   			 R.reduce((acc, serie) => {
-  				const datas = getSerieDatas(serie, layout.rows, sectionData.coordinates, attributesSeries, customAttributes, metadataCoordinates);
+  				const datas = getSerieDataWithMissingLines(serie, layout.rows, R.propOr(topCoordinates, 'coordinates', sectionData), attributesSeries, customAttributes, metadataCoordinates);
   				return R.concat(acc, datas);
   			}, [], rowsSeries)
   		];

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

@@ -1,62 +1,59 @@
 import * as R from 'ramda';
 
-const parseSerieIndexesHierarchies = (serieIndexes, previousSerie, dimensions, isSameSerie = true) => {
+const registerParsedIndexes = ({ isSameSerie, ...parsed }, register) => {
+  const merged = R.mergeWith((a, b) => R.append(a || [], b), parsed, register);
+  return ({ ...merged, isSameSerie });
+};
+
+const parseSerieIndexesHierarchies = (serieIndexes, previousSerie, dimensions, defaultIsSameSerie = 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 previous = R.isEmpty(previousSerie) ? {} : R.map(R.nth(dimensionIndex), previousSerie);
 			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
-    	});
+      return registerParsedIndexes(parsed, acc);
 		}
     const valueIndex = Math.abs(_valueIndex);
-    const _parentsIndexes = R.pathOr([], [dimensionIndex, 'values', valueIndex, 'parents'], dimensions);
+    const parents = 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);
+    const { presentParentsIndexes, missingParentsIndexes } = R.reduce((_acc, i) => {
+      if (previousRegisteredIndexes.has(i)) {
+        return R.over(R.lensProp('presentParentsIndexes'), p => R.isNil(p) ? [i] : R.append(i, p), _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);
+      else if (i > previousIndex && R.pathOr(false, [dimensionIndex, 'values', i, 'isSelected'], dimensions)) {
+        registeredIndexes.add(i);
+        return R.over(R.lensProp('missingParentsIndexes'), m => R.isNil(m) ? [i] :  R.append(i, m), _acc);
       }
       return _acc;
-    }, [[], []], _parentsIndexes);
+    }, {}, parents);
     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);
+    return registerParsedIndexes({ parentsIndexes: presentParentsIndexes, missingIndexes: missingParentsIndexes, registeredIndexes, isSameSerie: acc.isSameSerie && valueIndex === previousIndex }, acc);
+  }, { parentsIndexes: [], missingIndexes: [], registeredIndexes: [], isSameSerie: defaultIsSameSerie }, 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 parseSeriesIndexesHierarchies = (seriesIndexes, dimensions) => {
+  return R.reduce((acc, serieIndexes) => {
+    const previousSerie = R.last(acc) || {};
+    const { isSameSerie, ...parsed } = parseSerieIndexesHierarchies(serieIndexes, previousSerie, dimensions);
+    return R.append(R.assoc('indexes', serieIndexes, parsed), 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
-  );
+  const sections = R.pipe(
+    R.transpose,
+    ([_sections, _sectionsRows]) => {
+      if (R.isNil(_sections)) {
+        return [];
+      }
+      const sections = parseSeriesIndexesHierarchies(_sections, layout.sections);
+      const sectionsRows = R.map(rows => parseSeriesIndexesHierarchies(rows, layout.rows), _sectionsRows);
+      return R.transpose([sections, sectionsRows]);
+    }
+  )(layoutIndexes.sections);
+
 
   return ({ header, sections });
 };

package/src/rules2/src/table/refineLayoutSize2.js

@@ -2,8 +2,11 @@ import * as R from 'ramda';
 
 const toKey = indexes => R.reduce(
   (acc, _ind) => {
-    const ind = R.is(Array, _ind) ? toKey(_ind) : Math.abs(_ind);
-    return R.isEmpty(acc) ? String(ind) : `${acc}:${ind}`
+    const ind = R.is(Array, _ind) ? toKey(_ind) : String(Math.abs(_ind));
+    if (R.isEmpty(ind)) {
+      return acc;
+    }
+    return R.isEmpty(acc) ? ind : `${acc}:${ind}`
   },
   '',
   indexes
@@ -47,23 +50,58 @@ export const getCuratedCells = ({ layout, observations, shape }) => {
   return indexWithPivots(pivots, observations);
 };
 
+const filterSeries = (series, getHasStillData) => {
+  let removedMissingIndexes = [];
+  return R.reduce((acc, serie) => {
+    const hasStillData = getHasStillData(serie);
+    const serieParentsSets = R.map(p => new Set(p), R.propOr([], 'parentsIndexes', serie));
+    if (!hasStillData) {
+      removedMissingIndexes = R.addIndex(R.map)((mIs, ind) => {
+        const filtered = R.filter(i => serieParentsSets[ind].has(i), R.nth(ind, removedMissingIndexes) || []);
+        return R.concat(filtered, mIs);
+      }, serie.missingIndexes || []);
+      return acc;
+    }
+    const _serie = R.pipe(
+      R.over(
+        R.lensProp('missingIndexes'),
+        (missingIndexes = []) => R.addIndex(R.map)((mIs, ind) => {
+          const removed = R.nth(ind, removedMissingIndexes) || [];
+          if (R.isEmpty(removed)) {
+            return mIs;
+          }
+          const filteredRemoved = R.filter(i => serieParentsSets[ind].has(i), removed);
+          return R.concat(filteredRemoved, mIs || []);
+        }, missingIndexes)
+      ),
+      R.over(
+        R.lensProp('parentsIndexes'),
+        (parentsIndexes = []) => R.addIndex(R.map)((p, ind) => {
+          return R.reject(i => R.includes(i, R.nth(ind, removedMissingIndexes) || []), p || []);
+        }, parentsIndexes)
+      )
+    )(serie);
+    removedMissingIndexes = [];
+    return R.append(_serie, acc);
+  }, [], series);
+};
+
 export const refineSections = (sections, extractedKeys, curatedObs) => R.pipe(
   R.map(
     (section) => {
       const sectionKey = toKey(R.propOr([], 'indexes', R.head(section)));
+      const getHasRowStillData = (row) => {
+        const rowKey = toKey(R.prop('indexes', row));
+        return R.pipe(
+          R.path([sectionKey, rowKey]),
+          R.omit(extractedKeys),
+          R.isEmpty,
+          R.not
+        )(curatedObs);
+      };
       return R.over(
         R.lensIndex(1),
-        R.filter(
-          row => {
-            const rowKey = toKey(R.prop('indexes', row));
-            return R.pipe(
-              R.path([sectionKey, rowKey]),
-              R.omit(extractedKeys),
-              R.isEmpty,
-              R.not
-            )(curatedObs);
-          }
-        )
+        rows => filterSeries(rows, getHasRowStillData)
       )(section);
     }
   ),
@@ -72,8 +110,8 @@ export const refineSections = (sections, extractedKeys, curatedObs) => R.pipe(
   )
 )(sections);
 
-export const refineHeader = (header, extractedKeys, curatedObs) => R.filter( // extracted : { [sectionKey]: [...rowKeys] }
-  (header) => {
+export const refineHeader = (headers, extractedKeys, curatedObs) => {
+  const getHasHeaderStillData = (header) => {
     const headerKey = toKey(R.prop('indexes', header));
     return R.pipe(
       R.prop(headerKey),
@@ -90,8 +128,9 @@ export const refineHeader = (header, extractedKeys, curatedObs) => R.filter( //
       R.isEmpty,
       R.not
     )(curatedObs);
-  }
-)(header);
+  };
+  return filterSeries(headers, getHasHeaderStillData);
+};
 
 const getSerieLinesCount = serie => {
   const missingParents = R.propOr([], 'missingParents', serie);
@@ -245,7 +284,7 @@ export const refineLayoutSize = ({ layout, observations, limit }) => layoutIndex
   // total of cells in one column
   const columnCellsCount = headerDimCount + rowsCount;
 
-  const isVertical = columnCellsCount > rowCellsCount
+  const isVertical = columnCellsCount > rowCellsCount;
 
   const [toTruncate, toRefine] = segregateLayout(isVertical)(layoutIndexes);
 

package/test/getLayoutData2.test.js

@@ -1,8 +1,8 @@
 import { expect } from 'chai';
-import { getSerieDatas } from '../src/rules2/src/table/getLayoutData2';
+import { getSerieDataWithMissingLines, getSerieDataWithoutMissingLines } from '../src/rules2/src/table/getLayoutData2';
 
 describe('getLayoutData 2 tests', () => {
-  it('getSerieDatas test 1', () => {
+  it('getSerieDataWithMissingLines test 1', () => {
     const dimensions = [
 			{
 				id: 'D0',
@@ -28,9 +28,9 @@ describe('getLayoutData 2 tests', () => {
 		];
 
     const serie = { indexes: [0, 3], parentsIndexes: [[], []], missingIndexes: [[], [0, 2]] };
-    expect(getSerieDatas(serie, dimensions, {}, {}, {}, {})).to.deep.equal([
+    expect(getSerieDataWithMissingLines(serie, dimensions, {}, {}, {}, {})).to.deep.equal([
       {
-        data: [{ dimension: { id: 'D0' }, value: { id: 'v0', parents: [] } }, { dimension: { id: 'D1' }, value: { id: 'W', parents: [] } }],
+        data: [{ dimension: { id: 'D0' }, value: { id: 'v0', parents: [], missingParents: [] } }, { dimension: { id: 'D1' }, value: { id: 'W', parents: [], missingParents: [] } }],
         coordinates: { D0: 'v0', D1: 'W' },
         key: 'D0=v0:D1=W',
         flags: [],
@@ -38,7 +38,7 @@ describe('getLayoutData 2 tests', () => {
 				isEmpty: true,
       },
       {
-        data: [{ dimension: { id: 'D0' }, value: { id: 'v0', parents: [] } }, { dimension: { id: 'D1' }, value: { id: 'A', parents: [0] } }],
+        data: [{ dimension: { id: 'D0' }, value: { id: 'v0', parents: [], missingParents: [] } }, { dimension: { id: 'D1' }, value: { id: 'A', parents: [0], missingParents: [] } }],
         coordinates: { D0: 'v0', D1: 'A' },
         key: 'D0=v0:D1=A',
         flags: [],
@@ -46,7 +46,7 @@ describe('getLayoutData 2 tests', () => {
 				isEmpty: true
       },
       {
-        data: [{ dimension: { id: 'D0' }, value: { id: 'v0', parents: [] } }, { dimension: { id: 'D1' }, value: { id: 'USA', parents: [0, 2] } }],
+        data: [{ dimension: { id: 'D0' }, value: { id: 'v0', parents: [], missingParents: [] } }, { dimension: { id: 'D1' }, value: { id: 'USA', parents: [0, 2], missingParents: [] } }],
         coordinates: { D0: 'v0', D1: 'USA' },
         key: 'D0=v0:D1=USA',
         flags: [],
@@ -54,7 +54,7 @@ describe('getLayoutData 2 tests', () => {
       }
     ]);
   });
-  it('getSerieDatas test 2', () => {
+  it('getSerieDataWithMissingLines test 2', () => {
   	const dimensions = [
   		{
 				id: 'D0',
@@ -128,10 +128,10 @@ describe('getLayoutData 2 tests', () => {
   		missingIndexes: [[0, 2], [[0, 1], [0, 1]], [[0, 1], [0, 1]]],
   	};
 
-  	expect(getSerieDatas(serie, dimensions, topCoordinates, attributesSeries, {}, {})).to.deep.equal([
+  	expect(getSerieDataWithMissingLines(serie, dimensions, topCoordinates, attributesSeries, {}, {})).to.deep.equal([
   		{
   			data: [
-  				{ dimension: { id: 'D0' }, value: { id: 'W', parents: [] } }
+  				{ dimension: { id: 'D0' }, value: { id: 'W', parents: [], missingParents: [] } }
   			],
   			coordinates: { D0: 'W' },
   			key: 'D0=W',
@@ -141,7 +141,7 @@ describe('getLayoutData 2 tests', () => {
   		},
   		{
   			data: [
-  				{ dimension: { id: 'D0' }, value: { id: 'A', parents: [0] } }
+  				{ dimension: { id: 'D0' }, value: { id: 'A', parents: [0], missingParents: [] } }
   			],
   			coordinates: { D0: 'A' },
   			key: 'D0=A',
@@ -151,8 +151,8 @@ describe('getLayoutData 2 tests', () => {
   		},
   		{
   			data: [
-  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2] } },
-  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT', parents: [] }] }
+  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2], missingParents: [] } },
+  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT', parents: [], missingParents: [] }] }
   			],
   			coordinates: { D0: 'USA', D1: 'D1ROOT' },
   			key: 'D0=USA:D1=D1ROOT',
@@ -162,8 +162,8 @@ describe('getLayoutData 2 tests', () => {
   		},
   		{
   			data: [
-  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2] } },
-  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT>CHILD', parents: [0] }] }
+  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2], missingParents: [] } },
+  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT>CHILD', parents: [0], missingParents: [] }] }
   			],
   			coordinates: { D0: 'USA', D1: 'D1ROOT>CHILD' },
   			key: 'D0=USA:D1=D1ROOT>CHILD',
@@ -173,8 +173,8 @@ describe('getLayoutData 2 tests', () => {
   		},
   		{
   			data: [
-  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2] } },
-  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT>CHILD>CHILD', parents: [0, 1] }, { id: 'D2ROOT', parents: [] }] }
+  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2], missingParents: [] } },
+  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [] }, { id: 'D2ROOT', parents: [], missingParents: [] }] }
   			],
   			coordinates: { D0: 'USA', D1: 'D1ROOT>CHILD>CHILD', D2: 'D2ROOT' },
   			key: 'D0=USA:D1=D1ROOT>CHILD>CHILD:D2=D2ROOT',
@@ -184,8 +184,8 @@ describe('getLayoutData 2 tests', () => {
   		},
   		{
   			data: [
-  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2] } },
-  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT>CHILD>CHILD', parents: [0, 1] }, { id: 'D2ROOT>CHILD', parents: [0] }] }
+  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2], missingParents: [] } },
+  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [] }, { id: 'D2ROOT>CHILD', parents: [0], missingParents: [] }] }
   			],
   			coordinates: { D0: 'USA', D1: 'D1ROOT>CHILD>CHILD', D2: 'D2ROOT>CHILD' },
   			key: 'D0=USA:D1=D1ROOT>CHILD>CHILD:D2=D2ROOT>CHILD',
@@ -195,9 +195,9 @@ describe('getLayoutData 2 tests', () => {
   		},
   		{
   			data: [
-  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2] } },
-  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT>CHILD>CHILD', parents: [0, 1] }, { id: 'A0VAL' }, { id: 'D2ROOT>CHILD>CHILD', parents: [0, 1] }] },
-  				{ dimension: { id: 'COMB1' }, values: [{ id: 'D3ROOT', parents: [] }] }
+  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2], missingParents: [] } },
+  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [] }, { id: 'A0VAL' }, { id: 'D2ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [] }] },
+  				{ dimension: { id: 'COMB1' }, values: [{ id: 'D3ROOT', parents: [], missingParents: [] }] }
   			],
   			coordinates: { D0: 'USA', D1: 'D1ROOT>CHILD>CHILD', D2: 'D2ROOT>CHILD>CHILD', D3: 'D3ROOT' },
   			key: 'D0=USA:D1=D1ROOT>CHILD>CHILD:D2=D2ROOT>CHILD>CHILD:D3=D3ROOT',
@@ -207,9 +207,9 @@ describe('getLayoutData 2 tests', () => {
   		},
   		{
   			data: [
-  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2] } },
-  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT>CHILD>CHILD', parents: [0, 1] }, { id: 'A0VAL' }, { id: 'D2ROOT>CHILD>CHILD', parents: [0, 1] }] },
-  				{ dimension: { id: 'COMB1' }, values: [{ id: 'D3ROOT>CHILD', parents: [0] }] }
+  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2], missingParents: [] } },
+  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [] }, { id: 'A0VAL' }, { id: 'D2ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [] }] },
+  				{ dimension: { id: 'COMB1' }, values: [{ id: 'D3ROOT>CHILD', parents: [0], missingParents: [] }] }
   			],
   			coordinates: { D0: 'USA', D1: 'D1ROOT>CHILD>CHILD', D2: 'D2ROOT>CHILD>CHILD', D3: 'D3ROOT>CHILD' },
   			key: 'D0=USA:D1=D1ROOT>CHILD>CHILD:D2=D2ROOT>CHILD>CHILD:D3=D3ROOT>CHILD',
@@ -219,9 +219,9 @@ describe('getLayoutData 2 tests', () => {
   		},
   		{
   			data: [
-  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2] } },
-  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT>CHILD>CHILD', parents: [0, 1] }, { id: 'A0VAL' }, { id: 'D2ROOT>CHILD>CHILD', parents: [0, 1] }] },
-  				{ dimension: { id: 'COMB1' }, values: [{ id: 'D3ROOT>CHILD>CHILD', parents: [0, 1] }, { id: 'D4ROOT', parents: [] }] }
+  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2], missingParents: [] } },
+  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [] }, { id: 'A0VAL' }, { id: 'D2ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [] }] },
+  				{ dimension: { id: 'COMB1' }, values: [{ id: 'D3ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [] }, { id: 'D4ROOT', parents: [], missingParents: [] }] }
   			],
   			coordinates: { D0: 'USA', D1: 'D1ROOT>CHILD>CHILD', D2: 'D2ROOT>CHILD>CHILD', D3: 'D3ROOT>CHILD>CHILD', D4: 'D4ROOT' },
   			key: 'D0=USA:D1=D1ROOT>CHILD>CHILD:D2=D2ROOT>CHILD>CHILD:D3=D3ROOT>CHILD>CHILD:D4=D4ROOT',
@@ -232,9 +232,9 @@ describe('getLayoutData 2 tests', () => {
 
   		{
   			data: [
-  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2] } },
-  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT>CHILD>CHILD', parents: [0, 1] }, { id: 'A0VAL' }, { id: 'D2ROOT>CHILD>CHILD', parents: [0, 1] }] },
-  				{ dimension: { id: 'COMB1' }, values: [{ id: 'D3ROOT>CHILD>CHILD', parents: [0, 1] }, { id: 'D4ROOT>CHILD', parents: [0] }] }
+  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2], missingParents: [] } },
+  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [] }, { id: 'A0VAL' }, { id: 'D2ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [] }] },
+  				{ dimension: { id: 'COMB1' }, values: [{ id: 'D3ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [] }, { id: 'D4ROOT>CHILD', parents: [0], missingParents: [] }] }
   			],
   			coordinates: { D0: 'USA', D1: 'D1ROOT>CHILD>CHILD', D2: 'D2ROOT>CHILD>CHILD', D3: 'D3ROOT>CHILD>CHILD', D4: 'D4ROOT>CHILD' },
   			key: 'D0=USA:D1=D1ROOT>CHILD>CHILD:D2=D2ROOT>CHILD>CHILD:D3=D3ROOT>CHILD>CHILD:D4=D4ROOT>CHILD',
@@ -244,9 +244,9 @@ describe('getLayoutData 2 tests', () => {
   		},
   		{
   			data: [
-  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2] } },
-  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT>CHILD>CHILD', parents: [0, 1] }, { id: 'A0VAL' }, { id: 'D2ROOT>CHILD>CHILD', parents: [0, 1] }] },
-  				{ dimension: { id: 'COMB1' }, values: [{ id: 'D3ROOT>CHILD>CHILD', parents: [0, 1] }, { id: 'D4ROOT>CHILD>CHILD', parents: [0, 1] }] }
+  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2], missingParents: [] } },
+  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [] }, { id: 'A0VAL' }, { id: 'D2ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [] }] },
+  				{ dimension: { id: 'COMB1' }, values: [{ id: 'D3ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [] }, { id: 'D4ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [] }] }
   			],
   			coordinates: { D0: 'USA', D1: 'D1ROOT>CHILD>CHILD', D2: 'D2ROOT>CHILD>CHILD', D3: 'D3ROOT>CHILD>CHILD', D4: 'D4ROOT>CHILD>CHILD' },
   			key: 'D0=USA:D1=D1ROOT>CHILD>CHILD:D2=D2ROOT>CHILD>CHILD:D3=D3ROOT>CHILD>CHILD:D4=D4ROOT>CHILD>CHILD',
@@ -264,5 +264,114 @@ describe('getLayoutData 2 tests', () => {
 				}
   		}
   	]);
+  });
+	it('getSerieDataWithMissingLines test 2', () => {
+  	const dimensions = [
+  		{
+				id: 'D0',
+				values: [
+					{ id: 'W' },
+					{ id: 'NA', parentsIndexes: [0] },
+					{ id: 'A', parentsIndexes: [0, 1] },
+					{ id: 'USA', parentsIndexes: [0, 1, 2] },
+					{ id: 'CAN', parentsIndexes: [0, 1, 2] },
+					{ id: 'MEX', parentsIndexes: [0, 1, 2] }
+				]
+			},
+			{
+				id: 'COMB0',
+				concepts: ['D1', 'A0', 'D2'],
+				dimensions: [
+					{
+						id: 'D1',
+						values: [
+							{ id: 'D1ROOT' },
+							{ id: 'D1ROOT>CHILD' },
+							{ id: 'D1ROOT>CHILD>CHILD' },
+						]
+					},
+					{
+						id: 'D2',
+						values: [
+							{ id: 'D2ROOT' },
+							{ id: 'D2ROOT>CHILD' },
+							{ id: 'D2ROOT>CHILD>CHILD' },
+						]
+					}
+				]
+			},
+			{
+				id: 'COMB1',
+				concepts: ['D3', 'D4'],
+				dimensions: [
+					{
+						id: 'D3',
+						values: [
+							{ id: 'D3ROOT' },
+							{ id: 'D3ROOT>CHILD' },
+							{ id: 'D3ROOT>CHILD>CHILD' },
+						]
+					},
+					{
+						id: 'D4',
+						values: [
+							{ id: 'D4ROOT' },
+							{ id: 'D4ROOT>CHILD' },
+							{ id: 'D4ROOT>CHILD>CHILD' },
+						]
+					}
+				]
+			},
+  	];
+
+  	const attributesSeries = {
+  		'D1=D1ROOT>CHILD>CHILD:D2=D2ROOT>CHILD>CHILD': {
+  			A0: { id: 'A0', value: { id: 'A0VAL' }, coordinates: { D1: 'D1ROOT>CHILD>CHILD', D2: 'D2ROOT>CHILD>CHILD' } },
+  			A1: { id: 'A1', value: { id: 'A1VAL' }, coordinates: { D1: 'D1ROOT>CHILD>CHILD', D2: 'D2ROOT>CHILD>CHILD' } },
+  		}
+  	};
+
+  	const topCoordinates = {};
+
+  	const serie = {
+  		indexes: [3, [2, 2], [2, 2]],
+  		parentsIndexes: [[], [[], []], [[], []]],
+  		missingIndexes: [[0, 2], [[0, 1], [0, 1]], [[0, 1], [0, 1]]],
+  	};
+
+  	expect(getSerieDataWithoutMissingLines(serie, dimensions, topCoordinates, attributesSeries, {}, {})).to.deep.equal({
+  			data: [
+  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2], missingParents: [{ id: 'W', parents: [], missingParents: [] }, { id: 'A', parents: [0], missingParents: [] }] } },
+  				{
+						dimension: { id: 'COMB0' },
+						values: [
+							{ id: 'D1ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [{ id: 'D1ROOT', parents: [], missingParents: [] }, { id: 'D1ROOT>CHILD', parents: [0], missingParents: [] }] },
+							{ id: 'A0VAL' },
+							{ id: 'D2ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [{ id: 'D2ROOT', parents: [], missingParents: [] }, { id: 'D2ROOT>CHILD', parents: [0], missingParents: [] }] }
+						]
+					},
+  				{
+						dimension: { id: 'COMB1' },
+						values: [
+							{ id: 'D3ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [{ id: 'D3ROOT', parents: [], missingParents: [] }, { id: 'D3ROOT>CHILD', parents: [0], missingParents: [] }] },
+							{ id: 'D4ROOT>CHILD>CHILD', parents: [0, 1], missingParents: [{ id: 'D4ROOT', parents: [], missingParents: [] }, { id: 'D4ROOT>CHILD', parents: [0], missingParents: [] }] }
+						]
+					}
+  			],
+  			coordinates: { D0: 'USA', D1: 'D1ROOT>CHILD>CHILD', D2: 'D2ROOT>CHILD>CHILD', D3: 'D3ROOT>CHILD>CHILD', D4: 'D4ROOT>CHILD>CHILD' },
+  			key: 'D0=USA:D1=D1ROOT>CHILD>CHILD:D2=D2ROOT>CHILD>CHILD:D3=D3ROOT>CHILD>CHILD:D4=D4ROOT>CHILD>CHILD',
+  			flags: [],
+  			sideProps: {
+					coordinates: {
+						D0: 'USA',
+						D1: 'D1ROOT>CHILD>CHILD',
+						D2: 'D2ROOT>CHILD>CHILD',
+						D3: 'D3ROOT>CHILD>CHILD',
+						D4: 'D4ROOT>CHILD>CHILD',
+					},
+					hasAdvancedAttributes: true,
+					hasMetadata: false
+				}
+  		});
   });
 });

package/test/parseSeriesIndexesHierarchies.test.js

@@ -1,3 +1,4 @@
+import * as R from 'ramda';
 import { expect } from 'chai';
 import { parseSeriesIndexesHierarchies } from '../src/rules2/src/table/parseSeriesIndexesHierarchies';
 

package/test/refineLayoutSize2.test.js

@@ -182,7 +182,7 @@ describe('refineLayoutSize 2 tests', () => {
     const expected = {
       totalCells: 140,
       truncated: true,
-      header: [{ indexes: [] }],
+      header: [{ indexes: [], missingIndexes: [], parentsIndexes: [] }],
       sections: [
         [
           { indexes: [] },
@@ -220,6 +220,122 @@ describe('refineLayoutSize 2 tests', () => {
       })(layoutIndexes)
     ).to.deep.equal(expected);
   });
+  it('truncated missing indexes', () => {
+    const layout = {
+      header: [{ __index: 0 }, { __index: 1 }],
+      rows: [{ __index: 2 }],
+      sections: [],
+    };
+    //102 cells
+    const layoutIndexes = {
+      header: [
+        { indexes: [1, 1], parentsIndexes: [[], []], missingIndexes: [[0], [0]] },
+        { indexes: [1, 2], parentsIndexes: [[0], [0]], missingIndexes: [[], []] },
+        { indexes: [1, 3], parentsIndexes: [[0], [0]], missingIndexes: [[], []] },
+        { indexes: [2, 1], parentsIndexes: [[0], [0]], missingIndexes: [[], []] },
+        { indexes: [2, 2], parentsIndexes: [[0], [0]], missingIndexes: [[], []] },
+        { indexes: [2, 3], parentsIndexes: [[0], [0]], missingIndexes: [[], []] },
+      ],
+      sections: [
+        [
+          { indexes: [] },
+          [
+            { indexes: [0], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [1], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [2], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [3], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [4], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [5], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [6], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [7], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [8], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [9], parentsIndexes: [[]], missingIndexes: [[]] },
+          ]
+        ]
+      ]
+    };
+
+    const observations = {
+      '1:1:8': { orderedDimIndexes: [1, 1, 8] },
+      '1:1:9': { orderedDimIndexes: [1, 1, 9] },
+      '1:2:8': { orderedDimIndexes: [1, 2, 8] },
+      '1:2:9': { orderedDimIndexes: [1, 2, 9] },
+      '1:3:0': { orderedDimIndexes: [1, 3, 0] },
+      '1:3:1': { orderedDimIndexes: [1, 3, 1] },
+      '1:3:2': { orderedDimIndexes: [1, 3, 2] },
+      '1:3:3': { orderedDimIndexes: [1, 3, 3] },
+      '1:3:4': { orderedDimIndexes: [1, 3, 4] },
+      '1:3:5': { orderedDimIndexes: [1, 3, 5] },
+      '1:3:6': { orderedDimIndexes: [1, 3, 6] },
+      '1:3:7': { orderedDimIndexes: [1, 3, 7] },
+      '1:3:8': { orderedDimIndexes: [1, 3, 8] },
+      '1:3:9': { orderedDimIndexes: [1, 3, 9] },
+      '2:1:0': { orderedDimIndexes: [2, 1, 0] },
+      '2:1:1': { orderedDimIndexes: [2, 1, 1] },
+      '2:1:2': { orderedDimIndexes: [2, 1, 2] },
+      '2:1:3': { orderedDimIndexes: [2, 1, 3] },
+      '2:1:4': { orderedDimIndexes: [2, 1, 4] },
+      '2:1:5': { orderedDimIndexes: [2, 1, 5] },
+      '2:1:6': { orderedDimIndexes: [2, 1, 6] },
+      '2:1:7': { orderedDimIndexes: [2, 1, 7] },
+      '2:1:8': { orderedDimIndexes: [2, 1, 8] },
+      '2:1:9': { orderedDimIndexes: [2, 1, 9] },
+      '2:2:0': { orderedDimIndexes: [2, 2, 0] },
+      '2:2:1': { orderedDimIndexes: [2, 2, 1] },
+      '2:2:2': { orderedDimIndexes: [2, 2, 2] },
+      '2:2:3': { orderedDimIndexes: [2, 2, 3] },
+      '2:2:4': { orderedDimIndexes: [2, 2, 4] },
+      '2:2:5': { orderedDimIndexes: [2, 2, 5] },
+      '2:2:6': { orderedDimIndexes: [2, 2, 6] },
+      '2:2:7': { orderedDimIndexes: [2, 2, 7] },
+      '2:2:8': { orderedDimIndexes: [2, 2, 8] },
+      '2:2:9': { orderedDimIndexes: [2, 2, 9] },
+      '2:3:0': { orderedDimIndexes: [2, 3, 0] },
+      '2:3:1': { orderedDimIndexes: [2, 3, 1] },
+      '2:3:2': { orderedDimIndexes: [2, 3, 2] },
+      '2:3:3': { orderedDimIndexes: [2, 3, 3] },
+      '2:3:4': { orderedDimIndexes: [2, 3, 4] },
+      '2:3:5': { orderedDimIndexes: [2, 3, 5] },
+      '2:3:6': { orderedDimIndexes: [2, 3, 6] },
+      '2:3:7': { orderedDimIndexes: [2, 3, 7] },
+      '2:3:8': { orderedDimIndexes: [2, 3, 8] },
+      '2:3:9': { orderedDimIndexes: [2, 3, 9] },
+    };
+
+    const expected = {
+      header: [
+        { indexes: [1, 3], parentsIndexes: [[], []], missingIndexes: [[0], [0]] },
+        { indexes: [2, 1], parentsIndexes: [[0], [0]], missingIndexes: [[], []] },
+        { indexes: [2, 2], parentsIndexes: [[0], [0]], missingIndexes: [[], []] },
+        { indexes: [2, 3], parentsIndexes: [[0], [0]], missingIndexes: [[], []] },
+      ],
+      sections: [
+        [
+          { indexes: [] },
+          [
+            { indexes: [0], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [1], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [2], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [3], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [4], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [5], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [6], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [7], parentsIndexes: [[]], missingIndexes: [[]] },
+          ]
+        ]
+      ],
+      truncated: true,
+      totalCells: 102
+    };
+
+    expect(
+      refineLayoutSize({
+        layout,
+        observations,
+        limit: 90
+      })(layoutIndexes)
+    ).to.deep.equal(expected);
+  });
   /*it('no rows', () => {
 
     const layout = {