@sis-cc/dotstatsuite-components 17.13.0 → 17.15.0

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/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';