@sis-cc/dotstatsuite-components 18.0.0 → 18.1.0

package/lib/rules2/src/applyHierarchicalCodesToDim.js

@@ -0,0 +1,128 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyHierarchicalCodesToDim = undefined;
+
+var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');
+
+var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
+
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
+var _set = require('babel-runtime/core-js/set');
+
+var _set2 = _interopRequireDefault(_set);
+
+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 addParentId = function addParentId(id, ids) {
+  var last = R.last(ids);
+  return R.append(R.isNil(last) ? id : last + '.' + id, ids);
+};
+
+var applyHierarchicalCodesToDim = function applyHierarchicalCodesToDim(hCodes, dim) {
+  var confirmedHierarchisedChilds = new _set2.default([]);
+
+  var indexedValues = R.reduce(function (acc, val) {
+    if (!val.isSelected) {
+      return acc;
+    }
+    return R.assoc(val.id, val, acc);
+  }, {}, dim.values || []);
+
+  var parseHCodes = function parseHCodes(parentsDef, parentsInDim) {
+    return R.reduce(function (acc, hC) {
+      var codeID = hC.codeID,
+          _hC$hierarchicalCodes = hC.hierarchicalCodes,
+          hierarchicalCodes = _hC$hierarchicalCodes === undefined ? [] : _hC$hierarchicalCodes;
+
+      var hasInDim = R.has(codeID, indexedValues);
+      var isUnconfirmed = R.length(parentsInDim) !== R.length(parentsDef);
+      var children = parseHCodes(R.append(codeID, parentsDef), hasInDim ? addParentId(codeID, parentsInDim) : parentsInDim)(hierarchicalCodes);
+      if (!hasInDim) {
+        return R.concat(acc, children);
+      }
+      var val = (0, _extends3.default)({}, R.prop(codeID, indexedValues), {
+        parents: parentsInDim,
+        parent: R.last(parentsInDim),
+        children: children
+      });
+
+      if (isUnconfirmed) {
+        val = R.assoc('unconfirmed', true, val);
+        return R.append(val, acc);
+      }
+      confirmedHierarchisedChilds.add(codeID);
+      return R.append(val, acc);
+    }, []);
+  };
+
+  var parsed = parseHCodes([], [])(hCodes);
+
+  var flattenDescendants = R.reduce(function (acc, val) {
+    var children = flattenDescendants(val.children || []);
+    return R.concat(acc, R.prepend(val, children));
+  }, []);
+
+  var isValid = function isValid(val) {
+    return !val.unconfirmed || !confirmedHierarchisedChilds.has(val.id);
+  };
+
+  var refineCodes = R.reduce(function (acc, hC) {
+    var children = hC.children,
+        _hC$unconfirmed = hC.unconfirmed,
+        unconfirmed = _hC$unconfirmed === undefined ? false : _hC$unconfirmed,
+        val = (0, _objectWithoutProperties3.default)(hC, ['children', 'unconfirmed']);
+
+    if (isValid(hC)) {
+      var _children = refineCodes(children || []);
+      confirmedHierarchisedChilds.add(val.id);
+      return R.concat(acc, R.prepend(val, _children));
+    }
+    var flatDescendants = flattenDescendants(children);
+    var validDescendant = R.find(isValid, flatDescendants);
+    if (!validDescendant) {
+      return acc;
+    }
+    var refined = R.pipe(R.prepend(hC), R.map(function (v) {
+      confirmedHierarchisedChilds.add(v.id);
+      return R.omit(['unconfirmed', 'children'], v);
+    }))(flatDescendants);
+    return R.concat(acc, refined);
+  }, []);
+
+  var refined = refineCodes(parsed);
+
+  var missingValues = R.pipe(R.keys, R.filter(function (id) {
+    return !confirmedHierarchisedChilds.has(id);
+  }), function (ids) {
+    return R.props(ids, indexedValues);
+  }, R.map(function (v) {
+    return (0, _extends3.default)({}, v, { parents: [], parent: undefined });
+  }), R.sortBy(R.propOr(-1, '__indexPosition')))(indexedValues);
+
+  var hierarchicalIndexes = {};
+
+  return R.pipe(R.concat, R.addIndex(R.map)(function (v, ind) {
+    var parents = R.props(v.parents, hierarchicalIndexes);
+    var hierId = R.last(v.parents) ? R.last(v.parents) + '.' + v.id : v.id;
+    hierarchicalIndexes[hierId] = ind;
+    return (0, _extends3.default)({}, v, {
+      parents: parents,
+      __indexPosition: ind
+    });
+  }), function (values) {
+    return (0, _extends3.default)({}, dim, { values: values });
+  })(missingValues, refined);
+};
+exports.applyHierarchicalCodesToDim = applyHierarchicalCodesToDim;

