@sis-cc/dotstatsuite-components 16.2.0 → 16.4.0

package/lib/rules2/src/enhanceObservations.js

@@ -39,7 +39,14 @@ var parseAttributesValues = function parseAttributesValues(obs, attributes, inde
     if (R.isNil(attribute) || !R.prop('series', attribute)) {
       return acc;
     }
-    var value = R.nth(valueIndex, attribute.values || []);
+    var _value = R.nth(valueIndex, attribute.values || []);
+    var value = R.isNil(_value) ? _value : R.over(R.lensProp('display'), function () {
+      var display = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      return display && !R.includes(_value.id, _constants.REJECTED_VALUE_IDS);
+    })(_value);
+    if ((!R.propOr(true, 'display', attribute) || !R.propOr(true, 'display', value)) && !R.prop('combined', attribute)) {
+      value = null;
+    }
     var relationship = R.propOr([], 'relationship', attribute);
     var coordinates = {};
     var serieKey = R.pipe(function (dims) {
@@ -51,7 +58,7 @@ var parseAttributesValues = function parseAttributesValues(obs, attributes, inde
       return dim.id + '=' + valueId;
     }), R.ifElse(R.isEmpty, R.always(null), R.join(':')))(indexedDimensions);
 
-    return R.assoc(attribute.id, (0, _extends3.default)({}, R.pick(['id', 'name', 'relationship'], attribute), { value: value, serieKey: serieKey, coordinates: coordinates, isObs: R.isEmpty(relationship) }), acc);
+    return R.assoc(attribute.id, (0, _extends3.default)({}, R.pick(['id', 'name', 'relationship', 'display'], attribute), { value: value, serieKey: serieKey, coordinates: coordinates, isObs: R.isEmpty(relationship) }), acc);
   }, {}, attrValuesIndexes);
 };
 

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/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', {

package/lib/rules2/src/refineAttributes.js

@@ -25,7 +25,7 @@ var refineAttributes = exports.refineAttributes = function refineAttributes(pars
   }, {}, seriesCombinations);
   return R.map(function (attr) {
     if (R.has(attr.id, indexedRelationships)) {
-      return (0, _extends3.default)({}, attr, { series: true, relationship: R.prop(attr.id, indexedRelationships) });
+      return (0, _extends3.default)({}, attr, { series: true, relationship: R.prop(attr.id, indexedRelationships), combined: true });
     }
     return attr;
   }, parsedAttributes);

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/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 ? 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/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.2.0",
+  "version": "16.4.0",
   "main": "lib/index.js",
   "author": "OECD",
   "license": "MIT",

package/src/rules2/src/enhanceObservations.js

