@sis-cc/dotstatsuite-components 14.1.1 → 14.2.0

package/lib/rules/src/table/preparators/prepareData.js

@@ -53,11 +53,11 @@ var _getMetadataCoordinates = require('../../../../rules2/src/getMetadataCoordin
 
 var _getAdvancedAttributes = require('../../../../rules2/src/getAdvancedAttributes');
 
-var _getDimensionsSimpleHierarchies = require('../../../../rules2/src/getDimensionsSimpleHierarchies');
-
 var _duplicateObservations = require('../../../../rules2/src/duplicateObservations');
 
-var _hierarchiseDimension = require('../../../../rules2/src/hierarchiseDimension');
+var _hierarchiseDimensionWithAdvancedHierarchy = require('../../../../rules2/src/hierarchiseDimensionWithAdvancedHierarchy');
+
+var _hierarchiseDimensionWithNativeHierarchy = require('../../../../rules2/src/hierarchiseDimensionWithNativeHierarchy');
 
 var _getDimensionValuesIndexes = require('../../../../rules2/src/getDimensionValuesIndexes');
 
@@ -84,8 +84,7 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, customAtt
   var _customAttributes = R.assoc('units', unitsDefinitionCodes, customAttributes);
   var dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
 
-  var simpleHierarchies = (0, _getDimensionsSimpleHierarchies.getDimensionsSimpleHierarchies)(dimensions);
-  var hierarchies = R.mergeRight(simpleHierarchies, _options.hierarchies || {});
+  var hierarchies = _options.hierarchies || {};
   var dimensionsIndexedByIds = R.indexBy(R.prop('id'), dimensions);
 
   var parsedDimensionsIds = (0, _parseDimensionsIds.parseDimensionsIds)(dimensions);
@@ -167,8 +166,12 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, customAtt
   var seriesAdvancedAttributes = (0, _getAdvancedAttributes.getSeriesAdvancedAttributes)(seriesAttributesValues, dimensions, seriesAdvancedAttributesIds);
 
   var hierarchisedDimensions = R.map(function (dim) {
-    return (0, _hierarchiseDimension.hierarchiseDimension)(dim, R.propOr({}, dim.id, hierarchies));
+    if (R.isEmpty(R.propOr({}, dim.id, hierarchies))) {
+      return (0, _hierarchiseDimensionWithNativeHierarchy.hierarchiseDimensionWithNativeHierarchy)(dim);
+    }
+    return (0, _hierarchiseDimensionWithAdvancedHierarchy.hierarchiseDimensionWithAdvancedHierarchy)(dim, R.prop(dim.id, hierarchies));
   })(manyValuesDimensions);
+
   var valuesIndexes = R.reduce(function (acc, dim) {
     return (0, _extends4.default)({}, acc, (0, _defineProperty3.default)({}, dim.__index, (0, _getDimensionValuesIndexes.getDimensionValuesIndexes)(dim.values)));
   }, {}, R.values(hierarchisedDimensions));

package/lib/rules2/src/getHCodelistsRefsInData.js

@@ -22,7 +22,7 @@ var getHCodelistsRefs = exports.getHCodelistsRefs = function getHCodelistsRefs(a
     if (annotation.type !== 'HIER_CONTEXT') {
       return acc;
     }
-    var reference = annotation.text || '';
+    var reference = annotation.text || annotation.title || '';
     var match = reference.match(/([\w@_.]+):([\w@_.]+):([\w@_.]+)\(([\d.]+)\).([\w@_.]+)$/);
     if (R.isNil(match)) {
       return acc;

package/lib/rules2/src/{hierarchiseDimension.js → hierarchiseDimensionWithAdvancedHierarchy.js}

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.hierarchiseDimension = undefined;
+exports.hierarchiseDimensionWithAdvancedHierarchy = undefined;
 
 var _extends2 = require('babel-runtime/helpers/extends');
 
@@ -17,21 +17,13 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var hierarchiseDimension = exports.hierarchiseDimension = function hierarchiseDimension(dimension, hierarchy) {
+var hierarchiseDimensionWithAdvancedHierarchy = exports.hierarchiseDimensionWithAdvancedHierarchy = function hierarchiseDimensionWithAdvancedHierarchy(dimension, hierarchy) {
   var indexed = R.indexBy(R.prop('id'), dimension.values);
-  var _hierarchy = hierarchy;
-  if (!R.has('#ROOT', hierarchy)) {
-    var indexes = R.pluck('id', dimension.values);
-    var refinedHierarchy = R.pick(indexes, _hierarchy);
-    var childrenIds = R.pipe(R.values, R.unnest, R.indexBy(R.identity))(refinedHierarchy);
-    var rootIds = R.pipe(R.reject(function (val) {
-      return R.has(val.id, childrenIds);
-    }), R.sortBy(R.prop('__indexPosition')), R.pluck('id'))(dimension.values);
-    _hierarchy = R.assoc('#ROOT', rootIds, hierarchy);
-  }
 
+  var rest = indexed;
   var getChildren = function getChildren(parents) {
     return R.pipe(function (ids) {
+      rest = R.omit(ids, rest);
       return R.props(ids, indexed);
     }, R.filter(R.identity), R.map(function (val) {
       var _val = (0, _extends3.default)({}, val, {
@@ -40,8 +32,16 @@ var hierarchiseDimension = exports.hierarchiseDimension = function hierarchiseDi
       });
       var children = getChildren(R.append(val.id, parents));
       return R.prepend(_val, children);
-    }))(R.propOr([], R.last(parents) || '#ROOT', _hierarchy));
+    }))(R.propOr([], R.isEmpty(parents) ? '#ROOT' : R.join('.', parents), hierarchy));
   };
 
-  return R.set(R.lensProp('values'), R.flatten(getChildren([])))(dimension);
+  return R.set(R.lensProp('values'), R.pipe(getChildren, R.flatten, function (values) {
+    if (R.isEmpty(rest)) {
+      return values;
+    }
+    var sortedRest = R.pipe(R.values, R.map(function (val) {
+      return (0, _extends3.default)({}, val, { parent: undefined, parents: [] });
+    }), R.sortBy(R.prop('__indexPosition')))(rest);
+    return R.concat(sortedRest, values);
+  })([]))(dimension);
 };

package/lib/rules2/src/hierarchiseDimensionWithNativeHierarchy.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hierarchiseDimensionWithNativeHierarchy = undefined;
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+var hierarchiseDimensionWithNativeHierarchy = exports.hierarchiseDimensionWithNativeHierarchy = function hierarchiseDimensionWithNativeHierarchy(dimension) {
+  var values = R.sortBy(R.prop('__indexPosition'), dimension.values || []);
+  var grouped = R.groupBy(R.propOr('#ROOT', 'parent'), values);
+
+  var getChildren = function getChildren(parents) {
+    var childs = R.propOr([], R.last(parents) || '#ROOT', grouped);
+    return R.reduce(function (acc, child) {
+      var refined = R.assoc('parents', parents, child);
+      var children = getChildren(R.append(child.id, parents));
+      return R.concat(acc, R.prepend(refined, children));
+    }, [], childs);
+  };
+
+  return R.set(R.lensProp('values'), getChildren([]))(dimension);
+};

package/lib/rules2/src/parseHierarchicalCodelist.js

@@ -5,18 +5,53 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.parseHierarchicalCodelist = undefined;
 
+var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
+
+var _defineProperty3 = _interopRequireDefault(_defineProperty2);
+
+var _extends4 = require('babel-runtime/helpers/extends');
+
+var _extends5 = _interopRequireDefault(_extends4);
+
 var _ramda = require('ramda');
 
 var R = _interopRequireWildcard(_ramda);
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
 
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 var parseHierarchicalCodelist = exports.parseHierarchicalCodelist = function parseHierarchicalCodelist(sdmxJson, hierarchyId) {
   var hCodelist = R.pathOr({}, ['data', 'hierarchicalCodelists', 0], sdmxJson);
   var hierarchy = R.find(R.propEq('id', hierarchyId), hCodelist.hierarchies || []);
 
-  return R.pipe(R.propOr([], 'hierarchicalCodes'), R.reduce(function (acc, parentCode) {
-    var children = R.pluck('id', parentCode.hierarchicalCodes || []);
-    return R.assoc(parentCode.id, children, acc);
-  }, {}))(hierarchy);
+  var getParentedCodes = function getParentedCodes(codes, parent) {
+    var ids = R.pluck('codeID', codes);
+
+    var siblings = R.reduce(function (acc, code) {
+      if (R.isEmpty(code.hierarchicalCodes || [])) {
+        return acc;
+      }
+      return R.mergeRight(acc, getParentedCodes(code.hierarchicalCodes, code.id));
+    }, {}, codes);
+
+    return (0, _extends5.default)({}, siblings, (0, _defineProperty3.default)({}, parent, ids));
+  };
+
+  var getChildren = function getChildren(codes, parents) {
+    var ids = R.pluck('codeID', codes);
+
+    var children = R.reduce(function (acc, code) {
+      if (R.isEmpty(code.hierarchicalCodes || [])) {
+        return acc;
+      }
+      return (0, _extends5.default)({}, acc, getChildren(code.hierarchicalCodes, R.append(code.codeID, parents)));
+    }, {}, codes);
+    var key = R.isEmpty(parents) ? '#ROOT' : R.join('.', parents);
+    return (0, _extends5.default)({}, children, (0, _defineProperty3.default)({}, key, ids));
+  };
+
+  return R.pipe(R.propOr([], 'hierarchicalCodes'), function (codes) {
+    return getChildren(codes, []);
+  })(hierarchy);
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sis-cc/dotstatsuite-components",
   "description": "Set components based on React.",
-  "version": "14.1.1",
+  "version": "14.2.0",
   "main": "lib/index.js",
   "author": "OECD",
   "license": "MIT",

package/src/rules/src/table/preparators/prepareData.js

@@ -24,9 +24,9 @@ import {
   getObservationsAdvancedAttributes,
   getSeriesAdvancedAttributes
 } from '../../../../rules2/src/getAdvancedAttributes';
-import { getDimensionsSimpleHierarchies } from '../../../../rules2/src/getDimensionsSimpleHierarchies';
 import { duplicateObservations } from '../../../../rules2/src/duplicateObservations';
-import { hierarchiseDimension } from '../../../../rules2/src/hierarchiseDimension';
+import { hierarchiseDimensionWithAdvancedHierarchy } from '../../../../rules2/src/hierarchiseDimensionWithAdvancedHierarchy';
+import { hierarchiseDimensionWithNativeHierarchy } from '../../../../rules2/src/hierarchiseDimensionWithNativeHierarchy';
 import { getDimensionValuesIndexes } from '../../../../rules2/src/getDimensionValuesIndexes';
 
 export const prepareData = (sdmxJson, customAttributes, unitsProps={}, _options={}) => {
@@ -41,8 +41,7 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}, _options=
   const _customAttributes = R.assoc('units', unitsDefinitionCodes, customAttributes);
   const dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
 
-  const simpleHierarchies = getDimensionsSimpleHierarchies(dimensions);
-  const hierarchies = R.mergeRight(simpleHierarchies, _options.hierarchies || {});
+  const hierarchies = _options.hierarchies || {};
   const dimensionsIndexedByIds = R.indexBy(R.prop('id'), dimensions);
 
   const parsedDimensionsIds = parseDimensionsIds(dimensions);
@@ -166,9 +165,13 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}, _options=
     seriesAdvancedAttributesIds
   );
 
