@sis-cc/dotstatsuite-components 17.22.0 → 17.24.0

package/lib/rules/src/get-values-enhanced.js

@@ -65,8 +65,6 @@ var getValuesEnhanced = exports.getValuesEnhanced = function getValuesEnhanced(_
       _ref2$parent = _ref2.parent,
       parent = _ref2$parent === undefined ? '' : _ref2$parent,
       reportYearStart = _ref2.reportYearStart,
-      _ref2$_hiddenIds = _ref2._hiddenIds,
-      _hiddenIds = _ref2$_hiddenIds === undefined ? {} : _ref2$_hiddenIds,
       _ref2$hiddenIds = _ref2.hiddenIds,
       hiddenIds = _ref2$hiddenIds === undefined ? {} : _ref2$hiddenIds,
       _ref2$options = _ref2.options,
@@ -77,7 +75,7 @@ var getValuesEnhanced = exports.getValuesEnhanced = function getValuesEnhanced(_
 
     var valueAnnotations = R.pipe(R.propOr([], 'annotations'), R.flip(R.props)(annotations))(value);
 
-    var isHidden = _hiddenIds[parent] && R.includes(value.id, _hiddenIds[parent]) || R.has(parent + '.' + value.id, hiddenIds) || (0, _sdmxData.getIsHidden)(valueAnnotations);
+    var isHidden = R.has(parent + '.' + id, hiddenIds) || (0, _sdmxData.getIsHidden)(valueAnnotations);
 
     var _ref3 = isTimeDimension ? getTimePeriodAttributes({ reportYearStart: reportYearStart, options: options })(value) : { notes: [] },
         start = _ref3.start,

package/lib/rules/src/v8-transformer.js

@@ -31,8 +31,7 @@ var TIME_PERIOD_ID = 'TIME_PERIOD';
 
 var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew) {
   var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var locale = options.locale,
-      _hiddenIds = options.hiddenIds;
+  var locale = options.locale;
 
   var reportYearStart = (0, _getReportingYearStart.getReportingYearStart)(dataNew);
   var getName = R.prop('name');
@@ -46,7 +45,25 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
 
   var dataSetsAnnotations = R.props(R.pathOr([], [0, 'annotations'], dataSets), annotations);
 
-  var hiddenIds = (0, _src.getNotDisplayedIds)(dataSetsAnnotations);
+  /*
+    hiddenValues => codelistIds or codelistValuesIds for display computation
+    hiddenCombinations => used only for dimensions, if dimension values match the provided set, all dimension is removed
+  */
+
+  var _getNotDisplayedIds = (0, _src.getNotDisplayedIds)(dataSetsAnnotations),
+      hiddenValues = _getNotDisplayedIds.hiddenValues,
+      hiddenCombinations = _getNotDisplayedIds.hiddenCombinations;
+
+  var getIsAllDimHidden = function getIsAllDimHidden(_ref) {
+    var id = _ref.id,
+        values = _ref.values;
+
+    if (!R.has(id, hiddenCombinations)) {
+      return false;
+    }
+    var valuesIds = R.pluck('id', values);
+    return R.isEmpty(R.difference(valuesIds), hiddenCombinations[id]);
+  };
 
   //--------------------------------------------------------------------------------------------Header
   var getMeta = R.propOr({}, 'meta');
@@ -70,15 +87,14 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
     var obsAnnotations = R.props(observation.annotations || [], annotations);
     return (0, _extends3.default)({}, observation, {
       __index: index,
-      display: !R.has(observation.id, hiddenIds) && !(0, _sdmxData.getIsHidden)(obsAnnotations),
+      display: !R.has(observation.id, hiddenValues) && !(0, _sdmxData.getIsHidden)(obsAnnotations),
       name: getName(observation),
       values: (0, _getValuesEnhanced.getValuesEnhanced)({
         locale: locale,
         annotations: annotations,
         parent: observation.id,
         reportYearStart: reportYearStart,
-        _hiddenIds: _hiddenIds,
-        hiddenIds: hiddenIds,
+        hiddenIds: hiddenValues,
         options: options
       })(R.propOr([], 'values', observation)),
       roles: !R.isNil(observation.role) ? R.head(observation.role) : null
@@ -88,14 +104,13 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
   var datasetAttributes = R.map(function (attr) {
     var attrAnnotations = R.props(attr.annotations || [], annotations);
     return (0, _extends3.default)({}, attr, {
-      display: !R.has(attr.id, hiddenIds) && !(0, _sdmxData.getIsHidden)(attrAnnotations),
+      display: !R.has(attr.id, hiddenValues) && !(0, _sdmxData.getIsHidden)(attrAnnotations),
       name: getName(attr),
       values: (0, _getValuesEnhanced.getValuesEnhanced)({
         locale: locale,
         annotations: annotations,
         parent: attr.id,
-        _hiddenIds: _hiddenIds,
-        hiddenIds: hiddenIds,
+        hiddenIds: hiddenValues,
         options: options,
         reportYearStart: reportYearStart
       })(R.propOr([], 'values', attr))
@@ -124,18 +139,17 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
         isTimeDimension: isTimeDimension,
         reportYearStart: reportYearStart,
         parent: id,
-        _hiddenIds: _hiddenIds,
-        hiddenIds: hiddenIds,
+        hiddenIds: hiddenValues,
         options: options
       })(R.propOr([], 'values', observation));
-      var _idHidden = _hiddenIds[id] && R.isEmpty(R.difference(R.pluck('id')(values), _hiddenIds[id]));
-      var isHidden = _idHidden || R.has(id, hiddenIds) || (0, _sdmxData.getIsHidden)(dimAnnotations);
+      var isAllDimHidden = getIsAllDimHidden({ id: id, values: values });
+      var isHidden = isAllDimHidden || R.has(id, hiddenValues) || (0, _sdmxData.getIsHidden)(dimAnnotations);
       return {
         observation: R.append((0, _extends3.default)({}, observation, {
           display: !isHidden,
           __index: obsIndex,
           name: getName(observation),
-          values: _idHidden ? [] : values,
+          values: isAllDimHidden ? [] : values,
           role: isTimeDimension ? TIME_PERIOD_ID : R.head(R.propOr([], 'roles', observation))
         }))(acc.observation),
         dimensionsLayout: (0, _sdmxData.setAnnotationsLayout)(id, acc.dimensionsLayout)(dimAnnotations)

package/lib/rules2/src/getNotDisplayedIds.js

@@ -9,38 +9,50 @@ 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; } }
 
-var getNotDisplayedIds = exports.getNotDisplayedIds = function getNotDisplayedIds(annotations) {
-  return R.pipe(R.find(R.propEq('type', 'NOT_DISPLAYED')), function (annot) {
-    if (R.isNil(annot)) {
-      return {};
+var getNotDisplayedValues = function getNotDisplayedValues(annot) {
+  if (R.isNil(annot)) {
+    return {};
+  }
+  var ids = R.split(',', annot.title || '');
+  return R.reduce(function (acc, entry) {
+    if (R.isEmpty(entry)) {
+      return acc;
     }
-    var ids = R.split(',', annot.title || '');
-    return R.reduce(function (acc, entry) {
-      if (R.isEmpty(entry)) {
-        return acc;
-      }
-      var parsed = R.split('=', entry);
-      var dimensionId = parsed[0];
-      if (R.length(parsed) === 1) {
-        return R.assoc(dimensionId, dimensionId, acc);
+    var parsed = R.split('=', entry);
+    var dimensionId = parsed[0];
+    if (R.length(parsed) === 1) {
+      return R.assoc(dimensionId, dimensionId, acc);
+    }
+    var values = R.split('+', parsed[1]);
+    if (R.length(values) === 1 && R.isEmpty(values[0])) {
+      return R.assoc(dimensionId, dimensionId, acc);
+    }
+    return R.reduce(function (_acc, val) {
+      var _val = val;
+      if (R.isEmpty(val)) {
+        return _acc;
       }
-      var values = R.split('+', parsed[1]);
-      if (R.length(values) === 1 && R.isEmpty(values[0])) {
-        return R.assoc(dimensionId, dimensionId, acc);
+      if (R.test('/[()]/')) {
+        _val = R.replace(/[()]/g, '')(val);
       }
-      return R.reduce(function (_acc, val) {
-        var _val = val;
-        if (R.isEmpty(val)) {
-          return _acc;
-        }
-        if (R.test('/[()]/')) {
-          _val = R.replace(/[()]/g, '')(val);
-        }
-        var key = R.isEmpty(_val) ? dimensionId : dimensionId + '.' + _val;
-        return R.assoc(key, key, _acc);
-      }, acc, values);
-    }, {}, ids);
-  })(annotations);
+      var key = R.isEmpty(_val) ? dimensionId : dimensionId + '.' + _val;
+      return R.assoc(key, key, _acc);
+    }, acc, values);
+  }, {}, ids);
+};
+
+var getNotDisplayedIds = exports.getNotDisplayedIds = function getNotDisplayedIds(annotations) {
+  return R.pipe(R.find(R.propEq('type', 'NOT_DISPLAYED')), R.converge(function (hiddenValues, hiddenCombinations) {
+    return {
+      hiddenValues: hiddenValues,
+      hiddenCombinations: hiddenCombinations
+    };
+  }, [getNotDisplayedValues, function () {
+    var annot = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { title: '' };
+    return (0, _dotstatsuiteSdmxjs.getNotDisplayedCombinations)(annot);
+  }]))(annotations);
 };

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

@@ -168,7 +168,7 @@ var getLayoutCombinations = exports.getLayoutCombinations = function getLayoutCo
         layoutConcepts = _R$reduce3.layoutConcepts,
         relationship = _R$reduce3.relationship;
 
-    if (R.isEmpty(layoutConcepts)) {
+    if (R.isEmpty(relationship)) {
       return acc;
     }
     return R.append((0, _extends3.default)({}, comb, { relationship: relationship, concepts: layoutConcepts }), acc);
@@ -182,41 +182,59 @@ var getTableLayoutIds = exports.getTableLayoutIds = function getTableLayoutIds(d
   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 layoutRelationshipsSets = R.map(R.pipe(function (ids) {
+    return R.pick(ids, indexedCombinations);
+  }, R.values, R.pluck('relationship'), R.unnest, function (i) {
+    return new _set2.default(i);
+  }), 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.concat(acc, R.path([id, 'concepts'], 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) {
+  var _R$reduce4 = R.reduce(function (acc, dim) {
+    if (layoutConceptsSets.has(dim.id) || dim.header) {
       return acc;
     }
     if (layoutRelationshipsSets.header.has(dim.id)) {
-      return R.over(R.lensProp('header'), R.append(dim.id))(acc);
+      return R.over(R.lensPath(['nextLayout', 'header']), R.append(dim.id))(acc);
     }
     if (layoutRelationshipsSets.sections.has(dim.id)) {
-      return R.over(R.lensProp('sections'), R.append(dim.id))(acc);
+      return R.over(R.lensPath(['nextLayout', 'sections']), R.append(dim.id))(acc);
     }
     if (layoutRelationshipsSets.rows.has(dim.id)) {
-      return R.over(R.lensProp('rows'), R.append(dim.id))(acc);
+      return R.over(R.lensPath(['nextLayout', 'rows']), R.append(dim.id))(acc);
     }
     if ((0, _dotstatsuiteSdmxjs.isTimePeriodDimension)(dim)) {
-      return R.over(R.lensProp('header'), R.append(dim.id))(acc);
+      return R.over(R.lensPath(['nextLayout', '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.lensPath(['nextLayout', 'rows']), R.append(dim.id))(acc);
     }
-    return R.over(R.lensProp('sections'), R.append(dim.id))(acc);
-  }, layoutWithCombs, dimensions);
+    return R.over(R.lensProp('remaining'), R.append(dim.id))(acc);
+  }, { nextLayout: layoutWithCombs, remaining: [] }, dimensions),
+      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);
 };

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

@@ -269,6 +269,9 @@ var refineLayoutSize = exports.refineLayoutSize = function refineLayoutSize(_ref
 
     var cutLength = R.pipe(R.ifElse(R.identity, R.always(rowCellsCount), R.always(columnCellsCount)), R.divide(excess), Math.ceil)(isVertical);
 
+    var maxCutLength = isVertical ? rowsCount - 2 : headerValuesCount - 1;
+    cutLength = cutLength > maxCutLength ? maxCutLength : cutLength;
+
     var _truncateLayout = truncateLayout(isVertical)(cutLength, toTruncate),
         truncated = _truncateLayout.truncated,
         extractedKeys = _truncateLayout.extractedKeys;

package/package.json

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

package/src/rules/src/get-values-enhanced.js

@@ -40,7 +40,6 @@ export const getValuesEnhanced = ({
   isTimeDimension = false,
   parent = '',
   reportYearStart,
-  _hiddenIds = {},
   hiddenIds = {},
   options = {},
 }) => {
@@ -53,9 +52,7 @@ export const getValuesEnhanced = ({
         R.flip(R.props)(annotations),
       )(value);
 
-      const isHidden =
-        (_hiddenIds[parent] && R.includes(value.id, _hiddenIds[parent])) ||
-        R.has(`${parent}.${value.id}`, hiddenIds) ||
+      const isHidden = R.has(`${parent}.${id}`, hiddenIds) ||
         getIsHidden(valueAnnotations);
 
       const { start, notes } = isTimeDimension

package/src/rules/src/v8-transformer.js

@@ -14,7 +14,7 @@ import { getValuesEnhanced } from './get-values-enhanced';
 const TIME_PERIOD_ID = 'TIME_PERIOD';
 
 export const dataTransformer = (dataNew, options = {}) => {
-  const { locale, hiddenIds: _hiddenIds } = options;
+  const { locale } = options;
   const reportYearStart = getReportingYearStart(dataNew);
   const getName = R.prop('name')
   //---------------------------------------------------------------------------------------Annotations
@@ -30,7 +30,18 @@ export const dataTransformer = (dataNew, options = {}) => {
     annotations,
   );
 
-  const hiddenIds = getNotDisplayedIds(dataSetsAnnotations);
+  /*
+    hiddenValues => codelistIds or codelistValuesIds for display computation
+    hiddenCombinations => used only for dimensions, if dimension values match the provided set, all dimension is removed
+  */
+  const { hiddenValues, hiddenCombinations } = getNotDisplayedIds(dataSetsAnnotations);
+  const getIsAllDimHidden = ({ id, values }) => {
+    if (!R.has(id, hiddenCombinations)) {
+      return false;
+    }
+    const valuesIds = R.pluck('id', values);
+    return R.isEmpty(R.difference(valuesIds), hiddenCombinations[id]);
+  }
 
   //--------------------------------------------------------------------------------------------Header
   const getMeta = R.propOr({}, 'meta');
@@ -57,15 +68,14 @@ export const dataTransformer = (dataNew, options = {}) => {
       ...observation,
       __index: index,
       display:
-        !R.has(observation.id, hiddenIds) && !getIsHidden(obsAnnotations),
+        !R.has(observation.id, hiddenValues) && !getIsHidden(obsAnnotations),
       name: getName(observation),
       values: getValuesEnhanced({
         locale,
         annotations,
         parent: observation.id,
         reportYearStart,
-        _hiddenIds,
-        hiddenIds,
+        hiddenIds: hiddenValues,
         options,
       })(R.propOr([], 'values', observation)),
       roles: !R.isNil(observation.role) ? R.head(observation.role) : null,
@@ -76,14 +86,13 @@ export const dataTransformer = (dataNew, options = {}) => {
     const attrAnnotations = R.props(attr.annotations || [], annotations);
     return {
       ...attr,
-      display: !R.has(attr.id, hiddenIds) && !getIsHidden(attrAnnotations),
+      display: !R.has(attr.id, hiddenValues) && !getIsHidden(attrAnnotations),
       name: getName(attr),
       values: getValuesEnhanced({
         locale,
         annotations,
         parent: attr.id,
-        _hiddenIds,
-        hiddenIds,
+        hiddenIds: hiddenValues,
         options,
         reportYearStart,
       })(R.propOr([], 'values', attr)),
@@ -116,22 +125,19 @@ export const dataTransformer = (dataNew, options = {}) => {
           isTimeDimension,
           reportYearStart,
           parent: id,
-          _hiddenIds,
-          hiddenIds,
+          hiddenIds: hiddenValues,
           options,
         })(R.propOr([], 'values', observation));
-        const _idHidden =
-          _hiddenIds[id] &&
-          R.isEmpty(R.difference(R.pluck('id')(values), _hiddenIds[id]));
-        const isHidden =
-          _idHidden || R.has(id, hiddenIds) || getIsHidden(dimAnnotations);
+        const isAllDimHidden = getIsAllDimHidden({ id, values });
+        const isHidden = isAllDimHidden || R.has(id, hiddenValues)
+          || getIsHidden(dimAnnotations);
         return {
           observation: R.append({
             ...observation,
             display: !isHidden,
             __index: obsIndex,
             name: getName(observation),
-            values: _idHidden ? [] : values,
+            values: isAllDimHidden ? [] : values,
             role: isTimeDimension
               ? TIME_PERIOD_ID
               : R.head(R.propOr([], 'roles', observation)),

package/src/rules2/src/getNotDisplayedIds.js

@@ -1,44 +1,53 @@
 import * as R from 'ramda';
+import { getNotDisplayedCombinations } from '@sis-cc/dotstatsuite-sdmxjs';
+
+const getNotDisplayedValues = annot => {
+  if (R.isNil(annot)) {
+    return {};
+  }
+  const ids = R.split(',', annot.title || '');
+  return R.reduce(
+    (acc, entry) => {
+      if (R.isEmpty(entry)) {
+        return acc;
+      }
+      const parsed = R.split('=', entry);
+      const dimensionId = parsed[0];
+      if (R.length(parsed) === 1) {
+        return R.assoc(dimensionId, dimensionId, acc);
+      }
+      const values = R.split('+', parsed[1]);
+      if (R.length(values) === 1 && R.isEmpty(values[0])) {
+        return R.assoc(dimensionId, dimensionId, acc);
+      }
+      return R.reduce(
+        (_acc, val) => {
+          let _val = val
+          if (R.isEmpty(val)) {
+            return _acc;
+          }
+          if (R.test('/[()]/')) {
+            _val = R.replace(/[()]/g, '')(val)
+          }
+          const key = R.isEmpty(_val) ? dimensionId : `${dimensionId}.${_val}`;
+          return R.assoc(key, key, _acc);
+        },
+        acc,
+        values
+      );
+    },
+    {},
+    ids
+  );
+};
 
 export const getNotDisplayedIds = (annotations) => R.pipe(
   R.find(R.propEq('type', 'NOT_DISPLAYED')),
-  annot => {
-    if (R.isNil(annot)) {
-      return {};
-    }
-    const ids = R.split(',', annot.title || '');
-    return R.reduce(
-      (acc, entry) => {
-        if (R.isEmpty(entry)) {
-          return acc;
-        }
-        const parsed = R.split('=', entry);
-        const dimensionId = parsed[0];
-        if (R.length(parsed) === 1) {
-          return R.assoc(dimensionId, dimensionId, acc);
-        }
-        const values = R.split('+', parsed[1]);
-        if (R.length(values) === 1 && R.isEmpty(values[0])) {
-          return R.assoc(dimensionId, dimensionId, acc);
-        }
-        return R.reduce(
-          (_acc, val) => {
-            let _val = val
-            if (R.isEmpty(val)) {
-              return _acc;
-            }
-            if (R.test('/[()]/')) {
-              _val = R.replace(/[()]/g, '')(val)
-            }
-            const key = R.isEmpty(_val) ? dimensionId : `${dimensionId}.${_val}`;
-            return R.assoc(key, key, _acc);
-          },
-          acc,
-          values
-        );
-      },
-      {},
-      ids
-    );
-  }
+  R.converge((hiddenValues, hiddenCombinations) => ({
+    hiddenValues,
+    hiddenCombinations
+  }), [
+    getNotDisplayedValues,
+    (annot={ title: '' }) => getNotDisplayedCombinations(annot) 
+  ])
 )(annotations);

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

@@ -113,7 +113,7 @@ export const getLayoutCombinations = (combinations, layoutDimsIds, attributes) =
         { layoutConcepts: [], relationship: [] },
         comb.concepts || [],
       );
-      if (R.isEmpty(layoutConcepts)) {
+      if (R.isEmpty(relationship)) {
         return acc;
       }
       return R.append({ ...comb, relationship, concepts: layoutConcepts }, acc);
@@ -140,19 +140,19 @@ export const getTableLayoutIds = (
     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),
+  const layoutRelationshipsSets = R.map(R.pipe(
+    ids => R.pick(ids, indexedCombinations),
     R.values,
+    R.pluck('relationship'),
     R.unnest,
     i => new Set(i)
-  )(ids),layoutWithCombs);
+  ), 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.concat(acc, R.path([id, 'concepts'], indexedCombinations));
         }
         return R.append(id, acc);
       }, []),
@@ -162,25 +162,51 @@ export const getTableLayoutIds = (
     ids => new Set(ids)
   )(layoutWithCombs);
 
-  return R.reduce((acc, dim) => {
-    if (layoutConceptsSets.has(id) || !dim.series) {
+  const { nextLayout, remaining } = R.reduce((acc, dim) => {
+    if (layoutConceptsSets.has(dim.id) || dim.header) {
       return acc;
     }
     if (layoutRelationshipsSets.header.has(dim.id)) {
-      return R.over(R.lensProp('header'), R.append(dim.id))(acc);
+      return R.over(R.lensPath(['nextLayout', 'header']), R.append(dim.id))(acc);
     }
     if (layoutRelationshipsSets.sections.has(dim.id)) {
-      return R.over(R.lensProp('sections'), R.append(dim.id))(acc);
+      return R.over(R.lensPath(['nextLayout', 'sections']), R.append(dim.id))(acc);
     }
     if (layoutRelationshipsSets.rows.has(dim.id)) {
-      return R.over(R.lensProp('rows'), R.append(dim.id))(acc);
+      return R.over(R.lensPath(['nextLayout','rows']), R.append(dim.id))(acc);
     }
     if (isTimePeriodDimension(dim)) {
-      return R.over(R.lensProp('header'), R.append(dim.id))(acc);
+      return R.over(R.lensPath(['nextLayout','header']), R.append(dim.id))(acc);
     }
     if (isRefAreaDimension(dim)) {
-      return R.over(R.lensProp('rows'), R.append(dim.id))(acc);
+      return R.over(R.lensPath(['nextLayout','rows']), R.append(dim.id))(acc);
     }
-    return R.over(R.lensProp('sections'), R.append(dim.id))(acc);
-  }, layoutWithCombs, dimensions);
+    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);
 };

package/src/rules2/src/table/refineLayoutSize2.js

@@ -288,12 +288,15 @@ export const refineLayoutSize = ({ layout, observations, limit }) => layoutIndex
 
   const [toTruncate, toRefine] = segregateLayout(isVertical)(layoutIndexes);
 
-  const cutLength = R.pipe(
+  let cutLength = R.pipe(
     R.ifElse(R.identity, R.always(rowCellsCount), R.always(columnCellsCount)),
     R.divide(excess),
     Math.ceil
   )(isVertical);
 
+  const maxCutLength = isVertical ? rowsCount - 2 : headerValuesCount - 1;
+  cutLength = cutLength > maxCutLength ? maxCutLength : cutLength;
+
   const { truncated, extractedKeys } = truncateLayout(isVertical)(cutLength, toTruncate);
 
   const curatedObs = R.pipe(

package/test/getNotDisplayedIds.test.js

@@ -9,7 +9,7 @@ describe('getNotDisplayedIds tests', () => {
       { type: 'NOT_DISPLAYED', title: '' },
       { type: 'test2' },
     ];
-    expect(getNotDisplayedIds(annotations)).to.deep.equal({});
+    expect(getNotDisplayedIds(annotations)).to.deep.equal({ hiddenValues: {}, hiddenCombinations: {} });
   });
   it('complete case', () => {
     const annotations = [
@@ -19,25 +19,28 @@ describe('getNotDisplayedIds tests', () => {
       { type: 'test2' },
     ];
     const expected = {
-      d0: 'd0',
-      d1: 'd1',
-      'd2.v0': 'd2.v0',
-      'd3.v0': 'd3.v0',
-      'd4.v0': 'd4.v0',
-      'd4.v1': 'd4.v1',
-      'd5.v0': 'd5.v0',
-      'd5.v1': 'd5.v1',
-      'd5.v2': 'd5.v2',
-      'd6.v0': 'd6.v0',
-      'd6.v1': 'd6.v1',
-      'd7.v0': 'd7.v0',
-      'd7.v1': 'd7.v1',
-      'd8.v0': 'd8.v0',
-      'd8.v1': 'd8.v1',
-      d9: 'd9',
-
-
-
+      hiddenValues: {
+        d0: 'd0',
+        d1: 'd1',
+        'd2.v0': 'd2.v0',
+        'd3.v0': 'd3.v0',
+        'd4.v0': 'd4.v0',
+        'd4.v1': 'd4.v1',
+        'd5.v0': 'd5.v0',
+        'd5.v1': 'd5.v1',
+        'd5.v2': 'd5.v2',
+        'd6.v0': 'd6.v0',
+        'd6.v1': 'd6.v1',
+        'd7.v0': 'd7.v0',
+        'd7.v1': 'd7.v1',
+        'd8.v0': 'd8.v0',
+        'd8.v1': 'd8.v1',
+        d9: 'd9',
+      },
+      hiddenCombinations: {
+        d5: ['v0', 'v1'],
+        d6: ['v0', 'v1'],
+      }
     };
     expect(getNotDisplayedIds(annotations)).to.deep.equal(expected);
   });

package/test/getTableLayoutIds.test.js

@@ -1,8 +1,21 @@
 import { expect } from 'chai';
-import { injectCombinationsInLayout } from '../src/rules2/src/table/getTableLayoutIds';
+import { injectCombinationsInLayout, getTableLayoutIds } from '../src/rules2/src/table/getTableLayoutIds';
 
 describe('injectCombinationsInLayout', () => {
-  it('complete test', () => {
+  it('no combinations', () => {
+    const layoutIds = {
+      header: ['D1'],
+      sections: ['D2'],
+      rows: ['D3']
+    };
+    const combinations = [];
+    expect(injectCombinationsInLayout(combinations, layoutIds)).to.deep.equal({
+      header: ['D1'],
+      sections: ['D2'],
+      rows: ['D3']
+    });
+  });
+  it('partial start', () => {
     const layoutIds = {
       header: ['D1', 'C1', 'D2'],
       sections: ['C5', 'D5', 'D3'],
@@ -29,3 +42,72 @@ describe('injectCombinationsInLayout', () => {
     });
   });
 });
+
+describe('getTableLayoutIds tests', () => {
+  it('simple case blank start', () => {
+    const layoutIds = {
+      header: [],
+      sections: [],
+      rows: []
+    };
+    const combinations = [];
+    const attributes = [];
+    const dimensions = [
+      { id: 'REF_AREA' },
+      { id: 'MEASURE' },
+      { id: 'REF_SECTOR' },
+      { id: 'TIME_PERIOD' },
+    ];
+
+    expect(getTableLayoutIds(layoutIds, dimensions, attributes, combinations)).to.deep.equal({
+      header: ['TIME_PERIOD'],
+      sections: ['MEASURE', 'REF_SECTOR'],
+      rows: ['REF_AREA']
+    });
+  });
+  it('blank start with combinations', () => {
+    const layoutIds = {
+      header: [],
+      sections: ['COMB1'],
+      rows: []
+    };
+    const combinations = [
+      {
+        id: 'COMB1',
+        concepts: ['REF_SECTOR', 'MEASURE'],
+      },
+      {
+        id: 'COMB2',
+        concepts: ['UNIT_MEASURE', 'CURRENCY'],
+      },
+      {
+        id: 'COMB3',
+        concepts: ['ATTR1', 'ATTR2'],
+      },
+      {
+        id: 'COMB4',
+        concepts: ['ATTR3', 'ATTR4']
+      }
+    ];
+    const dimensions = [
+      { id: 'REF_AREA' },
+      { id: 'REF_SECTOR' },
+      { id: 'TRANSACTION' },
+      { id: 'MEASURE' },
+      { id: 'UNIT_MEASURE' },
+      { id: 'CURRENCY' }
+    ];
+    const attributes = [
+      { id: 'ATTR1', relationship: ['MEASURE'], series: true },
+      { id: 'ATTR2', relationship: ['MEASURE'], series: true },
+      { id: 'ATTR3', relationship: [], series: true },
+      { id: 'ATTR4', relationship: [], series: true },
+    ];
+
+    expect(getTableLayoutIds(layoutIds, dimensions, attributes, combinations)).to.deep.equal({
+      header: ['TRANSACTION'],
+      sections: ['COMB1', 'COMB3'],
+      rows: ['COMB2', 'REF_AREA']
+    });
+  });
+});

package/test/refineLayoutSize2.test.js

@@ -100,7 +100,7 @@ const partialObservations3 = {
 };
 
 describe('refineLayoutSize 2 tests', () => {
-  it('no changes under limit', () => {
+  /*it('no changes under limit', () => {
     const layout = {
       header: [{ __index: 0 }],
       sections: [{ __index: 1 }],
@@ -335,6 +335,73 @@ describe('refineLayoutSize 2 tests', () => {
         limit: 90
       })(layoutIndexes)
     ).to.deep.equal(expected);
+  });*/
+  it('cannot fit the limit', () => {
+    const layout = {
+      header: [{ __index: 1 }],
+      rows: [{ __index: 0 }],
+      sections: [],
+    };
+
+    const layoutIndexes = {
+      header: [
+        { indexes: [0], parentsIndexes: [[]], missingIndexes: [[]] },
+        { indexes: [1], parentsIndexes: [[]], missingIndexes: [[]] },
+      ],
+      sections: [
+        [
+          { indexes: [] },
+          [
+            { indexes: [0], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [1], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [2], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [3], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [4], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [5], parentsIndexes: [[]], missingIndexes: [[]] },
+          ]
+        ]
+      ]
+    };
+
+    const observations = {
+      '0:0': { orderedDimIndexes: [0, 0] },
+      '0:1': { orderedDimIndexes: [0, 1] },
+      '1:0': { orderedDimIndexes: [1, 0] },
+      '1:1': { orderedDimIndexes: [1, 1] },
+      '2:0': { orderedDimIndexes: [2, 0] },
+      '2:1': { orderedDimIndexes: [2, 1] },
+      '3:0': { orderedDimIndexes: [3, 0] },
+      '3:1': { orderedDimIndexes: [3, 1] },
+      '4:0': { orderedDimIndexes: [4, 0] },
+      '4:1': { orderedDimIndexes: [4, 1] },
+      '5:0': { orderedDimIndexes: [5, 0] },
+      '5:1': { orderedDimIndexes: [5, 1] },
+    };
+
+    const expected = {
+      header: [
+        { indexes: [0], parentsIndexes: [[]], missingIndexes: [[]] },
+        { indexes: [1], parentsIndexes: [[]], missingIndexes: [[]] },
+      ],
+      sections: [
+        [
+          { indexes: [] },
+          [
+            { indexes: [0], parentsIndexes: [[]], missingIndexes: [[]] },
+          ]
+        ]
+      ],
+      truncated: true,
+      totalCells: 31
+    };
+
+    expect(
+      refineLayoutSize({
+        layout,
+        observations,
+        limit: 2
+      })(layoutIndexes)
+    ).to.deep.equal(expected);
   });
   /*it('no rows', () => {