@@ -19,7 +19,13 @@ const parseAttributesValues = (obs, attributes, indexedDimensions) => {
       if (R.isNil(attribute) || !R.prop('series', attribute)) {
         return acc;
       }
-      let value = R.nth(valueIndex, attribute.values || []);
+      const _value = R.nth(valueIndex, attribute.values || []);
+      let value = R.isNil(_value)
+        ? _value
+        : R.over(R.lensProp('display'), (display=true) => display && !R.includes(_value.id, REJECTED_VALUE_IDS))(_value);
+      if ((!R.propOr(true, 'display', attribute) || !R.propOr(true, 'display', value)) && !R.prop('combined', attribute)) {
+        value = null;
+      }
       const relationship = R.propOr([], 'relationship', attribute);
       let coordinates = {};
       const serieKey = R.pipe(
@@ -33,7 +39,7 @@ const parseAttributesValues = (obs, attributes, indexedDimensions) => {
         R.ifElse(R.isEmpty, R.always(null), R.join(':'))
       )(indexedDimensions);
 
-      return R.assoc(attribute.id, { ...R.pick(['id', 'name', 'relationship'], attribute), value, serieKey, coordinates, isObs: R.isEmpty(relationship) }, acc);
+      return R.assoc(attribute.id, { ...R.pick(['id', 'name', 'relationship', 'display'], attribute), value, serieKey, coordinates, isObs: R.isEmpty(relationship) }, acc);
     },
     {},
     attrValuesIndexes

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/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';

package/src/rules2/src/refineAttributes.js

@@ -9,7 +9,7 @@ export const refineAttributes = (parsedAttributes, seriesCombinations) => {
   );
   return R.map(attr => {
     if (R.has(attr.id, indexedRelationships)) {
-      return { ...attr, series: true, relationship: R.prop(attr.id, indexedRelationships) };
+      return { ...attr, series: true, relationship: R.prop(attr.id, indexedRelationships), combined: true };
     }
     return attr;
   }, parsedAttributes);

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/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 ? 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/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/enhanceObservations2.test.js

@@ -74,7 +74,7 @@ describe('enhanceObservations tests', () => {
       },
       {
         id: 'a4',
-        values: [{ id: 'v0' }, { id: 'v1', display: false }],
+        values: [{ id: 'v0' }, { id: 'v1' }],
         relationship: ['d4'],
         series: true
       },
@@ -159,9 +159,9 @@ describe('enhanceObservations tests', () => {
         value: 22,
         formattedValue: '22',
         attributes: {
-          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v0' }, serieKey: 'd0=v0:d1=v0', coordinates: { d0: 'v0', d1: 'v0' }, isObs: false },
-          a3: { id: 'a3', relationship: ['d2', 'd3'], value: { id: 'v0' }, serieKey: 'd2=v0:d3=v0', coordinates: { d2: 'v0', d3: 'v0' }, isObs: false },
-          a4: { id: 'a4', relationship: ['d4'], value: { id: 'v0' }, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
+          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v0', display: true }, serieKey: 'd0=v0:d1=v0', coordinates: { d0: 'v0', d1: 'v0' }, isObs: false },
+          a3: { id: 'a3', relationship: ['d2', 'd3'], value: { id: 'v0', display: true }, serieKey: 'd2=v0:d3=v0', coordinates: { d2: 'v0', d3: 'v0' }, isObs: false },
+          a4: { id: 'a4', relationship: ['d4'], value: { id: 'v0', display: true }, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
         },
         indexedDimValIds: { d0: 'v0', d1: 'v0', d2: 'v0', d3: 'v0', d4: 'v0' }
       },
@@ -171,9 +171,9 @@ describe('enhanceObservations tests', () => {
         value: 17,
         formattedValue: '17',
         attributes: {
-          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v1' }, serieKey: 'd0=v0:d1=v0', coordinates: { d0: 'v0', d1: 'v0' }, isObs: false },
-          a3: { id: 'a3', relationship: ['d2', 'd3'], value: { id: 'v1' }, serieKey: 'd2=v0:d3=v1', coordinates: { d2: 'v0', d3: 'v1' }, isObs: false },
-          a4: { id: 'a4', relationship: ['d4'], value: { id: 'v0' }, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
+          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v1', display: true }, serieKey: 'd0=v0:d1=v0', coordinates: { d0: 'v0', d1: 'v0' }, isObs: false },
+          a3: { id: 'a3', relationship: ['d2', 'd3'], value: { id: 'v1', display: true }, serieKey: 'd2=v0:d3=v1', coordinates: { d2: 'v0', d3: 'v1' }, isObs: false },
+          a4: { id: 'a4', relationship: ['d4'], value: { id: 'v0', display: true }, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
         },
         indexedDimValIds: { d0: 'v0', d1: 'v0', d2: 'v0', d3: 'v1', d4: 'v0' }
       },
@@ -183,9 +183,9 @@ describe('enhanceObservations tests', () => {
         value: 55,
         formattedValue: '55',
         attributes: {
-          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v2' }, serieKey: 'd0=v1:d1=v0', coordinates: { d0: 'v1', d1: 'v0' }, isObs: false },
+          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v2', display: true }, serieKey: 'd0=v1:d1=v0', coordinates: { d0: 'v1', d1: 'v0' }, isObs: false },
           a3: { id: 'a3', relationship: ['d2', 'd3'], value: undefined, serieKey: 'd2=v0:d3=v0', coordinates: { d2: 'v0', d3: 'v0' }, isObs: false },
-          a4: { id: 'a4', relationship: ['d4'], value: { id: 'v0' }, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
+          a4: { id: 'a4', relationship: ['d4'], value: { id: 'v0', display: true }, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
         },
         indexedDimValIds: { d0: 'v1', d1: 'v0', d2: 'v0', d3: 'v0', d4: 'v0' }
       },
@@ -195,7 +195,7 @@ describe('enhanceObservations tests', () => {
         value: 35,
         formattedValue: '35',
         attributes: {
-          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v2' }, serieKey: 'd0=v2:d1=v0', coordinates: { d0: 'v2', d1: 'v0' }, isObs: false },
+          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v2', display: true }, serieKey: 'd0=v2:d1=v0', coordinates: { d0: 'v2', d1: 'v0' }, isObs: false },
           a3: { id: 'a3', relationship: ['d2', 'd3'], value: undefined, serieKey: 'd2=v0:d3=v0', coordinates: { d2: 'v0', d3: 'v0' }, isObs: false },
           a4: { id: 'a4', relationship: ['d4'], value: undefined, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
         },
@@ -207,7 +207,7 @@ describe('enhanceObservations tests', () => {
         value: 35,
         formattedValue: '35',
         attributes: {
-          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v2' }, serieKey: 'd0=v3:d1=v0', coordinates: { d0: 'v3', d1: 'v0' }, isObs: false },
+          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v2', display: true }, serieKey: 'd0=v3:d1=v0', coordinates: { d0: 'v3', d1: 'v0' }, isObs: false },
           a3: { id: 'a3', relationship: ['d2', 'd3'], value: undefined, serieKey: 'd2=v0:d3=v0', coordinates: { d2: 'v0', d3: 'v0' }, isObs: false },
           a4: { id: 'a4', relationship: ['d4'], value: undefined, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
         },
@@ -215,5 +215,43 @@ describe('enhanceObservations tests', () => {
       }
     });
   });
+  it('not displayed attributes and combinations', () => {
+    const attributes = [
+      { id: 'A1', display: false, series: true, values: [{ id: 'A1v' }], relationship: [] },
+      { id: 'A2', series: true, values: [{ id: 'A2v', display: false }], relationship: [] },
+      { id: 'A3', series: true, values: [{ id: '_T', display: true }], relationship: [] },
+      { id: 'A4', display: false, series: true, values: [{ id: 'A4v' }], relationship: [], combined: true },
+      { id: 'A5', series: true, values: [{ id: 'A5v', display: false }], relationship: [], combined: true },
+      { id: 'A6', series: true, values: [{ id: '_T', display: true }], relationship: [], combined: true },
+    ];
+
+    const dimensions = [];
+
+    const observations = {
+      obs: {
+        attrValuesIndexes: [0, 0, 0, 0, 0, 0],
+        dimValuesIndexes: [],
+        value: 22,
+      }
+    };
+
+    expect(enhanceObservations(dimensions, observations, attributes, {})).to.deep.equal({
+      obs: {
+        attrValuesIndexes: [0, 0, 0, 0, 0, 0],
+        dimValuesIndexes: [],
+        value: 22,
+        formattedValue: '22',
+        attributes: {
+          A1: { id: 'A1', display: false, value: null, relationship: [], serieKey: null, coordinates: {}, isObs: true },
+          A2: { id: 'A2', value: null, relationship: [], serieKey: null, coordinates: {}, isObs: true },
+          A3: { id: 'A3', value: null, relationship: [], serieKey: null, coordinates: {}, isObs: true },
+          A4: { id: 'A4', display: false, value: { id: 'A4v', display: true }, relationship: [], serieKey: null, coordinates: {}, isObs: true },
+          A5: { id: 'A5', value: { id: 'A5v', display: false }, relationship: [], serieKey: null, coordinates: {}, isObs: true },
+          A6: { id: 'A6', value: { id: '_T', display: false }, relationship: [], serieKey: null, coordinates: {}, isObs: true },
+        },
+        indexedDimValIds: {}
+      }
+    })
+  });
 });
 

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/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/refineAttributes.test.js

@@ -0,0 +1,29 @@
+import { expect } from 'chai';
+import { refineAttributes } from '../src/rules2/src';
+
+describe('refineAttributes tests', () => {
+  it('basic test', () => {
+    const attributes = [
+      { id: 'A1', relationship: [] },
+      { id: 'A2', relationship: ['D1', 'D2'] },
+      { id: 'A3', series: true, relationship: [] },
+      { id: 'A4', series: true, relationship: ['D3', 'D4'] },
+      { id: 'A5', header: true, relationship: [] },
+      { id: 'A6', series: true, relationship: ['D3', 'D4'] },
+    ];
+
+    const combinations = [
+      { id: 'COMB1', concepts: ['A1', 'A3', 'A4'], relationship: ['D5', 'D6'] },
+      { id: 'COMB2', concepts: ['A2'], relationship: [] },
+    ];
+
+    expect(refineAttributes(attributes, combinations)).to.deep.equal([
+      { id: 'A1', series: true, relationship: ['D5', 'D6'], combined: true },
+      { id: 'A2', series: true, relationship: [], combined: true },
+      { id: 'A3', series: true, relationship: ['D5', 'D6'], combined: true },
+      { id: 'A4', series: true, relationship: ['D5', 'D6'], combined: true },
+      { id: 'A5', header: true, relationship: [] },
+      { id: 'A6', series: true, relationship: ['D3', 'D4'] },
+    ]);
+  });
+});