@sis-cc/dotstatsuite-components 20.3.0 → 20.5.0

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

@@ -135,6 +135,37 @@ var getCombinationLevelCompatibility = exports.getCombinationLevelCompatibility
   return 'blank';
 };
 
+var filterLayoutIds = function filterLayoutIds(indexedCombinations, layoutDimsIds, obsAttributes) {
+  return function (layoutIds) {
+    var layoutConcepts = R.map(R.reduce(function (acc, id) {
+      if (R.has(id, indexedCombinations)) {
+        return R.concat(acc, R.path([id, 'concepts'], indexedCombinations));
+      }
+      return R.append(id, acc);
+    }, []), layoutIds);
+
+    return R.mapObjIndexed(function (ids, level) {
+      return R.filter(function (id) {
+        if (id === 'OBS_ATTRIBUTES') {
+          return !R.isEmpty(obsAttributes);
+        }
+        if (R.has(id, indexedCombinations)) {
+          var comb = R.prop(id, indexedCombinations);
+          var dims = R.filter(function (i) {
+            return layoutDimsIds.has(i);
+          }, comb.concepts);
+          if (!R.isEmpty(dims)) {
+            return true;
+          }
+          var oppositeIds = level === 'header' ? R.concat(R.prop('sections', layoutConcepts), R.prop('rows', layoutConcepts)) : R.prop('header', layoutConcepts);
+          return R.isEmpty(R.intersection(comb.relationship, oppositeIds));
+        }
+        return layoutDimsIds.has(id);
+      }, ids);
+    }, layoutIds);
+  };
+};
+
 var injectCombinationsInLayout = exports.injectCombinationsInLayout = function injectCombinationsInLayout(combinations, layoutIds) {
   var defaultLayoutIds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
 
@@ -277,6 +308,7 @@ var injectRemainingDimensionsInLayout = exports.injectRemainingDimensionsInLayou
 var getTableLayoutIds = exports.getTableLayoutIds = function getTableLayoutIds(defaultLayoutIds, currentLayoutIds, dimensions, attributes, combinations) {
   var layoutDimsIds = getLayoutDimsIds(dimensions);
   var layoutCombinations = getLayoutCombinations(combinations, layoutDimsIds, attributes);
+  var isBlank = R.pipe(R.values, R.all(R.isEmpty))(currentLayoutIds);
 
   var combinationsConcepts = R.pipe(R.pluck('_concepts'), R.unnest, function (ids) {
     return new _set2.default(ids);
@@ -285,12 +317,8 @@ var getTableLayoutIds = exports.getTableLayoutIds = function getTableLayoutIds(d
     return a.series && R.isEmpty(a.relationship || []) && a.display && !combinationsConcepts.has(a);
   }, attributes);
   var indexedCombinations = R.indexBy(R.prop('id'), layoutCombinations);
-  var filteredLayoutIds = R.map(R.filter(function (id) {
-    if (id === 'OBS_ATTRIBUTES') {
-      return !R.isEmpty(obsAttributes);
-    }
-    return R.has(id, indexedCombinations) || layoutDimsIds.has(id);
-  }), currentLayoutIds);
+  var filteredLayoutIds = filterLayoutIds(indexedCombinations, layoutDimsIds, obsAttributes)(isBlank ? defaultLayoutIds : currentLayoutIds);
+
   var layoutWithCombs = injectCombinationsInLayout(layoutCombinations, filteredLayoutIds, defaultLayoutIds);
   var layoutRelationshipsSets = R.map(R.pipe(function (ids) {
     return R.pick(ids, indexedCombinations);
@@ -316,10 +344,10 @@ var getTableLayoutIds = exports.getTableLayoutIds = function getTableLayoutIds(d
     if (layoutRelationshipsSets.header.has(dim.id) || defaultLayoutConceptsSets.header.has(dim.id)) {
       return R.over(R.lensPath(['nextLayout', 'header']), R.append(dim.id))(acc);
     }
-    if (layoutRelationshipsSets.sections.has(dim.id) || defaultLayoutConceptsSets.header.has(dim.id)) {
+    if (layoutRelationshipsSets.sections.has(dim.id) || defaultLayoutConceptsSets.sections.has(dim.id)) {
       return R.over(R.lensPath(['nextLayout', 'sections']), R.append(dim.id))(acc);
     }
-    if (layoutRelationshipsSets.rows.has(dim.id) || defaultLayoutConceptsSets.header.has(dim.id)) {
+    if (layoutRelationshipsSets.rows.has(dim.id) || defaultLayoutConceptsSets.rows.has(dim.id)) {
       return R.over(R.lensPath(['nextLayout', 'rows']), R.append(dim.id))(acc);
     }
     if ((0, _dotstatsuiteSdmxjs.isTimePeriodDimension)(dim)) {

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

@@ -39,49 +39,61 @@ var registerParsedIndexes = function registerParsedIndexes(_ref, register) {
   return (0, _extends3.default)({}, merged, { isSameSerie: isSameSerie });
 };
 
-var parseSerieIndexesHierarchies = function parseSerieIndexesHierarchies(serieIndexes, previousSerie, dimensions) {
-  var defaultIsSameSerie = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+var parseParentsIndexesWithPrevious = function parseParentsIndexesWithPrevious(parentsIndexes, previousParentsIndexes) {
+  var previousParentsSet = new _set2.default(previousParentsIndexes);
+  var lastParentIndexInPrevious = R.findLastIndex(function (i) {
+    return previousParentsSet.has(i);
+  }, parentsIndexes);
+
+  var _ref2 = lastParentIndexInPrevious !== -1 ? R.splitAt(lastParentIndexInPrevious + 1, parentsIndexes) : [[], parentsIndexes],
+      _ref3 = (0, _slicedToArray3.default)(_ref2, 2),
+      rawPresentParentsIndexes = _ref3[0],
+      missingParentsIndexes = _ref3[1];
+
+  var presentParentsIndexes = R.filter(function (i) {
+    return previousParentsSet.has(i);
+  }, rawPresentParentsIndexes);
+  return { presentParentsIndexes: presentParentsIndexes, missingParentsIndexes: missingParentsIndexes };
+};
 
+var parseSerieIndexesHierarchies = function parseSerieIndexesHierarchies(serieIndexes, previousSerie, dimensions, isSameSerie, replicate) {
   return R.addIndex(R.reduce)(function (acc, _valueIndex, dimensionIndex) {
     if (R.is(Array, _valueIndex)) {
       var previous = R.isEmpty(previousSerie) ? {} : R.map(R.nth(dimensionIndex), previousSerie);
-      var parsed = parseSerieIndexesHierarchies(_valueIndex, previous, R.pathOr([], [dimensionIndex, 'dimensions'], dimensions), acc.isSameSerie);
+      var parsed = parseSerieIndexesHierarchies(_valueIndex, previous, R.pathOr([], [dimensionIndex, 'dimensions'], dimensions), acc.isSameSerie, replicate);
       return registerParsedIndexes(parsed, acc);
     }
     var valueIndex = Math.abs(_valueIndex);
     var parents = R.pathOr([], [dimensionIndex, 'values', valueIndex, 'parents'], dimensions);
-    var previousIndex = acc.isSameSerie ? R.pipe(R.path(['indexes', dimensionIndex]), function (i) {
+    var previousIndex = R.pipe(R.path(['indexes', dimensionIndex]), function (i) {
       return R.isNil(i) ? -1 : Math.abs(i);
-    })(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, 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) {
-        registeredIndexes.add(i);
-        return R.over(R.lensProp('missingParentsIndexes'), function (m) {
-          return R.isNil(m) ? [i] : R.append(i, m);
-        }, _acc);
-      }
-      return _acc;
-    }, {}, parents),
-        presentParentsIndexes = _R$reduce.presentParentsIndexes,
-        missingParentsIndexes = _R$reduce.missingParentsIndexes;
-
-    registeredIndexes.add(valueIndex);
-    return registerParsedIndexes({ parentsIndexes: presentParentsIndexes, missingIndexes: missingParentsIndexes, registeredIndexes: registeredIndexes, isSameSerie: acc.isSameSerie && valueIndex === previousIndex }, acc);
-  }, { parentsIndexes: [], missingIndexes: [], registeredIndexes: [], isSameSerie: defaultIsSameSerie }, serieIndexes);
+    })(previousSerie);
+    var previousParentsIndexes = acc.isSameSerie ? R.pipe(R.pathOr([], ['parentsIndexes', dimensionIndex]), R.append(previousIndex))(previousSerie) : [];
+    var previousMissingIndexes = acc.isSameSerie ? R.pathOr([], ['missingIndexes', dimensionIndex], previousSerie) : [];
+    /*
+      if replicate = true (sections), missing parents insdexes are replicated on each brother nodes not just the first (as empty lines)
+      thats why passing previous missing as previous parents in case replicate = false
+    */
+
+    var _parseParentsIndexesW = parseParentsIndexesWithPrevious(parents, replicate ? previousParentsIndexes : R.concat(previousParentsIndexes, previousMissingIndexes)),
+        presentParentsIndexes = _parseParentsIndexesW.presentParentsIndexes,
+        missingParentsIndexes = _parseParentsIndexesW.missingParentsIndexes;
+
+    return registerParsedIndexes({
+      parentsIndexes: presentParentsIndexes,
+      missingIndexes: missingParentsIndexes,
+      isSameSerie: acc.isSameSerie && valueIndex === previousIndex
+    }, acc);
+  }, { parentsIndexes: [], missingIndexes: [], isSameSerie: isSameSerie }, serieIndexes);
 };
 
 var parseSeriesIndexesHierarchies = function parseSeriesIndexesHierarchies(seriesIndexes, dimensions) {
+  var replicateMissing = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
   return R.reduce(function (acc, serieIndexes) {
     var previousSerie = R.last(acc) || {};
 
-    var _parseSerieIndexesHie = parseSerieIndexesHierarchies(serieIndexes, previousSerie, dimensions),
+    var _parseSerieIndexesHie = parseSerieIndexesHierarchies(serieIndexes, previousSerie, dimensions, true, replicateMissing),
         isSameSerie = _parseSerieIndexesHie.isSameSerie,
         parsed = (0, _objectWithoutProperties3.default)(_parseSerieIndexesHie, ['isSameSerie']);
 
@@ -92,15 +104,16 @@ var parseSeriesIndexesHierarchies = function parseSeriesIndexesHierarchies(serie
 exports.parseSeriesIndexesHierarchies = parseSeriesIndexesHierarchies;
 var parseLayoutIndexesHierarchies = exports.parseLayoutIndexesHierarchies = function parseLayoutIndexesHierarchies(layoutIndexes, layout) {
   var header = parseSeriesIndexesHierarchies(layoutIndexes.header, layout.header);
-  var sections = R.pipe(R.transpose, function (_ref2) {
-    var _ref3 = (0, _slicedToArray3.default)(_ref2, 2),
-        _sections = _ref3[0],
-        _sectionsRows = _ref3[1];
+  var sections = R.pipe(R.transpose, function (_ref4) {
+    var _ref5 = (0, _slicedToArray3.default)(_ref4, 2),
+        _sections = _ref5[0],
+        _sectionsRows = _ref5[1];
 
     if (R.isNil(_sections)) {
       return [];
     }
-    var sections = parseSeriesIndexesHierarchies(_sections, layout.sections);
+    // replicate = true on sections
+    var sections = parseSeriesIndexesHierarchies(_sections, layout.sections, true);
     var sectionsRows = R.map(function (rows) {
       return parseSeriesIndexesHierarchies(rows, layout.rows);
     }, _sectionsRows);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sis-cc/dotstatsuite-components",
   "description": "Set components based on React.",
-  "version": "20.3.0",
+  "version": "20.5.0",
   "main": "lib/index.js",
   "type": "module",
   "author": "OECD",

package/src/rules2/src/table/getTableLayoutIds.js

@@ -72,6 +72,39 @@ export const getCombinationLevelCompatibility = (layoutRelationships, combinatio
   return 'blank';
 }
 
+const filterLayoutIds = (indexedCombinations, layoutDimsIds, obsAttributes) => (layoutIds) => {
+  const layoutConcepts = R.map(
+    R.reduce((acc, id) => {
+      if (R.has(id, indexedCombinations)) {
+        return R.concat(acc, R.path([id, 'concepts'], indexedCombinations));
+      }
+      return R.append(id, acc);
+    }, []),
+    layoutIds
+  );
+
+  return R.mapObjIndexed(
+    (ids, level) => R.filter(id => {
+      if (id === 'OBS_ATTRIBUTES') {
+        return !R.isEmpty(obsAttributes);
+      }
+      if (R.has(id, indexedCombinations)) {
+        const comb = R.prop(id, indexedCombinations);
+        const dims = R.filter(i => layoutDimsIds.has(i), comb.concepts);
+        if (!R.isEmpty(dims)) {
+          return true;
+        }
+        const oppositeIds = level === 'header'
+          ? R.concat(R.prop('sections', layoutConcepts), R.prop('rows', layoutConcepts))
+          : R.prop('header', layoutConcepts);
+        return R.isEmpty(R.intersection(comb.relationship, oppositeIds));
+      }
+      return layoutDimsIds.has(id);
+    }, ids),
+    layoutIds
+  );
+};
+
 export const injectCombinationsInLayout = (combinations, layoutIds, defaultLayoutIds = {}) => {
   const notInLayoutCombs = getCombinationsNotInLayout(combinations, layoutIds);
   if (R.isEmpty(notInLayoutCombs)) {
@@ -219,21 +252,16 @@ export const getTableLayoutIds = (
     layoutDimsIds,
     attributes,
   );
+  const isBlank = R.pipe(R.values, R.all(R.isEmpty))(currentLayoutIds);
 
   const combinationsConcepts = R.pipe(R.pluck('_concepts'), R.unnest, ids => new Set(ids))(combinations);
   const obsAttributes = R.filter(a => 
     a.series && R.isEmpty(a.relationship || []) && a.display && !combinationsConcepts.has(a)
   , attributes);
   const indexedCombinations = R.indexBy(R.prop('id'), layoutCombinations);
-  const filteredLayoutIds = R.map(
-    R.filter(id => {
-      if (id === 'OBS_ATTRIBUTES') {
-        return !R.isEmpty(obsAttributes);
-      }
-      return R.has(id, indexedCombinations) || layoutDimsIds.has(id);
-    }),
-    currentLayoutIds
-  );
+  const filteredLayoutIds = filterLayoutIds(indexedCombinations, layoutDimsIds, obsAttributes)
+    (isBlank ? defaultLayoutIds : currentLayoutIds);
+
   const layoutWithCombs = injectCombinationsInLayout(layoutCombinations, filteredLayoutIds, defaultLayoutIds);
   const layoutRelationshipsSets = R.map(R.pipe(
     ids => R.pick(ids, indexedCombinations),
@@ -267,10 +295,10 @@ export const getTableLayoutIds = (
     if (layoutRelationshipsSets.header.has(dim.id) || defaultLayoutConceptsSets.header.has(dim.id)) {
       return R.over(R.lensPath(['nextLayout', 'header']), R.append(dim.id))(acc);
     }
-    if (layoutRelationshipsSets.sections.has(dim.id) || defaultLayoutConceptsSets.header.has(dim.id)) {
+    if (layoutRelationshipsSets.sections.has(dim.id) || defaultLayoutConceptsSets.sections.has(dim.id)) {
       return R.over(R.lensPath(['nextLayout', 'sections']), R.append(dim.id))(acc);
     }
-    if (layoutRelationshipsSets.rows.has(dim.id)  || defaultLayoutConceptsSets.header.has(dim.id)) {
+    if (layoutRelationshipsSets.rows.has(dim.id)  || defaultLayoutConceptsSets.rows.has(dim.id)) {
       return R.over(R.lensPath(['nextLayout','rows']), R.append(dim.id))(acc);
     }
     if (isTimePeriodDimension(dim)) {

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

@@ -5,39 +5,56 @@ const registerParsedIndexes = ({ isSameSerie, ...parsed }, register) => {
   return ({ ...merged, isSameSerie });
 };
 
-const parseSerieIndexesHierarchies = (serieIndexes, previousSerie, dimensions, defaultIsSameSerie = true) => {
+const parseParentsIndexesWithPrevious = (parentsIndexes, previousParentsIndexes) => {
+  const previousParentsSet = new Set(previousParentsIndexes);
+  const lastParentIndexInPrevious = R.findLastIndex(i => previousParentsSet.has(i), parentsIndexes);
+  const [rawPresentParentsIndexes, missingParentsIndexes] = lastParentIndexInPrevious !== -1
+    ? R.splitAt(lastParentIndexInPrevious + 1, parentsIndexes)
+    : [[], parentsIndexes];
+  const presentParentsIndexes = R.filter(i => previousParentsSet.has(i), rawPresentParentsIndexes);
+  return ({ presentParentsIndexes, missingParentsIndexes });
+};
+
+const parseSerieIndexesHierarchies = (serieIndexes, previousSerie, dimensions, isSameSerie, replicate) => {
 	return R.addIndex(R.reduce)((acc, _valueIndex, dimensionIndex) => {
 		if (R.is(Array, _valueIndex)) {
       const previous = R.isEmpty(previousSerie) ? {} : R.map(R.nth(dimensionIndex), previousSerie);
-			const parsed = parseSerieIndexesHierarchies(_valueIndex, previous, R.pathOr([], [dimensionIndex, 'dimensions'], dimensions), acc.isSameSerie);
+			const parsed = parseSerieIndexesHierarchies(
+        _valueIndex,
+        previous,
+        R.pathOr([], [dimensionIndex, 'dimensions'], dimensions),
+        acc.isSameSerie,
+        replicate
+      );
       return registerParsedIndexes(parsed, acc);
 		}
     const valueIndex = Math.abs(_valueIndex);
     const parents = R.pathOr([], [dimensionIndex, 'values', valueIndex, 'parents'], dimensions);
-    const previousIndex = acc.isSameSerie
-      ? R.pipe(R.path(['indexes', dimensionIndex]), i => R.isNil(i) ? -1 : Math.abs(i))(previousSerie)
-      : -1;
-    const previousRegisteredIndexes = acc.isSameSerie? R.pathOr(new Set(), ['registeredIndexes', dimensionIndex], previousSerie) : new Set();
-    const registeredIndexes = new Set(previousRegisteredIndexes);
-    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 (i > previousIndex) {
-        registeredIndexes.add(i);
-        return R.over(R.lensProp('missingParentsIndexes'), m => R.isNil(m) ? [i] :  R.append(i, m), _acc);
-      }
-      return _acc;
-    }, {}, parents);
-    registeredIndexes.add(valueIndex);
-    return registerParsedIndexes({ parentsIndexes: presentParentsIndexes, missingIndexes: missingParentsIndexes, registeredIndexes, isSameSerie: acc.isSameSerie && valueIndex === previousIndex }, acc);
-  }, { parentsIndexes: [], missingIndexes: [], registeredIndexes: [], isSameSerie: defaultIsSameSerie }, serieIndexes);
+    const previousIndex = R.pipe(R.path(['indexes', dimensionIndex]), i => R.isNil(i) ? -1 : Math.abs(i))(previousSerie)
+    const previousParentsIndexes = acc.isSameSerie
+      ? R.pipe(R.pathOr([], ['parentsIndexes', dimensionIndex]), R.append(previousIndex))(previousSerie) : [];
+    const previousMissingIndexes = acc.isSameSerie
+      ? R.pathOr([], ['missingIndexes', dimensionIndex], previousSerie) : [];
+    /*
+      if replicate = true (sections), missing parents insdexes are replicated on each brother nodes not just the first (as empty lines)
+      thats why passing previous missing as previous parents in case replicate = false
+    */
+    const { presentParentsIndexes, missingParentsIndexes } = parseParentsIndexesWithPrevious(
+      parents,
+      replicate ? previousParentsIndexes : R.concat(previousParentsIndexes, previousMissingIndexes),
+    );
+    return registerParsedIndexes({
+      parentsIndexes: presentParentsIndexes,
+      missingIndexes: missingParentsIndexes,
+      isSameSerie: acc.isSameSerie && valueIndex === previousIndex
+    }, acc);
+  }, { parentsIndexes: [], missingIndexes: [], isSameSerie }, serieIndexes);
 };
 
-export const parseSeriesIndexesHierarchies = (seriesIndexes, dimensions) => {
+export const parseSeriesIndexesHierarchies = (seriesIndexes, dimensions, replicateMissing = false) => {
   return R.reduce((acc, serieIndexes) => {
     const previousSerie = R.last(acc) || {};
-    const { isSameSerie, ...parsed } = parseSerieIndexesHierarchies(serieIndexes, previousSerie, dimensions);
+    const { isSameSerie, ...parsed } = parseSerieIndexesHierarchies(serieIndexes, previousSerie, dimensions, true, replicateMissing);
     return R.append(R.assoc('indexes', serieIndexes, parsed), acc);
   }, [], seriesIndexes);
 };
@@ -50,7 +67,8 @@ export const parseLayoutIndexesHierarchies = (layoutIndexes, layout) => {
       if (R.isNil(_sections)) {
         return [];
       }
-      const sections = parseSeriesIndexesHierarchies(_sections, layout.sections);
+      // replicate = true on sections
+      const sections = parseSeriesIndexesHierarchies(_sections, layout.sections, true);
       const sectionsRows = R.map(rows => parseSeriesIndexesHierarchies(rows, layout.rows), _sectionsRows);
       return R.transpose([sections, sectionsRows]);
     }

package/test/getTableLayoutIds.test.js

@@ -329,8 +329,14 @@ describe('getTableLayoutIds tests', () => {
       rows: []
     };
 
+    const layoutIds3 = {
+      header: [],
+      sections: ['MEASURE'],
+      rows: []
+    }
+
     expect(getTableLayoutIds(defaultLayoutIds, layoutIds1, dimensions, attributes, combinations)).to.deep.equal({
-      header: ['COMB1', 'COMB3', 'REF_AREA'],
+      header: ['COMB1', 'REF_AREA', 'COMB3',],
       sections: ['COMB2'],
       rows: ['TRANSACTION']
     });
@@ -340,5 +346,11 @@ describe('getTableLayoutIds tests', () => {
       sections: ['COMB2'],
       rows: ['REF_AREA']
     });
+
+    expect(getTableLayoutIds(defaultLayoutIds, layoutIds3, dimensions, attributes, combinations)).to.deep.equal({
+      header: ['REF_AREA'],
+      sections: ['COMB1', 'COMB2', 'COMB3'],
+      rows: ['TRANSACTION']
+    });
   });
 });

package/test/parseSeriesIndexesHierarchies.test.js

@@ -23,45 +23,323 @@ describe('parseSeriesIndexesHierarchies tests', () => {
 		];
 
 		expect(parseSeriesIndexesHierarchies(seriesIndexes, dimensions)).to.deep.equal([
-			{ indexes: [2], parentsIndexes: [[]], missingIndexes: [[]], registeredIndexes: [new Set([2])] },
-			{ indexes: [3], parentsIndexes: [[]], missingIndexes: [[]], registeredIndexes: [new Set([2, 3])] },
-			{ indexes: [4], parentsIndexes: [[]], missingIndexes: [[]], registeredIndexes: [new Set([2, 3, 4])] },
+			{ indexes: [2], parentsIndexes: [[]], missingIndexes: [[]] },
+			{ indexes: [3], parentsIndexes: [[]], missingIndexes: [[]] },
+			{ indexes: [4], parentsIndexes: [[]], missingIndexes: [[]] },
 		])
 	});
-	it('with combination', () => {
+	it('hierarchical in second dimension, no replicate missing parents', () => {
 		const dimensions = [
+			{
+				id: 'D0',
+				values: [
+					{ id: 'v0' },
+					{ id: 'v1' },
+				]
+			},
+			{
+				id: 'D1',
+				values: [
+					{ id: 'v0' },
+					{ id: 'v1', parents: [0] },
+					{ id: 'v2', parents: [0, 1] },
+					{ id: 'v3', parents: [0, 1] },
+					{ id: 'v4', parents: [0, 1] },
+				]
+			},
+		];
+
+		const seriesIndexes = [
+			[0, 0],
+			[0, 1],
+			[0, 2],
+			[0, 3],
+			[0, 4],
+			[1, 2],
+			[1, 3],
+			[1, 4],
+		];
+
+		expect(parseSeriesIndexesHierarchies(seriesIndexes, dimensions)).to.deep.equal([
+			{ indexes: [0, 0], parentsIndexes: [[], []], missingIndexes: [[], []] },
+			{ indexes: [0, 1], parentsIndexes: [[], [0]], missingIndexes: [[], []] },
+			{ indexes: [0, 2], parentsIndexes: [[], [0, 1]], missingIndexes: [[], []] },
+			{ indexes: [0, 3], parentsIndexes: [[], [0, 1]], missingIndexes: [[], []] },
+			{ indexes: [0, 4], parentsIndexes: [[], [0, 1]], missingIndexes: [[], []] },
+			{ indexes: [1, 2], parentsIndexes: [[], []], missingIndexes: [[], [0, 1]] },
+			{ indexes: [1, 3], parentsIndexes: [[], [0, 1]], missingIndexes: [[], []] },
+			{ indexes: [1, 4], parentsIndexes: [[], [0, 1]], missingIndexes: [[], []] },
+		])
+	});
+	it('hierarchical in second dimension, replicate missing parents', () => {
+		const dimensions = [
+			{
+				id: 'D0',
+				values: [
+					{ id: 'v0' },
+					{ id: 'v1' },
+				]
+			},
+			{
+				id: 'D1',
+				values: [
+					{ id: 'v0' },
+					{ id: 'v1', parents: [0] },
+					{ id: 'v2', parents: [0, 1] },
+					{ id: 'v3', parents: [0, 1] },
+					{ id: 'v4', parents: [0, 1] },
+				]
+			},
+		];
+
+		const seriesIndexes = [
+			[0, 0],
+			[0, 1],
+			[0, 2],
+			[0, 3],
+			[0, 4],
+			[1, 2],
+			[1, 3],
+			[1, 4],
+		];
+
+		expect(parseSeriesIndexesHierarchies(seriesIndexes, dimensions, true)).to.deep.equal([
+			{ indexes: [0, 0], parentsIndexes: [[], []], missingIndexes: [[], []] },
+			{ indexes: [0, 1], parentsIndexes: [[], [0]], missingIndexes: [[], []] },
+			{ indexes: [0, 2], parentsIndexes: [[], [0, 1]], missingIndexes: [[], []] },
+			{ indexes: [0, 3], parentsIndexes: [[], [0, 1]], missingIndexes: [[], []] },
+			{ indexes: [0, 4], parentsIndexes: [[], [0, 1]], missingIndexes: [[], []] },
+			{ indexes: [1, 2], parentsIndexes: [[], []], missingIndexes: [[], [0, 1]] },
+			{ indexes: [1, 3], parentsIndexes: [[], []], missingIndexes: [[], [0, 1]] },
+			{ indexes: [1, 4], parentsIndexes: [[], []], missingIndexes: [[], [0, 1]] },
+		])
+	});
+	it('two hierarchical dimensions, no replicate missing parents', () => {
+		const dimensions = [
+			{
+				id: 'D0',
+				values: [
+					{ id: 'v0' },
+					{ id: 'v1', parents: [0] },
+					{ id: 'v2', parents: [0, 1] },
+					{ id: 'v3', parents: [0, 1] },
+				]
+			},
+			{
+				id: 'D1',
+				values: [
+					{ id: 'v0' },
+					{ id: 'v1', parents: [0] },
+					{ id: 'v2', parents: [0, 1] },
+					{ id: 'v3', parents: [0, 1] },
+				]
+			},
+		];
+
+		const seriesIndexes = [
+			[0, 0],
+			[0, 1],
+			[0, 2],
+			[0, 3],
+			[2, 2],
+			[2, 3],
+			[3, 2],
+			[3, 3],
+		];
+
+		expect(parseSeriesIndexesHierarchies(seriesIndexes, dimensions)).to.deep.equal([
+			{ indexes: [0, 0], parentsIndexes: [[], []], missingIndexes: [[], []] },
+			{ indexes: [0, 1], parentsIndexes: [[], [0]], missingIndexes: [[], []] },
+			{ indexes: [0, 2], parentsIndexes: [[], [0, 1]], missingIndexes: [[], []] },
+			{ indexes: [0, 3], parentsIndexes: [[], [0, 1]], missingIndexes: [[], []] },
+			{ indexes: [2, 2], parentsIndexes: [[0], []], missingIndexes: [[1], [0, 1]] },
+			{ indexes: [2, 3], parentsIndexes: [[0, 1], [0, 1]], missingIndexes: [[], []] },
+			{ indexes: [3, 2], parentsIndexes: [[0, 1], []], missingIndexes: [[], [0, 1]] },
+			{ indexes: [3, 3], parentsIndexes: [[0, 1], [0, 1]], missingIndexes: [[], []] },
+		])
+	});
+	it('two hierarchical dimensions, replicate missing parents', () => {
+		const dimensions = [
+			{
+				id: 'D0',
+				values: [
+					{ id: 'v0' },
+					{ id: 'v1', parents: [0] },
+					{ id: 'v2', parents: [0, 1] },
+					{ id: 'v3', parents: [0, 1] },
+				]
+			},
+			{
+				id: 'D1',
+				values: [
+					{ id: 'v0' },
+					{ id: 'v1', parents: [0] },
+					{ id: 'v2', parents: [0, 1] },
+					{ id: 'v3', parents: [0, 1] },
+				]
+			},
+		];
+
+		const seriesIndexes = [
+			[0, 0],
+			[0, 1],
+			[0, 2],
+			[0, 3],
+			[2, 2],
+			[2, 3],
+			[3, 2],
+			[3, 3],
+		];
+
+		expect(parseSeriesIndexesHierarchies(seriesIndexes, dimensions, true)).to.deep.equal([
+			{ indexes: [0, 0], parentsIndexes: [[], []], missingIndexes: [[], []] },
+			{ indexes: [0, 1], parentsIndexes: [[], [0]], missingIndexes: [[], []] },
+			{ indexes: [0, 2], parentsIndexes: [[], [0, 1]], missingIndexes: [[], []] },
+			{ indexes: [0, 3], parentsIndexes: [[], [0, 1]], missingIndexes: [[], []] },
+			{ indexes: [2, 2], parentsIndexes: [[0], []], missingIndexes: [[1], [0, 1]] },
+			{ indexes: [2, 3], parentsIndexes: [[0], []], missingIndexes: [[1], [0, 1]] },
+			{ indexes: [3, 2], parentsIndexes: [[0], []], missingIndexes: [[1], [0, 1]] },
+			{ indexes: [3, 3], parentsIndexes: [[0], []], missingIndexes: [[1], [0, 1]] },
+		])
+	});
+	it('two hierarchical dimensions in combination, no replicate missing parents', () => {
+		const dimensions = [
+			{
+				id: 'D0',
+					values: [
+						{ id: 'v0' },
+						{ id: 'v1', parents: [0] },
+						{ id: 'v2', parents: [0, 1] },
+					]
+			},
 			{
 				id: 'COMB',
 				dimensions: [{
+					id: 'D1',
 					values: [
 						{ id: 'v0' },
-						{ id: 'v1' },
-						{ id: 'v2' },
-						{ id: 'v3' },
-						{ id: 'v4' },
+						{ id: 'v1', parents: [0] },
+						{ id: 'v2', parents: [0, 1] },
+						{ id: 'v3', parents: [0, 1] },
 					]
-				},
-				{
+				},{
+					id: 'D2',
 					values: [
-						{ id: 'W', isSelected: true },
-						{ id: 'NA', parents: [0], isSelected: false },
-						{ id: 'A', parents: [0, 1], isSelected: true },
-						{ id: 'USA', parents: [0, 1, 2], isSelected: true },
-						{ id: 'CAN', parents: [0, 1, 2], isSelected: true },
-						{ id: 'MEX', parents: [0, 1, 2], isSelected: true }
+						{ id: 'v0' },
+						{ id: 'v1', parents: [0] },
+						{ id: 'v2', parents: [0, 1] },
+						{ id: 'v3', parents: [0, 1] },
 					]
 				}]
-			},
+			}
 		];
 
 		const seriesIndexes = [
-			[[0, 0]],
-			[[0, 1]],
+			[0, [0, 0]],
+			[0, [0, 1]],
+			[0, [0, 2]],
+			[0, [0, 3]],
+			[0, [2, 2]],
+			[0, [2, 3]],
+			[0, [3, 2]],
+			[0, [3, 3]],
+			[2, [0, 0]],
+			[2, [0, 1]],
+			[2, [0, 2]],
+			[2, [0, 3]],
+			[2, [2, 2]],
+			[2, [2, 3]],
+			[2, [3, 2]],
+			[2, [3, 3]],
 		];
 
 		expect(parseSeriesIndexesHierarchies(seriesIndexes, dimensions)).to.deep.equal([
-			{ indexes: [[0, 0]], parentsIndexes: [[[], []]], missingIndexes: [[[], []]], registeredIndexes: [[new Set([0]), new Set([0])]] },
-			{ indexes: [[0, 1]], parentsIndexes: [[[], [0]]], missingIndexes: [[[], []]], registeredIndexes: [[new Set([0]), new Set([0, 1])]] },
+			{ indexes: [0, [0, 0]], parentsIndexes: [[], [[], []]], missingIndexes: [[], [[], []]] },
+			{ indexes: [0, [0, 1]], parentsIndexes: [[], [[], [0]]], missingIndexes: [[], [[], []]] },
+			{ indexes: [0, [0, 2]], parentsIndexes: [[], [[], [0, 1]]], missingIndexes: [[], [[], []]] },
+			{ indexes: [0, [0, 3]], parentsIndexes: [[], [[], [0, 1]]], missingIndexes: [[], [[], []]] },
+			{ indexes: [0, [2, 2]], parentsIndexes: [[], [[0], []]], missingIndexes: [[], [[1], [0, 1]]] },
+			{ indexes: [0, [2, 3]], parentsIndexes: [[], [[0, 1], [0, 1]]], missingIndexes: [[], [[], []]] },
+			{ indexes: [0, [3, 2]], parentsIndexes: [[], [[0, 1], []]], missingIndexes: [[], [[], [0, 1]]] },
+			{ indexes: [0, [3, 3]], parentsIndexes: [[], [[0, 1], [0, 1]]], missingIndexes: [[], [[], []]] },
+			{ indexes: [2, [0, 0]], parentsIndexes: [[0], [[], []]], missingIndexes: [[1], [[], []]] },
+			{ indexes: [2, [0, 1]], parentsIndexes: [[0, 1], [[], [0]]], missingIndexes: [[], [[], []]] },
+			{ indexes: [2, [0, 2]], parentsIndexes: [[0, 1], [[], [0, 1]]], missingIndexes: [[], [[], []]] },
+			{ indexes: [2, [0, 3]], parentsIndexes: [[0, 1], [[], [0, 1]]], missingIndexes: [[], [[], []]] },
+			{ indexes: [2, [2, 2]], parentsIndexes: [[0, 1], [[0], []]], missingIndexes: [[], [[1], [0, 1]]] },
+			{ indexes: [2, [2, 3]], parentsIndexes: [[0, 1], [[0, 1], [0, 1]]], missingIndexes: [[], [[], []]] },
+			{ indexes: [2, [3, 2]], parentsIndexes: [[0, 1], [[0, 1], []]], missingIndexes: [[], [[], [0, 1]]] },
+			{ indexes: [2, [3, 3]], parentsIndexes: [[0, 1], [[0, 1], [0, 1]]], missingIndexes: [[], [[], []]] },
+		])
+	});
+	it('two hierarchical dimensions in combination, replicate missing parents', () => {
+		const dimensions = [
+			{
+				id: 'D0',
+					values: [
+						{ id: 'v0' },
+						{ id: 'v1', parents: [0] },
+						{ id: 'v2', parents: [0, 1] },
+					]
+			},
+			{
+				id: 'COMB',
+				dimensions: [{
+					id: 'D1',
+					values: [
+						{ id: 'v0' },
+						{ id: 'v1', parents: [0] },
+						{ id: 'v2', parents: [0, 1] },
+						{ id: 'v3', parents: [0, 1] },
+					]
+				},{
+					id: 'D2',
+					values: [
+						{ id: 'v0' },
+						{ id: 'v1', parents: [0] },
+						{ id: 'v2', parents: [0, 1] },
+						{ id: 'v3', parents: [0, 1] },
+					]
+				}]
+			}
+		];
+
+		const seriesIndexes = [
+			[0, [0, 0]],
+			[0, [0, 1]],
+			[0, [0, 2]],
+			[0, [0, 3]],
+			[0, [2, 2]],
+			[0, [2, 3]],
+			[0, [3, 2]],
+			[0, [3, 3]],
+			[2, [0, 0]],
+			[2, [0, 1]],
+			[2, [0, 2]],
+			[2, [0, 3]],
+			[2, [2, 2]],
+			[2, [2, 3]],
+			[2, [3, 2]],
+			[2, [3, 3]],
+		];
+
+		expect(parseSeriesIndexesHierarchies(seriesIndexes, dimensions, true)).to.deep.equal([
+			{ indexes: [0, [0, 0]], parentsIndexes: [[], [[], []]], missingIndexes: [[], [[], []]] },
+			{ indexes: [0, [0, 1]], parentsIndexes: [[], [[], [0]]], missingIndexes: [[], [[], []]] },
+			{ indexes: [0, [0, 2]], parentsIndexes: [[], [[], [0, 1]]], missingIndexes: [[], [[], []]] },
+			{ indexes: [0, [0, 3]], parentsIndexes: [[], [[], [0, 1]]], missingIndexes: [[], [[], []]] },
+			{ indexes: [0, [2, 2]], parentsIndexes: [[], [[0], []]], missingIndexes: [[], [[1], [0, 1]]] },
+			{ indexes: [0, [2, 3]], parentsIndexes: [[], [[0], []]], missingIndexes: [[], [[1], [0, 1]]] },
+			{ indexes: [0, [3, 2]], parentsIndexes: [[], [[0], []]], missingIndexes: [[], [[1], [0, 1]]] },
+			{ indexes: [0, [3, 3]], parentsIndexes: [[], [[0], []]], missingIndexes: [[], [[1], [0, 1]]] },
+			{ indexes: [2, [0, 0]], parentsIndexes: [[0], [[], []]], missingIndexes: [[1], [[], []]] },
+			{ indexes: [2, [0, 1]], parentsIndexes: [[0], [[], [0]]], missingIndexes: [[1], [[], []]] },
+			{ indexes: [2, [0, 2]], parentsIndexes: [[0], [[], [0, 1]]], missingIndexes: [[1], [[], []]] },
+			{ indexes: [2, [0, 3]], parentsIndexes: [[0], [[], [0, 1]]], missingIndexes: [[1], [[], []]] },
+			{ indexes: [2, [2, 2]], parentsIndexes: [[0], [[0], []]], missingIndexes: [[1], [[1], [0, 1]]] },
+			{ indexes: [2, [2, 3]], parentsIndexes: [[0], [[0], []]], missingIndexes: [[1], [[1], [0, 1]]] },
+			{ indexes: [2, [3, 2]], parentsIndexes: [[0], [[0], []]], missingIndexes: [[1], [[1], [0, 1]]] },
+			{ indexes: [2, [3, 3]], parentsIndexes: [[0], [[0], []]], missingIndexes: [[1], [[1], [0, 1]]] },
 		])
 	});
 });