@sis-cc/dotstatsuite-components 14.3.0 → 14.3.3

package/lib/rules2/src/getHCodelistsRefsInData.js

@@ -22,21 +22,24 @@ var getHCodelistsRefs = exports.getHCodelistsRefs = function getHCodelistsRefs(a
     if (annotation.type !== 'HIER_CONTEXT') {
       return acc;
     }
-    var reference = annotation.text || annotation.title || '';
-    var match = reference.match(/([\w@_.]+):([\w@_.]+):([\w@_.]+)\(([\d.]+)\).([\w@_.]+)$/);
-    if (R.isNil(match)) {
-      return acc;
-    }
-
-    var _R$tail = R.tail(match),
-        _R$tail2 = (0, _slicedToArray3.default)(_R$tail, 5),
-        codelistId = _R$tail2[0],
-        agencyId = _R$tail2[1],
-        code = _R$tail2[2],
-        version = _R$tail2[3],
-        hierarchy = _R$tail2[4];
-
-    return R.assoc(codelistId, { agencyId: agencyId, code: code, version: version, hierarchy: hierarchy, codelistId: codelistId }, acc);
+    var references = annotation.text || annotation.title || '';
+    var refs = R.pipe(R.split(','), R.reduce(function (acc2, ref) {
+      var match = ref.match(/([\w@_.]+):([\w@_.]+):([\w@_.]+)\(([\d.]+)\).([\w@_.]+)$/);
+      if (R.isNil(match)) {
+        return acc2;
+      }
+
+      var _R$tail = R.tail(match),
+          _R$tail2 = (0, _slicedToArray3.default)(_R$tail, 5),
+          codelistId = _R$tail2[0],
+          agencyId = _R$tail2[1],
+          code = _R$tail2[2],
+          version = _R$tail2[3],
+          hierarchy = _R$tail2[4];
+
+      return R.assoc(codelistId, { agencyId: agencyId, code: code, version: version, hierarchy: hierarchy, codelistId: codelistId }, acc2);
+    }, {}))(references);
+    return R.mergeRight(acc, refs);
   }, {}, annotations);
 };
 

package/lib/rules2/src/hierarchiseDimensionWithAdvancedHierarchy.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.hierarchiseDimensionWithAdvancedHierarchy = undefined;
+exports.hierarchiseDimensionWithAdvancedHierarchy = exports.refinePartialHierarchy = undefined;
 
 var _extends2 = require('babel-runtime/helpers/extends');
 
@@ -17,11 +17,59 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var hierarchiseDimensionWithAdvancedHierarchy = exports.hierarchiseDimensionWithAdvancedHierarchy = function hierarchiseDimensionWithAdvancedHierarchy(dimension, hierarchy) {
+var uniq = R.pipe(R.reduce(function (_ref, id) {
+  var ids = _ref.ids,
+      list = _ref.list;
+
+  if (R.has(id, list)) {
+    return { ids: ids, list: list };
+  }
+  return { ids: R.append(id, ids), list: R.assoc(id, id, list) };
+}, { ids: [], list: {} }), R.prop('ids'));
+
+var refinePartialHierarchy = exports.refinePartialHierarchy = function refinePartialHierarchy(hier, indexed) {
+  var _R$pipe = R.pipe(R.keys, R.reduce(function (_ref2, key) {
+    var intact = _ref2.intact,
+        broken = _ref2.broken;
+
+    var ids = R.filter(function (id) {
+      return R.has(id, indexed);
+    }, hier[key]);
+    if (key === '#ROOT') {
+      return { broken: broken, intact: R.assoc(key, ids, intact) };
+    }
+    var splitKey = R.split('.', key);
+    var filtered = R.takeLastWhile(function (id) {
+      return R.has(id, indexed);
+    }, splitKey);
+    if (R.length(filtered) === R.length(splitKey)) {
+      return { broken: broken, intact: R.assoc(key, ids, intact) };
+    }
+    var refinedKey = R.isEmpty(filtered) ? '#ROOT' : R.join('.', filtered);
+    return {
+      intact: intact,
+      broken: R.over(R.lensProp(refinedKey), R.ifElse(R.isNil, R.always([ids]), R.append(ids)))(broken)
+    };
+  }, { intact: {}, broken: {} }))(hier),
+      intact = _R$pipe.intact,
+      broken = _R$pipe.broken;
+
+  var intactIds = R.pipe(R.values, R.unnest)(intact);
+  var refinedBroken = R.pipe(R.omit(intactIds), R.over(R.lensProp('#ROOT'), R.pipe(function (i) {
+    return R.isNil(i) ? [] : i;
+  }, R.unnest, R.reject(R.flip(R.includes)(intactIds)))), R.map(R.pipe(R.unnest, uniq)))(broken);
+
+  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 = indexed;
-  var getChildren = function getChildren(parents) {
+  var getChildren = function getChildren(parents, hier) {
     return R.pipe(function (ids) {
       rest = R.omit(ids, rest);
       return R.props(ids, indexed);
@@ -30,9 +78,9 @@ var hierarchiseDimensionWithAdvancedHierarchy = exports.hierarchiseDimensionWith
         parent: R.last(parents),
         parents: parents
       });
-      var children = getChildren(R.append(val.id, parents));
+      var children = getChildren(R.append(val.id, parents), hier);
       return R.prepend(_val, children);
-    }))(R.propOr([], R.isEmpty(parents) ? '#ROOT' : R.join('.', parents), hierarchy));
+    }))(R.propOr([], R.isEmpty(parents) ? '#ROOT' : R.join('.', parents), hier));
   };
 
   return R.set(R.lensProp('values'), R.pipe(getChildren, R.flatten, function (values) {
@@ -43,5 +91,5 @@ var hierarchiseDimensionWithAdvancedHierarchy = exports.hierarchiseDimensionWith
       return (0, _extends3.default)({}, val, { parent: undefined, parents: [] });
     }), R.sortBy(R.prop('__indexPosition')))(rest);
     return R.concat(sortedRest, values);
