@sis-cc/dotstatsuite-components 17.27.0 → 17.29.0

package/lib/rules/src/layout.js

@@ -19,23 +19,25 @@ var isTableLayoutCompatible = function isTableLayoutCompatible(data, layout) {
   var combinationsDefinitions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
   var dataquery = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
 
-  var multiValuesDimensions = R.pipe(R.pathOr([], ['structure', 'dimensions', 'observation']), function (dimensions) {
+  var indexedCombinations = R.indexBy(R.prop('id'), combinationsDefinitions);
+  var indexedManyValuesDimensions = R.pipe(R.pathOr([], ['structure', 'dimensions', 'observation']), function (dimensions) {
     return (0, _src.refineDimensions)(dimensions, dataquery);
   }, R.reject(function (d) {
     return R.prop('header', d) || !R.length(d.values || []);
-  }), R.pluck('id'), R.map(function (d) {
-    var conceptId = R.find(function (comb) {
-      return R.includes(d, R.propOr([], 'concepts', comb));
-    })(combinationsDefinitions);
-    return conceptId ? conceptId.id : d;
-  }))(data);
-  var dimensionsInLayout = R.pipe(R.values, R.unnest)(layout);
-
-  var dimensionsLength = R.length(multiValuesDimensions);
-  var layoutLength = R.length(dimensionsInLayout);
-  var intersectionLength = R.length(R.intersection(multiValuesDimensions, dimensionsInLayout));
-
-  return R.all(R.equals(dimensionsLength))([intersectionLength, layoutLength]);
+  }), R.indexBy(R.prop('id')))(data);
+  var remainings = indexedManyValuesDimensions;
+  var layoutIds = R.pipe(R.values, R.unnest)(layout);
+  var hasFoundIrrelevant = false;
+  R.forEach(function (id) {
+    if (R.has(id, indexedManyValuesDimensions)) {
+      remainings = R.dissoc(id, remainings);
+    } else if (R.has(id, indexedCombinations)) {
+      remainings = R.omit(R.pathOr([], [id, 'concepts'], indexedCombinations), remainings);
+    } else if (id !== 'OBS_ATTRIBUTES') {
+      hasFoundIrrelevant = true;
+    }
+  }, layoutIds);
+  return R.isEmpty(remainings) && !hasFoundIrrelevant;
 };
 
 var isScatterLayoutCompatible = function isScatterLayoutCompatible(data, chartDimension) {
@@ -80,7 +82,15 @@ var isSharedLayoutCompatible = exports.isSharedLayoutCompatible = function isSha
     var dataquery = R.path(['config', 'sdmxSource', 'dataquery'], sharedData);
     var annotations = R.pathOr({}, ['structure', 'annotations'], sdmxData);
     var locale = R.pathOr({}, ['config', 'table', 'locale'], sharedData);
-    var combinationsDefinitions = (0, _src.getCombinationDefinitions)(annotations, locale);
+    var rawDefaultCombinationsDefinition = R.pathOr({}, ['config', 'defaultCombinations'], sharedData);
+    var _rawDefaultCombinatio = rawDefaultCombinationsDefinition.concepts,
+        concepts = _rawDefaultCombinatio === undefined ? '' : _rawDefaultCombinatio,
+        _rawDefaultCombinatio2 = rawDefaultCombinationsDefinition.names,
+        names = _rawDefaultCombinatio2 === undefined ? '' : _rawDefaultCombinatio2;
+
+    var defaultCombinationsDefinition = (0, _src.parseCombinationDefinition)(locale)(concepts, names);
+    var customCombinationsDefinitions = (0, _src.getCombinationDefinitions)(annotations, locale);
+    var combinationsDefinitions = R.isNil(customCombinationsDefinitions) || R.isEmpty(customCombinationsDefinitions) ? defaultCombinationsDefinition : customCombinationsDefinitions;
     return isTableLayoutCompatible(sdmxData, layoutIds, combinationsDefinitions, dataquery);
   }
   var chartDimension = R.pathOr({}, ['config', 'chart', 'chartDimension'], sharedData);

package/lib/rules2/src/index.js

@@ -147,6 +147,12 @@ Object.defineProperty(exports, 'getCombinationDefinitions', {
     return _getCombinationDefinitions.getCombinationDefinitions;
   }
 });
+Object.defineProperty(exports, 'parseCombinationDefinition', {
+  enumerable: true,
+  get: function get() {
+    return _getCombinationDefinitions.parseCombinationDefinition;
+  }
+});
 
 var _refineDimensions = require('./refineDimensions');
 
@@ -422,4 +428,13 @@ Object.defineProperty(exports, 'injectCombinationsInLayout', {
   get: function get() {
     return _getTableLayoutIds.injectCombinationsInLayout;
   }
+});
+
+var _declineObservationsOverAttributes = require('./table/declineObservationsOverAttributes');
+
+Object.defineProperty(exports, 'declineObservationsOverAttributes', {
+  enumerable: true,
+  get: function get() {
+    return _declineObservationsOverAttributes.declineObservationsOverAttributes;
+  }
 });

package/lib/rules2/src/parseAttributes.js