-  const hierarchisedDimensions = R.map(
-    dim => hierarchiseDimension(dim, R.propOr({}, dim.id, hierarchies))
-  )(manyValuesDimensions);
+  const hierarchisedDimensions = R.map(dim => {
+    if (R.isEmpty(R.propOr({}, dim.id, hierarchies))) {
+      return hierarchiseDimensionWithNativeHierarchy(dim);
+    }
+    return hierarchiseDimensionWithAdvancedHierarchy(dim, R.prop(dim.id, hierarchies));
+  })(manyValuesDimensions);
+
   const valuesIndexes = R.reduce(
     (acc, dim) => ({ ...acc, [dim.__index]: getDimensionValuesIndexes(dim.values) }),
     {},

package/src/rules2/src/getHCodelistsRefsInData.js

@@ -5,7 +5,7 @@ export const getHCodelistsRefs = annotations => R.reduce(
     if (annotation.type !== 'HIER_CONTEXT') {
       return acc;
     }
-    const reference = annotation.text || '';
+    const reference = annotation.text || annotation.title || '';
     const match = reference.match(/([\w@_.]+):([\w@_.]+):([\w@_.]+)\(([\d.]+)\).([\w@_.]+)$/);
     if (R.isNil(match)) {
       return acc;

package/src/rules2/src/hierarchiseDimensionWithAdvancedHierarchy.js

@@ -0,0 +1,44 @@
+import * as R from 'ramda';
+
+export const hierarchiseDimensionWithAdvancedHierarchy = (dimension, hierarchy) => {
+  const indexed = R.indexBy(R.prop('id'), dimension.values);
+
+  let rest = indexed;
+  const getChildren = (parents) => R.pipe(
+    ids => {
+      rest = R.omit(ids, rest);
+      return R.props(ids, indexed)
+    },
+    R.filter(R.identity),
+    R.map(
+      (val) => {
+        const _val = {
+          ...val,
+          parent: R.last(parents),
+          parents
+        };
+        const children = getChildren(R.append(val.id, parents));
+        return R.prepend(_val, children);
+      },
+    )
+  )(R.propOr([], R.isEmpty(parents) ? '#ROOT' : R.join('.', parents), hierarchy));
+
+  return R.set(
+    R.lensProp('values'),
+    R.pipe(
+      getChildren,
+      R.flatten,
+      values => {
+        if (R.isEmpty(rest)) {
+          return values;
+        }
+        const sortedRest = R.pipe(
+          R.values,
+          R.map(val => ({ ...val, parent: undefined, parents: [] })),
+          R.sortBy(R.prop('__indexPosition'))
+        )(rest);
+        return R.concat(sortedRest, values);
+      }
+    )([])
+  )(dimension);
+};

package/src/rules2/src/hierarchiseDimensionWithNativeHierarchy.js

@@ -0,0 +1,24 @@
+import * as R from 'ramda';
+
+export const hierarchiseDimensionWithNativeHierarchy = (dimension) => {
+  const values = R.sortBy(R.prop('__indexPosition'), dimension.values || []);
+  const grouped = R.groupBy(R.propOr('#ROOT', 'parent'), values);
+
+  const getChildren = (parents) => {
+    const childs = R.propOr([], R.last(parents) || '#ROOT', grouped);
+    return R.reduce(
+      (acc, child) => {
+        const refined = R.assoc('parents', parents, child);
+        const children = getChildren(R.append(child.id, parents));
+        return R.concat(acc, R.prepend(refined, children));
+      },
+      [],
+      childs
+    );
+  }
+
+  return R.set(
+    R.lensProp('values'),
+    getChildren([])
+  )(dimension);
+};

package/src/rules2/src/parseHierarchicalCodelist.js

@@ -4,11 +4,45 @@ export const parseHierarchicalCodelist = (sdmxJson, hierarchyId) => {
   const hCodelist = R.pathOr({}, ['data', 'hierarchicalCodelists', 0], sdmxJson);
   const hierarchy = R.find(R.propEq('id', hierarchyId), hCodelist.hierarchies || []);
 
+  const getParentedCodes = (codes, parent) => {
+    const ids = R.pluck('codeID', codes);
+
+    const siblings = R.reduce(
+      (acc, code) => {
+        if (R.isEmpty(code.hierarchicalCodes || [])) {
+          return acc;
+        }
+        return R.mergeRight(acc, getParentedCodes(code.hierarchicalCodes, code.id));
+      },
+      {},
+      codes
+    );
+
+    return ({ ...siblings, [parent]: ids });
+  };
+
+  const getChildren = (codes, parents) => {
+    const ids = R.pluck('codeID', codes);
+
+    const children = R.reduce(
+      (acc, code) => {
+        if (R.isEmpty(code.hierarchicalCodes || [])) {
+          return acc;
+        }
+        return ({
+          ...acc,
+          ...getChildren(code.hierarchicalCodes, R.append(code.codeID, parents))
+        });
+      },
+      {},
+      codes
+    );
+    const key = R.isEmpty(parents) ? '#ROOT' : R.join('.', parents);
+    return ({ ...children, [key]: ids });
+  }
+
   return R.pipe(
     R.propOr([], 'hierarchicalCodes'),
-    R.reduce((acc, parentCode) => {
-      const children = R.pluck('id', parentCode.hierarchicalCodes || []);
-      return R.assoc(parentCode.id, children, acc);
-    }, {}),
+    codes => getChildren(codes, []),
   )(hierarchy);
 };

package/test/getHCodelistsRefs.test.js

@@ -2,11 +2,11 @@ import { expect } from 'chai';
 import { getHCodelistsRefs } from '../src/rules2/src';
 
 describe('getHCodelistsRefs tests', () => {
-  it('basic case', () => {
+  it('complete case', () => {
     const annotations = [
       { type: 'test' },
       { type: 'HIER_CONTEXT', text: 'C1:A:HCL1(1.0).HIER1' },
-      { type: 'HIER_CONTEXT', text: 'C2:A:HCL2(1.0).HIER1' },
+      { type: 'HIER_CONTEXT', title: 'C2:A:HCL2(1.0).HIER1' },
       { type: 'HIER_CONTEXT', text: 'C1:A:HCL1(1.0).HIER2' },
     ];
 

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

@@ -1,7 +1,7 @@
 import { expect } from 'chai';
-import { hierarchiseDimension } from '../src/rules2/src/hierarchiseDimension';
+import { hierarchiseDimensionWithAdvancedHierarchy } from '../src/rules2/src/hierarchiseDimensionWithAdvancedHierarchy';
 
-describe('hierarchiseDimension tests', () => {
+describe('hierarchiseDimensionWithAdvancedHierarchy tests', () => {
   it('basic test', () => {
     const dimension = {
       id: 'test',
@@ -12,12 +12,12 @@ describe('hierarchiseDimension tests', () => {
         { id: 'USA' },
         { id: 'A' },
         { id: 'EA' },
-        { id: 'CHI' },
         { id: 'MEX' },
       ]
     };
 
     const hierarchy = {
+      '#ROOT': ['OECD', 'A', 'EA'],
       OECD: ['GER', 'FRA', 'USA'],
       A: ['USA', 'MEX'],
       EA: ['FRA', 'GER']
@@ -36,20 +36,20 @@ describe('hierarchiseDimension tests', () => {
         { id: 'EA', parent: undefined, parents: [] },
         { id: 'FRA', parent: 'EA', parents: ['EA'] },
         { id: 'GER', parent: 'EA', parents: ['EA'] },
-        { id: 'CHI', parent: undefined, parents: [] },
       ]
     }
 
-    expect(hierarchiseDimension(dimension, hierarchy)).to.deep.equal(hierarchised);
+    expect(hierarchiseDimensionWithAdvancedHierarchy(dimension, hierarchy)).to.deep.equal(hierarchised);
   });
   it('missing ids defined in the hierarchy', () => {
     const hierarchy = {
+      '#ROOT': ['W'],
       W: ['EA', 'A'],
-      A: ['NA', 'SA'],
-      NA: ['USA', 'CAN'],
-      SA: ['BRA'],
-      EA: ['FRA', 'GER'],
-      FRA: ['IDF', 'BRE', 'ALS']
+      '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 = {
@@ -82,6 +82,6 @@ describe('hierarchiseDimension tests', () => {
       ]
     };
 
-    expect(hierarchiseDimension(dimension, hierarchy)).to.deep.equal(hierarchised);
+    expect(hierarchiseDimensionWithAdvancedHierarchy(dimension, hierarchy)).to.deep.equal(hierarchised);
   });
 });

package/test/hierarchiseDimensionWithNativeHierarchy.test.js

@@ -0,0 +1,32 @@
+import { expect } from 'chai';
+import { hierarchiseDimensionWithNativeHierarchy } from '../src/rules2/src/hierarchiseDimensionWithNativeHierarchy';
+
+describe('hierarchiseDimensionWithNativeHierarchy tests', () => {
+  it('basic test', () => {
+    const dimension = {
+      id: 'test',
+      values: [
+        { id: 'FRA', parent: 'EA', __indexPosition: 101 },
+        { id: 'GER', parent: 'EA', __indexPosition: 100 },
+        { id: 'EA', parent: 'W', __indexPosition: 30 },
+        { id: 'A', parent: 'W', __indexPosition: 20 },
+        { id: 'W', parent: undefined, __indexPosition: 5 },
+        { id: 'CHI', parent: undefined, __indexPosition: 0 }
+      ]
+    };
+    
+    const expected = {
+      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 }
+      ]
+    };
+
+    expect(hierarchiseDimensionWithNativeHierarchy(dimension)).to.deep.equal(expected);
+  });
+});

package/test/parseHierarchicalCodelist.test.js

@@ -5,6 +5,7 @@ import hierarchicalCodelist from './mocks/h-codelist.json';
 describe('parseHierarchicalCodelist tests', () => {
   it('simple case', () => {
     const expected = {
+      '#ROOT': ['W', 'A', 'A2', 'OECD', 'EA00'],
       W: ['A', 'E', 'F', 'O', 'S', 'W_X'],
       A: ['A2', 'A3', 'A4', 'A5', 'A7', 'A8', 'A8_M', 'A9', 'A_X', 'A_O'],
       A2: ['BMU', 'CAN', 'GRL', 'SPM', 'USA'],
@@ -73,4 +74,67 @@ describe('parseHierarchicalCodelist tests', () => {
 
     expect(parseHierarchicalCodelist(hierarchicalCodelist, 'CONT_EN')).to.deep.equal(expected);
   });
+  it('deep hierarchies case', () => {
+    const hCodelist = {
+      data: {
+        hierarchicalCodelists: [{
+          hierarchies: [{
+            id: 'HIER',
+            hierarchicalCodes: [
+              {
+                codeID: 'OECD',
+                hierarchicalCodes: [
+                  {
+                    codeID: 'GER',
+                    hierarchicalCodes: [
+                      { codeID: 'BAV' }
+                    ]
+                  },
+                  {
+                    codeID: 'FRA',
+                    hierarchicalCodes: [
+                      { codeID: 'BZH' },
+                      { codeID: 'IDF' }
+                    ]
+                  }
+                ]
+              },
+              {
+                codeID: 'EA',
+                hierarchicalCodes: [
+                  {
+                    codeID: 'FRA',
+                    hierarchicalCodes: [
+                      { codeID: 'IDF' },
+                      { codeID: 'ALS' },
+                      { codeID: 'BZH' },
+                    ]
+                  },
+                  {
+                    codeID: 'GER',
+                    hierarchicalCodes: [
+                      { codeID: 'BAV' },
+                      { codeID: 'RHN' }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }]
+        }]
+      }
+    };
+
+    const expected = {
+      '#ROOT': ['OECD', 'EA'],
+      'OECD': ['GER', 'FRA'],
+      'OECD.GER': ['BAV'],
+      'OECD.FRA': ['BZH', 'IDF'],
+      'EA': ['FRA', 'GER'],
+      'EA.FRA': ['IDF', 'ALS', 'BZH'],
+      'EA.GER': ['BAV', 'RHN']
+    };
+
+    expect(parseHierarchicalCodelist(hCodelist, 'HIER')).to.deep.equal(expected);
+  });
 });

package/lib/rules2/src/getDimensionsSimpleHierarchies.js

@@ -1,42 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getDimensionsSimpleHierarchies = undefined;
-
-var _ramda = require('ramda');
-
-var R = _interopRequireWildcard(_ramda);
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-var getDimensionSimpleHierarchy = function getDimensionSimpleHierarchy(_ref) {
-  var values = _ref.values;
-
-  var indexed = R.indexBy(R.prop('id'), values);
-  return R.pipe(R.reduce(function (acc, value) {
-    var id = value.id,
-        parent = value.parent;
-
-    var _parent = R.isNil(parent) || !R.has(parent, indexed) ? '#ROOT' : parent;
-    return R.over(R.lensProp(_parent), function (ids) {
-      return R.isNil(ids) ? [id] : R.append(id, ids);
-    })(acc);
-  }, {}), R.map(R.sortBy(function (id) {
-    return R.pathOr(-1, [id, '__indexPosition'], indexed);
-  })))(values);
-};
-
-var getDimensionsSimpleHierarchies = exports.getDimensionsSimpleHierarchies = function getDimensionsSimpleHierarchies(dimensions) {
-  return R.reduce(function (acc, dim) {
-    var id = dim.id,
-        values = dim.values;
-
-    if (R.length(values) < 2) {
-      return acc;
-    }
-    var hierarchy = getDimensionSimpleHierarchy(dim);
-    return R.assoc(id, hierarchy, acc);
-  }, {}, dimensions);
-};

package/src/rules2/src/getDimensionsSimpleHierarchies.js

@@ -1,34 +0,0 @@
-import * as R from 'ramda';
-
-const getDimensionSimpleHierarchy = ({ values }) => {
-  const indexed = R.indexBy(R.prop('id'), values);
-  return R.pipe(
-    R.reduce(
-      (acc, value) => {
-        const { id, parent } = value;
-        const _parent = R.isNil(parent) || !R.has(parent, indexed)
-          ? '#ROOT'
-          : parent;
-        return R.over(
-          R.lensProp(_parent),
-          ids => R.isNil(ids) ? [id] : R.append(id, ids)
-        )(acc);
-      },
-      {}
-    ),
-    R.map(R.sortBy(id => R.pathOr(-1, [id, '__indexPosition'], indexed)))
-  )(values);
-};
-
-export const getDimensionsSimpleHierarchies = (dimensions) => R.reduce(
-  (acc, dim) => {
-    const { id, values } = dim;
-    if (R.length(values) < 2) {
-      return acc;
-    }
-    const hierarchy = getDimensionSimpleHierarchy(dim);
-    return R.assoc(id, hierarchy, acc);
-  },
-  {},
-  dimensions
-);

package/src/rules2/src/hierarchiseDimension.js

@@ -1,38 +0,0 @@
-import * as R from 'ramda';
-
-export const hierarchiseDimension = (dimension, hierarchy) => {
-  const indexed = R.indexBy(R.prop('id'), dimension.values);
-  let _hierarchy = hierarchy;
-  if (!R.has('#ROOT', hierarchy)) {
-    const indexes = R.pluck('id', dimension.values);
-    const refinedHierarchy = R.pick(indexes, _hierarchy);
-    const childrenIds = R.pipe(R.values, R.unnest, R.indexBy(R.identity))(refinedHierarchy);
-    const rootIds = R.pipe(
-      R.reject(val => R.has(val.id, childrenIds)),
-      R.sortBy(R.prop('__indexPosition')),
-      R.pluck('id')
-    )(dimension.values);
-    _hierarchy = R.assoc('#ROOT', rootIds, hierarchy);
-  }
-
-  const getChildren = (parents) => R.pipe(
-    ids => R.props(ids, indexed),
-    R.filter(R.identity),
-    R.map(
-      (val) => {
-        const _val = {
-          ...val,
-          parent: R.last(parents),
-          parents
-        };
-        const children = getChildren(R.append(val.id, parents));
-        return R.prepend(_val, children);
-      },
-    )
-  )(R.propOr([], R.last(parents) || '#ROOT', _hierarchy));
-
-  return R.set(
-    R.lensProp('values'),
-    R.flatten(getChildren([]))
-  )(dimension);
-};