-  })([]))(dimension);
+  })([], hierarchy))(dimension);
 };

package/lib/rules2/src/index.js

@@ -95,4 +95,13 @@ Object.defineProperty(exports, 'parseHierarchicalCodelist', {
   get: function get() {
     return _parseHierarchicalCodelist.parseHierarchicalCodelist;
   }
+});
+
+var _hierarchiseDimensionWithAdvancedHierarchy = require('./hierarchiseDimensionWithAdvancedHierarchy');
+
+Object.defineProperty(exports, 'refinePartialHierarchy', {
+  enumerable: true,
+  get: function get() {
+    return _hierarchiseDimensionWithAdvancedHierarchy.refinePartialHierarchy;
+  }
 });

package/package.json

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

package/src/rules2/src/getHCodelistsRefsInData.js

@@ -5,13 +5,22 @@ export const getHCodelistsRefs = annotations => R.reduce(
     if (annotation.type !== 'HIER_CONTEXT') {
       return acc;
     }
-    const reference = annotation.text || annotation.title || '';
-    const match = reference.match(/([\w@_.]+):([\w@_.]+):([\w@_.]+)\(([\d.]+)\).([\w@_.]+)$/);
-    if (R.isNil(match)) {
-      return acc;
-    }
-    const [codelistId, agencyId, code, version, hierarchy] = R.tail(match);
-    return R.assoc(codelistId, { agencyId, code, version, hierarchy, codelistId }, acc);
+    const references = annotation.text || annotation.title || '';
+    const refs = R.pipe(
+      R.split(','),
+      R.reduce(
+        (acc2, ref) => {
+          const match = ref.match(/([\w@_.]+):([\w@_.]+):([\w@_.]+)\(([\d.]+)\).([\w@_.]+)$/);
+          if (R.isNil(match)) {
+            return acc2;
+          }
+          const [codelistId, agencyId, code, version, hierarchy] = R.tail(match);
+          return R.assoc(codelistId, { agencyId, code, version, hierarchy, codelistId }, acc2);
+        },
+        {}
+      )
+    )(references);
+    return R.mergeRight(acc, refs);
   },
   {},
   annotations,

package/src/rules2/src/hierarchiseDimensionWithAdvancedHierarchy.js

@@ -1,10 +1,67 @@
 import * as R from 'ramda';
 
