@sis-cc/dotstatsuite-components 17.20.0 → 17.21.0

package/lib/rules2/src/index.js

@@ -407,4 +407,19 @@ Object.defineProperty(exports, 'parseLayoutIndexesHierarchies', {
   get: function get() {
     return _parseSeriesIndexesHierarchies.parseLayoutIndexesHierarchies;
   }
+});
+
+var _getTableLayoutIds = require('./table/getTableLayoutIds');
+
+Object.defineProperty(exports, 'getTableLayoutIds', {
+  enumerable: true,
+  get: function get() {
+    return _getTableLayoutIds.getTableLayoutIds;
+  }
+});
+Object.defineProperty(exports, 'injectCombinationsInLayout', {
+  enumerable: true,
+  get: function get() {
+    return _getTableLayoutIds.injectCombinationsInLayout;
+  }
 });

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

@@ -3,15 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getLayout = undefined;
+exports.getLayout = exports.parseCombination = exports.getConceptsSet = undefined;
 
-var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
+var _set = require('babel-runtime/core-js/set');
 
-var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
-
-var _extends2 = require('babel-runtime/helpers/extends');
-
-var _extends3 = _interopRequireDefault(_extends2);
+var _set2 = _interopRequireDefault(_set);
 
 var _ramda = require('ramda');
 
@@ -19,71 +15,91 @@ var R = _interopRequireWildcard(_ramda);
 
 var _dotstatsuiteSdmxjs = require('@sis-cc/dotstatsuite-sdmxjs');
 
