@sis-cc/dotstatsuite-components 17.12.6 → 17.13.0

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
+				}
+  		}
+  	]);
+  });
+});

package/test/{hierarchiseDimensionWithAdvancedHierarchy.test.js → hierarchiseDimensionWithAdvancedHierarchy2.test.js}

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { hierarchiseDimensionWithAdvancedHierarchy } from '../src/rules2/src/hierarchiseDimensionWithAdvancedHierarchy';
+import { hierarchiseDimensionWithAdvancedHierarchy } from '../src/rules2/src/hierarchiseDimensionWithAdvancedHierarchy2';
 
 describe('hierarchiseDimensionWithAdvancedHierarchy tests', () => {
   it('basic test', () => {
@@ -26,16 +26,16 @@ describe('hierarchiseDimensionWithAdvancedHierarchy tests', () => {
     const hierarchised = {
       id: 'test',
       values: [
-        { id: 'OECD', parent: undefined, parents: [] },
-        { id: 'GER', parent: 'OECD', parents: ['OECD'] },
-        { id: 'FRA', parent: 'OECD', parents: ['OECD'] },
-        { id: 'USA', parent: 'OECD', parents: ['OECD'] },
-        { id: 'A', parent: undefined, parents: [] },
-        { id: 'USA', parent: 'A', parents: ['A'] },
-        { id: 'MEX', parent: 'A', parents: ['A'] },
-        { id: 'EA', parent: undefined, parents: [] },
-        { id: 'FRA', parent: 'EA', parents: ['EA'] },
-        { id: 'GER', parent: 'EA', parents: ['EA'] },
+        { id: 'OECD', parent: undefined, parents: [], __indexPosition: 0 },
+        { id: 'GER', parent: 'OECD', parents: [0], __indexPosition: 1 },
+        { id: 'FRA', parent: 'OECD', parents: [0], __indexPosition: 2 },
+        { id: 'USA', parent: 'OECD', parents: [0], __indexPosition: 3 },
+        { id: 'A', parent: undefined, parents: [], __indexPosition: 4 },
+        { id: 'USA', parent: 'A', parents: [4], __indexPosition: 5 },
+        { id: 'MEX', parent: 'A', parents: [4], __indexPosition: 6 },
+        { id: 'EA', parent: undefined, parents: [], __indexPosition: 7 },
+        { id: 'FRA', parent: 'EA', parents: [7], __indexPosition: 8 },
+        { id: 'GER', parent: 'EA', parents: [7], __indexPosition: 9 },
       ]
     }
 
@@ -70,15 +70,15 @@ describe('hierarchiseDimensionWithAdvancedHierarchy tests', () => {
     const hierarchised = {
       id: 'test',
       values: [
-        { id: 'AFK', parent: undefined, parents: [], __indexPosition: 3 },
-        { id: 'USA', parent: undefined, parents: [], __indexPosition: 2 },
-        { id: 'CAN', parent: undefined, parents: [], __indexPosition: 1 },
-        { id: 'W', parent: undefined, parents: [], __indexPosition: 8 },
-        { id: 'EA', parent: 'W', parents: ['W'], __indexPosition: 6 },
-        { id: 'FRA', parent: 'EA', parents: ['W', 'EA'], __indexPosition: 5 },
-        { id: 'IDF', parent: 'FRA', parents: ['W', 'EA', 'FRA'], __indexPosition: 0 },
-        { id: 'GER', parent: 'EA', parents: ['W', 'EA'], __indexPosition: 4 },
-        { id: 'A', parent: 'W', parents: ['W'], __indexPosition: 7 },
+        { id: 'AFK', parent: undefined, parents: [], __indexPosition: 0 },
+        { id: 'USA', parent: undefined, parents: [], __indexPosition: 1 },
+        { id: 'CAN', parent: undefined, parents: [], __indexPosition: 2 },
+        { id: 'W', parent: undefined, parents: [], __indexPosition: 3 },
+        { id: 'EA', parent: 'W', parents: [3], __indexPosition: 4 },
+        { id: 'FRA', parent: 'EA', parents: [3, 4], __indexPosition: 5 },
+        { id: 'IDF', parent: 'FRA', parents: [3, 4, 5], __indexPosition: 6 },
+        { id: 'GER', parent: 'EA', parents: [3, 4], __indexPosition: 7 },
+        { id: 'A', parent: 'W', parents: [3], __indexPosition: 8 },
       ]
     };
 
@@ -114,18 +114,18 @@ describe('hierarchiseDimensionWithAdvancedHierarchy tests', () => {
     const expected = {
       id: 'test',
       values: [
-        { id: 'OECD', parents: [], parent: undefined },
-        { id: 'USA', parents: ['OECD'], parent: 'OECD' },
-        { id: 'NY', parents: ['OECD', 'USA'], parent: 'USA' },
-        { id: 'SF', parents: ['OECD', 'USA'], parent: 'USA' },
-        { id: 'LA', parents: ['OECD', 'USA'], parent: 'USA' },
-        { id: 'FRA', parents: ['OECD'], parent: 'OECD' },
-        { id: 'IDF', parents: ['OECD', 'FRA'], parent: 'FRA' },
-        { id: 'UE', parents: [], parent: undefined },
-        { id: 'FRA', parents: ['UE'], parent: 'UE' },
-        { id: 'IDF', parents: ['UE', 'FRA'], parent: 'FRA' },
-        { id: 'GER', parents: ['UE'], parent: 'UE' },
-        { id: 'BER', parents: ['UE', 'GER'], parent: 'GER' },
+        { id: 'OECD', parents: [], parent: undefined, __indexPosition: 0 },
+        { id: 'USA', parents: [0], parent: 'OECD', __indexPosition: 1 },
+        { id: 'NY', parents: [0, 1], parent: 'USA', __indexPosition: 2 },
+        { id: 'SF', parents: [0, 1], parent: 'USA', __indexPosition: 3 },
+        { id: 'LA', parents: [0, 1], parent: 'USA', __indexPosition: 4 },
+        { id: 'FRA', parents: [0], parent: 'OECD', __indexPosition: 5 },
+        { id: 'IDF', parents: [0, 5], parent: 'FRA', __indexPosition: 6 },
+        { id: 'UE', parents: [], parent: undefined, __indexPosition: 7 },
+        { id: 'FRA', parents: [7], parent: 'UE', __indexPosition: 8 },
+        { id: 'IDF', parents: [7, 8], parent: 'FRA', __indexPosition: 9 },
+        { id: 'GER', parents: [7], parent: 'UE', __indexPosition: 10 },
+        { id: 'BER', parents: [7, 10], parent: 'GER', __indexPosition: 11 },
       ]
     };
 
@@ -149,46 +149,11 @@ describe('hierarchiseDimensionWithAdvancedHierarchy tests', () => {
     const expected = {
       id: 'REF_AREA',
       values: [
-        { id: 'FRA', parents: [], parent: undefined },
-        { id: 'USA', parents: [], parent: undefined }
+        { id: 'FRA', parents: [], parent: undefined, __indexPosition: 0 },
+        { id: 'USA', parents: [], parent: undefined, __indexPosition: 1 }
       ]
     };
 
     expect(hierarchiseDimensionWithAdvancedHierarchy(dimension, hierarchy)).to.deep.equal(expected);
   });
-  it('non duplicates case 2', () => {
-    const hierarchy = {
-      '#ROOT': ['ONU', 'OECD'],
-      'ONU': ['USA', 'FRA'],
-      'OECD': ['FRA', 'USA'],
-      'ONU.USA': ['NY', 'LA'],
-      'ONU.FRA': ['PA', 'LY']
-    };
-
-    const dimension = {
-      id: 'REF_AREA',
-      values: [
-        { id: 'OECD' },
-        { id: 'FRA' },
-        { id: 'PA' },
-        { id: 'LY' },
-        { id: 'USA' },
-        { id: 'NY' },
-        { id: 'LA' },
-      ]
-    };
-
-    const expected = {
-      id: 'REF_AREA',
-      values: [
-        { id: 'OECD', parents: [], parent: undefined },
-        { id: 'FRA', parents: ['OECD'], parent: 'OECD' },
-        { id: 'PA', parents: ['OECD.FRA'], parent: 'FRA' },
-        { id: 'LY', parents: ['OECD.FRA'], parent: 'FRA' },
-        { id: 'USA', parents: ['OECD'], parent: 'OECD' },
-        { id: 'NY', parents: ['OECD.USA'], parent: 'USA' },
-        { id: 'LA', parents: ['OECD.USA'], parent: 'USA' },
-      ]
-    };
-  });
 });

package/test/{hierarchiseDimensionWithNativeHierarchy.test.js → hierarchiseDimensionWithNativeHierarchy2.test.js}

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { hierarchiseDimensionWithNativeHierarchy } from '../src/rules2/src/hierarchiseDimensionWithNativeHierarchy';
+import { hierarchiseDimensionWithNativeHierarchy } from '../src/rules2/src/hierarchiseDimensionWithNativeHierarchy2';
 
 describe('hierarchiseDimensionWithNativeHierarchy tests', () => {
   it('basic test', () => {
@@ -19,11 +19,11 @@ describe('hierarchiseDimensionWithNativeHierarchy tests', () => {
       id: 'test',
       values: [
         { id: 'CHI', parent: undefined, parents: [], __indexPosition: 0 },
-        { id: 'W', parent: undefined, parents: [], __indexPosition: 5 },
-        { id: 'A', parent: 'W', parents: ['W'], __indexPosition: 20 },
-        { id: 'EA', parent: 'W', parents: ['W'], __indexPosition: 30 },
-        { id: 'GER', parent: 'EA', parents: ['W', 'EA'], __indexPosition: 100 },
-        { id: 'FRA', parent: 'EA', parents: ['W', 'EA'], __indexPosition: 101 }
+        { id: 'W', parent: undefined, parents: [], __indexPosition: 1 },
+        { id: 'A', parent: 'W', parents: [1], __indexPosition: 2 },
+        { id: 'EA', parent: 'W', parents: [1], __indexPosition: 3 },
+        { id: 'GER', parent: 'EA', parents: [1, 3], __indexPosition: 4 },
+        { id: 'FRA', parent: 'EA', parents: [1, 3], __indexPosition: 5 }
       ]
     };
 
@@ -45,10 +45,10 @@ describe('hierarchiseDimensionWithNativeHierarchy tests', () => {
       id: 'test',
       values: [
         { id: 'CHI', parent: undefined, parents: [], __indexPosition: 0 },
-        { id: 'A', parent: undefined, parents: [], __indexPosition: 20 },
-        { id: 'EA', parent: undefined, parents: [], __indexPosition: 30 },
-        { id: 'GER', parent: 'EA', parents: ['EA'], __indexPosition: 100 },
-        { id: 'FRA', parent: 'EA', parents: ['EA'], __indexPosition: 101 }
+        { id: 'A', parent: undefined, parents: [], __indexPosition: 1 },
+        { id: 'EA', parent: undefined, parents: [], __indexPosition: 2 },
+        { id: 'GER', parent: 'EA', parents: [2], __indexPosition: 3 },
+        { id: 'FRA', parent: 'EA', parents: [2], __indexPosition: 4 }
       ]
     };
 
@@ -70,10 +70,10 @@ describe('hierarchiseDimensionWithNativeHierarchy tests', () => {
       id: 'test',
       values: [
         { id: 'CHI', parent: undefined, parents: [], __indexPosition: 0 },
-        { id: 'A', parent: undefined, parents: [], __indexPosition: 20 },
-        { id: 'EA', parent: undefined, parents: [], __indexPosition: 30 },
-        { id: 'GER', parent: 'EA', parents: ['EA'], __indexPosition: 100 },
-        { id: '', parent: undefined, parents: [], __indexPosition: 101 }
+        { id: 'A', parent: undefined, parents: [], __indexPosition: 1 },
+        { id: 'EA', parent: undefined, parents: [], __indexPosition: 2 },
+        { id: 'GER', parent: 'EA', parents: [2], __indexPosition: 3 },
+        { id: '', parent: undefined, parents: [], __indexPosition: 4 }
       ]
     };