package/lib/rules2/src/hierarchiseDimensionWithAdvancedHierarchy2.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.hierarchiseDimensionWithAdvancedHierarchy = exports.refinePartialHierarchy = undefined;
+exports.refinePartialHierarchy = undefined;
 
 var _extends2 = require('babel-runtime/helpers/extends');
 
@@ -62,39 +62,4 @@ var refinePartialHierarchy = exports.refinePartialHierarchy = function refinePar
   return (0, _extends3.default)({}, refinedBroken, intact, {
     '#ROOT': R.concat(refinedBroken['#ROOT'], intact['#ROOT'])
   });
-};
-
-var hierarchiseDimensionWithAdvancedHierarchy = exports.hierarchiseDimensionWithAdvancedHierarchy = function hierarchiseDimensionWithAdvancedHierarchy(dimension, _hierarchy) {
-  var indexed = R.indexBy(R.prop('id'), dimension.values);
-  var hierarchy = refinePartialHierarchy(_hierarchy, indexed);
-
-  var rest = R.pipe(R.values, R.unnest, R.flip(R.omit)(indexed), R.values)(hierarchy);
-  var index = R.length(rest) - 1;
-  var getChildren = function getChildren(_ref3) {
-    var parentsIndexes = _ref3.parentsIndexes,
-        parentId = _ref3.parentId;
-
-    var childrenIds = R.propOr([], parentId, hierarchy);
-    var children = R.reduce(function (acc, childId) {
-      if (!R.has(childId, indexed)) {
-        return acc;
-      }
-      index = index + 1;
-      var child = (0, _extends3.default)({}, R.prop(childId, indexed), { __indexPosition: index, parents: parentsIndexes, parent: R.isEmpty(parentsIndexes) ? undefined : R.pipe(R.split('.'), R.last)(parentId) });
-      var descendants = getChildren({ parentsIndexes: R.append(index, parentsIndexes), parentId: R.isEmpty(parentsIndexes) ? child.id : parentId + '.' + child.id });
-      return R.append(R.prepend(child, descendants), acc);
-    }, [], childrenIds);
-
-    return children;
-  };
-
-  return R.set(R.lensProp('values'), R.pipe(getChildren, R.flatten, function (values) {
-    if (R.isEmpty(rest)) {
-      return values;
-    }
-    var sortedRest = R.pipe(R.sortBy(R.prop('__indexPosition')), R.addIndex(R.map)(function (val, ind) {
-      return (0, _extends3.default)({}, val, { __indexPosition: ind, parent: undefined, parents: [] });
-    }))(rest);
-    return R.concat(sortedRest, values);
-  })({ parentsIndexes: [], parentId: '#ROOT' }))(dimension);
 };

package/lib/rules2/src/index.js

@@ -114,12 +114,6 @@ Object.defineProperty(exports, 'refinePartialHierarchy', {
     return _hierarchiseDimensionWithAdvancedHierarchy.refinePartialHierarchy;
   }
 });
-Object.defineProperty(exports, 'hierarchiseDimensionWithAdvancedHierarchy', {
-  enumerable: true,
-  get: function get() {
-    return _hierarchiseDimensionWithAdvancedHierarchy.hierarchiseDimensionWithAdvancedHierarchy;
-  }
-});
 
 var _hierarchiseDimensionWithNativeHierarchy = require('./hierarchiseDimensionWithNativeHierarchy2');
 
@@ -437,4 +431,13 @@ Object.defineProperty(exports, 'declineObservationsOverAttributes', {
   get: function get() {
     return _declineObservationsOverAttributes.declineObservationsOverAttributes;
   }
+});
+
+var _applyHierarchicalCodesToDim = require('./applyHierarchicalCodesToDim');
+
+Object.defineProperty(exports, 'applyHierarchicalCodesToDim', {
+  enumerable: true,
+  get: function get() {
+    return _applyHierarchicalCodesToDim.applyHierarchicalCodesToDim;
+  }
 });

package/lib/rules2/src/prepareData.js

@@ -35,8 +35,6 @@ var _getOneValueDimensions = require('./getOneValueDimensions');
 
 var _hierarchiseDimensionWithNativeHierarchy = require('./hierarchiseDimensionWithNativeHierarchy2');
 