@@ -23,7 +23,8 @@ var parseAttributes = exports.parseAttributes = function parseAttributes(attribu
   var indexedDimensions = R.indexBy(R.prop('id'), dimensions);
   return R.addIndex(R.map)(function (attr, index) {
     var res = R.assoc('index', index, attr);
-    if (R.isEmpty(attr.values || []) || !R.propOr(true, 'display', attr) || attr.id === _constants.REPORTING_YEAR_START_DAY || attr.id === _constants.REPYEARSTART) {
+    var displayableValuesCount = R.pipe(R.filter(R.propOr(true, 'display')), R.length)(attr);
+    if (R.isEmpty(attr.values || []) || !R.propOr(true, 'display', attr) || displayableValuesCount < 1 || attr.id === _constants.REPORTING_YEAR_START_DAY || attr.id === _constants.REPYEARSTART) {
       return R.assoc('display', false, res);
     }
     if (R.propEq('id', customAttributes.prefscale, attr)) {

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

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.declineObservationsOverAttributes = undefined;
+
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+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 declineObservationsOverAttributes = exports.declineObservationsOverAttributes = function declineObservationsOverAttributes(attrsIds, observations) {
+  var obsKeys = R.keys(observations);
+  return R.reduce(function (acc, obsKey) {
+    var obs = R.prop(obsKey, observations);
+    var enhancedObs = R.pipe(R.over(R.lensProp('orderedDimIndexes'), R.append(0)), R.over(R.lensProp('attributes'), R.omit(attrsIds)), R.assocPath(['indexedDimValIds', 'OBS_ATTRIBUTES'], 'OBS_VALUE'))(obs);
+    return R.addIndex(R.reduce)(function (_acc, attrId, attrIndex) {
+      var attr = R.pathOr({}, ['attributes', attrId], obs);
+      if (R.isEmpty(attr) || R.isNil(R.prop('value', attr)) || !R.pathOr(true, ['value', 'display'], attr)) {
+        return _acc;
+      }
+      var declinedKey = obsKey + ':' + (attrIndex + 1);
+      var declined = (0, _extends3.default)({}, obs, {
+        attributes: {},
+        value: R.prop('value', attr),
+        formattedValue: R.prop('value', attr),
+        orderedDimIndexes: R.append(attrIndex + 1, obs.orderedDimIndexes),
+        indexedDimValIds: (0, _extends3.default)({}, obs.indexedDimValIds, {
+          OBS_ATTRIBUTES: attr.id
+        })
+      });
+      return R.assoc(declinedKey, declined, _acc);
+    }, R.assoc(obsKey + ':0', enhancedObs, acc), attrsIds);
+  }, {}, obsKeys);
+};

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

@@ -65,12 +65,13 @@ var getCells = exports.getCells = function getCells(customAttributes, cellsAttri
     })(customAttributes);
 
     return R.mapObjIndexed(function (obs) {
-      var relevantAttributes = getCellRelevantAttributes(obs.attributes, attributesSeries, cellsAttributesId);
-      var flagsAndNotes = (0, _getFlagsAndNotes.getFlagsAndNotes)(R.omit(attributesInCellsCombination, relevantAttributes), _customAttributes);
-      var combinedSeries = getCellCombinedSeries(relevantAttributes, combinations.cells || []);
-      var hasAdvancedAttributes = R.pipe(R.omit(R.unnest([_customAttributes.flags || [], _customAttributes.notes || [], attributesInCellsCombination])), R.isEmpty, R.not)(relevantAttributes);
+      var isAttrCell = R.pathOr('OBS_VAL', ['indexedDimValIds', 'OBS_ATTR'], obs) !== 'OBS_VAL';
+      var relevantAttributes = isAttrCell ? [] : getCellRelevantAttributes(obs.attributes, attributesSeries, cellsAttributesId);
+      var flagsAndNotes = isAttrCell ? [] : (0, _getFlagsAndNotes.getFlagsAndNotes)(R.omit(attributesInCellsCombination, relevantAttributes), _customAttributes);
+      var combinedSeries = isAttrCell ? [] : getCellCombinedSeries(relevantAttributes, combinations.cells || []);
+      var hasAdvancedAttributes = isAttrCell ? false : R.pipe(R.omit(R.unnest([_customAttributes.flags || [], _customAttributes.notes || [], attributesInCellsCombination])), R.isEmpty, R.not)(relevantAttributes);
 
-      var hasMetadata = (0, _hasCellMetadata.hasCellMetadata)(metadataCoordinates, obs.indexedDimValIds);
+      var hasMetadata = isAttrCell ? false : (0, _hasCellMetadata.hasCellMetadata)(metadataCoordinates, obs.indexedDimValIds);
 
       return (0, _extends3.default)({}, R.pick(['indexedDimValIds', 'key'], obs), {
         flags: R.concat(flagsAndNotes, combinedSeries),

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

@@ -121,7 +121,9 @@ var combineConcepts = function combineConcepts(combDimValues, definition, attrVa
 };
 
 var getSerieFlagsAndSideProps = function getSerieFlagsAndSideProps(coordinates, validator, attributesValues, customAttributes, metadataCoordinates) {
-	var layoutAttrValues = R.reject(R.prop('isObs'), attributesValues);
+	var layoutAttrValues = R.reject(function (attr) {
+		return R.prop('isObs', attr) && !validator(attr.coordinates);
+	}, attributesValues);
 	var flags = (0, _getFlagsAndNotes.getFlagsAndNotes)(layoutAttrValues, customAttributes);
 	var hasMetadata = !R.isNil(R.find(validator, metadataCoordinates));
 	var hasAdvancedAttributes = getHasAdvancedAttributes(layoutAttrValues, customAttributes);
@@ -188,7 +190,12 @@ var getSerieDataWithMissingLines = function getSerieDataWithMissingLines(serie,
 	    attributes = _getSerieDimensionsDa.attributes,
 	    serieData = (0, _objectWithoutProperties3.default)(_getSerieDimensionsDa, ['attributes']);
 
-	var _getSerieFlagsAndSide = getSerieFlagsAndSideProps(serieCoordinates, coordinatesValidator, attributes, customAttributes, metadataCoordinates),
+	var topCoordinatesValidator = (0, _utils.getLayoutCoordinatesValidator)(topCoordinates);
+	var flagsValidator = function flagsValidator(coordinates) {
+		return coordinatesValidator(coordinates) && !topCoordinatesValidator(coordinates);
+	};
+
+	var _getSerieFlagsAndSide = getSerieFlagsAndSideProps(serieCoordinates, flagsValidator, attributes, customAttributes, metadataCoordinates),
 	    flags = _getSerieFlagsAndSide.flags,
 	    sideProps = _getSerieFlagsAndSide.sideProps;
 
@@ -234,7 +241,6 @@ var getLayoutData = function getLayoutData(layoutIndexes, layout, _ref) {
 	    sections = layoutIndexes.sections,
 	    rest = (0, _objectWithoutProperties3.default)(layoutIndexes, ['header', 'sections']);
 
-
 	var headerData = R.reduce(function (acc, serie) {
 		var datas = getSerieDataWithMissingLines(serie, layout.header, topCoordinates, attributesSeries, customAttributes, metadataCoordinates);
 		return R.concat(acc, datas);

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

@@ -45,6 +45,9 @@ var getLayoutPivots = function getLayoutPivots(layoutEntry) {
         return valIndexGetter(d)(indexes);
       }, R.prop('dimensions', c));
     }, function (d) {
+      if (d.id === 'OBS_ATTRIBUTES') {
+        return R.last(indexes);
+      }
       return valIndexGetter(d)(indexes);
     }), layoutEntry);
   };

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

@@ -123,10 +123,9 @@ var injectCombinationsInLayout = exports.injectCombinationsInLayout = function i
       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),
+        _R$reduce2 = (0, _slicedToArray3.default)(_R$reduce, 2),
         idsInSections = _R$reduce2[0],
-        idsInRows = _R$reduce2[1],
-        nowhere = _R$reduce2[2];
+        idsInRows = _R$reduce2[1];
 
     if (!R.isEmpty(idsInHeader) && R.isEmpty(idsInSections) && R.isEmpty(idsInRows)) {
       layoutRelationships.header = R.concat(layoutRelationships.header, relationship);
@@ -141,9 +140,8 @@ var injectCombinationsInLayout = exports.injectCombinationsInLayout = function i
       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, _extends4.default)({}, comb, { concepts: rowsConcepts }))(acc.rows);
+    layoutRelationships.rows = R.concat(layoutRelationships.rows, relationship);
+    var ids = injectCombination(comb)(acc.rows);
     return R.assoc('rows', ids)(acc);
   }, layoutIds, notInLayoutCombs);
 };
@@ -179,7 +177,17 @@ var getLayoutCombinations = exports.getLayoutCombinations = function getLayoutCo
   }, [], combinations);
 };
 
