@sis-cc/dotstatsuite-components 17.1.0 → 17.3.0

package/lib/rules/src/layout.js

@@ -11,10 +11,16 @@ var R = _interopRequireWildcard(_ramda);
 
 var _constants = require('./constants');
 
+var _src = require('../../rules2/src');
+
 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 isTableLayoutCompatible = function isTableLayoutCompatible(data, layout) {
-  var multiValuesDimensions = R.pipe(R.pathOr([], ['structure', 'dimensions', 'observation']), R.reject(R.pipe(R.propOr([], 'values'), R.length, R.gte(1))), R.pluck('id'))(data);
+  var dataquery = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+
+  var multiValuesDimensions = R.pipe(R.pathOr([], ['structure', 'dimensions', 'observation']), function (dimensions) {
+    return (0, _src.refineDimensions)(dimensions, dataquery);
+  }, R.reject(R.prop('header')), R.pluck('id'))(data);
   var dimensionsInLayout = R.pipe(R.values, R.unnest)(layout);
 
   var dimensionsLength = R.length(multiValuesDimensions);
@@ -63,7 +69,8 @@ var isSharedLayoutCompatible = exports.isSharedLayoutCompatible = function isSha
   var type = R.prop('type', sharedData);
   if (type === 'table') {
     var layoutIds = R.pathOr({}, ['config', 'table', 'layoutIds'], sharedData);
-    return isTableLayoutCompatible(sdmxData, layoutIds);
+    var dataquery = R.path(['config', 'sdmxSource', 'dataquery'], sharedData);
+    return isTableLayoutCompatible(sdmxData, layoutIds, dataquery);
   }
   var chartDimension = R.pathOr({}, ['config', 'chart', 'chartDimension'], sharedData);
   return isChartLayoutCompatible(sdmxData, type, chartDimension);

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

@@ -27,6 +27,8 @@ var _getReportingYearStart = require('./preparators/getReportingYearStart');
 
 var _src = require('../../rules2/src');
 
+var _refineTimePeriod = require('../../rules2/src/refineTimePeriod');
+
 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 }; }
@@ -78,14 +80,14 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
         end = reported.end;
         var reportTimeNote = (0, _date.getReportedTimePeriodNote)(reportYearStart, start, end, options.frequency, options.isRtl);
         notes = R.isNil(reportTimeNote) ? notes : R.append(reportTimeNote, notes);
-        __indexPosition = _dateFns2.default.getTime(new Date(R.prop('start', value)));
+        //__indexPosition = dateFns.getTime(new Date(R.prop('start', value)));
       }
       if (isNaN(__indexPosition)) {
         __indexPosition = (0, _dotstatsuiteSdmxjs.getCodeOrder)({ annotations: valueAnnotations });
       }
       var timeFormat = R.prop('timeFormat', options);
-      return (0, _extends3.default)({}, value, {
-        id: R.pipe(R.when(R.isNil, R.always(parent + '-' + __index)), R.when(R.always(isTimeDimension), R.replace(/M/g, '')))(value.id),
+      var res = (0, _extends3.default)({}, value, {
+        id: R.when(R.isNil, R.always(parent + '-' + __index))(value.id),
         display: !isHidden,
         name: R.when(R.always(isTimeDimension), R.always((0, _date.getReportedTimePeriodLabel)(options.frequency, timeFormat, locale)(reportYearStart, { id: value.id, reportedStart: start, start: new Date(value.start) })))(name),
         start: start ? start.toISOString() : null,
@@ -93,7 +95,14 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
         __indexPosition: __indexPosition,
         __index: __index
       });
-    }), R.sortWith([R.ascend(R.prop('__indexPosition')), R.ascend(R.propOr(-1, 'order'))]), R.addIndex(R.map)(function (val, index) {
+      return isTimeDimension ? (0, _refineTimePeriod.refineTimePeriod)(res, { locale: locale }) : res;
+    }), R.ifElse(R.always(isTimeDimension), R.pipe(R.sortWith([R.ascend(function (val) {
+      return _dateFns2.default.getTime(new Date(R.prop('start', val)));
+    }), R.descend(function (val) {
+      return _dateFns2.default.getTime(new Date(R.prop('end', val)));
+    })]), R.addIndex(R.map)(function (val, ind) {
+      return R.assoc('__indexcPosition', ind, val);
+    })), R.sortWith([R.ascend(R.prop('__indexPosition')), R.ascend(R.propOr(-1, 'order'))])), R.addIndex(R.map)(function (val, index) {
       return R.assoc('__indexPosition', index, val);
     }),
     /* NEW */

