@sis-cc/dotstatsuite-components 17.32.2 → 18.1.0

package/src/rules2/src/prepareData.js

@@ -12,12 +12,12 @@ import { getAttributesSeries } from './getAttributesSeries';
 import { getManyValuesDimensions } from './getManyValuesDimensions';
 import { getOneValueDimensions } from './getOneValueDimensions';
 import { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy2';
-import { hierarchiseDimensionWithAdvancedHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy2';
 import { getDataflowAttributes } from './getDataflowAttributes';
 import { getHeaderTitle } from './getHeaderTitle';
 import { getHeaderSubtitle } from './getHeaderSubtitle';
 import { getHeaderCombinations } from './getHeaderCombinations';
 import { getHeaderCoordinates } from './getHeaderCoordinates';
+import { applyHierarchicalCodesToDim } from './applyHierarchicalCodesToDim';
 
 export const prepareData = (sdmxJson, { customAttributes, locale, hierarchies, dataflow, display, defaultCombinations, dataquery }) => {
   const dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
@@ -46,7 +46,7 @@ export const prepareData = (sdmxJson, { customAttributes, locale, hierarchies, d
     if (R.isEmpty(R.propOr({}, dim.id, hierarchies))) {
       return hierarchiseDimensionWithNativeHierarchy(dim);
     }
-    return hierarchiseDimensionWithAdvancedHierarchy(dim, R.prop(dim.id, hierarchies));
+    return applyHierarchicalCodesToDim(R.prop(dim.id, hierarchies), dim);
   }, manyValuesDimensions)
   const duplicatedObservations = duplicateObs(R.values(hierarchisedDimensions), enhancedObservations);
 

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

@@ -51,7 +51,7 @@ const getCoordinates = (indexes, topCoordinates, definition) => R.addIndex(R.red
 }, topCoordinates, definition);
 
 const getAttributesSeries = (validator, attributesSeries) => R.reduce((acc, attrs) => {
-	const attr = R.head(R.values(attrs)) || {};
+	const attr = R.head(R.values(attrs));
 	if (R.length(attr.relationship || []) === 1 && !attr.combined) {
 		return acc;
 	}
@@ -87,7 +87,7 @@ const getSerieFlagsAndSideProps = (coordinates, validator, attributesValues, cus
   const flags = getFlagsAndNotes(layoutAttrValues, customAttributes);
   const hasMetadata = !R.isNil(R.find(validator, metadataCoordinates));
 	const hasDataAdvancedAttributes = R.any(
-		d => R.has('value', d) ? R.prop('hasAdvancedAttributes', d.value) : R.any(R.prop('hasAdvancedAttributes'), d.values)
+		d => R.has('value', d) ? d.hasAdvancedAttributes : R.any(R.prop('hasAdvancedAttributes'), d.values)
 	, data);
   const hasAdvancedAttributes = hasDataAdvancedAttributes || getHasAdvancedAttributes(layoutAttrValues, customAttributes);
   const sideProps = hasMetadata || hasAdvancedAttributes

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

@@ -23,7 +23,7 @@ const parseSerieIndexesHierarchies = (serieIndexes, previousSerie, dimensions, d
       if (previousRegisteredIndexes.has(i)) {
         return R.over(R.lensProp('presentParentsIndexes'), p => R.isNil(p) ? [i] : R.append(i, p), _acc);
       }
-      else if (i > previousIndex && R.pathOr(false, [dimensionIndex, 'values', i, 'isSelected'], dimensions)) {
+      else if (i > previousIndex) {
         registeredIndexes.add(i);
         return R.over(R.lensProp('missingParentsIndexes'), m => R.isNil(m) ? [i] :  R.append(i, m), _acc);
       }

package/src/viewer/src/app.js

@@ -1,8 +1,8 @@
 import React, { useState } from 'react';
 import { Helmet } from 'react-helmet';
 import { Tab2, Tabs2, Intent, Icon, Tooltip, Position } from '@blueprintjs/core';
-import { ThemeProvider } from '@material-ui/core/styles';
-import { createTheme } from '@material-ui/core/styles';
+import { ThemeProvider, StyledEngineProvider } from '@mui/material/styles';
+import { createTheme } from '@mui/material/styles';
 import { sisccTheme } from '@sis-cc/dotstatsuite-visions';
 import UseCase1 from './app/use-case-1';
 import TableCase from './app/table';
@@ -100,18 +100,20 @@ export default () => {
 */
 
   return (
-    <div style={{padding: 10}}>
-      <ThemeProvider theme={theme}>
-        <Helmet htmlAttributes={{ dir: isRtl ? 'rtl' : 'ltr' }} />
-        <button onClick={() => setRtl(!isRtl)}>{isRtl ? 'left to right' : 'right to left'}</button>
-        <Tabs2 renderActiveTabPanelOnly={false}>
-          <Tab2
-            id="uc1"
-            title={<AppTab label="full screen resizable chart" iconName="fullscreen" />}
-            panel={<UseCase1 isRtl={isRtl} config={config} style={style} options={options} />}
-          />
-        </Tabs2>
-      </ThemeProvider>
+    <div style={{ padding: 10 }}>
+      {/* <StyledEngineProvider injectFirst>
+        <ThemeProvider theme={theme}> */}
+      <Helmet htmlAttributes={{ dir: isRtl ? 'rtl' : 'ltr' }} />
+      <button onClick={() => setRtl(!isRtl)}>{isRtl ? 'left to right' : 'right to left'}</button>
+      <Tabs2 renderActiveTabPanelOnly={false}>
+        <Tab2
+          id="uc1"
+          title={<AppTab label="full screen resizable chart" iconName="fullscreen" />}
+          panel={<UseCase1 isRtl={isRtl} config={config} style={style} options={options} />}
+        />
+      </Tabs2>
+      {/* </ThemeProvider>
+      </StyledEngineProvider> */}
     </div>
   );
 };

package/src/viewer/src/index.js

@@ -3,7 +3,7 @@ import * as R from 'ramda';
 import cx from 'classnames';
 import useSize from '@react-hook/size';
 import { Loading, NoData, TableHtml5 } from '@sis-cc/dotstatsuite-visions';
-import { useTheme, makeStyles } from '@material-ui/core/styles';
+import { makeStyles, useTheme } from '@mui/styles';
 import getChartOptions from './chartUtils/options';
 import Header from './header';
 import Chart from './chart';

package/src/viewer/src/legends/AxisLegend.js

@@ -1,7 +1,7 @@
 import React from 'react';
 import PropTypes from 'prop-types';
 import * as R from 'ramda';
-import { makeStyles } from '@material-ui/core/styles';
+import makeStyles from '@mui/styles/makeStyles';
 import { SCATTER } from '../../../rules/src/constants';
 import { getFontFromTheme } from '../utils';
 

package/src/viewer/src/legends/ChartLegends.js

@@ -3,7 +3,7 @@ import * as R from 'ramda';
 import numeral from 'numeral';
 import { computeOptions } from '@sis-cc/dotstatsuite-d3-charts';
 import { ChoroplethLegend } from '../../../bridge-d3-react/src';
-import { useTheme } from '@material-ui/core/styles';
+import { useTheme } from '@mui/material/styles';
 import AxisLegend from './AxisLegend';
 import FocusLegend from './FocusLegend';
 import SeriesLegend from './SeriesLegend';

package/src/viewer/src/legends/Legend.js

@@ -1,7 +1,7 @@
 import React from 'react';
 import PropTypes from 'prop-types';
 import * as R from 'ramda';
-import { makeStyles } from '@material-ui/core/styles';
+import makeStyles from '@mui/styles/makeStyles';
 import { getFontFromTheme } from '../utils';
 
 const useStyles = makeStyles(theme => ({

package/test/applyHierarchicalCodesToDim.test.js

@@ -0,0 +1,147 @@
+import { applyHierarchicalCodesToDim } from '../src/rules2/src/applyHierarchicalCodesToDim';
+import { expect } from 'chai';
+import * as R from 'ramda';
+
+const hCodes = [
+  { codeID: 'PARENT_A', hierarchicalCodes: [
+    { codeID: 'ITEM', hierarchicalCodes: [
+      { codeID: 'CHILD_A', hierarchicalCodes: [] },
+      { codeID: 'CHILD_B', hierarchicalCodes: [] },
+    ] },
+    { codeID: 'BROTHER_A', hierarchicalCodes: [] },
+  ] },
+  { codeID: 'PARENT_B', hierarchicalCodes: [
+    { codeID: 'ITEM', hierarchicalCodes: [
+      { codeID: 'CHILD_A', hierarchicalCodes: [] },
+      { codeID: 'CHILD_C', hierarchicalCodes: [] },
+    ] },
+    { codeID: 'BROTHER_B', hierarchicalCodes: [] },
+  ] },
+];
+
+const dim = {
+  id: 'DIM',
+  values: [
+    { id: 'PARENT_A', isSelected: true },
+    { id: 'PARENT_B', isSelected: true },
+    { id: 'ITEM', isSelected: true },
+    { id: 'BROTHER_A', isSelected: true },
+    { id: 'BROTHER_B', isSelected: true },
+    { id: 'CHILD_A', isSelected: true },
+    { id: 'CHILD_B', isSelected: true },
+    { id: 'CHILD_C', isSelected: true },
+  ]
+};
+
+const deselectedDim = (indexes) => R.over(
+  R.lensProp('values'),
+  R.addIndex(R.map)((v, i) => R.includes(i, indexes) ? { ...v, isSelected: false } : v)
+)(dim);
+
+describe('refineHierarchicalCodelist tests', () => {
+  it('complete test', () => {
+    const expected = {
+      id: 'DIM',
+      values: [
+        { id: 'PARENT_A', parents: [], parent: undefined, isSelected: true, __indexPosition: 0 },
+        { id: 'ITEM', parents: [0], parent: 'PARENT_A', isSelected: true, __indexPosition: 1 },
+        { id: 'CHILD_A', parents: [0, 1], parent: 'PARENT_A.ITEM', isSelected: true, __indexPosition: 2 },
+        { id: 'CHILD_B', parents: [0, 1], parent: 'PARENT_A.ITEM', isSelected: true, __indexPosition: 3 },
+        { id: 'BROTHER_A', parents: [0], parent: 'PARENT_A', isSelected: true, __indexPosition: 4 },
+        { id: 'PARENT_B', parents: [], parent: undefined, isSelected: true, __indexPosition: 5 },
+        { id: 'ITEM', parents: [5], parent: 'PARENT_B', isSelected: true, __indexPosition: 6 },
+        { id: 'CHILD_A', parents: [5, 6], parent: 'PARENT_B.ITEM', isSelected: true, __indexPosition: 7 },
+        { id: 'CHILD_C', parents: [5, 6], parent: 'PARENT_B.ITEM', isSelected: true, __indexPosition: 8 },
+        { id: 'BROTHER_B', parents: [5], parent: 'PARENT_B', isSelected: true, __indexPosition: 9 },
+      ]
+    };
+
+    expect(applyHierarchicalCodesToDim(hCodes, dim)).to.deep.equal(expected);
+  });
+  it('partial test 1', () => {
+    const partialDim = deselectedDim([0]);
+
+    const expected = {
+      id: 'DIM',
+      values: [
+        { id: 'ITEM', parents: [], parent: undefined, isSelected: true, __indexPosition: 0 },
+        { id: 'CHILD_A', parents: [0], parent: 'ITEM', isSelected: true, __indexPosition: 1 },
+        { id: 'CHILD_B', parents: [0], parent: 'ITEM', isSelected: true, __indexPosition: 2 },
+        { id: 'BROTHER_A', parents: [], parent: undefined, isSelected: true, __indexPosition: 3 },
+        { id: 'PARENT_B', parents: [], parent: undefined, isSelected: true, __indexPosition: 4 },
+        { id: 'ITEM', parents: [4], parent: 'PARENT_B', isSelected: true, __indexPosition: 5 },
+        { id: 'CHILD_A', parents: [4, 5], parent: 'PARENT_B.ITEM', isSelected: true, __indexPosition: 6 },
+        { id: 'CHILD_C', parents: [4, 5], parent: 'PARENT_B.ITEM', isSelected: true, __indexPosition: 7 },
+        { id: 'BROTHER_B', parents: [4], parent: 'PARENT_B', isSelected: true, __indexPosition: 8 },
+      ]
+    };
+
+    expect(applyHierarchicalCodesToDim(hCodes, partialDim)).to.deep.equal(expected);
+  });
+  it('partial test 2', () => {
+    const partialDim = deselectedDim([1, 4, 7]);
+
+    const expected = {
+      id: 'DIM',
+      values: [
+        { id: 'PARENT_A', parents: [], parent: undefined, isSelected: true, __indexPosition: 0 },
+        { id: 'ITEM', parents: [0], parent: 'PARENT_A', isSelected: true, __indexPosition: 1 },
+        { id: 'CHILD_A', parents: [0, 1], parent: 'PARENT_A.ITEM', isSelected: true, __indexPosition: 2 },
+        { id: 'CHILD_B', parents: [0, 1], parent: 'PARENT_A.ITEM', isSelected: true, __indexPosition: 3 },
+        { id: 'BROTHER_A', parents: [0], parent: 'PARENT_A', isSelected: true, __indexPosition: 4 },
+      ]
+    };
+
+    expect(applyHierarchicalCodesToDim(hCodes, partialDim)).to.deep.equal(expected);
+  });
+  it('partial test 3', () => {
+    const partialDim = deselectedDim([0, 6]);
+
+    const expected = {
+      id: 'DIM',
+      values: [
+        { id: 'BROTHER_A', parents: [], parent: undefined, isSelected: true, __indexPosition: 0 },
+        { id: 'PARENT_B', parents: [], parent: undefined, isSelected: true, __indexPosition: 1 },
+        { id: 'ITEM', parents: [1], parent: 'PARENT_B', isSelected: true, __indexPosition: 2 },
+        { id: 'CHILD_A', parents: [1, 2], parent: 'PARENT_B.ITEM', isSelected: true, __indexPosition: 3 },
+        { id: 'CHILD_C', parents: [1, 2], parent: 'PARENT_B.ITEM', isSelected: true, __indexPosition: 4 },
+        { id: 'BROTHER_B', parents: [1], parent: 'PARENT_B', isSelected: true, __indexPosition: 5 },
+      ]
+    };
+
+    expect(applyHierarchicalCodesToDim(hCodes, partialDim)).to.deep.equal(expected);
+  });
+  it('partial test 4', () => {
+    const partialDim = deselectedDim([6]);
+
+    const expected = {
+      id: 'DIM',
+      values: [
+        { id: 'PARENT_A', parents: [], parent: undefined, isSelected: true, __indexPosition: 0 },
+        { id: 'ITEM', parents: [0], parent: 'PARENT_A', isSelected: true, __indexPosition: 1 },
+        { id: 'CHILD_A', parents: [0, 1], parent: 'PARENT_A.ITEM', isSelected: true, __indexPosition: 2 },
+        { id: 'BROTHER_A', parents: [0], parent: 'PARENT_A', isSelected: true, __indexPosition: 3 },
+        { id: 'PARENT_B', parents: [], parent: undefined, isSelected: true, __indexPosition: 4 },
+        { id: 'ITEM', parents: [4], parent: 'PARENT_B', isSelected: true, __indexPosition: 5 },
+        { id: 'CHILD_A', parents: [4, 5], parent: 'PARENT_B.ITEM', isSelected: true, __indexPosition: 6 },
+        {  id: 'CHILD_C', parents: [4, 5], parent: 'PARENT_B.ITEM', isSelected: true, __indexPosition: 7 },
+        { id: 'BROTHER_B', parents: [4], parent: 'PARENT_B', isSelected: true, __indexPosition: 8 },
+      ]
+    };
+
+    expect(applyHierarchicalCodesToDim(hCodes, partialDim)).to.deep.equal(expected);
+  });
+  it('partial test 5', () => {
+    const partialDim = deselectedDim([0, 1, 2, 3, 4]);
+
+    const expected = {
+      id: 'DIM',
+      values: [
+        { id: 'CHILD_A', parents: [], parent: undefined, isSelected: true, __indexPosition: 0 },
+        { id: 'CHILD_B', parents: [], parent: undefined, isSelected: true, __indexPosition: 1 },
+        { id: 'CHILD_C', parents: [], parent: undefined, isSelected: true, __indexPosition: 2 },
+      ]
+    };
+    expect(applyHierarchicalCodesToDim(hCodes, partialDim)).to.deep.equal(expected);
+  });
+});

package/test/getLayoutData2.test.js

@@ -439,52 +439,4 @@ describe('getLayoutData 2 tests', () => {
 			}
 		});
 	});
-	it('getSerieDataWithMissingLines, advanced attributes as dim level plus enpty series', () => {
-		const dimensions = [
-			{ 
-				id: 'D0',
-				values: [
-					{ id: 'D0V0', flags: [], hasAdvancedAttributes: true },
-					{ id: 'D0V1' }
-				]
-			}
-		];
-
-		const attributesSeries = {
-			'D1=D1V0': {},
-			'D0=D0V0:D1=D1V0': {},
-  	};
-
-		const topCoordinates = {};
-
-		const serie = {
-  		indexes: [0],
-  		parentsIndexes: [[]],
-  		missingIndexes: [[]],
-  	};
-
-		const customAttributes = {
-			flags: [],
-			notes: ['A0', 'A2']
-		}
-
-		expect(getSerieDataWithMissingLines(serie, dimensions, topCoordinates, attributesSeries, customAttributes, {})).to.deep.equal([{
-			data: [
-				{
-					dimension: { id: 'D0' },
-					value: { id: 'D0V0', missingParents: [], parents: [], flags: [], hasAdvancedAttributes: true }
-				},
-			],
-			coordinates: { D0: 'D0V0' },
-			key: 'D0=D0V0',
-			flags: [],
-			sideProps: {
-				coordinates: {
-					D0: 'D0V0',
-				},
-				hasAdvancedAttributes: true,
-				hasMetadata: false
-			}
-		}]);
-	});
 });

package/test/parseCombinations.test.js

@@ -146,20 +146,6 @@ describe('parseCombinations tests', () => {
         relationship: ['DIM4'],
         display: true,
       },
-      {
-        id: 'COMB11',
-        concepts: ['DIM4'],
-        relationship: ['DIM4'],
-        series: true,
-        display: true
-      },
-      {
-        id: 'COMB12',
-        concepts: ['DIM4'],
-        relationship: ['DIM4'],
-        series: true,
-        display: true
-      },
       {
         id: 'COMB14',
         concepts: ['DIM3', 'ATTR5', 'ATTR8'],

package/test/parseSeriesIndexesHierarchies.test.js

@@ -1,4 +1,3 @@
-import * as R from 'ramda';
 import { expect } from 'chai';
 import { parseSeriesIndexesHierarchies } from '../src/rules2/src/table/parseSeriesIndexesHierarchies';
 
@@ -29,43 +28,6 @@ describe('parseSeriesIndexesHierarchies tests', () => {
 			{ indexes: [4], parentsIndexes: [[]], missingIndexes: [[]], registeredIndexes: [new Set([2, 3, 4])] },
 		])
 	});
-	it('more complex stuff', () => {
-		const dimensions = [
-			{
-				id: 'D0',
-				values: [
-					{ id: 'v0' },
-					{ id: 'v1' },
-					{ id: 'v2' },
-					{ id: 'v3' },
-					{ id: 'v4' },
-				]
-			},
-			{
-				id: 'D1',
-				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 }
-				]
-			}
-		];
-
-		const seriesIndexes = [
-			[0, 3],
-			[0, 4],
-			[1, 5]
-		];
-
-		expect(parseSeriesIndexesHierarchies(seriesIndexes, dimensions)).to.deep.equal([
-			{ indexes: [0, 3], parentsIndexes: [[], []], missingIndexes: [[], [0, 2]], registeredIndexes: [new Set([0]), new Set([0, 2, 3])] },
-			{ indexes: [0, 4], parentsIndexes: [[], [0, 2]], missingIndexes: [[], []], registeredIndexes: [new Set([0]), new Set([0, 2, 3, 4])] },
-			{ indexes: [1, 5], parentsIndexes: [[], []], missingIndexes: [[], [0, 2]], registeredIndexes: [new Set([0, 1]), new Set([0, 2, 5])] },
-		])
-	});
 	it('with combination', () => {
 		const dimensions = [
 			{
@@ -102,56 +64,4 @@ describe('parseSeriesIndexesHierarchies tests', () => {
 			{ indexes: [[0, 1]], parentsIndexes: [[[], [0]]], missingIndexes: [[[], []]], registeredIndexes: [[new Set([0]), new Set([0, 1])]] },
 		])
 	});
-	it('combinations and inversed dimension', () => {
-		const dimensions = [
-			{
-				id: 'D',
-				values: [
-					{ id: 'A' },
-					{ id: 'B' },
-					{ id: 'C' }
-				]
-			},
-			{
-				id: 'COMB',
-				dimensions: [{
-					values: [
-						{ id: 'v0' },
-						{ id: 'v1' },
-						{ id: 'v2' },
-						{ id: 'v3' },
-						{ id: 'v4' },
-					]
-				},
-				{
-					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 }
-					]
-				}]
-			},
-		];
-
-		const seriesIndexes = [
-			[-2, [0, 2]],
-			[-2, [0, 3]],
-			[-1, [0, 2]],
-			[-1, [0, 3]],
-			[0, [0, 2]],
-			[0, [0, 3]],
-		];
-
-		expect(parseSeriesIndexesHierarchies(seriesIndexes, dimensions)).to.deep.equal([
-			{ indexes: [-2, [0, 2]], parentsIndexes: [[], [[], []]], missingIndexes: [[], [[], [0]]], registeredIndexes: [new Set([2]), [new Set([0]), new Set([0, 2])]] },
-			{ indexes: [-2, [0, 3]], parentsIndexes: [[], [[], [0, 2]]], missingIndexes: [[], [[], []]], registeredIndexes: [new Set([2]), [new Set([0]), new Set([0, 2, 3])]] },
-			{ indexes: [-1, [0, 2]], parentsIndexes: [[], [[], []]], missingIndexes: [[], [[], [0]]], registeredIndexes: [new Set([1, 2]), [new Set([0]), new Set([0, 2])]] },
-			{ indexes: [-1, [0, 3]], parentsIndexes: [[], [[], [0, 2]]], missingIndexes: [[], [[], []]], registeredIndexes: [new Set([1, 2]), [new Set([0]), new Set([0, 2, 3])]] },
-			{ indexes: [0, [0, 2]], parentsIndexes: [[], [[], []]], missingIndexes: [[], [[], [0]]], registeredIndexes: [new Set([0, 1, 2]), [new Set([0]), new Set([0, 2])]] },
-			{ indexes: [0, [0, 3]], parentsIndexes: [[], [[], [0, 2]]], missingIndexes: [[], [[], []]], registeredIndexes: [new Set([0, 1, 2]), [new Set([0]), new Set([0, 2, 3])]] },
-		])
-	})
 });

package/test/hierarchiseDimensionWithAdvancedHierarchy2.test.js

@@ -1,159 +0,0 @@
-import { expect } from 'chai';
-import { hierarchiseDimensionWithAdvancedHierarchy } from '../src/rules2/src/hierarchiseDimensionWithAdvancedHierarchy2';
-
-describe('hierarchiseDimensionWithAdvancedHierarchy tests', () => {
-  it('basic test', () => {
-    const dimension = {
-      id: 'test',
-      values: [
-        { id: 'FRA' },
-        { id: 'GER' },
-        { id: 'OECD' },
-        { id: 'USA' },
-        { id: 'A' },
-        { id: 'EA' },
-        { id: 'MEX' },
-      ]
-    };
-
-    const hierarchy = {
-      '#ROOT': ['OECD', 'A', 'EA'],
-      OECD: ['GER', 'FRA', 'USA'],
-      A: ['USA', 'MEX'],
-      EA: ['FRA', 'GER']
-    };
-
-    const hierarchised = {
-      id: 'test',
-      values: [
-        { 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 },
-      ]
-    }
-
-    expect(hierarchiseDimensionWithAdvancedHierarchy(dimension, hierarchy)).to.deep.equal(hierarchised);
-  });
-  it('missing ids defined in the hierarchy', () => {
-    const hierarchy = {
-      '#ROOT': ['W'],
-      W: ['EA', 'A'],
-      'W.A': ['NA', 'SA'],
-      'W.A.NA': ['USA', 'CAN'],
-      'W.A.SA': ['BRA'],
-      'W.EA': ['FRA', 'GER'],
-      'W.EA.FRA': ['IDF', 'BRE', 'ALS']
-    };
-
-    const dimension = {
-      id: 'test',
-      values: [
-        { id: 'IDF', __indexPosition: 0 },
-        { id: 'CAN', __indexPosition: 1 },
-        { id: 'USA', __indexPosition: 2 },
-        { id: 'AFK', __indexPosition: 3 },
-        { id: 'GER', __indexPosition: 4 },
-        { id: 'FRA', __indexPosition: 5 },
-        { id: 'EA', __indexPosition: 6 },
-        { id: 'A', __indexPosition: 7 },
-        { id: 'W', __indexPosition: 8 },
-      ]
-    };
-
-    const hierarchised = {
-      id: 'test',
-      values: [
-        { 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 },
-      ]
-    };
-
-    expect(hierarchiseDimensionWithAdvancedHierarchy(dimension, hierarchy)).to.deep.equal(hierarchised);
-  });
-  it('partial deep hierarchy', () => {
-    const hierarchy = {
-      '#ROOT': ['W'],
-      'W': ['OECD', 'UE'],
-      'W.OECD': ['USA', 'FRA'],
-      'W.OECD.USA': ['NY', 'SF', 'LA'],
-      'W.OECD.FRA': ['IDF'],
-      'W.UE': ['FRA', 'GER'],
-      'W.UE.FRA': ['IDF'],
-      'W.UE.GER': ['BER'],
-    };
-    const dimension = {
-      id: 'test',
-      values: [
-        { id: 'OECD' },
-        { id: 'UE' },
-        { id: 'USA' },
-        { id: 'FRA' },
-        { id: 'GER' },
-        { id: 'NY' },
-        { id: 'SF' },
-        { id: 'LA' },
-        { id: 'IDF' },
-        { id: 'BER' },
-      ]
-    };
-
-    const expected = {
-      id: 'test',
-      values: [
-        { 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 },
-      ]
-    };
-
-    expect(hierarchiseDimensionWithAdvancedHierarchy(dimension, hierarchy)).to.deep.equal(expected);
-  });
-  it('non duplicates case 1', () => {
-    const hierarchy = {
-      '#ROOT': ['ONU', 'OECD'],
-      'OECD': ['FRA', 'USA'],
-      'ONU': ['USA', 'FRA'],
-    };
-
-    const dimension = {
-      id: 'REF_AREA',
-      values: [
-        { id: 'FRA' },
-        { id: 'USA' }
-      ]
-    };
-
-    const expected = {
-      id: 'REF_AREA',
-      values: [
-        { id: 'FRA', parents: [], parent: undefined, __indexPosition: 0 },
-        { id: 'USA', parents: [], parent: undefined, __indexPosition: 1 }
-      ]
-    };
-
-    expect(hierarchiseDimensionWithAdvancedHierarchy(dimension, hierarchy)).to.deep.equal(expected);
-  });
-});