@sis-cc/dotstatsuite-components 17.26.1 → 17.28.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/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;
 

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

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

package/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/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.26.1",
+  "version": "17.28.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/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);
 };
 

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

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

package/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/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

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