@sis-cc/dotstatsuite-components 17.26.1 → 17.27.0

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

@@ -3,11 +3,15 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getTableLayoutIds = exports.getLayoutCombinations = exports.getLayoutDimsIds = exports.injectCombinationsInLayout = exports.injectCombination = exports.getLayoutRelationships = exports.getLayoutLevelRelationship = exports.indexCombsRelationships = exports.getCombinationsNotInLayout = undefined;
+exports.getTableLayoutIds = exports.injectRemainingDimensionsInLayout = exports.getLayoutCombinations = exports.getLayoutDimsIds = exports.injectCombinationsInLayout = exports.injectCombination = exports.getLayoutRelationships = exports.getLayoutLevelRelationship = exports.indexCombsRelationships = exports.getCombinationsNotInLayout = undefined;
 
-var _extends2 = require('babel-runtime/helpers/extends');
+var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
 
-var _extends3 = _interopRequireDefault(_extends2);
+var _defineProperty3 = _interopRequireDefault(_defineProperty2);
+
+var _extends3 = require('babel-runtime/helpers/extends');
+
+var _extends4 = _interopRequireDefault(_extends3);
 
 var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
 
@@ -139,7 +143,7 @@ var injectCombinationsInLayout = exports.injectCombinationsInLayout = function i
     }
     var rowsConcepts = R.concat(idsInRows, nowhere);
     layoutRelationships.rows = R.concat(layoutRelationships.rows, rowsConcepts);
-    var ids = injectCombination((0, _extends3.default)({}, comb, { concepts: rowsConcepts }))(acc.rows);
+    var ids = injectCombination((0, _extends4.default)({}, comb, { concepts: rowsConcepts }))(acc.rows);
     return R.assoc('rows', ids)(acc);
   }, layoutIds, notInLayoutCombs);
 };
@@ -159,7 +163,7 @@ var getLayoutCombinations = exports.getLayoutCombinations = function getLayoutCo
       }
       if (R.has(concept, indexedAttributes)) {
         var attr = R.prop(concept, indexedAttributes);
-        return attr.series ? (0, _extends3.default)({}, _acc, {
+        return attr.series ? (0, _extends4.default)({}, _acc, {
           relationship: R.concat(_acc.relationship, attr.relationship)
         }) : _acc;
       }
@@ -171,10 +175,69 @@ var getLayoutCombinations = exports.getLayoutCombinations = function getLayoutCo
     if (R.isEmpty(relationship)) {
       return acc;
     }
-    return R.append((0, _extends3.default)({}, comb, { relationship: relationship, concepts: layoutConcepts }), acc);
+    return R.append((0, _extends4.default)({}, comb, { relationship: relationship, concepts: layoutConcepts }), acc);
   }, [], combinations);
 };
 