-var extractConcepts = function extractConcepts(ids, indexedCombinations) {
+var extractConcepts = function extractConcepts(ids, indexedCombinations, layoutDimsIds) {
+  var entry = R.find(function (id) {
+    if (R.has(id, indexedCombinations)) {
+      var dimId = R.find(function (i) {
+        return layoutDimsIds.has(i);
+      }, R.pathOr([], [id, 'concepts'], indexedCombinations));
+      return !R.isNil(dimId);
+    }
+    return true;
+  }, ids);
+
   var getRelationship = function getRelationship(id) {
     if (R.has(id, indexedCombinations)) {
       return R.append(id, R.path([id, 'relationship'], indexedCombinations));
@@ -190,7 +198,7 @@ var extractConcepts = function extractConcepts(ids, indexedCombinations) {
     return R.assoc(id, getRelationship(id), acc);
   }, {}, ids);
 
-  var relationship = [R.head(ids)];
+  var relationship = [entry];
   while (!R.isEmpty(indexedRels)) {
     var related = R.pickBy(function (rels) {
       return !R.isEmpty(R.intersection(relationship, rels));
@@ -207,20 +215,31 @@ var extractConcepts = function extractConcepts(ids, indexedCombinations) {
   }, ids);
 };
 
-var injectRemainingDimensionsInLayout = exports.injectRemainingDimensionsInLayout = function injectRemainingDimensionsInLayout(layoutIds, remainingDims, indexedCombinations) {
+var injectRemainingDimensionsInLayout = exports.injectRemainingDimensionsInLayout = function injectRemainingDimensionsInLayout(layoutIds, remainingDims, indexedCombinations, layoutDimsIds) {
   var _layout = layoutIds;
   var _remaining = remainingDims;
 
-  if (R.isEmpty(_layout.rows)) {
+  var dimInRows = R.find(function (id) {
+    if (layoutDimsIds.has(id)) {
+      return true;
+    }
+    var dimId = R.find(function (i) {
+      return layoutDimsIds.has(i);
+    }, R.pathOr([], [id, 'concepts'], indexedCombinations));
+    return !R.isNil(dimId);
+  }, _layout.rows);
+
+  console.log({ dimInRows: dimInRows, layoutIds: layoutIds, indexedCombinations: indexedCombinations, layoutDimsIds: layoutDimsIds });
+  if (R.isNil(dimInRows)) {
     if (R.isEmpty(_remaining)) {
       var toTakeIn = R.isEmpty(_layout.sections) ? 'header' : 'sections';
 
-      var _extractConcepts = extractConcepts(R.prop(toTakeIn, _layout), indexedCombinations),
+      var _extractConcepts = extractConcepts(R.prop(toTakeIn, _layout), indexedCombinations, layoutDimsIds),
           _extractConcepts2 = (0, _slicedToArray3.default)(_extractConcepts, 2),
           extracted = _extractConcepts2[0],
           remains = _extractConcepts2[1];
 
-      _layout = (0, _extends4.default)({}, _layout, (0, _defineProperty3.default)({ rows: extracted }, toTakeIn, remains));
+      _layout = (0, _extends4.default)({}, _layout, (0, _defineProperty3.default)({ rows: R.concat(_layout.rows, extracted) }, toTakeIn, remains));
     } else {
       _layout = R.over(R.lensProp('rows'), R.append(R.head(_remaining)))(_layout);
       _remaining = R.tail(_remaining);
@@ -241,8 +260,18 @@ var injectRemainingDimensionsInLayout = exports.injectRemainingDimensionsInLayou
 var getTableLayoutIds = exports.getTableLayoutIds = function getTableLayoutIds(defaultLayoutIds, dimensions, attributes, combinations) {
   var layoutDimsIds = getLayoutDimsIds(dimensions);
   var layoutCombinations = getLayoutCombinations(combinations, layoutDimsIds, attributes);
+
+  var combinationsConcepts = R.pipe(R.pluck('_concepts'), R.unnest, function (ids) {
+    return new _set2.default(ids);
+  })(combinations);
+  var obsAttributes = R.filter(function (a) {
+    return a.series && R.isEmpty(a.relationship || []) && a.display && !combinationsConcepts.has(a);
+  }, attributes);
   var indexedCombinations = R.indexBy(R.prop('id'), layoutCombinations);
   var filteredLayoutIds = R.map(R.filter(function (id) {
+    if (id === 'OBS_ATTRIBUTES') {
+      return !R.isEmpty(obsAttributes);
+    }
     return R.has(id, indexedCombinations) || layoutDimsIds.has(id);
   }), defaultLayoutIds);
   var layoutWithCombs = injectCombinationsInLayout(layoutCombinations, filteredLayoutIds);
@@ -284,5 +313,5 @@ var getTableLayoutIds = exports.getTableLayoutIds = function getTableLayoutIds(d
       nextLayout = _R$reduce4.nextLayout,
       remaining = _R$reduce4.remaining;
 
-  return injectRemainingDimensionsInLayout(nextLayout, remaining, indexedCombinations);
+  return injectRemainingDimensionsInLayout(nextLayout, remaining, indexedCombinations, layoutDimsIds);
 };

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

@@ -9,6 +9,12 @@ var _extends2 = require('babel-runtime/helpers/extends');
 
 var _extends3 = _interopRequireDefault(_extends2);
 
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+var _declineObservationsOverAttributes = require('./declineObservationsOverAttributes');
+
 var _getLayout = require('./getLayout');
 
 var _getSortedLayoutIndexes = require('./getSortedLayoutIndexes');
@@ -29,6 +35,10 @@ var _getCuratedCells = require('./getCuratedCells');
 
 var _getSeriesCombinations = require('../getSeriesCombinations');
 
+var _getCellsMetadataCoordinates = require('./getCellsMetadataCoordinates');
+
+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 getTableProps = exports.getTableProps = function getTableProps(_ref) {
@@ -47,18 +57,40 @@ var getTableProps = exports.getTableProps = function getTableProps(_ref) {
       header = data.header;
 
 
+  var obsAttributes = R.filter(function (a) {
+    return a.series && R.isEmpty(a.relationship) && a.display && !a.combined;
+  }, attributes);
+  var dupObs = observations;
+  var hasDuplicatedCells = R.pipe(R.values, R.unnest, R.find(R.equals('OBS_ATTRIBUTES')))(layoutIds);
+  if (hasDuplicatedCells) {
+    var attrsIds = R.pluck('id', obsAttributes);
+    dupObs = (0, _declineObservationsOverAttributes.declineObservationsOverAttributes)(attrsIds, observations);
+  }
   var seriesCombinations = (0, _getSeriesCombinations.getSeriesCombinations)(combinations, oneValueDimensions);
-  var layout = (0, _getLayout.getLayout)(layoutIds, dimensions, seriesCombinations, isTimeInverted);
-  var layoutIndexes = (0, _getSortedLayoutIndexes.getSortedLayoutIndexes)(layout, observations);
+  var _dims = R.append({
+    id: 'OBS_ATTRIBUTES',
+    values: R.prepend({ id: 'OBS_VALUE' }, obsAttributes)
+  }, dimensions);
+  var layout = (0, _getLayout.getLayout)(layoutIds, _dims, seriesCombinations, isTimeInverted);
+  var layoutDimsIds = R.map(R.reduce(function (acc, entry) {
+    if (R.has('dimensions', entry)) {
+      return R.concat(acc, R.pluck('id', entry.dimensions));
+    }
+    return R.append(entry.id, acc);
+  }, []), layout);
+  var layoutIndexes = (0, _getSortedLayoutIndexes.getSortedLayoutIndexes)(layout, dupObs);
   var enhancedLayoutIndexes = (0, _parseSeriesIndexesHierarchies.parseLayoutIndexesHierarchies)(layoutIndexes, layout);
-  var refinedLayoutIndexes = (0, _refineLayoutSize.refineLayoutSize)({ layout: layout, observations: observations, limit: limit })(enhancedLayoutIndexes);
+  var refinedLayoutIndexes = (0, _refineLayoutSize.refineLayoutSize)({ layout: layout, observations: dupObs, limit: limit })(enhancedLayoutIndexes);
   var layoutData = (0, _getLayoutData.getLayoutData)(refinedLayoutIndexes, layout, { metadataCoordinates: metadataCoordinates, attributesSeries: attributesSeries, customAttributes: customAttributes, topCoordinates: header.coordinates });
 
-  var cellsAttributesIds = (0, _getCellsAttributesIds.getCellsAttributesIds)(layoutIds, attributes);
+  var cellsAttributesIds = (0, _getCellsAttributesIds.getCellsAttributesIds)(layoutDimsIds, attributes);
   var indexedCombinations = (0, _getIndexedCombinationsByDisplay.getIndexedCombinationsByDisplay)(layout, seriesCombinations);
-  var cells = (0, _getCells.getCells)(customAttributes, cellsAttributesIds, indexedCombinations, attributesSeries, metadataCoordinates)(observations);
+  var cellsMetadataCoordinates = (0, _getCellsMetadataCoordinates.getCellsMetadataCoordinates)(metadataCoordinates, oneValueDimensions, layoutDimsIds);
+  var cells = (0, _getCells.getCells)(customAttributes, cellsAttributesIds, indexedCombinations, attributesSeries, cellsMetadataCoordinates)(dupObs);
 
   return (0, _extends3.default)({}, layoutData, {
-    cells: (0, _getCuratedCells.getCuratedCells)(cells, layout)
+    cells: (0, _getCuratedCells.getCuratedCells)(cells, layout),
+    layout: layout,
+    combinations: seriesCombinations
   });
 };

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

@@ -276,8 +276,12 @@ var refineLayoutSize = exports.refineLayoutSize = function refineLayoutSize(_ref
         truncated = _truncateLayout.truncated,
         extractedKeys = _truncateLayout.extractedKeys;
 
+    var dimsLength = R.pipe(R.values, R.head, R.propOr([], 'orderedDimIndexes'), R.length)(observations);
+    var _layout = R.map(R.map(function (entry) {
+      return entry.id === 'OBS_ATTRIBUTES' ? R.assoc('__index', dimsLength - 1, entry) : entry;
+    }), layout);
     var curatedObs = R.pipe(getShape, function (shape) {
-      return getCuratedCells({ layout: layout, observations: observations, shape: shape });
+      return getCuratedCells({ layout: _layout, observations: observations, shape: shape });
     })(isVertical);
 
     var refined = refineLayout(isVertical)(toRefine, extractedKeys, curatedObs);

package/lib/rules2/src/utils.js

@@ -26,6 +26,12 @@ var getLayoutCoordinatesValidator = exports.getLayoutCoordinatesValidator = func
     if (R.isEmpty(coordinates)) {
       return false;
     }
+    if (R.has('OBS_ATTRIBUTES', layoutCoordinates) || R.has('OBS_ATTRIBUTES', topCoordinates)) {
+      var obsAttrCoord = R.prop('OBS_ATTRIBUTES', layoutCoordinates) || R.prop('OBS_ATTRIBUTES', topCoordinates);
+      if (obsAttrCoord !== 'OBS_VALUE') {
+        return false;
+      }
+    }
     var keys = R.keys(coordinates);
     var res = true;
     var notInTop = {};
@@ -37,6 +43,7 @@ var getLayoutCoordinatesValidator = exports.getLayoutCoordinatesValidator = func
         notInTop[key] = key;
       }
     }, keys);
-    return res && !R.isEmpty(notInTop);
+    return res;
+    //return res && !R.isEmpty(notInTop);
   };
 };

package/package.json

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

package/src/rules/src/layout.js

@@ -6,26 +6,35 @@ import {
   STACKED_ROW,
   V_SYMBOL
 } from './constants';
-import { getCombinationDefinitions, refineDimensions } from '../../rules2/src';
+import {
+  getCombinationDefinitions,
+  refineDimensions,
+  parseCombinationDefinition
+} from '../../rules2/src';
 
 const isTableLayoutCompatible = (data, layout, combinationsDefinitions = [], dataquery = '') => {
-  const multiValuesDimensions = R.pipe(
+  const indexedCombinations = R.indexBy(R.prop('id'), combinationsDefinitions);
+  const indexedManyValuesDimensions = R.pipe(
     R.pathOr([], ['structure', 'dimensions', 'observation']),
     dimensions => refineDimensions(dimensions, dataquery),
     R.reject(d => R.prop('header', d) || !R.length(d.values || [])),
-    R.pluck('id'),
-    R.map(d => {
-      const conceptId = R.find(comb => R.includes(d, R.propOr([], 'concepts', comb)))(combinationsDefinitions)
-      return conceptId ? conceptId.id : d
-    }),
+    R.indexBy(R.prop('id'))
   )(data);
-  const dimensionsInLayout = R.pipe(R.values, R.unnest)(layout);
-
-  const dimensionsLength = R.length(multiValuesDimensions);
-  const layoutLength = R.length(dimensionsInLayout);
-  const intersectionLength = R.length(R.intersection(multiValuesDimensions, dimensionsInLayout));
-
-  return R.all(R.equals(dimensionsLength))([intersectionLength, layoutLength]);
+  let remainings = indexedManyValuesDimensions;
+  const layoutIds = R.pipe(R.values, R.unnest)(layout);
+  let hasFoundIrrelevant = false;
+  R.forEach(id => {
+    if (R.has(id, indexedManyValuesDimensions)) {
+      remainings = R.dissoc(id, remainings);
+    }
+    else if (R.has(id, indexedCombinations)) {
+      remainings = R.omit(R.pathOr([], [id, 'concepts'], indexedCombinations), remainings);
+    }
+    else if (id !== 'OBS_ATTRIBUTES') {
+      hasFoundIrrelevant = true;
+    }
+  }, layoutIds);
+  return R.isEmpty(remainings) && !hasFoundIrrelevant;
 };
 
 
@@ -90,8 +99,13 @@ export const isSharedLayoutCompatible = (sdmxData, sharedData) => {
     const layoutIds = R.pathOr({}, ['config', 'table', 'layoutIds'], sharedData);
     const dataquery = R.path(['config', 'sdmxSource', 'dataquery'], sharedData);
     const annotations = R.pathOr({}, ['structure', 'annotations'], sdmxData)
-    const locale = R.pathOr({}, ['config', 'table', 'locale'], sharedData)
-    const combinationsDefinitions = getCombinationDefinitions(annotations, locale)
+    const locale = R.pathOr({}, ['config', 'table', 'locale'], sharedData);
+    const rawDefaultCombinationsDefinition = R.pathOr({}, ['config', 'defaultCombinations'], sharedData);
+    const { concepts='', names='' } = rawDefaultCombinationsDefinition;
+    const defaultCombinationsDefinition = parseCombinationDefinition(locale)(concepts, names);
+    const customCombinationsDefinitions = getCombinationDefinitions(annotations, locale);
+    const combinationsDefinitions = R.isNil(customCombinationsDefinitions) || R.isEmpty(customCombinationsDefinitions)
+      ? defaultCombinationsDefinition : customCombinationsDefinitions;
     return isTableLayoutCompatible(sdmxData, layoutIds, combinationsDefinitions, dataquery);
   }
   const chartDimension = R.pathOr({}, ['config', 'chart', 'chartDimension'], sharedData);

package/src/rules2/src/index.js

@@ -15,7 +15,7 @@ export { duplicateObs } from './duplicateObservations';
 export { refinePartialHierarchy, hierarchiseDimensionWithAdvancedHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy2';
 export { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy2';
 export { getDimensionValuesIndexes } from './getDimensionValuesIndexes';
-export { getCombinationDefinitions } from './getCombinationDefinitions';
+export { getCombinationDefinitions, parseCombinationDefinition } from './getCombinationDefinitions';
 export { refineDimensions } from './refineDimensions';
 export { parseAttributes } from './parseAttributes';
 export { parseCombinations } from './parseCombinations';
@@ -46,3 +46,4 @@ export { getTableLabelAccessor } from './table/getTableLabelAccessor';
 export { parseValueHierarchy } from './table/parseValueHierarchy';
 export { parseLayoutIndexesHierarchies } from './table/parseSeriesIndexesHierarchies';
 export { getTableLayoutIds, injectCombinationsInLayout } from './table/getTableLayoutIds';
+export { declineObservationsOverAttributes } from './table/declineObservationsOverAttributes';

package/src/rules2/src/parseAttributes.js

@@ -5,8 +5,13 @@ export const parseAttributes = (attributes, dimensions, customAttributes) => {
   const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
   return R.addIndex(R.map)((attr, index) => {
     let res = R.assoc('index', index, attr);
+    const displayableValuesCount = R.pipe(
+      R.filter(R.propOr(true, 'display')),
+      R.length,
+    )(attr);
     if (R.isEmpty(attr.values || []) || !R.propOr(true, 'display', attr)
-      || attr.id === REPORTING_YEAR_START_DAY || attr.id === REPYEARSTART) {
+      || displayableValuesCount < 1 || attr.id === REPORTING_YEAR_START_DAY
+      || attr.id === REPYEARSTART) {
       return R.assoc('display', false, res);
     }
     if (R.propEq('id', customAttributes.prefscale, attr)) {

package/src/rules2/src/table/declineObservationsOverAttributes.js

@@ -0,0 +1,32 @@
+import * as R from 'ramda';
+
+export const declineObservationsOverAttributes = (attrsIds, observations) => {
+  const obsKeys = R.keys(observations);
+  return R.reduce((acc, obsKey) => {
+    const obs = R.prop(obsKey, observations);
+    const enhancedObs = R.pipe(
+      R.over(R.lensProp('orderedDimIndexes'), R.append(0)),
+      R.over(R.lensProp('attributes'), R.omit(attrsIds)),
+      R.assocPath(['indexedDimValIds', 'OBS_ATTRIBUTES'], 'OBS_VALUE')
+    )(obs);
+    return R.addIndex(R.reduce)((_acc, attrId, attrIndex) => {
+      const attr = R.pathOr({}, ['attributes', attrId], obs);
+      if (R.isEmpty(attr) || R.isNil(R.prop('value', attr)) || !R.pathOr(true, ['value', 'display'], attr)) {
+        return _acc;
+      }
+      const declinedKey = `${obsKey}:${attrIndex+1}`;
+      const declined = {
+        ...obs,
+        attributes: {},
+        value: R.prop('value', attr),
+        formattedValue: R.prop('value', attr),
+        orderedDimIndexes: R.append(attrIndex+1, obs.orderedDimIndexes),
+        indexedDimValIds: {
+          ...obs.indexedDimValIds,
+          OBS_ATTRIBUTES: attr.id
+        }
+      };
+      return R.assoc(declinedKey, declined, _acc);
+    }, R.assoc(`${obsKey}:0`, enhancedObs, acc), attrsIds);
+  }, {}, obsKeys);
+};

package/src/rules2/src/table/getCells.js

@@ -62,16 +62,17 @@ export const getCells = (customAttributes, cellsAttributesId, combinations, attr
 
   return R.mapObjIndexed(
     obs => {
-      const relevantAttributes = getCellRelevantAttributes(obs.attributes, attributesSeries, cellsAttributesId);
-      const flagsAndNotes = getFlagsAndNotes(R.omit(attributesInCellsCombination, relevantAttributes), _customAttributes);
-      const combinedSeries = getCellCombinedSeries(relevantAttributes, combinations.cells || []);
-      const hasAdvancedAttributes = R.pipe(
+      const isAttrCell = R.pathOr('OBS_VAL', ['indexedDimValIds', 'OBS_ATTR'], obs) !== 'OBS_VAL';
+      const relevantAttributes = isAttrCell ? [] : getCellRelevantAttributes(obs.attributes, attributesSeries, cellsAttributesId);
+      const flagsAndNotes = isAttrCell ? [] : getFlagsAndNotes(R.omit(attributesInCellsCombination, relevantAttributes), _customAttributes);
+      const combinedSeries = isAttrCell ? [] : getCellCombinedSeries(relevantAttributes, combinations.cells || []);
+      const hasAdvancedAttributes = isAttrCell ? false : R.pipe(
         R.omit(R.unnest([_customAttributes.flags || [], _customAttributes.notes || [], attributesInCellsCombination])),
         R.isEmpty,
         R.not
       )(relevantAttributes);
 
-      const hasMetadata = hasCellMetadata(metadataCoordinates, obs.indexedDimValIds);
+      const hasMetadata = isAttrCell ? false : hasCellMetadata(metadataCoordinates, obs.indexedDimValIds);
 
       return ({
         ...R.pick(['indexedDimValIds', 'key'], obs),

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

@@ -80,7 +80,7 @@ const combineConcepts = (combDimValues, definition, attrValues) => R.over(
 	})));
 
 const getSerieFlagsAndSideProps = (coordinates, validator, attributesValues, customAttributes, metadataCoordinates) => {
-	const layoutAttrValues = R.reject(R.prop('isObs'), attributesValues);
+	const layoutAttrValues = R.reject(attr => R.prop('isObs', attr) && !validator(attr.coordinates), attributesValues);
   const flags = getFlagsAndNotes(layoutAttrValues, customAttributes);
   const hasMetadata = !R.isNil(R.find(validator, metadataCoordinates));
   const hasAdvancedAttributes = getHasAdvancedAttributes(layoutAttrValues, customAttributes);
@@ -142,7 +142,9 @@ export const getSerieDataWithMissingLines = (serie, definition, topCoordinates,
 	{ parentsIndexes: _parentsIndexes, missingParents: [] }, missingParentsIndexes);
 
 	const { attributes, ...serieData } = getSerieDimensionsData(serie, definition, attributesValues, getMissingParents);
-	const { flags, sideProps } = getSerieFlagsAndSideProps(serieCoordinates, coordinatesValidator, attributes, customAttributes, metadataCoordinates);
+	const topCoordinatesValidator = getLayoutCoordinatesValidator(topCoordinates);
+	const flagsValidator = coordinates => coordinatesValidator(coordinates) && !topCoordinatesValidator(coordinates);
+	const { flags, sideProps } = getSerieFlagsAndSideProps(serieCoordinates, flagsValidator, attributes, customAttributes, metadataCoordinates);
 	return R.append({ ...serieData, flags, sideProps, coordinates: serieCoordinates }, lines);
 };
 
@@ -165,7 +167,6 @@ export const getSerieDataWithoutMissingLines = (serie, definition, topCoordinate
 
 export const getLayoutData = (layoutIndexes, layout, { metadataCoordinates, attributesSeries, customAttributes, topCoordinates={} }) => {
   const { header, sections, ...rest } = layoutIndexes;
-
   const headerData = R.reduce((acc, serie) => {
   	const datas = getSerieDataWithMissingLines(serie, layout.header, topCoordinates, attributesSeries, customAttributes, metadataCoordinates);
   	return R.concat(acc, datas);

package/src/rules2/src/table/getSortedLayoutIndexes.js

@@ -21,7 +21,12 @@ const getLayoutPivots = layoutEntry => {
     R.ifElse(
       R.has('dimensions'),
       c => R.map(d => valIndexGetter(d)(indexes), R.prop('dimensions', c)),
-      d => valIndexGetter(d)(indexes)
+      d => {
+        if (d.id === 'OBS_ATTRIBUTES') {
+          return R.last(indexes);
+        }
+        return valIndexGetter(d)(indexes);
+      }
     ),
     layoutEntry
   );

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

@@ -57,7 +57,7 @@ export const injectCombinationsInLayout = (combinations, layoutIds) => {
       i => idsInHeaderSet.has(i),
       relationship
     );
-    const [idsInSections, idsInRows, nowhere] = R.reduce((_acc, id) => {
+    const [idsInSections, idsInRows] = R.reduce((_acc, id) => {
       if (idsInSectionsSet.has(id))
         return R.over(R.lensIndex(0), R.append(id), _acc);
       if (idsInRowsSet.has(id))
@@ -77,9 +77,8 @@ export const injectCombinationsInLayout = (combinations, layoutIds) => {
       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);
+    layoutRelationships.rows = R.concat(layoutRelationships.rows, relationship);
+    const ids = injectCombination(comb)(acc.rows);
     return R.assoc('rows', ids)(acc);
   }, layoutIds, notInLayoutCombs);
 };
@@ -123,7 +122,15 @@ export const getLayoutCombinations = (combinations, layoutDimsIds, attributes) =
   );
 };
 
-const extractConcepts = (ids, indexedCombinations) => {
+const extractConcepts = (ids, indexedCombinations, layoutDimsIds) => {
+  const entry = R.find(id => {
+    if (R.has(id, indexedCombinations)) {
+      const dimId = R.find(i => layoutDimsIds.has(i), R.pathOr([], [id, 'concepts'], indexedCombinations));
+      return !R.isNil(dimId);
+    }
+    return true;
+  }, ids);
+
   const getRelationship = id => {
     if (R.has(id, indexedCombinations)) {
       return R.append(id, R.path([id, 'relationship'], indexedCombinations));
@@ -134,7 +141,7 @@ const extractConcepts = (ids, indexedCombinations) => {
     R.assoc(id, getRelationship(id), acc)
   , {}, ids);
   
-  let relationship = [R.head(ids)];
+  let relationship = [entry];
   while (!R.isEmpty(indexedRels)) {
     const related = R.pickBy(rels => !R.isEmpty(R.intersection(relationship, rels)), indexedRels);
     if (R.isEmpty(related)) {
@@ -147,15 +154,24 @@ const extractConcepts = (ids, indexedCombinations) => {
   return R.partition(id => set.has(id), ids);
 }
 
-export const injectRemainingDimensionsInLayout = (layoutIds, remainingDims, indexedCombinations) => {
+export const injectRemainingDimensionsInLayout = (layoutIds, remainingDims, indexedCombinations, layoutDimsIds) => {
   let _layout = layoutIds;
   let _remaining = remainingDims;
 
-  if (R.isEmpty(_layout.rows)) {
+  const dimInRows = R.find(id => {
+    if (layoutDimsIds.has(id)) {
+      return true;
+    }
+    const dimId = R.find(i => layoutDimsIds.has(i), R.pathOr([], [id, 'concepts'], indexedCombinations));
+    return !R.isNil(dimId);
+  }, _layout.rows);
+
+  console.log({ dimInRows, layoutIds, indexedCombinations, layoutDimsIds });
+  if (R.isNil(dimInRows)) {
     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 });
+      const [extracted, remains] = extractConcepts(R.prop(toTakeIn, _layout), indexedCombinations, layoutDimsIds);
+      _layout = ({ ..._layout, rows: R.concat(_layout.rows, extracted), [toTakeIn]: remains });
     }
     else {
       _layout = R.over(R.lensProp('rows'), R.append(R.head(_remaining)))(_layout);
@@ -187,9 +203,19 @@ export const getTableLayoutIds = (
     layoutDimsIds,
     attributes,
   );
+
+  const combinationsConcepts = R.pipe(R.pluck('_concepts'), R.unnest, ids => new Set(ids))(combinations);
+  const obsAttributes = R.filter(a => 
+    a.series && R.isEmpty(a.relationship || []) && a.display && !combinationsConcepts.has(a)
+  , attributes);
   const indexedCombinations = R.indexBy(R.prop('id'), layoutCombinations);
   const filteredLayoutIds = R.map(
-    R.filter(id => R.has(id, indexedCombinations) || layoutDimsIds.has(id)),
+    R.filter(id => {
+      if (id === 'OBS_ATTRIBUTES') {
+        return !R.isEmpty(obsAttributes);
+      }
+      return R.has(id, indexedCombinations) || layoutDimsIds.has(id);
+    }),
     defaultLayoutIds,
   );
   const layoutWithCombs = injectCombinationsInLayout(layoutCombinations, filteredLayoutIds);
@@ -236,5 +262,5 @@ export const getTableLayoutIds = (
     return R.over(R.lensProp('remaining'), R.append(dim.id))(acc);
   }, { nextLayout: layoutWithCombs, remaining: [] }, dimensions);
 
-  return injectRemainingDimensionsInLayout(nextLayout, remaining, indexedCombinations);
+  return injectRemainingDimensionsInLayout(nextLayout, remaining, indexedCombinations, layoutDimsIds);
 };

package/src/rules2/src/table/getTableProps.js

@@ -1,3 +1,5 @@
+import * as R from 'ramda';
+import { declineObservationsOverAttributes } from './declineObservationsOverAttributes';
 import { getLayout } from './getLayout';
 import { getSortedLayoutIndexes } from './getSortedLayoutIndexes';
 import { parseLayoutIndexesHierarchies } from './parseSeriesIndexesHierarchies';
@@ -8,6 +10,7 @@ import { getIndexedCombinationsByDisplay } from './getIndexedCombinationsByDispl
 import { getCells } from './getCells';
 import { getCuratedCells } from './getCuratedCells';
 import { getSeriesCombinations } from '../getSeriesCombinations';
+import { getCellsMetadataCoordinates } from './getCellsMetadataCoordinates';
 
 export const getTableProps = ({ data, layoutIds, customAttributes, limit, isTimeInverted }) => {
   const {
@@ -21,22 +24,52 @@ export const getTableProps = ({ data, layoutIds, customAttributes, limit, isTime
     header
   } = data;
 
+  const obsAttributes = R.filter(
+    a => a.series && R.isEmpty(a.relationship) && a.display && !a.combined,
+    attributes
+  );
+  let dupObs = observations;
+  const hasDuplicatedCells = R.pipe(
+    R.values,
+    R.unnest,
+    R.find(R.equals('OBS_ATTRIBUTES')),
+  )(layoutIds);
+  if (hasDuplicatedCells) {
+    const attrsIds = R.pluck('id', obsAttributes);
+    dupObs = declineObservationsOverAttributes(attrsIds, observations);
+  }
   const seriesCombinations = getSeriesCombinations(combinations, oneValueDimensions);
-  const layout = getLayout(layoutIds, dimensions, seriesCombinations, isTimeInverted);
-  const layoutIndexes = getSortedLayoutIndexes(layout, observations);
+  const _dims =  R.append(
+    {
+      id: 'OBS_ATTRIBUTES',
+      values: R.prepend({ id: 'OBS_VALUE' }, obsAttributes),
+    },
+    dimensions,
+  );
+  const layout = getLayout(layoutIds, _dims, seriesCombinations, isTimeInverted);
+  const layoutDimsIds = R.map(R.reduce((acc, entry) => {
+    if (R.has('dimensions', entry)) {
+      return R.concat(acc, R.pluck('id', entry.dimensions));
+    }
+    return R.append(entry.id, acc);
+  }, []), layout);
+  const layoutIndexes = getSortedLayoutIndexes(layout, dupObs);
   const enhancedLayoutIndexes = parseLayoutIndexesHierarchies(
     layoutIndexes,
     layout,
   );
-  const refinedLayoutIndexes = refineLayoutSize({ layout, observations, limit })(enhancedLayoutIndexes);
+  const refinedLayoutIndexes = refineLayoutSize({ layout, observations: dupObs, limit })(enhancedLayoutIndexes);
   const layoutData = getLayoutData(refinedLayoutIndexes, layout, { metadataCoordinates, attributesSeries, customAttributes, topCoordinates: header.coordinates });
 
-  const cellsAttributesIds = getCellsAttributesIds(layoutIds, attributes);
+  const cellsAttributesIds = getCellsAttributesIds(layoutDimsIds, attributes);
   const indexedCombinations = getIndexedCombinationsByDisplay(layout, seriesCombinations);
-  const cells = getCells(customAttributes, cellsAttributesIds, indexedCombinations, attributesSeries, metadataCoordinates)(observations);
+  const cellsMetadataCoordinates = getCellsMetadataCoordinates(metadataCoordinates, oneValueDimensions, layoutDimsIds);
+  const cells = getCells(customAttributes, cellsAttributesIds, indexedCombinations, attributesSeries, cellsMetadataCoordinates)(dupObs);
 
   return ({
     ...layoutData,
-    cells: getCuratedCells(cells, layout)
+    cells: getCuratedCells(cells, layout),
+    layout,
+    combinations: seriesCombinations
   });
 };

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

@@ -299,9 +299,14 @@ export const refineLayoutSize = ({ layout, observations, limit }) => layoutIndex
 
   const { truncated, extractedKeys } = truncateLayout(isVertical)(cutLength, toTruncate);
 
+  const dimsLength = R.pipe(R.values, R.head, R.propOr([], 'orderedDimIndexes'), R.length)(observations);
+  const _layout = R.map( 
+    R.map(entry => entry.id === 'OBS_ATTRIBUTES' ? R.assoc('__index', dimsLength - 1, entry) : entry),
+    layout
+  );
   const curatedObs = R.pipe(
     getShape,
-    (shape) => getCuratedCells({ layout, observations, shape })
+    (shape) => getCuratedCells({ layout: _layout, observations, shape })
   )(isVertical);
 
 

package/src/rules2/src/utils.js

@@ -15,6 +15,13 @@ export const getLayoutCoordinatesValidator = (layoutCoordinates, topCoordinates=
   if (R.isEmpty(coordinates)) {
     return false;
   }
+  if (R.has('OBS_ATTRIBUTES', layoutCoordinates) || R.has('OBS_ATTRIBUTES', topCoordinates)) {
+    const obsAttrCoord = R.prop('OBS_ATTRIBUTES', layoutCoordinates)
+    || R.prop('OBS_ATTRIBUTES', topCoordinates);
+    if (obsAttrCoord !== 'OBS_VALUE') {
+      return false;
+    }
+  }
   const keys = R.keys(coordinates);
   let res = true;
   let notInTop = {};
@@ -26,5 +33,6 @@ export const getLayoutCoordinatesValidator = (layoutCoordinates, topCoordinates=
       notInTop[key] = key;
     }
   }, keys);
-  return res && !R.isEmpty(notInTop);
+  return res;
+  //return res && !R.isEmpty(notInTop);
 };

package/test/getSortedLayoutIndexes.test.js

@@ -1099,4 +1099,40 @@ describe('getSortedLayoutIndexes tests', () => {
 
     expect(getSortedLayoutIndexes(layout, observations)).to.deep.equal(expected); 
   });
+  it('OBS_ATTRIBUTES', () => {
+    const layout = {
+      header: [{ id: 'd1', __index: 0 }, { id: 'OBS_ATTRIBUTES' }],
+      sections: [{ id: 'd2', __index: 1 }],
+      rows: [{ id: 'd3', __index: 2 }],
+    };
+
+    const observations = {
+      '0:0:0:0': { orderedDimIndexes: [0, 0, 0, 0] },
+      '0:0:0:1': { orderedDimIndexes: [0, 0, 0, 1] },
+      '0:0:1:0': { orderedDimIndexes: [0, 0, 1, 0] },
+      '0:0:1:1': { orderedDimIndexes: [0, 0, 1, 1] },
+      '0:1:0:0': { orderedDimIndexes: [0, 1, 0, 0] },
+      '0:1:0:1': { orderedDimIndexes: [0, 1, 0, 1] },
+      '0:1:1:0': { orderedDimIndexes: [0, 1, 1, 0] },
+      '0:1:1:1': { orderedDimIndexes: [0, 1, 1, 1] },
+      '1:0:0:0': { orderedDimIndexes: [1, 0, 0, 0] },
+      '1:0:0:1': { orderedDimIndexes: [1, 0, 0, 1] },
+      '1:0:1:0': { orderedDimIndexes: [1, 0, 1, 0] },
+      '1:0:1:1': { orderedDimIndexes: [1, 0, 1, 1] },
+      '1:1:0:0': { orderedDimIndexes: [1, 1, 0, 0] },
+      '1:1:0:1': { orderedDimIndexes: [1, 1, 0, 1] },
+      '1:1:1:0': { orderedDimIndexes: [1, 1, 1, 0] },
+      '1:1:1:1': { orderedDimIndexes: [1, 1, 1, 1] },
+    };
+
+    const layoutIndexes = {
+      header: [[0, 0], [0, 1], [1, 0], [1, 1]],
+      sections: [
+        [[0], [[0], [1]]],
+        [[1], [[0], [1]]]
+      ]
+    };
+
+    expect(getSortedLayoutIndexes(layout, observations)).to.deep.equal(layoutIndexes);
+  });
 });

package/test/getTableLayoutIds.test.js

@@ -224,4 +224,28 @@ describe('getTableLayoutIds tests', () => {
       rows: ['D4']
     });
   });
+  it('nothing in rows with combination without dimensions', () => {
+    const combinations = [{
+      id: 'COMB',
+      concepts: ['A1', 'A2']
+    }];
+    const attributes = [
+      { id: 'A1', series: true, relationship: ['D1'] },
+      { id: 'A2', series: true, relationship: ['D1'] },
+    ]
+    const dimensions = [
+      { id: 'D1' },
+      { id: 'D2' },
+    ];
+    const layoutIds = {
+      header: ['D2'],
+      sections: ['COMB', 'D1'],
+      rows: ['D3']
+    };
+    expect(getTableLayoutIds(layoutIds, dimensions, attributes, combinations)).to.deep.equal({
+      header: ['D2'],
+      sections: [],
+      rows: ['COMB', 'D1']
+    });
+  });
 });

package/test/refineLayoutSize2.test.js

@@ -403,6 +403,109 @@ describe('refineLayoutSize 2 tests', () => {
       })(layoutIndexes)
     ).to.deep.equal(expected);
   });
+  it('truncation with OBS_ATTRIBUTES in layout', () => {
+    const layout = {
+      header: [{ __index: 1 }, { id: 'OBS_ATTRIBUTES' }],
+      rows: [{ __index: 0 }],
+      sections: [],
+    };
+
+    const layoutIndexes = {
+      header: [
+        { indexes: [0, 0], parentsIndexes: [[]], missingIndexes: [[]] },
+        { indexes: [0, 1], parentsIndexes: [[]], missingIndexes: [[]] },
+        { indexes: [1, 0], parentsIndexes: [[]], missingIndexes: [[]] },
+        { indexes: [1, 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: [[]] },
+            { indexes: [6], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [7], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [8], parentsIndexes: [[]], missingIndexes: [[]] },
+          ]
+        ]
+      ]
+    };
+
+    const observations = {
+      '0:0:0': { orderedDimIndexes: [0, 0, 0] },
+      '0:0:1': { orderedDimIndexes: [0, 0, 1] },
+      '0:1:0': { orderedDimIndexes: [0, 1, 0] },
+      '0:1:1': { orderedDimIndexes: [0, 1, 1] },    
+      '1:0:0': { orderedDimIndexes: [1, 0, 0] },
+      '1:0:1': { orderedDimIndexes: [1, 0, 1] },
+      '1:1:0': { orderedDimIndexes: [1, 1, 0] },
+      '1:1:1': { orderedDimIndexes: [1, 1, 1] },
+      '2:0:0': { orderedDimIndexes: [2, 0, 0] },
+      '2:0:1': { orderedDimIndexes: [2, 0, 1] },
+      '2:1:0': { orderedDimIndexes: [2, 1, 0] },
+      '2:1:1': { orderedDimIndexes: [2, 1, 1] },
+      '3:0:0': { orderedDimIndexes: [3, 0, 0] },
+      '3:0:1': { orderedDimIndexes: [3, 0, 1] },
+      '3:1:0': { orderedDimIndexes: [3, 1, 0] },
+      '3:1:1': { orderedDimIndexes: [3, 1, 1] },
+      '4:0:0': { orderedDimIndexes: [4, 0, 0] },
+      '4:0:1': { orderedDimIndexes: [4, 0, 1] },
+      '4:1:0': { orderedDimIndexes: [4, 1, 0] },
+      '4:1:1': { orderedDimIndexes: [4, 1, 1] },
+      '5:0:0': { orderedDimIndexes: [5, 0, 0] },
+      '5:0:1': { orderedDimIndexes: [5, 0, 1] },
+      '5:1:0': { orderedDimIndexes: [5, 1, 0] },
+      '5:1:1': { orderedDimIndexes: [5, 1, 1] },
+      '6:0:0': { orderedDimIndexes: [6, 0, 0] },
+      '6:0:1': { orderedDimIndexes: [6, 0, 1] },
+      '6:1:0': { orderedDimIndexes: [6, 1, 0] },
+      '6:1:1': { orderedDimIndexes: [6, 1, 1] },
+      '7:0:0': { orderedDimIndexes: [7, 0, 0] },
+      '7:0:1': { orderedDimIndexes: [7, 0, 1] },
+      '7:1:0': { orderedDimIndexes: [7, 1, 0] },
+      '7:1:1': { orderedDimIndexes: [7, 1, 1] },
+      '8:0:0': { orderedDimIndexes: [8, 0, 0] },
+      '8:0:1': { orderedDimIndexes: [8, 0, 1] },
+      '8:1:0': { orderedDimIndexes: [8, 1, 0] },
+      '8:1:1': { orderedDimIndexes: [8, 1, 1] },
+    };
+
+    const expected = {
+      header: [
+        { indexes: [0, 0], parentsIndexes: [[]], missingIndexes: [[]] },
+        { indexes: [0, 1], parentsIndexes: [[]], missingIndexes: [[]] },
+        { indexes: [1, 0], parentsIndexes: [[]], missingIndexes: [[]] },
+        { indexes: [1, 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: [[]] },
+          ]
+        ]
+      ],
+      truncated: true,
+      totalCells: 70
+    };
+
+    expect(
+      refineLayoutSize({
+        layout,
+        observations,
+        limit: 52
+      })(layoutIndexes)
+    ).to.deep.equal(expected);
+  });
   /*it('no rows', () => {
 
     const layout = {