@sis-cc/dotstatsuite-components 19.0.0 → 19.1.0

package/lib/rules2/src/applyHierarchicalCodesToDim.js

@@ -5,10 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 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);
@@ -30,8 +26,57 @@ var addParentId = function addParentId(id, ids) {
   return R.append(R.isNil(last) ? id : last + '.' + id, ids);
 };
 
-var applyHierarchicalCodesToDim = function applyHierarchicalCodesToDim(hCodes, dim) {
+var refineUnconfirmedPaths = function refineUnconfirmedPaths(paths) {
+  var confirmedPaths = R.filter(function (p) {
+    return p.length === 1;
+  }, paths);
+  if (!R.isEmpty(confirmedPaths)) {
+    confirmedPaths = R.reduce(function (acc, k) {
+      if (R.has(k, acc)) {
+        return acc;
+      }
+      var ps = R.prop(k, paths);
+      var flatConfirmed = R.unnest(R.values(acc));
+      var filtered = R.filter(function (p) {
+        return !!R.find(function (cP) {
+          return R.includes(p, cP) || R.includes(cP, p);
+        }, flatConfirmed);
+      }, ps);
+      if (!R.isEmpty(filtered)) {
+        return R.assoc(k, [R.head(filtered)], acc);
+      }
+      return acc;
+    }, confirmedPaths, R.keys(paths));
+  }
+  var remainingIds = R.reject(function (id) {
+    return R.has(id, confirmedPaths);
+  }, R.keys(paths));
+  var getCommonPaths = function getCommonPaths(ids) {
+    var _R$reduce = R.reduce(function (acc, id) {
+      var ps = R.prop(id, paths);
+      if (R.isEmpty(acc.commonPaths)) {
+        return R.assoc('commonPaths', ps, acc);
+      }
+      var common = R.intersection(acc.commonPaths, ps);
+      return R.isEmpty(common) ? R.assoc('rejectedChildrenIds', id, acc) : R.assoc('commonPaths', common, acc);
+    }, { commonPaths: [], rejectedIds: [] })(ids),
+        commonPaths = _R$reduce.commonPaths,
+        rejectedIds = _R$reduce.rejectedIds;
+
+    if (!R.isEmpty(rejectedIds)) {
+      return R.append(R.head(commonPaths), getCommonPaths(rejectedIds));
+    }
+    return [R.head(commonPaths)];
+  };
+  var commons = getCommonPaths(remainingIds);
+  return R.reduce(function (acc, id) {
+    return R.assoc(id, R.intersection(commons, R.prop(id, paths)), acc);
+  }, confirmedPaths, remainingIds);
+};
+
+var applyHierarchicalCodesToDim = exports.applyHierarchicalCodesToDim = function applyHierarchicalCodesToDim(hCodes, dim) {
   var confirmedHierarchisedChilds = new _set2.default([]);
+  var unconfirmedPaths = {};
 
   var indexedValues = R.reduce(function (acc, val) {
     if (!val.isSelected) {
@@ -52,13 +97,18 @@ var applyHierarchicalCodesToDim = function applyHierarchicalCodesToDim(hCodes, d
       if (!hasInDim) {
         return R.concat(acc, children);
       }
+      var path = R.join('.', parentsDef);
       var val = (0, _extends3.default)({}, R.prop(codeID, indexedValues), {
+        path: path,
         parents: parentsInDim,
         parent: R.last(parentsInDim),
         children: children
       });
 
       if (isUnconfirmed) {
+        unconfirmedPaths = R.over(R.lensProp(val.id), function (paths) {
+          return R.append(path, paths || []);
+        }, unconfirmedPaths);
         val = R.assoc('unconfirmed', true, val);
         return R.append(val, acc);
       }
@@ -69,34 +119,33 @@ var applyHierarchicalCodesToDim = function applyHierarchicalCodesToDim(hCodes, d
 
   var parsed = parseHCodes([], [])(hCodes);
 
+  var _unconfirmedPaths = R.pipe(R.reject(function (id) {
+    return confirmedHierarchisedChilds.has(id);
+  }), function (ids) {
+    return R.pick(ids, unconfirmedPaths);
+  })(R.keys(unconfirmedPaths));
+
+  var refinedUnconfirmedPaths = refineUnconfirmedPaths(_unconfirmedPaths);
+
   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);
+    return !val.unconfirmed || R.includes(val.path, R.propOr([], val.id, refinedUnconfirmedPaths));
   };
 
   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 _flatDescendants = flattenDescendants(hC.children);
+    var flatDescendants = R.prepend(hC, _flatDescendants);
     var validDescendant = R.find(isValid, flatDescendants);
     if (!validDescendant) {
       return acc;
     }
-    var refined = R.pipe(R.prepend(hC), R.map(function (v) {
+    var refined = R.pipe(R.map(function (v) {
       confirmedHierarchisedChilds.add(v.id);
-      return R.omit(['unconfirmed', 'children'], v);
+      return R.omit(['unconfirmed', 'children', 'path'], v);
     }))(flatDescendants);
     return R.concat(acc, refined);
   }, []);
@@ -112,7 +161,6 @@ var applyHierarchicalCodesToDim = function applyHierarchicalCodesToDim(hCodes, d
   }), 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;
@@ -124,5 +172,4 @@ var applyHierarchicalCodesToDim = function applyHierarchicalCodesToDim(hCodes, d
   }), function (values) {
     return (0, _extends3.default)({}, dim, { values: values });
   })(missingValues, refined);
-};
-exports.applyHierarchicalCodesToDim = applyHierarchicalCodesToDim;
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sis-cc/dotstatsuite-components",
   "description": "Set components based on React.",
-  "version": "19.0.0",
+  "version": "19.1.0",
   "main": "lib/index.js",
   "type": "module",
   "author": "OECD",

package/src/rules2/src/applyHierarchicalCodesToDim.js

@@ -5,8 +5,53 @@ const addParentId = (id, ids) => {
   return R.append(R.isNil(last) ? id : `${last}.${id}`, ids); 
 }
 
+const refineUnconfirmedPaths = (paths) => {
+  let confirmedPaths = R.filter(p => p.length === 1, paths);
+  if (!R.isEmpty(confirmedPaths)) {
+    confirmedPaths = R.reduce((acc, k) => {
+      if (R.has(k, acc)) {
+        return acc;
+      }
+      const ps = R.prop(k, paths);
+      const flatConfirmed = R.unnest(R.values(acc));
+      const filtered = R.filter(p => !!R.find(cP => R.includes(p, cP) || R.includes(cP, p), flatConfirmed), ps);
+      if (!R.isEmpty(filtered)) {
+        return R.assoc(k, [R.head(filtered)], acc);
+      }
+      return acc;
+    }, confirmedPaths, R.keys(paths));
+  }
+  const remainingIds = R.reject(id => R.has(id, confirmedPaths), R.keys(paths));
+  const getCommonPaths = ids => {
+    const { commonPaths, rejectedIds } = R.reduce(
+      (acc, id) => {
+        const ps = R.prop(id, paths);
+        if (R.isEmpty(acc.commonPaths)) {
+          return R.assoc('commonPaths', ps, acc);
+        }
+        const common = R.intersection(acc.commonPaths, ps);
+        return R.isEmpty(common)
+          ? R.assoc('rejectedChildrenIds', id, acc)
+          : R.assoc('commonPaths', common, acc);
+      },
+      { commonPaths: [], rejectedIds: [] }
+    )(ids);
+    if (!R.isEmpty(rejectedIds)) {
+      return R.append(R.head(commonPaths), getCommonPaths(rejectedIds));
+    }
+    return [R.head(commonPaths)];
+  };
+  const commons = getCommonPaths(remainingIds);
+  return R.reduce(
+    (acc, id) => R.assoc(id, R.intersection(commons, R.prop(id, paths)), acc),
+    confirmedPaths,
+    remainingIds
+  );
+};
+
 export const applyHierarchicalCodesToDim = (hCodes, dim) => {
-  let confirmedHierarchisedChilds = new Set([]);
+  const confirmedHierarchisedChilds = new Set([]);
+  let unconfirmedPaths = {};
 
   const indexedValues = R.reduce((acc, val) => {
     if (!val.isSelected) {
@@ -26,14 +71,17 @@ export const applyHierarchicalCodesToDim = (hCodes, dim) => {
     if (!hasInDim) {
       return R.concat(acc, children);
     }
+    const path = R.join('.', parentsDef);
     let val = {
       ...R.prop(codeID, indexedValues),
+      path,
       parents: parentsInDim,
       parent: R.last(parentsInDim),
       children
     };
 
     if (isUnconfirmed) {
+      unconfirmedPaths = R.over(R.lensProp(val.id), paths => R.append(path, paths || []), unconfirmedPaths);
       val = R.assoc('unconfirmed', true, val);
       return R.append(val, acc);
     }
@@ -43,30 +91,31 @@ export const applyHierarchicalCodesToDim = (hCodes, dim) => {
 
   const parsed = parseHCodes([], [])(hCodes);
 
+  const _unconfirmedPaths = R.pipe(
+    R.reject(id => confirmedHierarchisedChilds.has(id)),
+    ids => R.pick(ids, unconfirmedPaths)
+  )(R.keys(unconfirmedPaths));
+
+  const refinedUnconfirmedPaths = refineUnconfirmedPaths(_unconfirmedPaths);
+
   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 isValid = val => !val.unconfirmed || R.includes(val.path, R.propOr([], val.id, refinedUnconfirmedPaths));
 
   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 _flatDescendants = flattenDescendants(hC.children);
+    const flatDescendants = R.prepend(hC, _flatDescendants);
     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);
+        return R.omit(['unconfirmed', 'children', 'path'], v);
       })
     )(flatDescendants);
     return R.concat(acc, refined);
@@ -83,7 +132,6 @@ export const applyHierarchicalCodesToDim = (hCodes, dim) => {
   )(indexedValues);
 
   let hierarchicalIndexes = {};
-
   return R.pipe(
     R.concat,
     R.addIndex(R.map)((v, ind) => {

package/test/applyHierarchicalCodesToDim.test.js

@@ -144,4 +144,17 @@ describe('refineHierarchicalCodelist tests', () => {
     };
     expect(applyHierarchicalCodesToDim(hCodes, partialDim)).to.deep.equal(expected);
   });
+  it('partial test 6', () => {
+    const partialDim = deselectedDim([0, 1, 3, 4, 6]);
+
+    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_C', parents: [0], parent: 'ITEM', isSelected: true, __indexPosition: 2 },
+      ]
+    };
+    expect(applyHierarchicalCodesToDim(hCodes, partialDim)).to.deep.equal(expected);
+  });
 });