+var extractConcepts = function extractConcepts(ids, indexedCombinations) {
+  var getRelationship = function getRelationship(id) {
+    if (R.has(id, indexedCombinations)) {
+      return R.append(id, R.path([id, 'relationship'], indexedCombinations));
+    }
+    return [id];
+  };
+  var indexedRels = R.reduce(function (acc, id) {
+    return R.assoc(id, getRelationship(id), acc);
+  }, {}, ids);
+
+  var relationship = [R.head(ids)];
+  while (!R.isEmpty(indexedRels)) {
+    var related = R.pickBy(function (rels) {
+      return !R.isEmpty(R.intersection(relationship, rels));
+    }, indexedRels);
+    if (R.isEmpty(related)) {
+      break;
+    }
+    indexedRels = R.omit(R.keys(related), indexedRels);
+    relationship = R.concat(relationship, R.unnest(R.values(related)));
+  }
+  var set = new _set2.default(relationship);
+  return R.partition(function (id) {
+    return set.has(id);
+  }, ids);
+};
+
+var injectRemainingDimensionsInLayout = exports.injectRemainingDimensionsInLayout = function injectRemainingDimensionsInLayout(layoutIds, remainingDims, indexedCombinations) {
+  var _layout = layoutIds;
+  var _remaining = remainingDims;
+
+  if (R.isEmpty(_layout.rows)) {
+    if (R.isEmpty(_remaining)) {
+      var toTakeIn = R.isEmpty(_layout.sections) ? 'header' : 'sections';
+
+      var _extractConcepts = extractConcepts(R.prop(toTakeIn, _layout), indexedCombinations),
+          _extractConcepts2 = (0, _slicedToArray3.default)(_extractConcepts, 2),
+          extracted = _extractConcepts2[0],
+          remains = _extractConcepts2[1];
+
+      _layout = (0, _extends4.default)({}, _layout, (0, _defineProperty3.default)({ rows: extracted }, toTakeIn, remains));
+    } else {
+      _layout = R.over(R.lensProp('rows'), R.append(R.head(_remaining)))(_layout);
+      _remaining = R.tail(_remaining);
+    }
+  }
+  if (!R.isEmpty(_remaining)) {
+    var hasNoHeader = R.isEmpty(_layout.header);
+    var firstRemaining = R.head(_remaining);
+    _remaining = hasNoHeader ? R.tail(_remaining) : _remaining;
+    _layout = (0, _extends4.default)({}, _layout, {
+      sections: R.concat(_layout.sections, _remaining),
+      header: hasNoHeader ? [firstRemaining] : _layout.header
+    });
+  }
+  return _layout;
+};
+
 var getTableLayoutIds = exports.getTableLayoutIds = function getTableLayoutIds(defaultLayoutIds, dimensions, attributes, combinations) {
   var layoutDimsIds = getLayoutDimsIds(dimensions);
   var layoutCombinations = getLayoutCombinations(combinations, layoutDimsIds, attributes);
@@ -221,20 +284,5 @@ var getTableLayoutIds = exports.getTableLayoutIds = function getTableLayoutIds(d
       nextLayout = _R$reduce4.nextLayout,
       remaining = _R$reduce4.remaining;
 
-  var _remaining = remaining;
-  return R.pipe(R.when(function (l) {
-    return R.isEmpty(l.rows) && !R.isEmpty(_remaining);
-  }, function (l) {
-    var nextL = R.over(R.lensProp('rows'), R.append(R.head(_remaining)))(l);
-    _remaining = R.tail(_remaining);
-    return nextL;
-  }), R.when(function (l) {
-    return R.isEmpty(l.header) && !R.isEmpty(_remaining);
-  }, function (l) {
-    var nextL = R.over(R.lensProp('header'), R.append(R.head(_remaining)))(l);
-    _remaining = R.tail(_remaining);
-    return nextL;
-  }), R.when(R.always(!R.isEmpty(_remaining)), function (l) {
-    return R.over(R.lensProp('sections'), R.flip(R.concat)(_remaining))(l);;
-  }))(nextLayout);
+  return injectRemainingDimensionsInLayout(nextLayout, remaining, indexedCombinations);
 };

package/package.json

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

package/src/rules2/src/table/getTableLayoutIds.js

@@ -123,6 +123,58 @@ export const getLayoutCombinations = (combinations, layoutDimsIds, attributes) =
   );
 };
 
+const extractConcepts = (ids, indexedCombinations) => {
+  const getRelationship = id => {
+    if (R.has(id, indexedCombinations)) {
+      return R.append(id, R.path([id, 'relationship'], indexedCombinations));
+    }
+    return [id];
+  };
+  let indexedRels = R.reduce((acc, id) =>
+    R.assoc(id, getRelationship(id), acc)
+  , {}, ids);
+  
+  let relationship = [R.head(ids)];
+  while (!R.isEmpty(indexedRels)) {
+    const related = R.pickBy(rels => !R.isEmpty(R.intersection(relationship, rels)), indexedRels);
+    if (R.isEmpty(related)) {
+      break;
+    }
+    indexedRels = R.omit(R.keys(related), indexedRels);
+    relationship = R.concat(relationship, R.unnest(R.values(related)));
+  }
+  const set = new Set(relationship);
+  return R.partition(id => set.has(id), ids);
+}
+
+export const injectRemainingDimensionsInLayout = (layoutIds, remainingDims, indexedCombinations) => {
+  let _layout = layoutIds;
+  let _remaining = remainingDims;
+
+  if (R.isEmpty(_layout.rows)) {
+    if (R.isEmpty(_remaining)) {
+      const toTakeIn = R.isEmpty(_layout.sections) ? 'header' : 'sections';
+      const [extracted, remains] = extractConcepts(R.prop(toTakeIn, _layout), indexedCombinations);
+      _layout = ({ ..._layout, rows: extracted, [toTakeIn]: remains });
+    }
+    else {
+      _layout = R.over(R.lensProp('rows'), R.append(R.head(_remaining)))(_layout);
+      _remaining = R.tail(_remaining)
+    }
+  }
+  if (!R.isEmpty(_remaining)) {
+    const hasNoHeader = R.isEmpty(_layout.header);
+    const firstRemaining = R.head(_remaining);
+    _remaining = hasNoHeader ? R.tail(_remaining) : _remaining;
+    _layout = {
+      ..._layout,
+      sections: R.concat(_layout.sections, _remaining),
+      header: hasNoHeader ? [firstRemaining] : _layout.header,
+    };
+  }
+  return _layout;
+};
+
 export const getTableLayoutIds = (
   defaultLayoutIds,
   dimensions,
@@ -184,29 +236,5 @@ export const getTableLayoutIds = (
     return R.over(R.lensProp('remaining'), R.append(dim.id))(acc);
   }, { nextLayout: layoutWithCombs, remaining: [] }, dimensions);
 