-export const hierarchiseDimensionWithAdvancedHierarchy = (dimension, hierarchy) => {
+const uniq = R.pipe(
+  R.reduce(
+    ({ ids, list }, id) => {
+      if (R.has(id, list)) {
+        return ({ ids, list });
+      }
+      return ({ ids: R.append(id, ids), list: R.assoc(id, id, list) });
+    },
+    { ids: [], list: {} }
+  ),
+  R.prop('ids')
+);
+
+export const refinePartialHierarchy = (hier, indexed) => {
+  const { intact, broken } = R.pipe(
+    R.keys,
+    R.reduce(
+      ({ intact, broken }, key) => {
+        const ids = R.filter(id => R.has(id, indexed), hier[key]);
+        if (key === '#ROOT') {
+          return ({ broken, intact: R.assoc(key, ids, intact) });
+        }
+        const splitKey = R.split('.', key);
+        const filtered = R.takeLastWhile(id => R.has(id, indexed), splitKey);
+        if (R.length(filtered) === R.length(splitKey)) {
+          return ({ broken, intact: R.assoc(key, ids, intact) });
+        }
+        const refinedKey = R.isEmpty(filtered) ? '#ROOT' : R.join('.', filtered);
+        return ({
+          intact,
+          broken: R.over(R.lensProp(refinedKey), R.ifElse(R.isNil, R.always([ids]), R.append(ids)))(broken)
+        });
+      },
+      { intact: {}, broken: {} }
+    )
+  )(hier);
+  const intactIds = R.pipe(R.values, R.unnest)(intact);
+  const refinedBroken = R.pipe(
+    R.omit(intactIds),
+    R.over(
+      R.lensProp('#ROOT'),
+      R.pipe(
+        i => R.isNil(i) ? [] : i,
+        R.unnest,
+        R.reject(R.flip(R.includes)(intactIds)))
+      ),
+    R.map(R.pipe(R.unnest, uniq))
+  )(broken);
+
+  return ({
+    ...refinedBroken,
+    ...intact,
+    '#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);
 
   let rest = indexed;
-  const getChildren = (parents) => R.pipe(
+  const getChildren = (parents, hier) => R.pipe(
     ids => {
       rest = R.omit(ids, rest);
       return R.props(ids, indexed)
@@ -17,11 +74,11 @@ export const hierarchiseDimensionWithAdvancedHierarchy = (dimension, hierarchy)
           parent: R.last(parents),
           parents
         };
-        const children = getChildren(R.append(val.id, parents));
+        const children = getChildren(R.append(val.id, parents), hier);
         return R.prepend(_val, children);
       },
     )
-  )(R.propOr([], R.isEmpty(parents) ? '#ROOT' : R.join('.', parents), hierarchy));
+  )(R.propOr([], R.isEmpty(parents) ? '#ROOT' : R.join('.', parents), hier));
 
   return R.set(
     R.lensProp('values'),
@@ -39,6 +96,6 @@ export const hierarchiseDimensionWithAdvancedHierarchy = (dimension, hierarchy)
         )(rest);
         return R.concat(sortedRest, values);
       }
-    )([])
+    )([], hierarchy)
   )(dimension);
 };

package/src/rules2/src/index.js

@@ -11,3 +11,4 @@ export { getMSDInformations } from './getMSDInformations';
 export { getNotDisplayedIds } from './getNotDisplayedIds';
 export { getHCodelistsRefs, getHCodelistsRefsInData } from './getHCodelistsRefsInData';
 export { parseHierarchicalCodelist } from './parseHierarchicalCodelist';
+export { refinePartialHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy';

package/test/getHCodelistsRefs.test.js

@@ -8,11 +8,14 @@ describe('getHCodelistsRefs tests', () => {
       { type: 'HIER_CONTEXT', text: 'C1:A:HCL1(1.0).HIER1' },
       { type: 'HIER_CONTEXT', title: 'C2:A:HCL2(1.0).HIER1' },
       { type: 'HIER_CONTEXT', text: 'C1:A:HCL1(1.0).HIER2' },
+      { type: 'HIER_CONTEXT', text: 'C3:A:HCL3(1.0).HIER,C4:A:HCL4(1.0).HIER' }
     ];
 
     const expected = {
       C1: { agencyId: 'A', codelistId: 'C1', code: 'HCL1', hierarchy: 'HIER2', version: '1.0' },
       C2: { agencyId: 'A', codelistId: 'C2', code: 'HCL2', hierarchy: 'HIER1', version: '1.0' },
+      C3: { agencyId: 'A', codelistId: 'C3', code: 'HCL3', hierarchy: 'HIER', version: '1.0' },
+      C4: { agencyId: 'A', codelistId: 'C4', code: 'HCL4', hierarchy: 'HIER', version: '1.0' },
     }
   
     expect(getHCodelistsRefs(annotations)).to.deep.equal(expected);

package/test/hierarchiseDimensionWithAdvancedHierarchy.test.js

@@ -55,33 +55,140 @@ describe('hierarchiseDimensionWithAdvancedHierarchy tests', () => {
     const dimension = {
       id: 'test',
       values: [
-        { id: 'IDF' },
-        { id: 'CAN' },
-        { id: 'USA' },
-        { id: 'AFK' },
-        { id: 'GER' },
-        { id: 'FRA' },
-        { id: 'EA' },
-        { id: 'A' },
-        { id: 'W' },
+        { 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: 'CAN', parent: undefined, parents: [] },
-        { id: 'USA', parent: undefined, parents: [] },
-        { id: 'AFK', parent: undefined, parents: [] },
-        { id: 'W', parent: undefined, parents: [] },
-        { id: 'EA', parent: 'W', parents: ['W'] },
-        { id: 'FRA', parent: 'EA', parents: ['W', 'EA'] },
-        { id: 'IDF', parent: 'FRA', parents: ['W', 'EA', 'FRA'] },
-        { id: 'GER', parent: 'EA', parents: ['W', 'EA'] },
-        { id: 'A', parent: 'W', parents: ['W'] },
+        { 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 },
       ]
     };
 
     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 },
+        { 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' },
+      ]
+    };
+
+    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 },
+        { id: 'USA', parents: [], parent: undefined }
+      ]
+    };
+
+    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' },
+      ]
+    };
+  });
 });