@sis-cc/dotstatsuite-components 19.0.0 → 19.2.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/lib/rules2/src/parseCombinations.js

@@ -35,7 +35,6 @@ var hasInvalidValues = R.pipe(R.prop('values'), R.anyPass([R.isNil, R.complement
 var isConceptInvalid = R.anyPass([hasInvalidValues /* add more... */]);
 var filterValidConcepts = R.reject(isConceptInvalid);
 // concepts is an array of ids... (misnamed!)
-var conceptIdsLens = R.lensProp('concepts');
 var rejectInvalidConceptIds = function rejectInvalidConceptIds() {
   var concepts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   return function () {
@@ -44,7 +43,7 @@ var rejectInvalidConceptIds = function rejectInvalidConceptIds() {
     var validConceptIds = R.pluck('id', filterValidConcepts(concepts));
     return R.reduce(function (acc, comb) {
       var refinedConcepts = R.intersection(validConceptIds, comb.concepts);
-      if (R.length(refinedConcepts) < 2) {
+      if (R.length(refinedConcepts) < 1) {
         return acc;
       }
       return R.append((0, _extends4.default)({}, comb, { concepts: refinedConcepts }), acc);

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

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sis-cc/dotstatsuite-components",
   "description": "Set components based on React.",
-  "version": "19.0.0",
+  "version": "19.2.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/src/rules2/src/parseCombinations.js

@@ -18,14 +18,13 @@ const hasInvalidValues = R.pipe(
 const isConceptInvalid = R.anyPass([hasInvalidValues /* add more... */]);
 const filterValidConcepts = R.reject(isConceptInvalid);
 // concepts is an array of ids... (misnamed!)
-const conceptIdsLens = R.lensProp('concepts');
 const rejectInvalidConceptIds =
   (concepts = []) =>
   (combinations = []) => {
     const validConceptIds = R.pluck('id', filterValidConcepts(concepts));
     return R.reduce((acc, comb) => {
       const refinedConcepts = R.intersection(validConceptIds, comb.concepts);
-      if (R.length(refinedConcepts) < 2) {
+      if (R.length(refinedConcepts) < 1) {
         return acc;
       }
       return R.append({ ...comb, concepts: refinedConcepts }, acc);

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) ? d.hasAdvancedAttributes : R.any(R.prop('hasAdvancedAttributes'), d.values)
+		d => R.has('value', d) ? R.prop('hasAdvancedAttributes', d.value) : R.any(R.prop('hasAdvancedAttributes'), d.values)
 	, data);
   const hasAdvancedAttributes = hasDataAdvancedAttributes || getHasAdvancedAttributes(layoutAttrValues, customAttributes);
   const sideProps = hasMetadata || hasAdvancedAttributes

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

package/test/getLayoutData2.test.js

@@ -439,4 +439,52 @@ 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,6 +146,20 @@ 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'],