package/lib/rules2/src/getManyValuesDimensions.js

@@ -22,7 +22,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 var getManyValuesDimensions = exports.getManyValuesDimensions = function getManyValuesDimensions(dimensions, attributesSeries, customAttributes, combinations) {
   var combConceptsIds = R.pipe(R.pluck('concepts'), R.unnest)(combinations);
   return R.reduce(function (acc, dim) {
-    if (R.length(dim.values || []) < 2) {
+    if (dim.header) {
       return acc;
     }
     var enhancedValues = R.map(function (val) {

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) {
+    if (!dim.header) {
       return acc;
     }
     var attrValues = R.propOr({}, dim.id, indexedRelevantAttributes);

package/lib/rules2/src/index.js

@@ -157,6 +157,15 @@ Object.defineProperty(exports, 'getCombinationDefinitions', {
   }
 });
 
+var _refineDimensions = require('./refineDimensions');
+
+Object.defineProperty(exports, 'refineDimensions', {
+  enumerable: true,
+  get: function get() {
+    return _refineDimensions.refineDimensions;
+  }
+});
+
 var _parseAttributes = require('./parseAttributes');
 
 Object.defineProperty(exports, 'parseAttributes', {

package/lib/rules2/src/parseAttributes.js

@@ -39,8 +39,8 @@ var parseAttributes = exports.parseAttributes = function parseAttributes(attribu
       return (0, _extends3.default)({}, res, { series: true, relationship: [] });
     }
     var seriesDimensions = R.pipe(R.pathOr([], ['relationship', 'dimensions']), R.filter(function (id) {
-      var values = R.path([id, 'values'], indexedDimensions);
-      return R.length(values) > 1;
+      var dimension = R.prop(id, indexedDimensions);
+      return !dimension.header;
     }))(attr);
     if (R.length(seriesDimensions) > 0) {
       return (0, _extends3.default)({}, res, { series: true, relationship: seriesDimensions });

package/lib/rules2/src/parseCombinations.js

@@ -42,11 +42,11 @@ var parseCombinations = exports.parseCombinations = function parseCombinations(c
         return false;
       }
       if (R.has(concept, indexedDimensions)) {
-        var values = R.path([concept, 'values'], indexedDimensions);
-        relationship = R.length(values) > 1 ? R.append(concept, relationship) : relationship;
+        var dimension = R.prop(concept, indexedDimensions);
+        relationship = !dimension.header ? R.append(concept, relationship) : relationship;
         ids = (0, _extends4.default)({}, ids, (0, _defineProperty3.default)({}, concept, concept));
-        displayable_values_count += R.length(values);
-        return R.length(values) > 1;
+        displayable_values_count += R.length(dimension.values || []);
+        return !dimension.header;
       } else if (!R.has(concept, indexedAttributes)) {
         return false;
       }

package/lib/rules2/src/prepareData.js

@@ -11,6 +11,8 @@ var R = _interopRequireWildcard(_ramda);
 
 var _src = require('../../rules/src');
 
+var _refineDimensions = require('./refineDimensions');
+
 var _enhanceObservations = require('./enhanceObservations');
 
 var _parseAttributes = require('./parseAttributes');
@@ -53,9 +55,11 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, _ref) {
       hierarchies = _ref.hierarchies,
       dataflow = _ref.dataflow,
       display = _ref.display,
-      defaultCombinations = _ref.defaultCombinations;
+      defaultCombinations = _ref.defaultCombinations,
+      dataquery = _ref.dataquery;
 
   var dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
+  var refinedDimensions = (0, _refineDimensions.refineDimensions)(dimensions, dataquery);
   var attributes = R.pathOr([], ['data', 'structure', 'attributes', 'observation'], sdmxJson);
   var annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
   var observations = (0, _src.getObservations)(sdmxJson);
@@ -68,15 +72,15 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, _ref) {
   }
   var metadataCoordinates = (0, _getMetadataCoordinates.getMetadataCoordinates)(sdmxJson);
 
-  var parsedAttributes = (0, _parseAttributes.parseAttributes)(attributes, dimensions, customAttributes);
-  var parsedCombinations = (0, _parseCombinations.parseCombinations)(combinations, parsedAttributes, dimensions);
+  var parsedAttributes = (0, _parseAttributes.parseAttributes)(attributes, refinedDimensions, customAttributes);
+  var parsedCombinations = (0, _parseCombinations.parseCombinations)(combinations, parsedAttributes, refinedDimensions);
   var seriesCombinations = R.filter(R.prop('series'), parsedCombinations);
   var refinedAttributes = (0, _refineAttributes.refineAttributes)(parsedAttributes, seriesCombinations);
 
-  var enhancedObservations = (0, _enhanceObservations.enhanceObservations)(dimensions, observations, refinedAttributes, { customAttributes: customAttributes });
+  var enhancedObservations = (0, _enhanceObservations.enhanceObservations)(refinedDimensions, observations, refinedAttributes, { customAttributes: customAttributes });
   var attributesSeries = (0, _getAttributesSeries.getAttributesSeries)(enhancedObservations);
-  var manyValuesDimensions = (0, _getManyValuesDimensions.getManyValuesDimensions)(dimensions, attributesSeries, customAttributes, seriesCombinations);
-  var oneValueDimensions = (0, _getOneValueDimensions.getOneValueDimensions)(dimensions, parsedAttributes);
+  var manyValuesDimensions = (0, _getManyValuesDimensions.getManyValuesDimensions)(refinedDimensions, attributesSeries, customAttributes, seriesCombinations);
+  var oneValueDimensions = (0, _getOneValueDimensions.getOneValueDimensions)(refinedDimensions, parsedAttributes);
   var headerCoordinates = (0, _getHeaderCoordinates.getHeaderCoordinates)(oneValueDimensions);
   var hierarchisedDimensions = R.map(function (dim) {
     if (R.isEmpty(R.propOr({}, dim.id, hierarchies))) {

package/lib/rules2/src/refineDimensions.js

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.refineDimensions = 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 refineDimensions = exports.refineDimensions = function refineDimensions() {
+  var dimensions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var dataquery = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+
+  var selectionIds = R.pipe(R.split('.'), R.map(R.split('+')))(dataquery);
+
+  return R.addIndex(R.map)(function (dim, index) {
+    var selection = R.nth(index, selectionIds);
+    if (R.isNil(selection) || R.length(selection) === 0 || R.isEmpty(R.head(selection))) {
+      return (0, _extends3.default)({}, dim, { header: R.length(dim.values || []) <= 1 });
+    }
+    var values = R.map(function (val) {
+      if (R.includes(val.id, selection)) {
+        return val;
+      }
+      return R.assoc('empty', true, val);
+    }, dim.values || []);
+    return (0, _extends3.default)({}, dim, { values: values, header: R.length(values) <= 1 || R.length(selection) === 1 });
+  }, dimensions);
+};

package/lib/rules2/src/refineTimePeriod.js

@@ -0,0 +1,146 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.refineTimePeriod = exports.getStartDate = undefined;
+
+var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
+
+var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
+
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+var _dateFns = require('date-fns');
+
+var dateFns = _interopRequireWildcard(_dateFns);
+
+var _date = require('../../rules/src/date');
+
+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 computeDisplayFreq = function computeDisplayFreq(start, duration) {
+  var startMinute = dateFns.startOfMinute(start);
+  var startHour = dateFns.startOfHour(start);
+  var startDay = dateFns.startOfDay(start);
+  if (!dateFns.isEqual(start, startMinute) || duration === 'S') {
+    return 'S';
+  } else if (!dateFns.isEqual(start, startHour) || !dateFns.isEqual(start, startDay) || duration === 'H' || duration === 'm') {
+    return 'm';
+  } else if (!dateFns.isFirstDayOfMonth(start) || duration === 'D') {
+    return 'D';
+  } else if (dateFns.getMonth(start) !== 0 || duration === 'M') {
+    return 'M';
+  }
+  return 'Y';
+};
+
+var getAdder = function getAdder(duration) {
+  if (duration === 'S') return dateFns.addSeconds;
+  if (duration === 'm') return dateFns.addMinutes;
+  if (duration === 'H') return dateFns.addHours;
+  if (duration === 'D') return dateFns.addDays;
+  if (duration === 'M') return dateFns.addMonths;
+  return dateFns.addYears;
+};
+
+var getFormat = function getFormat(freqDisplay) {
+  if (freqDisplay === 'Y') return 'YYYY';
+  if (freqDisplay === 'D') return 'YYYY-MM-DD';
+  if (freqDisplay === 'H' || freqDisplay === 'm') {
+    return 'HH:mm';
+  }
+  if (freqDisplay === 'S') {
+    return 'HH:mm:ss';
+  }
+  return 'MMM';
+};
+
+var getEndDate = function getEndDate(start, mult, duration) {
+  var adder = getAdder(duration);
+  var endDate = adder(start, Number(mult));
+  var startTZ = start.getTimezoneOffset();
+  var endTZ = endDate.getTimezoneOffset();
+  if (startTZ !== endTZ) {
+    endDate = dateFns.addMinutes(endDate, Math.abs(endTZ) - Math.abs(startTZ));
+  }
+  return dateFns.subSeconds(endDate, 1);
+};
+
+var computeName = function computeName(start, end, freqDisplay, locale) {
+  var opts = { locale: (0, _date.getLocale)(locale) };
+  var isSameDay = dateFns.isSameDay(start, end);
+  var isSameYear = dateFns.isSameYear(start, end);
+  if (freqDisplay === 'H' || freqDisplay === 'm' || freqDisplay === 'S') {
+    var dayFormat = getFormat('D');
+    var timeFormat = getFormat(freqDisplay);
+    if (isSameDay) return dateFns.format(start, dayFormat, opts) + ' ' + dateFns.format(start, timeFormat, opts) + ' - ' + dateFns.format(end, timeFormat, opts);
+    return dateFns.format(start, dayFormat + ' ' + timeFormat, opts) + ' - ' + dateFns.format(end, dayFormat + ' ' + timeFormat, opts);
+  }
+  if (freqDisplay === 'D' || freqDisplay === 'Y') {
+    var _format = getFormat(freqDisplay);
+    return dateFns.format(start, _format, opts) + ' - ' + dateFns.format(end, _format, opts);
+  }
+  var yearFormat = getFormat('Y');
+  var monthFormat = getFormat('M');
+  if (isSameYear && locale === 'fr') {
+    return dateFns.format(start, monthFormat, opts) + ' - ' + dateFns.format(end, monthFormat, opts) + ' ' + dateFns.format(start, yearFormat, opts);
+  }
+  var format = locale === 'fr' ? monthFormat + ' ' + yearFormat : yearFormat + '-' + monthFormat;
+  return dateFns.format(start, format, opts) + ' - ' + dateFns.format(end, format, opts);
+};
+
+var getStartDate = exports.getStartDate = function getStartDate(start) {
+  if (!R.includes('T', start) && !R.endsWith('Z', start)) {
+    return new Date(start);
+  }
+  var date = new Date(start);
+  return dateFns.addMinutes(date, -date.getTimezoneOffset());
+};
+
+var refineTimePeriod = exports.refineTimePeriod = function refineTimePeriod(timePeriod, _ref) {
+  var locale = _ref.locale;
+  var id = timePeriod.id;
+
+  var split = R.split('/', id);
+  if (R.length(split) !== 2) {
+    var _start = getStartDate(R.prop('start', timePeriod));
+    var end = getStartDate(R.prop('end', timePeriod));
+    return (0, _extends3.default)({}, timePeriod, { start: _start.toISOString(), end: end.toISOString() });
+  }
+
+  var _split = (0, _slicedToArray3.default)(split, 2),
+      start = _split[0],
+      range = _split[1];
+
+  var startDate = getStartDate(start);
+  var match = R.match(/^P(T?)(\d+)([YMDHS])$/, range);
+  if (R.isEmpty(match) || !dateFns.isValid(startDate)) {
+    return timePeriod;
+  }
+
+  var _R$tail = R.tail(match),
+      _R$tail2 = (0, _slicedToArray3.default)(_R$tail, 3),
+      timeIndicator = _R$tail2[0],
+      mult = _R$tail2[1],
+      _duration = _R$tail2[2];
+
+  var duration = !R.isEmpty(timeIndicator) && _duration === 'M' ? 'm' : _duration;
+  var endDate = getEndDate(startDate, mult, duration);
+  var freqDisplay = computeDisplayFreq(start, duration);
+  var name = computeName((0, _date.dateWithoutTZ)(startDate), (0, _date.dateWithoutTZ)(endDate), freqDisplay, locale);
+  return (0, _extends3.default)({}, timePeriod, {
+    id: id,
+    name: name,
+    start: startDate.toISOString(),
+    end: endDate.toISOString()
+  });
+};

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

@@ -79,6 +79,9 @@ var getLayout = exports.getLayout = function getLayout(layoutIds, dimensions, co
       if (R.has(id, conceptIds)) {
         return acc;
       }
+      if (!R.has(id, indexedDimensions)) {
+        return acc;
+      }
       return R.append(R.prop(id, indexedDimensions), acc);
     }, [], layoutIds[key]);
     return R.concat(rest, combs);

package/package.json

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

package/src/rules/src/layout.js

@@ -6,11 +6,13 @@ import {
   STACKED_ROW,
   V_SYMBOL
 } from './constants';
+import { refineDimensions } from '../../rules2/src';
 
-const isTableLayoutCompatible = (data, layout) => {
+const isTableLayoutCompatible = (data, layout, dataquery='') => {
   const multiValuesDimensions = R.pipe(
     R.pathOr([], ['structure', 'dimensions', 'observation']),
-    R.reject(R.pipe(R.propOr([], 'values'), R.length, R.gte(1))),
+    dimensions => refineDimensions(dimensions, dataquery),
+    R.reject(R.prop('header')),
     R.pluck('id')
   )(data);
   const dimensionsInLayout = R.pipe(R.values, R.unnest)(layout);
@@ -82,7 +84,8 @@ export const isSharedLayoutCompatible = (sdmxData, sharedData) => {
   const type = R.prop('type', sharedData);
   if (type === 'table') {
     const layoutIds = R.pathOr({}, ['config', 'table', 'layoutIds'], sharedData);
-    return isTableLayoutCompatible(sdmxData, layoutIds);
+    const dataquery = R.path(['config', 'sdmxSource', 'dataquery'], sharedData);
+    return isTableLayoutCompatible(sdmxData, layoutIds, dataquery);
   }
   const chartDimension = R.pathOr({}, ['config', 'chart', 'chartDimension'], sharedData);
   return isChartLayoutCompatible(sdmxData, type, chartDimension);

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

@@ -7,6 +7,7 @@ import {
 import { getReportedTimePeriodLabel, getReportedTimePeriodNote, getReportedTimePeriod } from './date';
 import { getReportingYearStart } from './preparators/getReportingYearStart';
 import { getNotDisplayedIds } from '../../rules2/src';
+import { refineTimePeriod } from '../../rules2/src/refineTimePeriod';
 
 const TIME_PERIOD_ID = 'TIME_PERIOD';
 
@@ -55,23 +56,17 @@ export const dataTransformer = (dataNew, options = {}) => {
           end = reported.end;
           const reportTimeNote = getReportedTimePeriodNote(reportYearStart, start, end, options.frequency, options.isRtl);
           notes = R.isNil(reportTimeNote) ? notes : R.append(reportTimeNote, notes);
-          __indexPosition = dateFns.getTime(new Date(R.prop('start', value)));
+          //__indexPosition = dateFns.getTime(new Date(R.prop('start', value)));
         }
         if (isNaN(__indexPosition)) {
           __indexPosition = getCodeOrder({ annotations: valueAnnotations });
         }
         const timeFormat = R.prop('timeFormat', options);
-        return ({
+        const res = ({
           ...value,
-          id: R.pipe(
-            R.when(
-              R.isNil,
-              R.always(`${parent}-${__index}`)
-            ),
-            R.when(
-              R.always(isTimeDimension),
-              R.replace(/M/g, '')
-            )
+          id: R.when(
+            R.isNil,
+            R.always(`${parent}-${__index}`)
           )(value.id),
           display: !isHidden,
           name: R.when(
@@ -83,11 +78,22 @@ export const dataTransformer = (dataNew, options = {}) => {
           __indexPosition,
           __index,
         });
+        return isTimeDimension ? refineTimePeriod(res, { locale }) : res;
       }),
-      R.sortWith([
-        R.ascend(R.prop('__indexPosition')),
-        R.ascend(R.propOr(-1, 'order'))
-      ]),
+      R.ifElse(
+        R.always(isTimeDimension),
+        R.pipe(
+          R.sortWith([
+            R.ascend(val => dateFns.getTime(new Date(R.prop('start', val)))),
+            R.descend(val => dateFns.getTime(new Date(R.prop('end', val)))),
+          ]),
+          R.addIndex(R.map)((val, ind) => R.assoc('__indexcPosition', ind, val))
+        ),
+        R.sortWith([
+          R.ascend(R.prop('__indexPosition')),
+          R.ascend(R.propOr(-1, 'order'))
+        ])
+      ),
       R.addIndex(R.map)((val, index) => R.assoc('__indexPosition', index, val)),
       /* NEW */
       R.sortBy(R.prop('__index'))

package/src/rules2/src/getManyValuesDimensions.js

@@ -5,7 +5,7 @@ export const getManyValuesDimensions = (dimensions, attributesSeries, customAttr
   const combConceptsIds = R.pipe(R.pluck('concepts'), R.unnest)(combinations);
   return R.reduce(
     (acc, dim) => {
-      if (R.length(dim.values || []) < 2) {
+      if (dim.header) {
         return acc;
       }
       const enhancedValues = R.map(val => {

package/src/rules2/src/getOneValueDimensions.js

@@ -22,7 +22,7 @@ export const getOneValueDimensions = (dimensions, attributes) => {
   );
   return R.reduce(
     (acc, dim) => {
-      if (R.length(dim.values || []) !== 1) {
+      if (!dim.header) {
         return acc;
       }
       const attrValues = R.propOr({}, dim.id, indexedRelevantAttributes);

package/src/rules2/src/index.js

@@ -18,6 +18,7 @@ export { hierarchiseDimensionWithAdvancedHierarchy } from './hierarchiseDimensio
 export { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy';
 export { getDimensionValuesIndexes } from './getDimensionValuesIndexes';
 export { getCombinationDefinitions } from './getCombinationDefinitions';
+export { refineDimensions } from './refineDimensions';
 export { parseAttributes } from './parseAttributes';
 export { parseCombinations } from './parseCombinations';
 export { refineAttributes } from './refineAttributes';

package/src/rules2/src/parseAttributes.js

@@ -24,8 +24,8 @@ export const parseAttributes = (attributes, dimensions, customAttributes) => {
     const seriesDimensions = R.pipe(
       R.pathOr([], ['relationship', 'dimensions']),
       R.filter(id => {
-        const values = R.path([id, 'values'], indexedDimensions);
-        return R.length(values) > 1;
+        const dimension = R.prop(id, indexedDimensions);
+        return !dimension.header;
       }),
     )(attr);
     if (R.length(seriesDimensions) > 0) {

package/src/rules2/src/parseCombinations.js

@@ -21,11 +21,11 @@ export const parseCombinations = (combinations, parsedAttributes, dimensions) =>
             return false;
           }
           if (R.has(concept, indexedDimensions)) {
-            const values = R.path([concept, 'values'], indexedDimensions);
-            relationship = R.length(values) > 1 ? R.append(concept, relationship) : relationship;
+            const dimension = R.prop(concept, indexedDimensions);
+            relationship = !dimension.header ? R.append(concept, relationship) : relationship;
             ids = { ...ids, [concept]: concept };
-            displayable_values_count += R.length(values);
-            return R.length(values) > 1;
+            displayable_values_count += R.length(dimension.values || []);
+            return !dimension.header;
           }
           else if (!R.has(concept, indexedAttributes)) {
             return false;

package/src/rules2/src/prepareData.js

@@ -1,5 +1,6 @@
 import * as R from 'ramda';
 import { getObservations } from '../../rules/src';
+import { refineDimensions } from './refineDimensions';
 import { enhanceObservations } from './enhanceObservations';
 import { parseAttributes } from './parseAttributes';
 import { getCombinationDefinitions, parseCombinationDefinition } from './getCombinationDefinitions';
@@ -18,8 +19,9 @@ import { getHeaderSubtitle } from './getHeaderSubtitle';
 import { getHeaderCombinations } from './getHeaderCombinations';
 import { getHeaderCoordinates } from './getHeaderCoordinates';
 
-export const prepareData = (sdmxJson, { customAttributes, locale, hierarchies, dataflow, display, defaultCombinations }) => {
+export const prepareData = (sdmxJson, { customAttributes, locale, hierarchies, dataflow, display, defaultCombinations, dataquery }) => {
   const dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
+  const refinedDimensions = refineDimensions(dimensions, dataquery);
   const attributes = R.pathOr([], ['data', 'structure', 'attributes', 'observation'], sdmxJson);
   const annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
   const observations = getObservations(sdmxJson);
@@ -30,15 +32,15 @@ export const prepareData = (sdmxJson, { customAttributes, locale, hierarchies, d
   }
   const metadataCoordinates = getMetadataCoordinates(sdmxJson);
 
-  const parsedAttributes = parseAttributes(attributes, dimensions, customAttributes);
-  const parsedCombinations = parseCombinations(combinations, parsedAttributes, dimensions);
+  const parsedAttributes = parseAttributes(attributes, refinedDimensions, customAttributes);
+  const parsedCombinations = parseCombinations(combinations, parsedAttributes, refinedDimensions);
   const seriesCombinations = R.filter(R.prop('series'), parsedCombinations);
   const refinedAttributes = refineAttributes(parsedAttributes, seriesCombinations);
 
-  const enhancedObservations = enhanceObservations(dimensions, observations, refinedAttributes, { customAttributes });
+  const enhancedObservations = enhanceObservations(refinedDimensions, observations, refinedAttributes, { customAttributes });
   const attributesSeries = getAttributesSeries(enhancedObservations);
-  const manyValuesDimensions = getManyValuesDimensions(dimensions, attributesSeries, customAttributes, seriesCombinations);
-  const oneValueDimensions = getOneValueDimensions(dimensions, parsedAttributes);
+  const manyValuesDimensions = getManyValuesDimensions(refinedDimensions, attributesSeries, customAttributes, seriesCombinations);
+  const oneValueDimensions = getOneValueDimensions(refinedDimensions, parsedAttributes);
   const headerCoordinates = getHeaderCoordinates(oneValueDimensions);
   const hierarchisedDimensions = R.map(dim => {
     if (R.isEmpty(R.propOr({}, dim.id, hierarchies))) {

package/src/rules2/src/refineDimensions.js

@@ -0,0 +1,19 @@
+import * as R from 'ramda';
+
+export const refineDimensions = (dimensions=[], dataquery='') => {
+  const selectionIds = R.pipe(R.split('.'), R.map(R.split('+')))(dataquery);
+
+  return R.addIndex(R.map)((dim, index) => {
+    const selection = R.nth(index, selectionIds);
+    if (R.isNil(selection) || R.length(selection) === 0 || R.isEmpty(R.head(selection))) {
+      return { ...dim, header: R.length(dim.values || []) <= 1 };
+    }
+    const values = R.map(val => {
+      if (R.includes(val.id, selection)) {
+        return val;
+      }
+      return R.assoc('empty', true, val);
+    }, dim.values || []);
+    return { ...dim, values, header: R.length(values) <= 1 || R.length(selection) === 1 };
+  }, dimensions);
+};