-var _hierarchiseDimensionWithAdvancedHierarchy = require('./hierarchiseDimensionWithAdvancedHierarchy2');
-
 var _getDataflowAttributes = require('./getDataflowAttributes');
 
 var _getHeaderTitle = require('./getHeaderTitle');
@@ -47,6 +45,8 @@ var _getHeaderCombinations = require('./getHeaderCombinations');
 
 var _getHeaderCoordinates = require('./getHeaderCoordinates');
 
+var _applyHierarchicalCodesToDim = require('./applyHierarchicalCodesToDim');
+
 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 prepareData = exports.prepareData = function prepareData(sdmxJson, _ref) {
@@ -86,7 +86,7 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, _ref) {
     if (R.isEmpty(R.propOr({}, dim.id, hierarchies))) {
       return (0, _hierarchiseDimensionWithNativeHierarchy.hierarchiseDimensionWithNativeHierarchy)(dim);
     }
-    return (0, _hierarchiseDimensionWithAdvancedHierarchy.hierarchiseDimensionWithAdvancedHierarchy)(dim, R.prop(dim.id, hierarchies));
+    return (0, _applyHierarchicalCodesToDim.applyHierarchicalCodesToDim)(R.prop(dim.id, hierarchies), dim);
   }, manyValuesDimensions);
   var duplicatedObservations = (0, _duplicateObservations.duplicateObs)(R.values(hierarchisedDimensions), enhancedObservations);
 

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

