@sis-cc/dotstatsuite-components 16.1.6 → 16.3.0

package/lib/rules2/src/enhanceObservations.js

@@ -36,13 +36,10 @@ var parseAttributesValues = function parseAttributesValues(obs, attributes, inde
 
   return R.addIndex(R.reduce)(function (acc, valueIndex, attrIndex) {
     var attribute = R.nth(attrIndex, attributes);
-    if (R.isNil(attribute) || !R.propOr(true, 'display', attribute) || !R.prop('series', attribute)) {
+    if (R.isNil(attribute) || !R.prop('series', attribute)) {
       return acc;
     }
     var value = R.nth(valueIndex, attribute.values || []);
-    if (!R.propOr(true, 'display', value) || R.includes(R.prop('id', value), _constants.REJECTED_VALUE_IDS)) {
-      value = null;
-    }
     var relationship = R.propOr([], 'relationship', attribute);
     var coordinates = {};
     var serieKey = R.pipe(function (dims) {

package/lib/rules2/src/getHeaderCombinations.js

@@ -23,20 +23,32 @@ var getHeaderCombinations = exports.getHeaderCombinations = function getHeaderCo
 
     var header = (0, _src.dimensionValueDisplay)(display)(comb);
 
-    var values = R.pipe(R.reduce(function (_acc, concept) {
+    var combinedDisplay = function combinedDisplay(_display, values) {
+      if (_display === 'label') {
+        return R.pipe(R.filter(R.propOr(true, 'display')), R.map((0, _src.dimensionValueDisplay)(_display)), R.join(', '))(values);
+      }
+      return R.pipe(R.map((0, _src.dimensionValueDisplay)(_display)), R.join(', '))(values);
+    };
+
+    var label = R.pipe(R.reduce(function (_acc, concept) {
       var artefact = R.has(concept, indexedDimensions) ? R.prop(concept, indexedDimensions) : R.prop(concept, indexedAttributes);
       if (R.isNil(artefact) || !R.propOr(true, 'display', artefact || {})) {
         return _acc;
       }
       var value = R.path(['values', 0], artefact);
-      if (R.isNil(value) || !R.propOr(true, 'display', value || {})) {
+      if (R.isNil(value)) {
         return _acc;
       }
-      return R.append((0, _src.dimensionValueDisplay)(display)(value), _acc);
-    }, []), R.join(', '))(comb.concepts || []);
-    if (R.isEmpty(values)) {
+      return R.append(value, _acc);
+    }, []), function (values) {
+      if (display === 'both') {
+        return '(' + combinedDisplay('code', values) + ') ' + combinedDisplay('label', values);
+      }
+      return combinedDisplay(display, values);
+    })(comb.concepts || []);
+    if (R.isEmpty(label)) {
       return acc;
     }
-    return R.append({ header: header, label: values }, acc);
+    return R.append({ header: header, label: label }, acc);
   }, [], combinations);
 };

package/lib/rules2/src/getOneValueDimensions.js

@@ -39,7 +39,7 @@ var getOneValueDimensions = exports.getOneValueDimensions = function getOneValue
     })(acc);
   }, {}, attributes);
   return R.reduce(function (acc, dim) {
-    if (R.length(dim.values || []) !== 1 || !R.propOr(true, 'display', dim) || !R.pathOr(true, ['values', 0, 'display'], dim) || R.includes(R.path(['values', 0, 'id'], dim), _constants.REJECTED_VALUE_IDS)) {
+    if (R.length(dim.values || []) !== 1) {
       return acc;
     }
     var attrValues = R.propOr({}, dim.id, indexedRelevantAttributes);

package/lib/rules2/src/getSeriesCombinations.js

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSeriesCombinations = 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 getSeriesCombinations = exports.getSeriesCombinations = function getSeriesCombinations(combinations, oneValuesDimensions) {
+  var indexedValues = R.reduce(function (acc, dim) {
+    var value = R.head(dim.values);
+    return R.assoc(dim.id, value, acc);
+  }, {}, oneValuesDimensions);
+
+  return R.reduce(function (acc, comb) {
+    if (!R.prop('series', comb)) {
+      return acc;
+    }
+    var fixedDimValues = R.pick(comb.concepts, indexedValues);
+    return R.append((0, _extends3.default)({}, comb, { fixedDimValues: fixedDimValues }), acc);
+  }, [], combinations);
+};

package/lib/rules2/src/index.js

@@ -247,6 +247,15 @@ Object.defineProperty(exports, 'getHeaderSubtitle', {
   }
 });
 
+var _getSeriesCombinations = require('./getSeriesCombinations');
+
+Object.defineProperty(exports, 'getSeriesCombinations', {
+  enumerable: true,
+  get: function get() {
+    return _getSeriesCombinations.getSeriesCombinations;
+  }
+});
+
 var _getHeaderCombinations = require('./getHeaderCombinations');
 
 Object.defineProperty(exports, 'getHeaderCombinations', {
@@ -362,4 +371,13 @@ Object.defineProperty(exports, 'getTableProps', {
   get: function get() {
     return _getTableProps.getTableProps;
   }
+});
+
+var _getTableLabelAccessor = require('./table/getTableLabelAccessor');
+
+Object.defineProperty(exports, 'getTableLabelAccessor', {
+  enumerable: true,
+  get: function get() {
+    return _getTableLabelAccessor.getTableLabelAccessor;
+  }
 });

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getCells = exports.getCellCombinedAttributes = exports.getCellRelevantAttributes = undefined;
+exports.getCells = exports.getCellCombinedSeries = exports.getCellRelevantAttributes = undefined;
 
 var _extends2 = require('babel-runtime/helpers/extends');
 
@@ -17,8 +17,6 @@ var _getFlagsAndNotes = require('./getFlagsAndNotes');
 
 var _hasCellMetadata = require('../hasCellMetadata');
 
-var _utils = require('../utils');
-
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -36,13 +34,22 @@ var getCellRelevantAttributes = exports.getCellRelevantAttributes = function get
   }, attributes);
 };
 
-var getCellCombinedAttributes = exports.getCellCombinedAttributes = function getCellCombinedAttributes(attributes, combinations) {
+var getCellCombinedSeries = exports.getCellCombinedSeries = function getCellCombinedSeries(attributes, combinations) {
   return R.reduce(function (acc, comb) {
-    var values = (0, _utils.trimedProps)(comb.concepts, attributes);
+    var values = R.reduce(function (acc, concept) {
+      if (R.has(concept, comb.fixedDimValues || {})) {
+        return R.append(R.prop(concept, comb.fixedDimValues), acc);
+      }
+      if (R.has(concept, attributes || {})) {
+        return R.append(R.path([concept, 'value'], attributes), acc);
+      }
+      return acc;
+    }, [], comb.concepts);
+
     if (R.isEmpty(values)) {
       return acc;
     }
-    return R.append((0, _extends3.default)({}, R.pick(['id', 'name'], comb), { values: R.pluck('value', values) }), acc);
+    return R.append((0, _extends3.default)({}, R.pick(['id', 'name'], comb), { values: values }), acc);
   }, [], combinations);
 };
 
@@ -60,13 +67,13 @@ var getCells = exports.getCells = function getCells(customAttributes, cellsAttri
     return R.mapObjIndexed(function (obs) {
       var relevantAttributes = getCellRelevantAttributes(obs.attributes, attributesSeries, cellsAttributesId);
       var flagsAndNotes = (0, _getFlagsAndNotes.getFlagsAndNotes)(R.omit(attributesInCellsCombination, relevantAttributes), _customAttributes);
-      var combinedAttributes = getCellCombinedAttributes(relevantAttributes, combinations.cells || []);
+      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 hasMetadata = (0, _hasCellMetadata.hasCellMetadata)(metadataCoordinates, obs.indexedDimValIds);
 
       return (0, _extends3.default)({}, R.pick(['indexedDimValIds', 'key'], obs), {
-        flags: R.concat(flagsAndNotes, combinedAttributes),
+        flags: R.concat(flagsAndNotes, combinedSeries),
         sideProps: hasAdvancedAttributes || hasMetadata ? { hasAdvancedAttributes: hasAdvancedAttributes, hasMetadata: hasMetadata, coordinates: obs.indexedDimValIds } : null,
         intValue: R.is(Number, obs.value) ? obs.value : null,
         value: obs.formattedValue

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

@@ -9,6 +9,8 @@ var _ramda = require('ramda');
 
 var R = _interopRequireWildcard(_ramda);
 
+var _constants = require('../constants');
+
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
 
 var getFlagsAndNotes = exports.getFlagsAndNotes = function getFlagsAndNotes(attributesValues, customAttributes) {
@@ -20,7 +22,7 @@ var getFlagsAndNotes = exports.getFlagsAndNotes = function getFlagsAndNotes(attr
       return acc;
     }
     var attr = R.prop(id, attributesValues);
-    if (R.isNil(attr.value)) {
+    if (R.isNil(attr.value) || !R.pathOr(true, ['value', 'display'], attr) || !R.propOr(true, 'display', attr) || R.includes(R.path(['value', 'id'], attr), _constants.REJECTED_VALUE_IDS)) {
       return acc;
     }
     return R.append(index < flagsIds.length ? R.assoc('code', R.path(['value', 'id'], attr), attr) : attr, acc);

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

@@ -25,14 +25,10 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var getLayout = exports.getLayout = function getLayout(layoutIds, dimensions, combinations, isTimeInverted, fixedDimensions) {
+var getLayout = exports.getLayout = function getLayout(layoutIds, dimensions, combinations, isTimeInverted) {
   var indexedDimensions = R.pipe(R.indexBy(R.prop('id')), R.map(function (d) {
     return (0, _dotstatsuiteSdmxjs.isTimePeriodDimension)(d) && isTimeInverted ? R.assoc('isInverted', true, d) : d;
   }))(dimensions);
-  var indexedFixedDimsValues = R.reduce(function (acc, dim) {
-    var value = R.head(dim.values);
-    return !dim.display || !value.display ? acc : R.assoc(dim.id, R.head(dim.values), acc);
-  }, {}, fixedDimensions);
   var indexedHeaderIds = R.indexBy(R.identity, layoutIds.header);
   var indexedSectionsIds = R.indexBy(R.identity, layoutIds.sections);
   var indexedRowsIds = (0, _extends3.default)({}, indexedSectionsIds, R.indexBy(R.identity, layoutIds.rows));
@@ -51,8 +47,7 @@ var getLayout = exports.getLayout = function getLayout(layoutIds, dimensions, co
 
     if (R.isEmpty(rest)) {
       layout = R.over(R.lensProp('header'), R.append((0, _extends3.default)({}, comb, {
-        dimensions: (0, _utils.trimedProps)(comb.concepts, indexedDimensions),
-        fixedDimValues: R.pick(comb.concepts, indexedFixedDimsValues)
+        dimensions: (0, _utils.trimedProps)(comb.concepts, indexedDimensions)
       })))(layout);
     } else if (!R.isEmpty(idsInHeader)) {
       return;
@@ -62,8 +57,7 @@ var getLayout = exports.getLayout = function getLayout(layoutIds, dimensions, co
       }, comb.relationship);
       if (R.isEmpty(idsNotInSections)) {
         layout = R.over(R.lensProp('sections'), R.append((0, _extends3.default)({}, comb, {
-          dimensions: (0, _utils.trimedProps)(comb.concepts, indexedDimensions),
-          fixedDimValues: R.pick(comb.concepts, indexedFixedDimsValues)
+          dimensions: (0, _utils.trimedProps)(comb.concepts, indexedDimensions)
         })))(layout);
       } else {
         var idsNotInRows = R.reject(function (id) {
@@ -73,8 +67,7 @@ var getLayout = exports.getLayout = function getLayout(layoutIds, dimensions, co
           layout = R.over(R.lensProp('rows'), R.append((0, _extends3.default)({}, comb, {
             dimensions: R.pipe(R.omit(layoutIds.sections), function (o) {
               return (0, _utils.trimedProps)(comb.concepts, o);
-            })(indexedDimensions),
-            fixedDimValues: R.pick(comb.concepts, indexedFixedDimsValues)
+            })(indexedDimensions)
           })))(layout);
         }
       }

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

@@ -145,10 +145,7 @@ var getSubLayoutData = function getSubLayoutData(series, _definition, _ref) {
       var values = R.reduce(function (_acc, id) {
         if (R.has(id, dimValues)) {
           var _value = R.prop(id, dimValues);
-          if (!R.propOr(true, 'display', _value) || R.includes(R.prop('id', _value), _constants.REJECTED_VALUE_IDS)) {
-            return _acc;
-          }
-          return R.append(R.dissoc('display', _value), _acc);
+          return R.append(_value, _acc);
         }
         if (R.has(id, fixedDimValues)) {
           return R.append(R.prop(id, fixedDimValues), _acc);

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

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTableLabelAccessor = undefined;
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+var _src = require('../../../rules/src');
+
+var _constants = require('../constants');
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+var getRefinedMissinParentsLabels = R.pipe(R.propOr([], 'missingParents'), R.reduce(function (acc, par) {
+  if (!R.propOr(true, 'display', par) || R.includes(par.id, _constants.REJECTED_VALUE_IDS)) {
+    return acc;
+  }
+  return R.append((0, _src.dimensionValueDisplay)('label')(par), acc);
+}, []));
+
+var granularDisplay = function granularDisplay(display, value) {
+  if (display === 'label') {
+    return R.converge(function (missingParents, label) {
+      return R.isEmpty(missingParents) ? label : R.join(' > ', R.append(label, missingParents));
+    }, [getRefinedMissinParentsLabels, (0, _src.dimensionValueDisplay)(display)])(value);
+  } else if (display === 'both') {
+    return '(' + granularDisplay('code', value) + ') ' + granularDisplay('label', value);
+  }
+  return (0, _src.dimensionValueDisplay)(display)(value);
+};
+
+var combinedDisplay = function combinedDisplay(_display) {
+  return R.pipe(R.reduce(function (acc, val) {
+    if ((!R.propOr(true, 'display', val) || R.includes(val.id, _constants.REJECTED_VALUE_IDS)) && _display === 'label') {
+      return acc;
+    }
+    return R.append(granularDisplay(_display, val), acc);
+  }, []), R.join(', '));
+};
+
+var getTableLabelAccessor = exports.getTableLabelAccessor = function getTableLabelAccessor(display) {
+  return function (item) {
+    if (!R.is(Array, item)) {
+      return granularDisplay(display, item);
+    }
+    if (display === 'both') {
+      return R.converge(function (ids, labels) {
+        return '(' + ids + ') ' + labels;
+      }, [combinedDisplay('code'), combinedDisplay('label')])(item);
+    }
+    return combinedDisplay(display)(item);
+  };
+};

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

@@ -29,6 +29,8 @@ var _getCells = require('./getCells');
 
 var _getCuratedCells = require('./getCuratedCells');
 
+var _getSeriesCombinations = require('../getSeriesCombinations');
+
 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 }; }
@@ -48,8 +50,8 @@ var getTableProps = exports.getTableProps = function getTableProps(_ref) {
       attributes = data.attributes;
 
 
-  var seriesCombinations = R.filter(R.prop('series'), combinations);
-  var layout = (0, _getLayout.getLayout)(layoutIds, dimensions, seriesCombinations, isTimeInverted, oneValueDimensions);
+  var seriesCombinations = (0, _getSeriesCombinations.getSeriesCombinations)(combinations, oneValueDimensions);
+  var layout = (0, _getLayout.getLayout)(layoutIds, dimensions, seriesCombinations, isTimeInverted);
   var layoutIndexes = (0, _getSortedLayoutIndexes.getSortedLayoutIndexes)(layout, observations);
   var refinedLayoutIndexes = (0, _refineLayoutSize.refineLayoutSize)({ layout: layout, observations: observations, limit: limit })(layoutIndexes);
   var layoutData = (0, _getLayoutData.getLayoutData)(refinedLayoutIndexes, layout, { metadataCoordinates: metadataCoordinates, attributesSeries: attributesSeries, customAttributes: customAttributes });

package/package.json

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

package/src/rules2/src/enhanceObservations.js

@@ -16,13 +16,10 @@ const parseAttributesValues = (obs, attributes, indexedDimensions) => {
   return R.addIndex(R.reduce)(
     (acc, valueIndex, attrIndex) => {
       const attribute = R.nth(attrIndex, attributes);
-      if (R.isNil(attribute) || !R.propOr(true, 'display', attribute) || !R.prop('series', attribute)) {
+      if (R.isNil(attribute) || !R.prop('series', attribute)) {
         return acc;
       }
       let value = R.nth(valueIndex, attribute.values || []);
-      if (!R.propOr(true, 'display', value) || R.includes(R.prop('id', value), REJECTED_VALUE_IDS)) {
-        value = null;
-      }
       const relationship = R.propOr([], 'relationship', attribute);
       let coordinates = {};
       const serieKey = R.pipe(

package/src/rules2/src/getHeaderCombinations.js

@@ -12,26 +12,41 @@ export const getHeaderCombinations = (combinations, dimensions, attributes, disp
 
       const header = dimensionValueDisplay(display)(comb);
 
-      const values = R.pipe(
-        R.reduce((_acc, concept) => {
-          const artefact = R.has(concept, indexedDimensions)
-            ? R.prop(concept, indexedDimensions)
-            : R.prop(concept, indexedAttributes);
-          if (R.isNil(artefact) || !R.propOr(true, 'display', artefact || {})) {
-            return _acc;
-          }
-          const value = R.path(['values', 0], artefact);
-          if (R.isNil(value) || !R.propOr(true, 'display', value || {})) {
-            return _acc;
+      const combinedDisplay = (_display, values) => {
+        if (_display === 'label') {
+          return R.pipe(R.filter(R.propOr(true, 'display')), R.map(dimensionValueDisplay(_display)), R.join(', '))(values);
+        }
+        return R.pipe(R.map(dimensionValueDisplay(_display)), R.join(', '))(values);
+      };
+
+      const label = R.pipe(
+        R.reduce(
+          (_acc, concept) => {
+            const artefact = R.has(concept, indexedDimensions)
+              ? R.prop(concept, indexedDimensions)
+              : R.prop(concept, indexedAttributes);
+            if (R.isNil(artefact) || !R.propOr(true, 'display', artefact || {})) {
+              return _acc;
+            }
+            const value = R.path(['values', 0], artefact);
+            if (R.isNil(value)) {
+              return _acc;
+            }
+            return R.append(value, _acc);
+          },
+          []
+        ),
+        values => {
+          if (display === 'both') {
+            return `(${combinedDisplay('code', values)}) ${combinedDisplay('label', values)}`
           }
-          return R.append(dimensionValueDisplay(display)(value), _acc);
-        }, []),
-        R.join(', '),
+          return combinedDisplay(display, values);
+        }
       )(comb.concepts || []);
-      if (R.isEmpty(values)) {
+      if (R.isEmpty(label)) {
         return acc;
       }
-      return R.append({ header, label: values }, acc);
+      return R.append({ header, label }, acc);
     },
     [],
     combinations,

package/src/rules2/src/getOneValueDimensions.js

@@ -22,8 +22,7 @@ export const getOneValueDimensions = (dimensions, attributes) => {
   );
   return R.reduce(
     (acc, dim) => {
-      if (R.length(dim.values || []) !== 1 || !R.propOr(true, 'display', dim) || !R.pathOr(true, ['values', 0, 'display'], dim)
-        || R.includes(R.path(['values', 0, 'id'], dim), REJECTED_VALUE_IDS)) {
+      if (R.length(dim.values || []) !== 1) {
         return acc;
       }
       const attrValues = R.propOr({}, dim.id, indexedRelevantAttributes);

package/src/rules2/src/getSeriesCombinations.js

@@ -0,0 +1,24 @@
+import * as R from 'ramda';
+
+export const getSeriesCombinations = (combinations, oneValuesDimensions) => {
+  const indexedValues =  R.reduce(
+    (acc, dim) => {
+      const value = R.head(dim.values);
+      return R.assoc(dim.id, value, acc);
+    },
+    {},
+    oneValuesDimensions
+  );
+
+  return R.reduce(
+    (acc, comb) => {
+      if (!R.prop('series', comb)) {
+        return acc;
+      }
+      const fixedDimValues = R.pick(comb.concepts, indexedValues);
+      return R.append({ ...comb, fixedDimValues }, acc);
+    },
+    [],
+    combinations
+  );
+};

package/src/rules2/src/index.js

@@ -28,6 +28,7 @@ export { getOneValueDimensions } from './getOneValueDimensions';
 export { getDataflowAttributes } from './getDataflowAttributes';
 export { getHeaderTitle } from './getHeaderTitle';
 export { getHeaderSubtitle } from './getHeaderSubtitle';
+export { getSeriesCombinations } from './getSeriesCombinations';
 export { getHeaderCombinations } from './getHeaderCombinations';
 export { getLayout } from './table/getLayout';
 export { getSortedLayoutIndexes } from './table/getSortedLayoutIndexes';
@@ -41,3 +42,4 @@ export { getCells } from './table/getCells';
 export { getCuratedCells } from './table/getCuratedCells';
 export { prepareData } from './prepareData';
 export { getTableProps } from './table/getTableProps';
+export { getTableLabelAccessor } from './table/getTableLabelAccessor';

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

@@ -1,7 +1,6 @@
 import * as R from 'ramda';
 import { getFlagsAndNotes } from './getFlagsAndNotes';
 import { hasCellMetadata } from '../hasCellMetadata';
-import { trimedProps } from '../utils';
 
 export const getCellRelevantAttributes = (attributes, attributesSeries, cellAttributeIds) => R.filter(
   (attr) => {
@@ -17,17 +16,30 @@ export const getCellRelevantAttributes = (attributes, attributesSeries, cellAttr
   attributes
 );
 
-export const getCellCombinedAttributes = (attributes, combinations) => R.reduce(
+export const getCellCombinedSeries = (attributes, combinations) => R.reduce(
   (acc, comb) => {
-    const values = trimedProps(comb.concepts, attributes);
+    const values = R.reduce(
+      (acc, concept) => {
+        if (R.has(concept, comb.fixedDimValues || {})) {
+          return R.append(R.prop(concept, comb.fixedDimValues), acc);
+        }
+        if (R.has(concept, attributes || {})) {
+          return R.append(R.path([concept, 'value'], attributes), acc);
+        }
+        return acc;
+      },
+      [],
+      comb.concepts
+    );
+
     if (R.isEmpty(values)) {
       return acc;
     }
-    return R.append({ ...R.pick(['id', 'name'], comb), values: R.pluck('value', values) }, acc);
+    return R.append({ ...R.pick(['id', 'name'], comb), values }, acc);
   },
   [],
   combinations
-)
+);
 
 // combinations = { cells, layout };
 export const getCells = (customAttributes, cellsAttributesId, combinations, attributesSeries, metadataCoordinates) => observations => {
@@ -52,7 +64,7 @@ export const getCells = (customAttributes, cellsAttributesId, combinations, attr
     obs => {
       const relevantAttributes = getCellRelevantAttributes(obs.attributes, attributesSeries, cellsAttributesId);
       const flagsAndNotes = getFlagsAndNotes(R.omit(attributesInCellsCombination, relevantAttributes), _customAttributes);
-      const combinedAttributes = getCellCombinedAttributes(relevantAttributes, combinations.cells || []);
+      const combinedSeries = getCellCombinedSeries(relevantAttributes, combinations.cells || []);
       const hasAdvancedAttributes = R.pipe(
         R.omit(R.unnest([_customAttributes.flags || [], _customAttributes.notes || [], attributesInCellsCombination])),
         R.isEmpty,
@@ -63,7 +75,7 @@ export const getCells = (customAttributes, cellsAttributesId, combinations, attr
 
       return ({
         ...R.pick(['indexedDimValIds', 'key'], obs),
-        flags: R.concat(flagsAndNotes, combinedAttributes),
+        flags: R.concat(flagsAndNotes, combinedSeries),
         sideProps: hasAdvancedAttributes || hasMetadata ? { hasAdvancedAttributes, hasMetadata, coordinates: obs.indexedDimValIds } : null,
         intValue: R.is(Number, obs.value) ? obs.value : null,
         value: obs.formattedValue,

package/src/rules2/src/table/getFlagsAndNotes.js

@@ -1,4 +1,5 @@
 import * as R from 'ramda';
+import { REJECTED_VALUE_IDS } from '../constants';
 
 export const getFlagsAndNotes = (attributesValues, customAttributes) => {
   const flagsIds = R.propOr([], 'flags', customAttributes);
@@ -10,7 +11,8 @@ export const getFlagsAndNotes = (attributesValues, customAttributes) => {
         return acc;
       }
       const attr = R.prop(id, attributesValues);
-      if (R.isNil(attr.value)) {
+      if (R.isNil(attr.value) || !R.pathOr(true, ['value', 'display'], attr) || !R.propOr(true, 'display', attr)
+        || R.includes(R.path(['value', 'id'], attr), REJECTED_VALUE_IDS)) {
         return acc;
       }
       return R.append(index < flagsIds.length ? R.assoc('code', R.path(['value', 'id'], attr), attr) : attr, acc);

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

@@ -2,19 +2,11 @@ import * as R from 'ramda';
 import { isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
 import { trimedProps } from '../utils';
 
-export const getLayout = (layoutIds, dimensions, combinations, isTimeInverted, fixedDimensions) => {
+export const getLayout = (layoutIds, dimensions, combinations, isTimeInverted) => {
     const indexedDimensions = R.pipe(
       R.indexBy(R.prop('id')),
       R.map(d => (isTimePeriodDimension(d) && isTimeInverted ? R.assoc('isInverted', true, d) : d)),
     )(dimensions);
-    const indexedFixedDimsValues = R.reduce(
-      (acc, dim) => {
-        const value = R.head(dim.values);
-        return !dim.display || !value.display ? acc : R.assoc(dim.id, R.head(dim.values), acc);
-      },
-      {},
-      fixedDimensions,
-    );
     const indexedHeaderIds = R.indexBy(R.identity, layoutIds.header);
     const indexedSectionsIds = R.indexBy(R.identity, layoutIds.sections);
     const indexedRowsIds = { ...indexedSectionsIds, ...R.indexBy(R.identity, layoutIds.rows) };
@@ -30,7 +22,6 @@ export const getLayout = (layoutIds, dimensions, combinations, isTimeInverted, f
           R.append({
             ...comb,
             dimensions: trimedProps(comb.concepts, indexedDimensions),
-            fixedDimValues: R.pick(comb.concepts, indexedFixedDimsValues),
           }),
         )(layout);
       } else if (!R.isEmpty(idsInHeader)) {
@@ -43,7 +34,6 @@ export const getLayout = (layoutIds, dimensions, combinations, isTimeInverted, f
             R.append({
               ...comb,
               dimensions: trimedProps(comb.concepts, indexedDimensions),
-              fixedDimValues: R.pick(comb.concepts, indexedFixedDimsValues),
             }),
           )(layout);
         } else {
@@ -56,7 +46,6 @@ export const getLayout = (layoutIds, dimensions, combinations, isTimeInverted, f
                 dimensions: R.pipe(R.omit(layoutIds.sections), o => trimedProps(comb.concepts, o))(
                   indexedDimensions,
                 ),
-                fixedDimValues: R.pick(comb.concepts, indexedFixedDimsValues),
               }),
             )(layout);
           }

package/src/rules2/src/table/getLayoutData.js

@@ -122,10 +122,7 @@ const getSubLayoutData = (series, _definition, { metadataCoordinates, attributes
             (_acc, id) => {
               if (R.has(id, dimValues)) {
                 const value = R.prop(id, dimValues);
-                if (!R.propOr(true, 'display', value) || R.includes(R.prop('id', value), REJECTED_VALUE_IDS)) {
-                  return _acc;
-                }
-                return R.append(R.dissoc('display', value), _acc);
+                return R.append(value, _acc);
               }
               if (R.has(id, fixedDimValues)) {
                 return R.append(R.prop(id, fixedDimValues), _acc);

package/src/rules2/src/table/getTableLabelAccessor.js

@@ -0,0 +1,53 @@
+import * as R from 'ramda';
+import { dimensionValueDisplay } from '../../../rules/src';
+import { REJECTED_VALUE_IDS } from '../constants';
+
+const getRefinedMissinParentsLabels = R.pipe(
+  R.propOr([], 'missingParents'),
+  R.reduce((acc, par) => {
+    if (!R.propOr(true, 'display', par) || R.includes(par.id, REJECTED_VALUE_IDS)) {
+      return acc;
+    }
+    return R.append(dimensionValueDisplay('label')(par), acc);
+  }, []),
+);
+
+const granularDisplay = (display, value) => {
+    if (display === 'label') {
+      return R.converge(
+        (missingParents, label) =>
+          R.isEmpty(missingParents) ? label : R.join(' > ', R.append(label, missingParents)),
+        [
+          getRefinedMissinParentsLabels,
+          dimensionValueDisplay(display),
+        ],
+      )(value);
+    } else if (display === 'both') {
+      return `(${granularDisplay('code', value)}) ${granularDisplay('label', value)}`;
+    }
+    return dimensionValueDisplay(display)(value);
+  };
+
+const combinedDisplay = _display => R.pipe(
+  R.reduce((acc, val) => {
+    if ((!R.propOr(true, 'display', val) || R.includes(val.id, REJECTED_VALUE_IDS))
+      && _display === 'label') {
+      return acc;
+    }
+    return R.append(granularDisplay(_display, val), acc);
+  }, []),
+  R.join(', '),
+);
+
+export const getTableLabelAccessor = display => item => {
+  if (!R.is(Array, item)) {
+    return granularDisplay(display, item);
+  }
+  if (display === 'both') {
+    return R.converge((ids, labels) => `(${ids}) ${labels}`, [
+      combinedDisplay('code'),
+      combinedDisplay('label'),
+    ])(item);
+  }
+  return combinedDisplay(display)(item);
+}; 

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

@@ -7,6 +7,7 @@ import { getCellsAttributesIds } from './getCellsAttributesIds';
 import { getIndexedCombinationsByDisplay } from './getIndexedCombinationsByDisplay';
 import { getCells } from './getCells';
 import { getCuratedCells } from './getCuratedCells';
+import { getSeriesCombinations } from '../getSeriesCombinations';
 
 export const getTableProps = ({ data, layoutIds, customAttributes, limit, isTimeInverted }) => {
   const {
@@ -19,8 +20,8 @@ export const getTableProps = ({ data, layoutIds, customAttributes, limit, isTime
     attributes
   } = data;
 
-  const seriesCombinations = R.filter(R.prop('series'), combinations);
-  const layout = getLayout(layoutIds, dimensions, seriesCombinations, isTimeInverted, oneValueDimensions);
+  const seriesCombinations = getSeriesCombinations(combinations, oneValueDimensions);
+  const layout = getLayout(layoutIds, dimensions, seriesCombinations, isTimeInverted);
   const layoutIndexes = getSortedLayoutIndexes(layout, observations);
   const refinedLayoutIndexes = refineLayoutSize({ layout, observations, limit })(layoutIndexes);
   const layoutData = getLayoutData(refinedLayoutIndexes, layout, { metadataCoordinates, attributesSeries, customAttributes });

package/test/getCells.test.js

@@ -8,7 +8,8 @@ const customAttributes = {
 
 describe('getCells tests', () => {
   it('flags', () => {
-    expect(getCells(customAttributes, ['FL1', 'FL2', 'FT1', 'FT2', 'FT3'], [], {}, {})({
+    expect(
+      getCells(customAttributes, ['FL1', 'FL2', 'FT1', 'FT2', 'FT3'], [], {}, [])({
         a: {
           key: 'a',
           value: 33,
@@ -21,8 +22,7 @@ describe('getCells tests', () => {
           },
           indexedDimValIds: {}
         }
-    }, 'label', customAttributes,
-    { unitsDefinitionCodes: [], unitsSeries: {}, unitsDisplay: 'cells', unitDimension: {} }, [])).to.deep.equal({
+    })).to.deep.equal({
       a: {
         key: 'a',
         value: '33',
@@ -37,4 +37,45 @@ describe('getCells tests', () => {
       }
     })
   });
+  it('combinations', () => {
+    const combinations = {
+      cells: [{ id: 'CELLS_COMB', concepts: ['D1', 'D2', 'A1', 'A4'], fixedDimValues: { D1: { id: 'D1V' } } }],
+      layout: [{ id: 'LAYOUT_COMB', concepts: ['D3', 'A2', 'A3'] }]
+    };
+
+    const attributesSeries = {
+      'D3=v0': { serieKey: 'D3=v0', A2: { value: 'A2V' } }
+    };
+
+    const cellsAttributesIds = ['FL1', 'FT1', 'A1'];
+
+    const observations = {
+      'obs': {
+        formattedValue: '33',
+        value: 33,
+        attributes: {
+          FL1: { id: 'FL1', value: { id: 'A' } },
+          FT1: { id: 'FT1', value: { id: 'V' } },
+          A1: { id: 'A1', value: { id: 'A1V' } },
+          A2: { id: 'A2', value: { id: 'A2V' }, serieKey: 'D3=v0' },
+          A3: { id: 'A3', value: { id: 'A3V' }, serieKey: 'D3=v0' },
+        }
+      }
+    };
+
+
+    expect(getCells(customAttributes, cellsAttributesIds, combinations, attributesSeries, [])(observations)).to.deep.equal({
+      'obs': {
+        value: '33',
+        intValue: 33,
+        sideProps: null,
+        flags: [
+          { code: 'A', id: 'FL1', value: { id: 'A' } }, // regular flag
+          { id: 'FT1', value: { id: 'V' } }, // regular foot note
+          { id: 'A3', value: { id: 'A3V' }, serieKey: 'D3=v0' }, // rejected layout combination value displayed as a footnote
+          { id: 'CELLS_COMB', values: [{ id: 'D1V' }, { id: 'A1V' }] } // cell level combination with fixed dim value
+        ]
+      }
+    });
+  });
 });

package/test/getLayout.test.js

@@ -0,0 +1,42 @@
+import { expect } from 'chai';
+import { getLayout } from '../src/rules2/src';
+
+describe('getLayout tests', () => {
+  it('complete test', () => {
+    const isTimeInverted = true;
+    const dimensions = [
+      { id: 'D1', values: [{ id: 'v1' }, { id: 'v2' }] },
+      { id: 'D2', values: [{ id: 'v1' }, { id: 'v2' }] },
+      { id: 'D3', values: [{ id: 'v1' }, { id: 'v2' }] },
+      { id: 'D4', values: [{ id: 'v1' }, { id: 'v2' }] },
+      { id: 'TIME_PERIOD', values: [{ id: 'v1' }, { id: 'v2' }] }
+    ];
+
+    const layoutIds = {
+      header: ['TIME_PERIOD'],
+      sections: ['D1'],
+      rows: ['D4', 'D2', 'D3']
+    };
+
+    const combinations = [
+       { id: 'COMB1', concepts: ['D2', 'D3'], relationship: [] }, // rejected for empty relationship
+       { id: 'COMB2', concepts: ['D3', 'D4', 'A1'], relationship: ['D3', 'D4', 'TIME_PERIOD'] }, // rejected because relationship is incompatible with layout
+       { id: 'COMB3', concepts: ['D1', 'D2', 'A2', 'D5'], relationship: ['D1', 'D2', 'D3'] },
+    ];
+
+    expect(getLayout(layoutIds, dimensions, combinations, isTimeInverted)).to.deep.equal({
+      header: [{ id: 'TIME_PERIOD', isInverted: true, values: [{ id: 'v1' }, { id: 'v2' }] }],
+      sections: [{ id: 'D1', values: [{ id: 'v1' }, { id: 'v2' }] }],
+      rows: [
+        { id: 'D4', values: [{ id: 'v1' }, { id: 'v2' }] },
+        { id: 'D3', values: [{ id: 'v1' }, { id: 'v2' }] },
+        {
+          id: 'COMB3',
+          concepts: ['D1', 'D2', 'A2', 'D5'],
+          relationship: ['D1', 'D2', 'D3'],
+          dimensions: [{ id: 'D2', values: [{ id: 'v1' }, { id: 'v2' }] }] // D1 kept at section level
+        },
+      ]
+    })
+  });
+});

package/test/getLayoutData.test.js

@@ -62,28 +62,28 @@ describe('getLayoutData tests', () => {
           { data: [{ dimension: { id: 'S' }, value: { id: 'S_V1' } }], key: 'S=S_V1', flags: [], sideProps: null, coordinates: { S: 'S_V1' } },
           [
             {
-              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V1' }, { id: 'R2_V1' }, { id: 'ATTR_V1' }] }],
+              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V1', display: true }, { id: 'R2_V1', display: true }, { id: 'ATTR_V1' }] }],
               key: 'R1=R1_V1:R2=R2_V1',
               coordinates: { R1: 'R1_V1', R2: 'R2_V1', S: 'S_V1' },
               flags: [],
               sideProps: null
             },
             {
-              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V1' }, { id: 'ATTR_V2' }] }],
+              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V1', display: true }, { id: 'R2_V2', display: false }, { id: 'ATTR_V2' }] }],
               key: 'R1=R1_V1:R2=R2_V2',
               coordinates: { R1: 'R1_V1', R2: 'R2_V2', S: 'S_V1' },
               flags: [],
               sideProps: null
             },
             {
-              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V2' }, { id: 'R2_V1' }, { id: 'ATTR_V3' }] }],
+              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V2', display: true }, { id: 'R2_V1', display: true }, { id: 'ATTR_V3' }] }],
               key: 'R1=R1_V2:R2=R2_V1',
               coordinates: { R1: 'R1_V2', R2: 'R2_V1', S: 'S_V1' },
               flags: [],
               sideProps: null
             },
             {
-              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V2' }, { id: 'ATTR_V4' }] }],
+              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V2', display: true }, { id: 'R2_V2', display: false }, { id: 'ATTR_V4' }] }],
               key: 'R1=R1_V2:R2=R2_V2',
               coordinates: { R1: 'R1_V2', R2: 'R2_V2', S: 'S_V1' },
               flags: [],
@@ -95,28 +95,28 @@ describe('getLayoutData tests', () => {
           { data: [{ dimension: { id: 'S' }, value: { id: 'S_V2' } }], key: 'S=S_V2', flags: [], sideProps: null, coordinates: { S: 'S_V2' } },
           [
             {
-              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V1' }, { id: 'R2_V1' }, { id: 'ATTR_V1' }] }],
+              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V1', display: true }, { id: 'R2_V1', display: true }, { id: 'ATTR_V1' }] }],
               key: 'R1=R1_V1:R2=R2_V1',
               coordinates: { R1: 'R1_V1', R2: 'R2_V1', S: 'S_V2' },
               flags: [],
               sideProps: null
             },
             {
-              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V1' }, { id: 'ATTR_V2' }] }],
+              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V1', display: true }, { id: 'R2_V2', display: false }, { id: 'ATTR_V2' }] }],
               key: 'R1=R1_V1:R2=R2_V2',
               coordinates: { R1: 'R1_V1', R2: 'R2_V2', S: 'S_V2' },
               flags: [],
               sideProps: null
             },
             {
-              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V2' }, { id: 'R2_V1' }, { id: 'ATTR_V3' }] }],
+              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V2', display: true }, { id: 'R2_V1', display: true }, { id: 'ATTR_V3' }] }],
               key: 'R1=R1_V2:R2=R2_V1',
               coordinates: { R1: 'R1_V2', R2: 'R2_V1', S: 'S_V2' },
               flags: [],
               sideProps: null
             },
             {
-              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V2' }, { id: 'ATTR_V4' }] }],
+              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V2', display: true }, { id: 'R2_V2', display: false }, { id: 'ATTR_V4' }] }],
               key: 'R1=R1_V2:R2=R2_V2',
               coordinates: { R1: 'R1_V2', R2: 'R2_V2', S: 'S_V2' },
               flags: [],

package/test/getOneValueDimensions.test.js

@@ -24,6 +24,9 @@ describe('getOneValueDimensions tests', () => {
     expect(getOneValueDimensions(dimensions, attributes)).to.deep.equal([
       { id: 'd0', values: [{ id: 'v' }], attrValues: { a1: { id: 'a1', header: true, values: [{ id: 'v' }], relationship: ['d0'], value: { id: 'v' } } } },
       { id: 'd1', values: [{ id: 'v' }], attrValues: {} },
+      { id: 'd2', values: [{ id: 'v' }], display: false, attrValues: {} },
+      { id: 'd3', values: [{ id: 'v', display: false }], attrValues: {} },
+      { id: 'd4', values: [{ id: '_T' }], attrValues: {} },
     ])
   });
 });

package/test/getSeriesCombinations.test.js

@@ -0,0 +1,29 @@
+import { expect } from 'chai';
+import { getSeriesCombinations } from '../src/rules2/src/';
+
+describe('getSeriesCombinations tests', () => {
+  it('basic test', () => {
+    const oneValueDimensions = [
+      { id: 'D1', values: [{ id: 'v', display: false }] },
+      { id: 'D2', values: [{ id: 'v' }] }
+    ];
+    const combinations = [
+      { id: 'COMB1', header: true, concepts: ['D1', 'D2'] },
+      { id: 'COMB2', series: true, concepts: ['D1', 'D2', 'A1', 'A2'] },
+      { id: 'COMB3', series: true, concepts: ['D3', 'D4', 'A3'] },
+    ];
+
+    expect(getSeriesCombinations(combinations, oneValueDimensions)).to.deep.equal([
+      {
+        id: 'COMB2',
+        series: true,
+        concepts: ['D1', 'D2', 'A1', 'A2'],
+        fixedDimValues: {
+          D1: { id: 'v', display: false },
+          D2: { id: 'v' }
+        }
+      },
+      { id: 'COMB3', series: true, concepts: ['D3', 'D4', 'A3'], fixedDimValues: {} },
+    ])
+  });
+});

package/test/getTableLabelAccessor.test.js

@@ -0,0 +1,25 @@
+import { expect } from 'chai';
+import { getTableLabelAccessor } from '../src/rules2/src/table/getTableLabelAccessor';
+
+describe('getTableLabelAccessor tests', () => {
+  const values = [
+    { id: 'V0', name: 'Value 0', display: false },
+    { id: 'V1', name: 'Value 1', missingParents: [{ id: 'P0', name: 'Parent 0' }, { id: 'P1', name: 'Parent 1', display: false }] },
+    { id: '_T', name: 'Value 2' },
+  ];
+  it('combination label display', () => {
+    expect(getTableLabelAccessor('label')(values)).to.deep.equal('Parent 0 > Value 1');
+  });
+  it('combination code display', () => {
+    expect(getTableLabelAccessor('code')(values)).to.deep.equal('V0, V1, _T');
+  });
+  it('combination both display', () => {
+    expect(getTableLabelAccessor('both')(values)).to.deep.equal('(V0, V1, _T) Parent 0 > Value 1');
+  });
+  it('single value witrh missingParents', () => {
+    expect(getTableLabelAccessor('label')(values[1])).to.deep.equal('Parent 0 > Value 1');
+  });
+  it('not displayed single value', () => {
+    expect(getTableLabelAccessor('both')(values[0])).to.deep.equal('(V0) Value 0');
+  });
+});