-var _utils = require('../utils');
-
 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 getLayout = exports.getLayout = function getLayout(layoutIds, dimensions, combinations, isTimeInverted) {
-  var indexedDimensions = R.pipe(R.indexBy(R.prop('id')), R.map(function (d) {
-    return (0, _dotstatsuiteSdmxjs.isTimePeriodDimension)(d) && isTimeInverted ? R.assoc('isInverted', true, d) : d;
-  }))(dimensions);
-  var indexedHeaderIds = R.indexBy(R.identity, layoutIds.header);
-  var indexedSectionsIds = R.indexBy(R.identity, layoutIds.sections);
-  var indexedRowsIds = (0, _extends3.default)({}, indexedSectionsIds, R.indexBy(R.identity, layoutIds.rows));
-  var layout = { header: [], sections: [], rows: [] };
-  R.forEach(function (comb) {
-    if (R.isEmpty(comb.relationship)) {
-      return;
-    }
-
-    var _R$partition = R.partition(function (id) {
-      return R.has(id, indexedHeaderIds);
-    }, comb.relationship),
-        _R$partition2 = (0, _slicedToArray3.default)(_R$partition, 2),
-        idsInHeader = _R$partition2[0],
-        rest = _R$partition2[1];
-
-    if (R.isEmpty(rest)) {
-      layout = R.over(R.lensProp('header'), R.append((0, _extends3.default)({}, comb, {
-        dimensions: (0, _utils.trimedProps)(comb.concepts, indexedDimensions)
-      })))(layout);
-    } else if (!R.isEmpty(idsInHeader)) {
-      return;
+var getConceptsSet = exports.getConceptsSet = function getConceptsSet(ids, indexedCombinations, _upper) {
+  var upper = R.isNil(_upper) ? new _set2.default([]) : _upper;
+  var res = new _set2.default([]);
+  R.forEach(function (id) {
+    if (!R.has(id, indexedCombinations)) {
+      res.add(id);
     } else {
-      var idsNotInSections = R.reject(function (id) {
-        return R.has(id, indexedSectionsIds);
-      }, comb.relationship);
-      if (R.isEmpty(idsNotInSections)) {
-        layout = R.over(R.lensProp('sections'), R.append((0, _extends3.default)({}, comb, {
-          dimensions: (0, _utils.trimedProps)(comb.concepts, indexedDimensions)
-        })))(layout);
-      } else {
-        var idsNotInRows = R.reject(function (id) {
-          return R.has(id, indexedRowsIds);
-        }, comb.relationship);
-        if (R.isEmpty(idsNotInRows)) {
-          layout = R.over(R.lensProp('rows'), R.append((0, _extends3.default)({}, comb, {
-            dimensions: R.pipe(R.omit(layoutIds.sections), function (o) {
-              return (0, _utils.trimedProps)(comb.concepts, o);
-            })(indexedDimensions)
-          })))(layout);
+      var comb = R.prop(id, indexedCombinations);
+      R.forEach(function (c) {
+        if (!upper.has(c)) {
+          res.add(c);
         }
-      }
+      }, comb.concepts);
     }
-  }, combinations);
-  return R.mapObjIndexed(function (combs, key) {
-    var conceptIds = R.pipe(R.pluck('concepts'), R.unnest, R.indexBy(R.identity))(combs);
-    var rest = R.reduce(function (acc, id) {
-      if (R.has(id, conceptIds)) {
-        return acc;
-      }
-      if (!R.has(id, indexedDimensions)) {
+  }, ids);
+  return res;
+};
+
+var parseCombination = exports.parseCombination = function parseCombination(_upperIds, _excludedIds) {
+  return function (comb, indexedDimensions) {
+    var upperIds = R.isNil(_upperIds) ? new _set2.default([]) : _upperIds;
+    var excludedIds = R.isNil(_excludedIds) ? new _set2.default([]) : _excludedIds;
+
+    var concepts = comb.concepts,
+        relationship = comb.relationship;
+
+    var dimensions = R.reduce(function (acc, id) {
+      if (upperIds.has(id) || !R.has(id, indexedDimensions)) {
         return acc;
       }
-      return R.append(R.prop(id, indexedDimensions), acc);
-    }, [], layoutIds[key]);
-    return R.concat(rest, combs);
-  }, layout);
+      var dim = R.prop(id, indexedDimensions);
+      return R.append(dim, acc);
+    }, [], concepts);
+    var excludedDep = R.find(function (i) {
+      return excludedIds.has(i);
+    }, relationship);
+    if (excludedDep) {
+      return dimensions;
+    }
+    return R.assoc('dimensions', dimensions, comb);
+  };
+};
+
+var getLayout = exports.getLayout = function getLayout(_layoutIds, dimensions, combinations, isTimeInverted) {
+  var layoutIds = R.mergeRight({ header: [], sections: [], rows: [] }, _layoutIds);
+  var applyInversionOnTimeDim = function applyInversionOnTimeDim(dim) {
+    return (0, _dotstatsuiteSdmxjs.isTimePeriodDimension)(dim) && isTimeInverted ? R.assoc('isInverted', true, dim) : dim;
+  };
+
+  var indexedDimensions = R.reduce(function (acc, dim) {
+    return R.assoc(dim.id, applyInversionOnTimeDim(dim), acc);
+  }, {}, dimensions);
+
+  var indexedCombinations = R.indexBy(R.prop('id'), combinations);
+  var headerConceptsSet = getConceptsSet(layoutIds.header, indexedCombinations);
+  var sectionsConceptsSet = getConceptsSet(layoutIds.sections, indexedCombinations);
+  var rowsConceptsSet = getConceptsSet(R.concat(layoutIds.sections, layoutIds.rows), indexedCombinations);
+
+  var getLayoutLevel = function getLayoutLevel(_upperIds, _excludedIds) {
+    return function (ids) {
+      return R.reduce(function (acc, id) {
+        if (R.has(id, indexedDimensions)) {
+          var dim = R.prop(id, indexedDimensions);
+          return R.append(dim, acc);
+        }
+        if (!R.has(id, indexedCombinations)) {
+          return acc;
+        }
+        var comb = R.prop(id, indexedCombinations);
+        var parsedCombination = parseCombination(_upperIds, _excludedIds)(comb, indexedDimensions);
+        if (R.is(Array, parsedCombination)) {
+          return R.concat(acc, parsedCombination);
+        }
+        return R.append(parsedCombination, acc);
+      }, [], ids);
+    };
+  };
+
+  var header = getLayoutLevel(null, rowsConceptsSet)(layoutIds.header);
+  var sections = getLayoutLevel(null, headerConceptsSet)(layoutIds.sections);
+  var rows = getLayoutLevel(sectionsConceptsSet, headerConceptsSet)(layoutIds.rows);
+
+  return { header: header, sections: sections, rows: rows };
 };

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

@@ -0,0 +1,222 @@
+'use strict';
+
+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;
+
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
+var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
+
+var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
+
+var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');
+
+var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
+
+var _set = require('babel-runtime/core-js/set');
+
+var _set2 = _interopRequireDefault(_set);
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+var _dotstatsuiteSdmxjs = require('@sis-cc/dotstatsuite-sdmxjs');
+
+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 getCombinationsNotInLayout = exports.getCombinationsNotInLayout = function getCombinationsNotInLayout(combinations, layoutIds) {
+  var _layoutIds$header = layoutIds.header,
+      header = _layoutIds$header === undefined ? [] : _layoutIds$header,
+      _layoutIds$sections = layoutIds.sections,
+      sections = _layoutIds$sections === undefined ? [] : _layoutIds$sections,
+      _layoutIds$rows = layoutIds.rows,
+      rows = _layoutIds$rows === undefined ? [] : _layoutIds$rows;
+
+  var idsInLayout = new _set2.default([].concat((0, _toConsumableArray3.default)(header), (0, _toConsumableArray3.default)(sections), (0, _toConsumableArray3.default)(rows)));
+  return R.reject(function (comb) {
+    return idsInLayout.has(comb.id);
+  }, combinations);
+};
+
+var indexCombsRelationships = exports.indexCombsRelationships = function indexCombsRelationships(combinations) {
+  return R.reduce(function (acc, comb) {
+    var id = comb.id,
+        _comb$relationship = comb.relationship,
+        relationship = _comb$relationship === undefined ? [] : _comb$relationship;
+
+    return R.assoc(id, relationship, acc);
+  }, {}, combinations);
+};
+
+var getLayoutLevelRelationship = exports.getLayoutLevelRelationship = function getLayoutLevelRelationship(indexedRelationships) {
+  return function (ids) {
+    return R.reduce(function (acc, id) {
+      if (R.has(id, indexedRelationships)) {
+        return R.concat(acc, R.prop(id, indexedRelationships));
+      }
+      return R.append(id, acc);
+    }, [], ids);
+  };
+};
+
+var getLayoutRelationships = exports.getLayoutRelationships = function getLayoutRelationships(indexedRelationships, layoutIds) {
+  return R.map(getLayoutLevelRelationship(indexedRelationships), layoutIds);
+};
+
+var injectCombination = exports.injectCombination = function injectCombination(combination) {
+  return function (ids) {
+    var id = combination.id,
+        _combination$concepts = combination.concepts,
+        concepts = _combination$concepts === undefined ? [] : _combination$concepts;
+
+    var conceptsSet = new _set2.default(concepts);
+    var inject = true;
+    var refined = R.reduce(function (acc, i) {
+      if (!conceptsSet.has(i)) {
+        return R.append(i, acc);
+      }
+      if (inject) {
+        inject = false;
+        return R.append(id, acc);
+      }
+      return acc;
+    }, [], ids);
+    return inject ? R.append(id, refined) : refined;
+  };
+};
+
+var injectCombinationsInLayout = exports.injectCombinationsInLayout = function injectCombinationsInLayout(combinations, layoutIds) {
+  var notInLayoutCombs = getCombinationsNotInLayout(combinations, layoutIds);
+  if (R.isEmpty(notInLayoutCombs)) {
+    return layoutIds;
+  }
+  var indexedCombsRelationships = indexCombsRelationships(combinations);
+  var layoutRelationships = getLayoutRelationships(indexedCombsRelationships, layoutIds);
+  return R.reduce(function (acc, comb) {
+    var _comb$relationship2 = comb.relationship,
+        relationship = _comb$relationship2 === undefined ? [] : _comb$relationship2;
+
+    var idsInHeaderSet = new _set2.default(layoutRelationships.header);
+    var idsInSectionsSet = new _set2.default(layoutRelationships.sections);
+    var idsInRowsSet = new _set2.default(layoutRelationships.rows);
+
+    var _R$partition = R.partition(function (i) {
+      return idsInHeaderSet.has(i);
+    }, relationship),
+        _R$partition2 = (0, _slicedToArray3.default)(_R$partition, 2),
+        idsInHeader = _R$partition2[0],
+        rest = _R$partition2[1];
+
+    var _R$reduce = R.reduce(function (_acc, id) {
+      if (idsInSectionsSet.has(id)) return R.over(R.lensIndex(0), R.append(id), _acc);
+      if (idsInRowsSet.has(id)) return R.over(R.lensIndex(1), R.append(id), _acc);
+      return R.over(R.lensIndex(2), R.append(id), _acc);
+    }, [[], [], []], rest),
+        _R$reduce2 = (0, _slicedToArray3.default)(_R$reduce, 3),
+        idsInSections = _R$reduce2[0],
+        idsInRows = _R$reduce2[1],
+        nowhere = _R$reduce2[2];
+
+    if (!R.isEmpty(idsInHeader) && R.isEmpty(idsInSections) && R.isEmpty(idsInRows)) {
+      layoutRelationships.header = R.concat(layoutRelationships.header, relationship);
+      var _ids = injectCombination(comb)(acc.header);
+      return R.assoc('header', _ids)(acc);
+    }
+    if (!R.isEmpty(idsInHeader)) {
+      return acc;
+    }
+    if (!R.isEmpty(idsInSections) && R.isEmpty(idsInRows)) {
+      layoutRelationships.sections = R.concat(layoutRelationships.sections, relationship);
+      var _ids2 = injectCombination(comb)(acc.sections);
+      return R.assoc('sections', _ids2)(acc);
+    }
+    var rowsConcepts = R.concat(idsInRows, nowhere);
+    layoutRelationships.rows = R.concat(layoutRelationships.rows, rowsConcepts);
+    var ids = injectCombination((0, _extends3.default)({}, comb, { concepts: rowsConcepts }))(acc.rows);
+    return R.assoc('rows', ids)(acc);
+  }, layoutIds, notInLayoutCombs);
+};
+
+var getLayoutDimsIds = exports.getLayoutDimsIds = function getLayoutDimsIds(dimensions) {
+  return R.reduce(function (acc, d) {
+    return d.header ? acc : acc.add(d.id);
+  }, new _set2.default([]), dimensions);
+};
+
+var getLayoutCombinations = exports.getLayoutCombinations = function getLayoutCombinations(combinations, layoutDimsIds, attributes) {
+  var indexedAttributes = R.indexBy(R.prop('id'), attributes);
+  return R.reduce(function (acc, comb) {
+    var _R$reduce3 = R.reduce(function (_acc, concept) {
+      if (layoutDimsIds.has(concept)) {
+        return R.map(R.append(concept), _acc);
+      }
+      if (R.has(concept, indexedAttributes)) {
+        var attr = R.prop(concept, indexedAttributes);
+        return attr.series ? (0, _extends3.default)({}, _acc, {
+          relationship: R.concat(_acc.relationship, attr.relationship)
+        }) : _acc;
+      }
+      return _acc;
+    }, { layoutConcepts: [], relationship: [] }, comb.concepts || []),
+        layoutConcepts = _R$reduce3.layoutConcepts,
+        relationship = _R$reduce3.relationship;
+
+    if (R.isEmpty(layoutConcepts)) {
+      return acc;
+    }
+    return R.append((0, _extends3.default)({}, comb, { relationship: relationship, concepts: layoutConcepts }), acc);
+  }, [], combinations);
+};
+
+var getTableLayoutIds = exports.getTableLayoutIds = function getTableLayoutIds(defaultLayoutIds, dimensions, attributes, combinations) {
+  var layoutDimsIds = getLayoutDimsIds(dimensions);
+  var layoutCombinations = getLayoutCombinations(combinations, layoutDimsIds, attributes);
+  var indexedCombinations = R.indexBy(R.prop('id'), layoutCombinations);
+  var filteredLayoutIds = R.map(R.filter(function (id) {
+    return R.has(id, indexedCombinations) || layoutDimsIds.has(id);
+  }), defaultLayoutIds);
+
+  var layoutWithCombs = injectCombinationsInLayout(layoutCombinations, filteredLayoutIds);
+  var layoutRelationshipsSets = R.map(function (ids) {
+    return R.pipe(R.pick(ids, indexedCombsRelationships), R.values, R.unnest, function (i) {
+      return new _set2.default(i);
+    })(ids);
+  }, layoutWithCombs);
+  var layoutConceptsSets = R.pipe(R.map(R.reduce(function (acc, id) {
+    if (R.has(id, indexedCombinations)) {
+      return R.concat(acc, R.path([id, 'relationship'], indexedCombinations));
+    }
+    return R.append(id, acc);
+  }, [])), R.values, R.unnest, function (ids) {
+    return new _set2.default(ids);
+  })(layoutWithCombs);
+
+  return R.reduce(function (acc, dim) {
+    if (layoutConceptsSets.has(id) || !dim.series) {
+      return acc;
+    }
+    if (layoutRelationshipsSets.header.has(dim.id)) {
+      return R.over(R.lensProp('header'), R.append(dim.id))(acc);
+    }
+    if (layoutRelationshipsSets.sections.has(dim.id)) {
+      return R.over(R.lensProp('sections'), R.append(dim.id))(acc);
+    }
+    if (layoutRelationshipsSets.rows.has(dim.id)) {
+      return R.over(R.lensProp('rows'), R.append(dim.id))(acc);
+    }
+    if ((0, _dotstatsuiteSdmxjs.isTimePeriodDimension)(dim)) {
+      return R.over(R.lensProp('header'), R.append(dim.id))(acc);
+    }
+    if ((0, _dotstatsuiteSdmxjs.isRefAreaDimension)(dim)) {
+      return R.over(R.lensProp('rows'), R.append(dim.id))(acc);
+    }
+    return R.over(R.lensProp('sections'), R.append(dim.id))(acc);
+  }, layoutWithCombs, dimensions);
+};

package/package.json

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

package/src/rules2/src/index.js

@@ -45,3 +45,4 @@ export { getTableProps } from './table/getTableProps';
 export { getTableLabelAccessor } from './table/getTableLabelAccessor';
 export { parseValueHierarchy } from './table/parseValueHierarchy';
 export { parseLayoutIndexesHierarchies } from './table/parseSeriesIndexesHierarchies';
+export { getTableLayoutIds, injectCombinationsInLayout } from './table/getTableLayoutIds';

package/src/rules2/src/table/getLayout.js

@@ -1,72 +1,84 @@
 import * as R from 'ramda';
 import { isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
-import { trimedProps } from '../utils';
 
-export const getLayout = (layoutIds, dimensions, combinations, isTimeInverted) => {
-    const indexedDimensions = R.pipe(
-      R.indexBy(R.prop('id')),
-      R.map(d => (isTimePeriodDimension(d) && isTimeInverted ? R.assoc('isInverted', true, d) : d)),
-    )(dimensions);
-    const indexedHeaderIds = R.indexBy(R.identity, layoutIds.header);
-    const indexedSectionsIds = R.indexBy(R.identity, layoutIds.sections);
-    const indexedRowsIds = { ...indexedSectionsIds, ...R.indexBy(R.identity, layoutIds.rows) };
-    let layout = { header: [], sections: [], rows: [] };
-    R.forEach(comb => {
-      if (R.isEmpty(comb.relationship)) {
-        return;
-      }
-      const [idsInHeader, rest] = R.partition(id => R.has(id, indexedHeaderIds), comb.relationship);
-      if (R.isEmpty(rest)) {
-        layout = R.over(
-          R.lensProp('header'),
-          R.append({
-            ...comb,
-            dimensions: trimedProps(comb.concepts, indexedDimensions),
-          }),
-        )(layout);
-      } else if (!R.isEmpty(idsInHeader)) {
-        return;
-      } else {
-        const idsNotInSections = R.reject(id => R.has(id, indexedSectionsIds), comb.relationship);
-        if (R.isEmpty(idsNotInSections)) {
-          layout = R.over(
-            R.lensProp('sections'),
-            R.append({
-              ...comb,
-              dimensions: trimedProps(comb.concepts, indexedDimensions),
-            }),
-          )(layout);
-        } else {
-          const idsNotInRows = R.reject(id => R.has(id, indexedRowsIds), comb.relationship);
-          if (R.isEmpty(idsNotInRows)) {
-            layout = R.over(
-              R.lensProp('rows'),
-              R.append({
-                ...comb,
-                dimensions: R.pipe(R.omit(layoutIds.sections), o => trimedProps(comb.concepts, o))(
-                  indexedDimensions,
-                ),
-              }),
-            )(layout);
-          }
+export const getConceptsSet = (ids, indexedCombinations, _upper) => {
+  const upper = R.isNil(_upper) ? new Set([]) : _upper;
+  const res = new Set([]);
+  R.forEach(id => {
+    if (!R.has(id, indexedCombinations)) {
+      res.add(id);
+    }
+    else {
+      const comb = R.prop(id, indexedCombinations);
+      R.forEach(c => {
+        if (!upper.has(c)) {
+          res.add(c);
         }
-      }
-    }, combinations);
-    return R.mapObjIndexed((combs, key) => {
-      const conceptIds = R.pipe(R.pluck('concepts'), R.unnest, R.indexBy(R.identity))(combs);
-      const rest = R.reduce(
-        (acc, id) => {
-          if (R.has(id, conceptIds)) {
-            return acc;
-          }
-          if (!R.has(id, indexedDimensions)) {
-            return acc;
-          }
-          return R.append(R.prop(id, indexedDimensions), acc);
-        },
-        [],
-        layoutIds[key],
-      );
-      return R.concat(rest, combs);
-    }, layout);
-  };
+      }, comb.concepts);
+    }
+  }, ids);
+  return res;
+};
+
+export const parseCombination = (_upperIds, _excludedIds) => (comb, indexedDimensions) => {
+  const upperIds = R.isNil(_upperIds) ? new Set([]) : _upperIds;
+  const excludedIds = R.isNil(_excludedIds) ? new Set([]) : _excludedIds;
+
+  const { concepts, relationship } = comb;
+  const dimensions = R.reduce((acc, id) => {
+    if (upperIds.has(id) || !R.has(id, indexedDimensions)) {
+      return acc
+    }
+    const dim = R.prop(id, indexedDimensions);
+    return R.append(dim, acc);
+  }, [], concepts);
+  const excludedDep = R.find(i => excludedIds.has(i), relationship);
+  if (excludedDep) {
+    return dimensions;
+  }
+  return R.assoc('dimensions', dimensions, comb);
+};
+
+export const getLayout = (_layoutIds, dimensions, combinations, isTimeInverted) => {
+  const layoutIds = R.mergeRight(
+    { header: [], sections: [], rows: [] },
+    _layoutIds,
+  );
+  const applyInversionOnTimeDim = dim =>
+    isTimePeriodDimension(dim) && isTimeInverted
+      ? R.assoc('isInverted', true, dim)
+      : dim;
+
+  const indexedDimensions = R.reduce(
+    (acc, dim) => R.assoc(dim.id, applyInversionOnTimeDim(dim), acc),
+    {},
+    dimensions,
+  );
+  
+  const indexedCombinations = R.indexBy(R.prop('id'), combinations);
+  const headerConceptsSet = getConceptsSet(layoutIds.header, indexedCombinations);
+  const sectionsConceptsSet = getConceptsSet(layoutIds.sections, indexedCombinations);
+  const rowsConceptsSet = getConceptsSet(R.concat(layoutIds.sections, layoutIds.rows), indexedCombinations);
+
+  const getLayoutLevel = (_upperIds, _excludedIds) => ids => R.reduce((acc, id) => {
+    if (R.has(id, indexedDimensions)) {
+      const dim = R.prop(id, indexedDimensions);
+      return R.append(dim, acc);
+    }
+    if (!R.has(id, indexedCombinations)) {
+      return acc;
+    }
+    const comb = R.prop(id, indexedCombinations);
+    const parsedCombination = parseCombination(_upperIds, _excludedIds)(comb, indexedDimensions);
+    if (R.is(Array, parsedCombination)) {
+      return R.concat(acc, parsedCombination);
+    }
+    return R.append(parsedCombination, acc);
+  }, [], ids);
+  
+  const header = getLayoutLevel(null, rowsConceptsSet)(layoutIds.header);
+  const sections = getLayoutLevel(null, headerConceptsSet)(layoutIds.sections);
+  const rows = getLayoutLevel(sectionsConceptsSet, headerConceptsSet)(layoutIds.rows);
+
+  return ({ header, sections, rows });
+};

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

@@ -0,0 +1,186 @@
+import * as R from 'ramda';
+import { isTimePeriodDimension, isRefAreaDimension } from '@sis-cc/dotstatsuite-sdmxjs';
+
+export const getCombinationsNotInLayout = (combinations, layoutIds) => {
+  const { header=[], sections=[], rows=[] } = layoutIds;
+  const idsInLayout = new Set([...header, ...sections, ...rows]);
+  return R.reject(comb => idsInLayout.has(comb.id), combinations);
+};
+
+export const indexCombsRelationships = (combinations) => R.reduce((acc, comb) => {
+  const { id, relationship=[] } = comb;
+  return R.assoc(id, relationship, acc);
+}, {}, combinations);
+
+export const getLayoutLevelRelationship = indexedRelationships => ids => R.reduce((acc, id) => {
+  if (R.has(id, indexedRelationships)) {
+    return R.concat(acc, R.prop(id, indexedRelationships));
+  }
+  return R.append(id, acc);
+}, [], ids);
+
+export const getLayoutRelationships = (indexedRelationships, layoutIds) => R.map(
+  getLayoutLevelRelationship(indexedRelationships),
+  layoutIds
+);
+
+export const injectCombination = combination => ids => {
+  const { id, concepts=[] } = combination;
+  const conceptsSet = new Set(concepts);
+  let inject = true;
+  const refined = R.reduce((acc, i) => {
+    if (!conceptsSet.has(i)) {
+      return R.append(i, acc);
+    }
+    if (inject) {
+      inject = false;
+      return R.append(id, acc);
+    }
+    return acc;
+  }, [], ids);
+  return inject ? R.append(id, refined) : refined;
+};
+
+export const injectCombinationsInLayout = (combinations, layoutIds) => {
+  const notInLayoutCombs = getCombinationsNotInLayout(combinations, layoutIds);
+  if (R.isEmpty(notInLayoutCombs)) {
+    return layoutIds;
+  }
+  const indexedCombsRelationships = indexCombsRelationships(combinations);
+  let layoutRelationships = getLayoutRelationships(indexedCombsRelationships, layoutIds);
+  return R.reduce((acc, comb) => {
+    const { relationship=[] } = comb;
+    const idsInHeaderSet = new Set(layoutRelationships.header);
+    const idsInSectionsSet = new Set(layoutRelationships.sections);
+    const idsInRowsSet = new Set(layoutRelationships.rows);
+    const [idsInHeader, rest] = R.partition(
+      i => idsInHeaderSet.has(i),
+      relationship
+    );
+    const [idsInSections, idsInRows, nowhere] = R.reduce((_acc, id) => {
+      if (idsInSectionsSet.has(id))
+        return R.over(R.lensIndex(0), R.append(id), _acc);
+      if (idsInRowsSet.has(id))
+        return R.over(R.lensIndex(1), R.append(id), _acc);
+      return R.over(R.lensIndex(2), R.append(id), _acc);
+    }, [[], [], []], rest);
+    if (!R.isEmpty(idsInHeader) && R.isEmpty(idsInSections) && R.isEmpty(idsInRows)) {
+      layoutRelationships.header = R.concat(layoutRelationships.header, relationship);
+      const ids = injectCombination(comb)(acc.header);
+      return R.assoc('header', ids)(acc);
+    }
+    if (!R.isEmpty(idsInHeader)) {
+      return acc;
+    }
+    if (!R.isEmpty(idsInSections) && R.isEmpty(idsInRows)) {
+      layoutRelationships.sections = R.concat(layoutRelationships.sections, relationship);
+      const ids = injectCombination(comb)(acc.sections);
+      return R.assoc('sections', ids)(acc);
+    }
+    const rowsConcepts = R.concat(idsInRows, nowhere);
+    layoutRelationships.rows = R.concat(layoutRelationships.rows, rowsConcepts);
+    const ids = injectCombination({ ...comb, concepts: rowsConcepts })(acc.rows);
+    return R.assoc('rows', ids)(acc);
+  }, layoutIds, notInLayoutCombs);
+};
+
+export const getLayoutDimsIds = dimensions => R.reduce(
+  (acc, d) => (d.header ? acc : acc.add(d.id)),
+  new Set([]),
+  dimensions,
+);
+
+export const getLayoutCombinations = (combinations, layoutDimsIds, attributes) => {
+  const indexedAttributes = R.indexBy(R.prop('id'), attributes);
+  return R.reduce(
+    (acc, comb) => {
+      const { layoutConcepts, relationship } = R.reduce(
+        (_acc, concept) => {
+          if (layoutDimsIds.has(concept)) {
+            return R.map(R.append(concept), _acc);
+          }
+          if (R.has(concept, indexedAttributes)) {
+            const attr = R.prop(concept, indexedAttributes);
+            return attr.series
+              ? {
+                  ..._acc,
+                  relationship: R.concat(_acc.relationship, attr.relationship),
+                }
+              : _acc;
+          }
+          return _acc;
+        },
+        { layoutConcepts: [], relationship: [] },
+        comb.concepts || [],
+      );
+      if (R.isEmpty(layoutConcepts)) {
+        return acc;
+      }
+      return R.append({ ...comb, relationship, concepts: layoutConcepts }, acc);
+    },
+    [],
+    combinations,
+  );
+};
+
+export const getTableLayoutIds = (
+  defaultLayoutIds,
+  dimensions,
+  attributes,
+  combinations
+) => {
+  const layoutDimsIds = getLayoutDimsIds(dimensions);
+  const layoutCombinations = getLayoutCombinations(
+    combinations,
+    layoutDimsIds,
+    attributes,
+  );
+  const indexedCombinations = R.indexBy(R.prop('id'), layoutCombinations);
+  const filteredLayoutIds = R.map(
+    R.filter(id => R.has(id, indexedCombinations) || layoutDimsIds.has(id)),
+    defaultLayoutIds,
+  );
+
+  const layoutWithCombs = injectCombinationsInLayout(layoutCombinations, filteredLayoutIds);
+  const layoutRelationshipsSets = R.map(ids => R.pipe(
+    R.pick(ids, indexedCombsRelationships),
+    R.values,
+    R.unnest,
+    i => new Set(i)
+  )(ids),layoutWithCombs);
+  const layoutConceptsSets = R.pipe(
+    R.map(
+      R.reduce((acc, id) => {
+        if (R.has(id, indexedCombinations)) {
+          return R.concat(acc, R.path([id, 'relationship'], indexedCombinations));
+        }
+        return R.append(id, acc);
+      }, []),
+    ),
+    R.values,
+    R.unnest,
+    ids => new Set(ids)
+  )(layoutWithCombs);
+
+  return R.reduce((acc, dim) => {
+    if (layoutConceptsSets.has(id) || !dim.series) {
+      return acc;
+    }
+    if (layoutRelationshipsSets.header.has(dim.id)) {
+      return R.over(R.lensProp('header'), R.append(dim.id))(acc);
+    }
+    if (layoutRelationshipsSets.sections.has(dim.id)) {
+      return R.over(R.lensProp('sections'), R.append(dim.id))(acc);
+    }
+    if (layoutRelationshipsSets.rows.has(dim.id)) {
+      return R.over(R.lensProp('rows'), R.append(dim.id))(acc);
+    }
+    if (isTimePeriodDimension(dim)) {
+      return R.over(R.lensProp('header'), R.append(dim.id))(acc);
+    }
+    if (isRefAreaDimension(dim)) {
+      return R.over(R.lensProp('rows'), R.append(dim.id))(acc);
+    }
+    return R.over(R.lensProp('sections'), R.append(dim.id))(acc);
+  }, layoutWithCombs, dimensions);
+};

package/test/getLayout.test.js

@@ -9,32 +9,44 @@ describe('getLayout tests', () => {
       { id: 'D2', values: [{ id: 'v1' }, { id: 'v2' }] },
       { id: 'D3', values: [{ id: 'v1' }, { id: 'v2' }] },
       { id: 'D4', values: [{ id: 'v1' }, { id: 'v2' }] },
+      { id: 'D5', values: [{ id: 'v1' }, { id: 'v2' }] },
       { id: 'TIME_PERIOD', values: [{ id: 'v1' }, { id: 'v2' }] }
     ];
 
     const layoutIds = {
-      header: ['TIME_PERIOD'],
-      sections: ['D1'],
-      rows: ['D4', 'D2', 'D3']
+      header: ['TIME_PERIOD', 'COMB1', 'COMB2'],
+      sections: ['D4'],
+      rows: ['COMB3', 'COMB4']
     };
 
     const combinations = [
-       { id: 'COMB1', concepts: ['D2', 'D3'], relationship: [] }, // rejected for empty relationship
-       { id: 'COMB2', concepts: ['D3', 'D4', 'A1'], relationship: ['D3', 'D4', 'TIME_PERIOD'] }, // rejected because relationship is incompatible with layout
-       { id: 'COMB3', concepts: ['D1', 'D2', 'A2', 'D5'], relationship: ['D1', 'D2', 'D3'] },
+       { id: 'COMB1', concepts: ['D1', 'D2'], relationship: ['D1', 'D2'] },
+       { id: 'COMB2', concepts: ['D3', 'A1'], relationship: ['D3', 'D4', 'TIME_PERIOD'] },
+       { id: 'COMB3', concepts: ['D4', 'D5'], relationship: ['D4', 'D5'] },
+       { id: 'COMB4', concepts: ['A2', 'A3'], relationship: ['D5', 'TIME_PERIOD'] }
     ];
 
     expect(getLayout(layoutIds, dimensions, combinations, isTimeInverted)).to.deep.equal({
-      header: [{ id: 'TIME_PERIOD', isInverted: true, values: [{ id: 'v1' }, { id: 'v2' }] }],
-      sections: [{ id: 'D1', values: [{ id: 'v1' }, { id: 'v2' }] }],
-      rows: [
-        { id: 'D4', values: [{ id: 'v1' }, { id: 'v2' }] },
+      header: [
+        { id: 'TIME_PERIOD', isInverted: true, values: [{ id: 'v1' }, { id: 'v2' }] },
+        {
+          id: 'COMB1',
+          concepts: ['D1', 'D2'],
+          relationship: ['D1', 'D2'],
+          dimensions: [
+            { id: 'D1', values: [{ id: 'v1' }, { id: 'v2' }] },
+            { id: 'D2', values: [{ id: 'v1' }, { id: 'v2' }] },
+          ]
+        },
         { id: 'D3', values: [{ id: 'v1' }, { id: 'v2' }] },
+      ],
+      sections: [{ id: 'D4', values: [{ id: 'v1' }, { id: 'v2' }] }],
+      rows: [
         {
           id: 'COMB3',
-          concepts: ['D1', 'D2', 'A2', 'D5'],
-          relationship: ['D1', 'D2', 'D3'],
-          dimensions: [{ id: 'D2', values: [{ id: 'v1' }, { id: 'v2' }] }] // D1 kept at section level
+          concepts: ['D4', 'D5'],
+          relationship: ['D4', 'D5'],
+          dimensions: [{ id: 'D5', values: [{ id: 'v1' }, { id: 'v2' }] }]
         },
       ]
     })

package/test/getTableLayoutIds.test.js

@@ -0,0 +1,31 @@
+import { expect } from 'chai';
+import { injectCombinationsInLayout } from '../src/rules2/src/table/getTableLayoutIds';
+
+describe('injectCombinationsInLayout', () => {
+  it('complete test', () => {
+    const layoutIds = {
+      header: ['D1', 'C1', 'D2'],
+      sections: ['C5', 'D5', 'D3'],
+      rows: ['D4']
+    };
+
+    const combinations = [
+      { id: 'C1', concepts: ['D0', 'A2'], relationship: ['D0'] }, // already in header
+      { id: 'C2', concepts: ['D1', 'D2', 'A1'], relationship: ['D1', 'D2', 'D0'] }, // concepts are in header and relate to one of C1 concepts
+      { id: 'C3', concepts: ['D1', 'D2', 'D3'], relationship: ['D1', 'D2', 'D3'] }, // concepts both in header & sections -> rejected
+      { id: 'C4', concepts: ['D1', 'D2', 'D4'], relationship: ['D1', 'D2', 'D4'] }, // concepts both in header & rows -> rejected
+      { id: 'C5', concepts: ['D6', 'D7'], relationship: ['D6', 'D7', 'D5'] }, // already in sections
+      { id: 'C6', concepts: ['D3', 'D5'], relationship: ['D3', 'D5', 'D7'] }, // concepts in sections and relate to one C5 concept
+      { id: 'C7', concepts: ['D3', 'D8'], relationship: ['D3', 'D8'] }, // partial concepts in sections, none in rows
+      { id: 'C8', concepts: ['A1', 'A2', 'D9'], relationship: ['D0', 'D9'] }, // partial concepts in header nothing elsewhere
+      { id: 'C9', concepts: ['A3', 'D10', 'D11', 'D12'], relationship: ['D10', 'D11', 'D12'] }, // all new concepts
+      { id: 'C10', concepts: ['D10', 'D8'], relationship: ['D10', 'D8'] }, // relates to one concept of C7 and to one of C9
+    ];
+
+    expect(injectCombinationsInLayout(combinations, layoutIds)).to.deep.equal({
+      header: ['C2', 'C1', 'C8'],
+      sections: ['C5', 'C6', 'C7'],
+      rows: ['D4', 'C9', 'C10']
+    });
+  });
+});