@@ -61,7 +61,7 @@ var parseSerieIndexesHierarchies = function parseSerieIndexesHierarchies(serieIn
         return R.over(R.lensProp('presentParentsIndexes'), function (p) {
           return 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'), function (m) {
           return R.isNil(m) ? [i] : R.append(i, m);

package/package.json

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

package/src/rules2/src/applyHierarchicalCodesToDim.js

@@ -0,0 +1,101 @@
+import * as R from 'ramda';
+
+const addParentId = (id, ids) => {
+  const last = R.last(ids);
+  return R.append(R.isNil(last) ? id : `${last}.${id}`, ids); 
+}
+
+export const applyHierarchicalCodesToDim = (hCodes, dim) => {
+  let confirmedHierarchisedChilds = new Set([]);
+
+  const indexedValues = R.reduce((acc, val) => {
+    if (!val.isSelected) {
+      return acc;
+    }
+    return R.assoc(val.id, val, acc);
+  }, {}, dim.values || []);
+
+  const parseHCodes = (parentsDef, parentsInDim) => R.reduce((acc, hC) => {
+    const { codeID, hierarchicalCodes = [] } = hC;
+    const hasInDim = R.has(codeID, indexedValues);
+    const isUnconfirmed = R.length(parentsInDim) !== R.length(parentsDef);
+    const children = parseHCodes(
+      R.append(codeID, parentsDef),
+      hasInDim ? addParentId(codeID, parentsInDim) : parentsInDim
+    )(hierarchicalCodes);
+    if (!hasInDim) {
+      return R.concat(acc, children);
+    }
+    let val = {
+      ...R.prop(codeID, indexedValues),
+      parents: parentsInDim,
+      parent: R.last(parentsInDim),
+      children
+    };
+
+    if (isUnconfirmed) {
+      val = R.assoc('unconfirmed', true, val);
+      return R.append(val, acc);
+    }
+    confirmedHierarchisedChilds.add(codeID);
+    return R.append(val, acc);
+  }, []);
+
+  const parsed = parseHCodes([], [])(hCodes);
+
+  const flattenDescendants = R.reduce((acc, val ) => {
+    const children = flattenDescendants(val.children || []);
+    return R.concat(acc, R.prepend(val, children));
+  }, []);
+
+  const isValid = val => !val.unconfirmed || !confirmedHierarchisedChilds.has(val.id);
+
+  const refineCodes = R.reduce((acc, hC) => {
+    const { children, unconfirmed = false, ...val } = hC;
+    if (isValid(hC)) {
+      const _children = refineCodes(children || []);
+      confirmedHierarchisedChilds.add(val.id);
+      return R.concat(acc, R.prepend(val, _children));
+    }
+    const flatDescendants = flattenDescendants(children);
+    const validDescendant = R.find(isValid, flatDescendants);
+    if (!validDescendant) {
+      return acc;
+    }
+    const refined = R.pipe(
+      R.prepend(hC),
+      R.map(v => {
+        confirmedHierarchisedChilds.add(v.id);
+        return R.omit(['unconfirmed', 'children'], v);
+      })
+    )(flatDescendants);
+    return R.concat(acc, refined);
+  }, []);
+
+  const refined = refineCodes(parsed);
+
+  const missingValues = R.pipe(
+    R.keys,
+    R.filter(id => !confirmedHierarchisedChilds.has(id)),
+    ids => R.props(ids, indexedValues),
+    R.map(v => ({ ...v, parents: [], parent: undefined })),
+    R.sortBy(R.propOr(-1, '__indexPosition')),
+  )(indexedValues);
+
+  let hierarchicalIndexes = {};
+
+  return R.pipe(
+    R.concat,
+    R.addIndex(R.map)((v, ind) => {
+      const parents = R.props(v.parents, hierarchicalIndexes);
+      const hierId = R.last(v.parents) ? `${R.last(v.parents)}.${v.id}` : v.id;
+      hierarchicalIndexes[hierId] = ind;
+      return {
+        ...v,
+        parents,
+        __indexPosition: ind
+      };
+    }),
+    values => ({ ...dim, values })
+  )(missingValues, refined);
+};

package/src/rules2/src/hierarchiseDimensionWithAdvancedHierarchy2.js

@@ -55,48 +55,3 @@ export const refinePartialHierarchy = (hier, indexed) => {
     '#ROOT': R.concat(refinedBroken['#ROOT'], intact['#ROOT'])
   })
 };
-
-export const hierarchiseDimensionWithAdvancedHierarchy = (dimension, _hierarchy) => {
-  const indexed = R.indexBy(R.prop('id'), dimension.values);
-  const hierarchy = refinePartialHierarchy(_hierarchy, indexed);
-
-  const rest = R.pipe(
-    R.values,
-    R.unnest,
-    R.flip(R.omit)(indexed),
-    R.values,
-  )(hierarchy);
-  let index = R.length(rest) - 1;
-  const getChildren = ({ parentsIndexes, parentId }) => {
-    const childrenIds = R.propOr([], parentId, hierarchy);
-    const children = R.reduce((acc, childId) => {
-      if (!R.has(childId, indexed)) {
-        return acc;
-      }
-      index = index + 1;
-      const child = { ...R.prop(childId, indexed), __indexPosition: index, parents: parentsIndexes, parent: R.isEmpty(parentsIndexes) ? undefined : R.pipe(R.split('.'), R.last)(parentId) };
-      const descendants = getChildren({ parentsIndexes: R.append(index, parentsIndexes), parentId: R.isEmpty(parentsIndexes) ? child.id : `${parentId}.${child.id}` });
-      return R.append(R.prepend(child, descendants), acc);
-    }, [], childrenIds);
-
-    return children;
-  }
-
-  return R.set(
-    R.lensProp('values'),
-    R.pipe(
-      getChildren,
-      R.flatten,
-      values => {
-        if (R.isEmpty(rest)) {
-          return values;
-        }
-        const sortedRest = R.pipe(
-          R.sortBy(R.prop('__indexPosition')),
-          R.addIndex(R.map)((val, ind) => ({ ...val, __indexPosition: ind, parent: undefined, parents: [] })),
-        )(rest);
-        return R.concat(sortedRest, values);
-      }
-    )({ parentsIndexes: [], parentId: '#ROOT' })
-  )(dimension);
-};

package/src/rules2/src/index.js

@@ -12,7 +12,7 @@ export { getHCodelistsRefs, getHCodelistsRefsInData } from './getHCodelistsRefsI
 export { parseHierarchicalCodelist } from './parseHierarchicalCodelist';
 export { getMetadataCoordinates } from './getMetadataCoordinates';
 export { duplicateObs } from './duplicateObservations';
-export { refinePartialHierarchy, hierarchiseDimensionWithAdvancedHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy2';
+export { refinePartialHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy2';
 export { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy2';
 export { getDimensionValuesIndexes } from './getDimensionValuesIndexes';
 export { getCombinationDefinitions, parseCombinationDefinition } from './getCombinationDefinitions';
@@ -47,3 +47,4 @@ export { parseValueHierarchy } from './table/parseValueHierarchy';
 export { parseLayoutIndexesHierarchies } from './table/parseSeriesIndexesHierarchies';
 export { getTableLayoutIds, injectCombinationsInLayout } from './table/getTableLayoutIds';
 export { declineObservationsOverAttributes } from './table/declineObservationsOverAttributes';
+export { applyHierarchicalCodesToDim } from './applyHierarchicalCodesToDim';

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/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/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/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);
-  });
-});