-  let _remaining = remaining;
-  return R.pipe(
-    R.when(
-      l => R.isEmpty(l.rows) && !R.isEmpty(_remaining),
-      l => {
-        const nextL = R.over(R.lensProp('rows'), R.append(R.head(_remaining)))(l);
-        _remaining = R.tail(_remaining)
-        return nextL;
-      }
-    ),
-    R.when(
-      l => R.isEmpty(l.header) && !R.isEmpty(_remaining),
-      l => {
-        const nextL = R.over(R.lensProp('header'), R.append(R.head(_remaining)))(l);
-        _remaining = R.tail(_remaining)
-        return nextL;
-      }
-    ),
-    R.when(
-      R.always(!R.isEmpty(_remaining)),
-      l => {
-        return R.over(R.lensProp('sections'), R.flip(R.concat)(_remaining))(l);;
-      }
-    ),
-  )(nextLayout);
+  return injectRemainingDimensionsInLayout(nextLayout, remaining, indexedCombinations);
 };

package/test/getTableLayoutIds.test.js

@@ -110,4 +110,118 @@ describe('getTableLayoutIds tests', () => {
       rows: ['COMB2', 'REF_AREA']
     });
   });
+  it('nothing in rows 2', () => {
+    const combinations = [];
+    const attributes = [];
+    const dimensions = [
+      { id: 'D1', header: true },
+      { id: 'D2' },
+      { id: 'D3', header: true }
+    ];
+    const layoutIds = {
+      sections: ['D1'],
+      header: ['D2'],
+      rows: ['D3']
+    };
+
+    expect(getTableLayoutIds(layoutIds, dimensions, attributes, combinations)).to.deep.equal({
+      header: [],
+      sections: [],
+      rows: ['D2']
+    });
+  });
+  it('nothing in rows with combinations', () => {
+    const combinations = [
+      {
+        id: 'COMB1',
+        concepts: ['D1', 'D2']
+      },
+      {
+        id: 'COMB2',
+        concepts: ['A1', 'A2']
+      },
+    ];
+    const attributes = [
+      { id: 'A1', series: true, relationship: ['D1', 'D2'] },
+      { id: 'A2', series: true, relationship: ['D1', 'D2'] },
+    ];
+    const dimensions = [
+      { id: 'D1' },
+      { id: 'D2' },
+      { id: 'D3' }
+    ];
+    const layoutIds = {
+      sections: ['D1', 'D2'],
+      header: ['D3'],
+      rows: []
+    };
+
+    expect(getTableLayoutIds(layoutIds, dimensions, attributes, combinations)).to.deep.equal({
+      header: ['D3'],
+      sections: [],
+      rows: ['COMB1', 'COMB2']
+    });
+  });
+  it('nothing in rows with combinations 2', () => {
+    const combinations = [
+      {
+        id: 'COMB1',
+        concepts: ['D1', 'D2']
+      },
+      {
+        id: 'COMB2',
+        concepts: ['A1', 'A2']
+      },
+    ];
+    const attributes = [
+      { id: 'A1', series: true, relationship: ['D1', 'D2'] },
+      { id: 'A2', series: true, relationship: ['D1', 'D2'] },
+    ];
+    const dimensions = [
+      { id: 'D1' },
+      { id: 'D2' },
+      { id: 'D3' },
+      { id: 'D4' }
+    ];
+    const layoutIds1 = {
+      sections: ['COMB1', 'D4', 'COMB2'],
+      header: ['D3'],
+      rows: []
+    };
+    const layoutIds2 = {
+      sections: ['D4', 'COMB1', 'COMB2'],
+      header: ['D3'],
+      rows: []
+    };
+    const layoutIds3 = {
+      sections: ['COMB2', 'COMB1', 'D4'],
+      header: ['D3'],
+      rows: []
+    };
+    const layoutIds4 = {
+      sections: ['COMB1', 'COMB2'],
+      header: ['D3'],
+      rows: []
+    };
+    expect(getTableLayoutIds(layoutIds1, dimensions, attributes, combinations)).to.deep.equal({
+      header: ['D3'],
+      sections: ['D4'],
+      rows: ['COMB1', 'COMB2']
+    });
+    expect(getTableLayoutIds(layoutIds2, dimensions, attributes, combinations)).to.deep.equal({
+      header: ['D3'],
+      sections: ['COMB1', 'COMB2'],
+      rows: ['D4']
+    });
+    expect(getTableLayoutIds(layoutIds3, dimensions, attributes, combinations)).to.deep.equal({
+      header: ['D3'],
+      sections: ['D4'],
+      rows: ['COMB2', 'COMB1']
+    });
+    expect(getTableLayoutIds(layoutIds4, dimensions, attributes, combinations)).to.deep.equal({
+      header: ['D3'],
+      sections: ['COMB1', 'COMB2'],
+      rows: ['D4']
+    });
+  });
 });