@sis-cc/dotstatsuite-components 17.12.6 → 17.14.0

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

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

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

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

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

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

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

@@ -50,12 +50,12 @@ export const getCuratedCells = ({ layout, observations, shape }) => {
 export const refineSections = (sections, extractedKeys, curatedObs) => R.pipe(
   R.map(
     (section) => {
-      const sectionKey = toKey(R.head(section) || []);
+      const sectionKey = toKey(R.propOr([], 'indexes', R.head(section)));
       return R.over(
         R.lensIndex(1),
         R.filter(
-          rowData => {
-            const rowKey = toKey(rowData);
+          row => {
+            const rowKey = toKey(R.prop('indexes', row));
             return R.pipe(
               R.path([sectionKey, rowKey]),
               R.omit(extractedKeys),
@@ -74,7 +74,7 @@ export const refineSections = (sections, extractedKeys, curatedObs) => R.pipe(
 
 export const refineHeader = (header, extractedKeys, curatedObs) => R.filter( // extracted : { [sectionKey]: [...rowKeys] }
   (header) => {
-    const headerKey = toKey(header);
+    const headerKey = toKey(R.prop('indexes', header));
     return R.pipe(
       R.prop(headerKey),
       (sections) => {
@@ -93,6 +93,12 @@ export const refineHeader = (header, extractedKeys, curatedObs) => R.filter( //
   }
 )(header);
 
+const getSerieLinesCount = serie => {
+  const missingParents = R.propOr([], 'missingParents', serie);
+  const missingParentsRowsCount = R.pipe(R.flatten, R.length)(missingParents);
+  return missingParentsRowsCount + 1;
+}
+
 export const truncateSectionRows = (n, sectionsData) => {
   let truncated = sectionsData;
   let extractedKeys = {};
@@ -101,26 +107,42 @@ export const truncateSectionRows = (n, sectionsData) => {
     const lastSection = R.last(truncated);
     const rows = lastSection[1];
     const rowsLength = R.length(rows);
-    const sectionKey = toKey(R.head(lastSection));
-    if (rowsLength > _n) {
-      const [rest, extracted] = R.splitAt(R.negate(_n), rows);
-      const updatedSection = R.set(R.lensIndex(1), rest)(lastSection);
-      truncated = R.set(R.lensIndex(-1), updatedSection)(truncated);
-      extractedKeys = { ...extractedKeys, [sectionKey]: R.map(toKey, extracted) };
-      _n = 0;
+    let truncatedRowsCount = 0;
+    while (_n > 0 && truncatedRowsCount !== rowsLength) {
+      const rowsCount = getSerieLinesCount(R.nth(-1 * truncatedRowsCount, rows));
+      _n = _n - rowsCount;
+      truncatedRowsCount++;
     }
-    else {
+    const sectionKey = R.pipe(R.head, R.prop('indexes'), toKey)(lastSection);
+    extractedKeys = {
+      ...extractedKeys,
+      [sectionKey]: R.pipe(
+        R.takeLast(truncatedRowsCount),
+        R.map(r => toKey(R.prop('indexes', r)))
+      )(rows)
+    };
+    if (_n > 0) {
       truncated = R.dropLast(1, truncated);
-      extractedKeys = { ...extractedKeys, [sectionKey]: R.map(toKey, rows) };
-      _n = _n - rowsLength;
+    }
+    else {
+      truncated = R.over(R.lensIndex(-1), R.over(R.lensIndex(1), R.dropLast(truncatedRowsCount)))(truncated);
     }
   }
   return ({ truncated, extractedKeys });
 };
 
 export const truncateHeader = (n, headerData) => {
-  const [truncated, extracted] = R.splitAt(R.negate(n))(headerData);
-  return ({ truncated, extractedKeys: R.map(toKey, extracted) });
+  let { truncated, extractedKeys } = { truncated: headerData, extractedKeys: [] };
+  let _n = n;
+  while (_n > 0) {
+    const lastHeader = R.last(truncated);
+    const columnsCount = getSerieLinesCount(lastHeader);
+    const extractedKey = toKey(R.prop('indexes', lastHeader));
+    extractedKeys = R.append(extractedKey, extractedKeys);
+    truncated = R.dropLast(1, truncated);
+    _n = _n - columnsCount;
+  }
+  return ({ truncated, extractedKeys });
 };
 
 const truncateLayout = (isVertical) => R.ifElse(
@@ -161,13 +183,17 @@ export const refineLayoutSize = ({ layout, observations, limit }) => layoutIndex
   //number of dimensions in header
   const headerDimCount = R.pipe(
     R.head, // first column
-    R.when(R.isNil, R.always([])),
+    R.when(R.isNil, R.always({})),
+    R.propOr([], 'indexes'),
     R.length // number of dims
   )(header);
 
   //number of columns for values
   const headerValuesCount = R.pipe(
-    R.length,
+    R.reduce((acc, header) => {
+      const columnsCount = getSerieLinesCount(header);
+      return acc + columnsCount;
+    }, 0),
     R.when(R.equals(0), R.always(1))
   )(header);
 
@@ -179,6 +205,7 @@ export const refineLayoutSize = ({ layout, observations, limit }) => layoutIndex
     R.head, // firstSection
     R.last, // rows,
     R.head, // first row
+    R.propOr([], 'indexes'),
     R.length
   )(sections);
 
@@ -189,8 +216,10 @@ export const refineLayoutSize = ({ layout, observations, limit }) => layoutIndex
   const rowsCount = R.pipe(
     R.map(R.last),
     R.unnest,
-    R.length,
-    R.add(1)
+    R.reduce((acc, row) => {
+      const rowsCount = getSerieLinesCount(row);
+      return acc + rowsCount;
+    }, 1)
   )(sections);
 
   // total of cells in all rows
@@ -198,7 +227,7 @@ export const refineLayoutSize = ({ layout, observations, limit }) => layoutIndex
 
   // number of sections cells
   const sectionsCellsCount = R.ifElse(
-    R.pipe(R.head, R.head, R.length, R.equals(0)),
+    R.pipe(R.head, R.head, R.propOr([], 'indexes'), R.length, R.equals(0)),
     R.always(0),
     R.length
   )(sections);

package/test/getLayoutData2.test.js

@@ -0,0 +1,268 @@
+import { expect } from 'chai';
+import { getSerieDatas } from '../src/rules2/src/table/getLayoutData2';
+
+describe('getLayoutData 2 tests', () => {
+  it('getSerieDatas test 1', () => {
+    const dimensions = [
+			{
+				id: 'D0',
+				values: [
+					{ id: 'v0' },
+					{ id: 'v1' },
+					{ id: 'v2' },
+					{ id: 'v3' },
+					{ id: 'v4' },
+				]
+			},
+			{
+				id: 'D1',
+				values: [
+					{ id: 'W', isSelected: true },
+					{ id: 'NA', parentsIndexes: [0], isSelected: false },
+					{ id: 'A', parentsIndexes: [0, 1], isSelected: true },
+					{ id: 'USA', parentsIndexes: [0, 1, 2], isSelected: true },
+					{ id: 'CAN', parentsIndexes: [0, 1, 2], isSelected: true },
+					{ id: 'MEX', parentsIndexes: [0, 1, 2], isSelected: true }
+				]
+			}
+		];
+
+    const serie = { indexes: [0, 3], parentsIndexes: [[], []], missingIndexes: [[], [0, 2]] };
+    expect(getSerieDatas(serie, dimensions, {}, {}, {}, {})).to.deep.equal([
+      {
+        data: [{ dimension: { id: 'D0' }, value: { id: 'v0', parents: [] } }, { dimension: { id: 'D1' }, value: { id: 'W', parents: [] } }],
+        coordinates: { D0: 'v0', D1: 'W' },
+        key: 'D0=v0:D1=W',
+        flags: [],
+        sideProps: null,
+				isEmpty: true,
+      },
+      {
+        data: [{ dimension: { id: 'D0' }, value: { id: 'v0', parents: [] } }, { dimension: { id: 'D1' }, value: { id: 'A', parents: [0] } }],
+        coordinates: { D0: 'v0', D1: 'A' },
+        key: 'D0=v0:D1=A',
+        flags: [],
+        sideProps: null,
+				isEmpty: true
+      },
+      {
+        data: [{ dimension: { id: 'D0' }, value: { id: 'v0', parents: [] } }, { dimension: { id: 'D1' }, value: { id: 'USA', parents: [0, 2] } }],
+        coordinates: { D0: 'v0', D1: 'USA' },
+        key: 'D0=v0:D1=USA',
+        flags: [],
+        sideProps: null,
+      }
+    ]);
+  });
+  it('getSerieDatas 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(getSerieDatas(serie, dimensions, topCoordinates, attributesSeries, {}, {})).to.deep.equal([
+  		{
+  			data: [
+  				{ dimension: { id: 'D0' }, value: { id: 'W', parents: [] } }
+  			],
+  			coordinates: { D0: 'W' },
+  			key: 'D0=W',
+  			flags: [],
+  			sideProps: null,
+				isEmpty: true
+  		},
+  		{
+  			data: [
+  				{ dimension: { id: 'D0' }, value: { id: 'A', parents: [0] } }
+  			],
+  			coordinates: { D0: 'A' },
+  			key: 'D0=A',
+  			flags: [],
+  			sideProps: null,
+				isEmpty: true
+  		},
+  		{
+  			data: [
+  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2] } },
+  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT', parents: [] }] }
+  			],
+  			coordinates: { D0: 'USA', D1: 'D1ROOT' },
+  			key: 'D0=USA:D1=D1ROOT',
+  			flags: [],
+  			sideProps: null,
+				isEmpty: true
+  		},
+  		{
+  			data: [
+  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2] } },
+  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT>CHILD', parents: [0] }] }
+  			],
+  			coordinates: { D0: 'USA', D1: 'D1ROOT>CHILD' },
+  			key: 'D0=USA:D1=D1ROOT>CHILD',
+  			flags: [],
+  			sideProps: null,
+				isEmpty: true
+  		},
+  		{
+  			data: [
+  				{ dimension: { id: 'D0' }, value: { id: 'USA', parents: [0, 2] } },
+  				{ dimension: { id: 'COMB0' }, values: [{ id: 'D1ROOT>CHILD>CHILD', parents: [0, 1] }, { id: 'D2ROOT', parents: [] }] }
+  			],
+  			coordinates: { D0: 'USA', D1: 'D1ROOT>CHILD>CHILD', D2: 'D2ROOT' },
+  			key: 'D0=USA:D1=D1ROOT>CHILD>CHILD:D2=D2ROOT',
+  			flags: [],
+  			sideProps: null,
+				isEmpty: true
+  		},
+  		{
+  			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] }] }
+  			],
+  			coordinates: { D0: 'USA', D1: 'D1ROOT>CHILD>CHILD', D2: 'D2ROOT>CHILD' },
+  			key: 'D0=USA:D1=D1ROOT>CHILD>CHILD:D2=D2ROOT>CHILD',
+  			flags: [],
+  			sideProps: null,
+				isEmpty: true
+  		},
+  		{
+  			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: [] }] }
+  			],
+  			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',
+  			flags: [],
+  			sideProps: null,
+				isEmpty: true
+  		},
+  		{
+  			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] }] }
+  			],
+  			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',
+  			flags: [],
+  			sideProps: null,
+				isEmpty: true
+  		},
+  		{
+  			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: [] }] }
+  			],
+  			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',
+  			flags: [],
+  			sideProps: null,
+				isEmpty: true
+  		},
+
+  		{
+  			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] }] }
+  			],
+  			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',
+  			flags: [],
+  			sideProps: null,
+				isEmpty: true
+  		},
+  		{
+  			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] }] }
+  			],
+  			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
+				}
+  		}
+  	]);
+  });
+});