@sis-cc/dotstatsuite-components 8.12.0 → 8.13.0

package/lib/rules/src/factories/stacked-dimension.js

@@ -4,40 +4,34 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 
-var _isNil2 = require('lodash/isNil');
+var _ramda = require('ramda');
 
-var _isNil3 = _interopRequireDefault(_isNil2);
-
-var _find2 = require('lodash/find');
-
-var _find3 = _interopRequireDefault(_find2);
-
-var _head2 = require('lodash/head');
-
-var _head3 = _interopRequireDefault(_head2);
-
-var _get2 = require('lodash/get');
-
-var _get3 = _interopRequireDefault(_get2);
+var R = _interopRequireWildcard(_ramda);
 
 var _dotstatsuiteSdmxjs = require('@sis-cc/dotstatsuite-sdmxjs');
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+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; } }
 
 exports.default = function (dimensions, singularity) {
-  var mode = (0, _get3.default)(singularity, 'mode') === 'percent' ? 'percent' : 'values';
+  var value = dimensions.value,
+      values = dimensions.values;
+
+  var mode = R.prop('mode', singularity) === 'percent' ? 'percent' : 'values';
+  if (R.length(values) === 1) {
+    return { mode: mode, id: R.pathOr(null, [0, 'id'], value) };
+  }
   var serieDimension = null;
-  var id = (0, _get3.default)(singularity, 'id');
-  if (!(0, _isNil3.default)(id)) {
-    serieDimension = (0, _find3.default)(dimensions, { id: id });
+  var id = R.prop('id', singularity);
+  if (!R.isNil(id)) {
+    serieDimension = R.find(R.propEq('id', id), values);
   }
-  var areaDimension = (0, _dotstatsuiteSdmxjs.getRefAreaDimension)({ dimensions: dimensions });
-  var timeDimension = (0, _dotstatsuiteSdmxjs.getTimePeriodDimension)({ dimensions: dimensions });
+  var areaDimension = (0, _dotstatsuiteSdmxjs.getRefAreaDimension)({ dimensions: values });
+  var timeDimension = (0, _dotstatsuiteSdmxjs.getTimePeriodDimension)({ dimensions: values });
 
-  serieDimension = serieDimension || areaDimension || timeDimension || (0, _head3.default)(dimensions);
+  serieDimension = serieDimension || areaDimension || timeDimension || R.head(values);
 
   return {
     mode: mode,
-    id: (0, _get3.default)(serieDimension, 'id', null)
+    id: R.propOr(null, 'id', serieDimension)
   };
 };

package/lib/rules/src/factories/stacked-series.js

@@ -4,69 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 
-var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
+var _extends2 = require('babel-runtime/helpers/extends');
 
-var _defineProperty3 = _interopRequireDefault(_defineProperty2);
-
-var _extends3 = require('babel-runtime/helpers/extends');
-
-var _extends4 = _interopRequireDefault(_extends3);
-
-var _take2 = require('lodash/take');
-
-var _take3 = _interopRequireDefault(_take2);
-
-var _sumBy2 = require('lodash/sumBy');
-
-var _sumBy3 = _interopRequireDefault(_sumBy2);
-
-var _sortBy2 = require('lodash/sortBy');
-
-var _sortBy3 = _interopRequireDefault(_sortBy2);
-
-var _split2 = require('lodash/split');
-
-var _split3 = _interopRequireDefault(_split2);
-
-var _reduce2 = require('lodash/reduce');
-
-var _reduce3 = _interopRequireDefault(_reduce2);
-
-var _map2 = require('lodash/map');
-
-var _map3 = _interopRequireDefault(_map2);
-
-var _keyBy2 = require('lodash/keyBy');
-
-var _keyBy3 = _interopRequireDefault(_keyBy2);
-
-var _join2 = require('lodash/join');
-
-var _join3 = _interopRequireDefault(_join2);
-
-var _isUndefined2 = require('lodash/isUndefined');
-
-var _isUndefined3 = _interopRequireDefault(_isUndefined2);
-
-var _head2 = require('lodash/head');
-
-var _head3 = _interopRequireDefault(_head2);
-
-var _has2 = require('lodash/has');
-
-var _has3 = _interopRequireDefault(_has2);
-
-var _groupBy2 = require('lodash/groupBy');
-
-var _groupBy3 = _interopRequireDefault(_groupBy2);
-
-var _get2 = require('lodash/get');
-
-var _get3 = _interopRequireDefault(_get2);
-
-var _find2 = require('lodash/find');
-
-var _find3 = _interopRequireDefault(_find2);
+var _extends3 = _interopRequireDefault(_extends2);
 
 var _dotstatsuiteSdmxjs = require('@sis-cc/dotstatsuite-sdmxjs');
 
@@ -74,137 +14,121 @@ var _dimensionUtils = require('../dimension-utils');
 
 var _observationFormater = require('../observation-formater');
 
+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 flatDatapoints = function flatDatapoints(observations, dimensions, dimensionsWithValuesIndexedById, serieDimensionId, display, formaterAttrs) {
-  return (0, _map3.default)(observations, function (observationValue, observationKey) {
+
+  var datapoints = R.mapObjIndexed(function (observationValue, observationKey) {
     var x = null;
-    var y = Number((0, _head3.default)(observationValue));
+    var y = Number(R.head(observationValue));
     var formater = (0, _observationFormater.getObservationFormater)(observationValue, formaterAttrs);
-    var splittedKey = (0, _split3.default)(observationKey, ':');
+    var splittedKey = R.split(':', observationKey);
     var layerKey = [];
-    var layerDimensions = (0, _reduce3.default)(splittedKey, function (memo, dimensionValueIndex, dimensionIndex) {
-      var dimension = (0, _get3.default)(dimensions, '[' + dimensionIndex + ']');
-      if ((0, _has3.default)(dimensionsWithValuesIndexedById, dimension.id)) {
-        var dimensionValue = (0, _extends4.default)({}, (0, _get3.default)(dimension, 'values[' + dimensionValueIndex + ']', {}), {
-          index: dimensionValueIndex,
-          label: (0, _dimensionUtils.dimensionValueDisplay)(display)((0, _get3.default)(dimension, 'values[' + dimensionValueIndex + ']', {}))
-        });
-        if (dimension.id === serieDimensionId) {
-          x = dimensionValue;
-        } else {
-          memo.push(dimensionValue);
-          layerKey.push(dimensionValueIndex);
-        }
+    var layerDimensions = R.addIndex(R.reduce)(function (memo, dimensionValueIndex, dimensionIndex) {
+      var dimension = R.nth(dimensionIndex, dimensions);
+      var _dimensionValue = R.pathOr({}, ['values', Number(dimensionValueIndex)], dimension);
+      var label = (0, _dimensionUtils.dimensionValueDisplay)(display)(_dimensionValue);
+      var dimensionValue = (0, _extends3.default)({}, _dimensionValue, {
+        index: Number(dimensionValueIndex),
+        label: label
+      });
+      if (dimension.id === serieDimensionId) {
+        x = dimensionValue;
+      } else if (R.has(dimension.id, dimensionsWithValuesIndexedById)) {
+        memo.push(dimensionValue);
+        layerKey.push(dimensionValueIndex);
       }
       return memo;
-    }, []);
-    return { formater: formater, x: x, y: y, layerDimensions: layerDimensions, layerKey: (0, _join3.default)(layerKey, ':') };
-  });
+    }, [], splittedKey);
+    return { formater: formater, x: x, y: y, layerDimensions: layerDimensions, layerKey: R.join(':', layerKey) };
+  }, observations);
+
+  return R.values(datapoints);
 };
 
 var serie = function serie(observations, dimensions, dimensionsWithValuesIndexedById, serieDimensionId, display, formaterAttrs) {
-  var serieDimension = (0, _find3.default)(dimensionsWithValuesIndexedById, function (d) {
-    return d.id === serieDimensionId;
-  });
-  if ((0, _isUndefined3.default)(serieDimension)) {
-    return [];
+  var serieDimension = R.find(R.propEq('id', serieDimensionId), dimensions);
+  if (R.isNil(serieDimension)) {
+    return { datapoints: [], layerSeries: [] };
   }
   var _flatDatapoints = flatDatapoints(observations, dimensions, dimensionsWithValuesIndexedById, serieDimensionId, display, formaterAttrs);
-  var layeredDatapoints = (0, _groupBy3.default)(_flatDatapoints, function (dp) {
-    return dp.layerKey;
-  }); // { [layeredKey]: [dps] }
-  var layerFullSeries = (0, _map3.default)(layeredDatapoints, function (datapoints, layerKey) {
-    return { layerDimensions: (0, _get3.default)((0, _head3.default)(datapoints), 'layerDimensions'), layerKey: layerKey };
-  }); // [{ layerDimensions, layerKey }]
-  var layerSeries = (0, _take3.default)((0, _sortBy3.default)(layerFullSeries, function (layer) {
-    return layer.layerKey;
-  }), 5);
-  var layeredDatapointsKeyedByX = (0, _reduce3.default)(layeredDatapoints, function (memo, layerDps, key) {
-    var dps = (0, _keyBy3.default)(layerDps, function (dp) {
-      return (0, _get3.default)(dp, 'x.id', '');
-    });
-    return (0, _extends4.default)({}, memo, (0, _defineProperty3.default)({}, '' + key, dps));
-  }, {}); // { [layeredKey]: { [x.id]: dp } }
-  var datapoints = (0, _map3.default)(serieDimension.values, function (serieValue, index) {
+
+  var layeredDatapoints = R.groupBy(R.prop('layerKey'), _flatDatapoints); // { [layeredKey]: [dps] }
+
+  var layerFullSeries = R.map(function (datapoints) {
+    return {
+      layerDimensions: R.prop('layerDimensions', R.head(datapoints)),
+      layerKey: R.prop('layerKey', R.head(datapoints))
+    };
+  }, R.values(layeredDatapoints)); // [{ layerDimensions, layerKey }]
+  var layerSeries = R.take(5, R.sortBy(R.prop('layerKey'), layerFullSeries));
+  var layeredDatapointsKeyedByX = R.mapObjIndexed(R.indexBy(R.path(['x', 'id'])), layeredDatapoints); // { [layeredKey]: { [x.id]: dp } }
+  var datapoints = R.addIndex(R.map)(function (serieValue, index) {
     var serieValueId = serieValue.id;
     var x = (0, _dimensionUtils.dimensionValueDisplay)(display)(serieValue);
-    var y = (0, _map3.default)(layerSeries, function (_ref) {
+    var y = R.map(function (_ref) {
       var layerKey = _ref.layerKey;
-      return (0, _get3.default)(layeredDatapointsKeyedByX, layerKey + '.' + serieValueId + '.y', null);
-    });
-    var formaters = (0, _map3.default)(layerSeries, function (_ref2) {
+      return R.pathOr(null, [layerKey, serieValueId, 'y'], layeredDatapointsKeyedByX);
+    }, layerSeries);
+    var formaters = R.map(function (_ref2) {
       var layerKey = _ref2.layerKey;
-      return (0, _get3.default)(layeredDatapointsKeyedByX, layerKey + '.' + serieValueId + '.formater', null);
-    });
+      return R.pathOr(null, [layerKey, serieValueId, 'formater'], layeredDatapointsKeyedByX);
+    }, layerSeries);
     return { category: x, formaters: formaters, index: index, x: x, y: y, key: serieValueId };
-  });
+  }, serieDimension.values);
+  var _datapoints = R.when(R.pipe(R.length, R.equals(1)), R.pipe(R.set(R.lensPath([0, 'category']), ''), R.set(R.lensPath([0, 'x']), '')), datapoints);
   return {
-    datapoints: datapoints,
-    layerSeries: (0, _map3.default)(layerSeries, function (layer) {
+    datapoints: _datapoints,
+    layerSeries: R.map(function (layer) {
       return {
-        id: (0, _join3.default)((0, _map3.default)(layer.layerDimensions, function (l) {
-          return l.id;
-        }), ' - '),
-        label: (0, _join3.default)((0, _map3.default)(layer.layerDimensions, function (l) {
-          return l.label;
-        }), ' - ')
+        id: R.pipe(R.prop('layerDimensions'), R.pluck('id'), R.join(' - '))(layer),
+        label: R.pipe(R.prop('layerDimensions'), R.pluck('label'), R.join(' - '))(layer)
       };
-    })
+    }, layerSeries)
   };
 };
 
-var percentSerie = function percentSerie(serie) {
-  return [{
-    layerSeries: serie.layerSeries,
-    datapoints: (0, _map3.default)(serie.datapoints, function (dp) {
-      var total = (0, _sumBy3.default)(dp.y, function (val) {
-        return Math.abs(val);
-      });
-      if (!total) {
-        return dp;
-      }
-      return (0, _extends4.default)({}, dp, {
-        y: (0, _map3.default)(dp.y, function (value) {
-          return Math.abs(value) / total * 100;
-        }),
-        formaters: null
-      });
-    })
-  }];
-};
+var percentSerie = R.pipe(R.over(R.lensProp('datapoints'), R.map(function (dp) {
+  var total = R.pipe(R.map(function (v) {
+    return Math.abs(v);
+  }), R.sum)(dp.y);
+  if (!total) {
+    return dp;
+  }
+  return (0, _extends3.default)({}, dp, {
+    y: R.map(function (v) {
+      return Math.abs(v) / total * 100;
+    }, dp.y),
+    formaters: null
+  });
+})), R.of);
 
-var serieSortedByTotal = function serieSortedByTotal(serie) {
-  return [{
-    layerSeries: serie.layerSeries,
-    datapoints: (0, _sortBy3.default)(serie.datapoints, function (dp) {
-      return (0, _sumBy3.default)(dp.y, function (val) {
-        return val > 0 ? -1 * val : 0;
-      });
-    })
-  }];
-};
+var serieSortedByTotal = R.pipe(R.over(R.lensProp('datapoints'), R.sortBy(R.pipe(R.prop('y'), R.map(function (v) {
+  return v > 0 ? R.negate(v) : 0;
+}), R.sum))), R.of);
 
-var serieSortedByDataOrder = function serieSortedByDataOrder(serie) {
-  return [{ //to robustize with date generation, as in timeline series
-    layerSeries: serie.layerSeries,
-    datapoints: (0, _sortBy3.default)(serie.datapoints, function (dp) {
-      return dp.index;
-    })
-  }];
-};
+var serieSortedByDataOrder = R.pipe(R.over(R.lensProp('datapoints'), R.sortBy(R.prop('index'))), R.of);
 
 exports.default = function (_ref3, dimensionsWithValuesIndexedById, singularity, display, formaterAttrs) {
   var observations = _ref3.observations,
       dimensions = _ref3.dimensions;
 
-  var mode = (0, _get3.default)(singularity, 'mode', 'values');
-  var serieDimensionId = (0, _get3.default)(singularity, 'id', null);
+  var mode = R.propOr('values', 'mode', singularity);
+  var serieDimensionId = R.propOr(null, 'id', singularity);
   var _serie = serie(observations, dimensions, dimensionsWithValuesIndexedById, serieDimensionId, display, formaterAttrs);
   if (mode === 'percent') {
     return percentSerie(_serie);
   } else if ((0, _dotstatsuiteSdmxjs.isTimePeriodDimension)({ id: serieDimensionId })) {
     return serieSortedByDataOrder(_serie);
   }
-  return serieSortedByTotal(_serie);
+  //console.log('raw serie', _serie);
+  var res = serieSortedByTotal(_serie);
+  //console.log('serie', res);
+  return res;
 };

package/lib/rules/src/index.js

@@ -482,10 +482,7 @@ var _symbolDimension = function _symbolDimension(data, ids) {
 var symbolDimension = exports.symbolDimension = (0, _memoizee2.default)(_symbolDimension);
 
 var _stackedDimension = function _stackedDimension(data, singularity) {
-  var _splitDimensions4 = splitDimensions(data),
-      values = _splitDimensions4.values;
-
-  return (0, _stackedDimension3.default)(values, singularity);
+  return (0, _stackedDimension3.default)(splitDimensions(data), singularity);
 };
 var stackedDimension = exports.stackedDimension = (0, _memoizee2.default)(_stackedDimension);
 
@@ -618,8 +615,8 @@ var parseFocus = exports.parseFocus = (0, _memoizee2.default)(_parseFocus);
 var _defaultSubtitle = function _defaultSubtitle(data, display) {
   var REJECTED_SUBTITLE_IDS = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _constants.DEFAULT_REJECTED_SUBTITLE_IDS;
 
-  var _splitDimensions5 = splitDimensions(data),
-      value = _splitDimensions5.value;
+  var _splitDimensions4 = splitDimensions(data),
+      value = _splitDimensions4.value;
 
   var values = (0, _reduce3.default)(R.reject(R.prop('isHidden'))(value), function (memo, d) {
     var dvId = (0, _get3.default)(d, 'values[0].id');

package/lib/rules/src/properties/index.js

@@ -375,7 +375,7 @@ var toProperties = exports.toProperties = function toProperties(props, state, _o
     },
     stackedDimension: {
       id: 'stackedDimension',
-      isActive: (0, _stacked.isStacked)(props.type),
+      isActive: (0, _stacked.isStackedDimActive)(props),
       options: (0, _utils.chartDimensionOptions)(props, _stacked.isStacked),
       onChange: R.pipe(_utils.optionParser, (0, _stacked.onChangeStackedDimension)(props, state), _onChange),
       value: (0, _utils.chartDimensionToOption)('stackedDimension')(props, state)

package/lib/rules/src/properties/stacked.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.stackedStateFromNewProps = exports.onChangeStackedMode = exports.stackedModeOptions = exports.onChangeStackedDimension = exports.toStackedSingularity = exports.isStacked = undefined;
+exports.stackedStateFromNewProps = exports.onChangeStackedMode = exports.isStackedDimActive = exports.stackedModeOptions = exports.onChangeStackedDimension = exports.toStackedSingularity = exports.isStacked = undefined;
 
 var _extends2 = require('babel-runtime/helpers/extends');
 
@@ -23,6 +23,8 @@ var _constants = require('../constants');
 
 var _utils = require('./utils');
 
+var _ = require('../');
+
 var _focus = require('./focus');
 
 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; } }
@@ -68,6 +70,20 @@ var onChangeStackedDimension = exports.onChangeStackedDimension = function onCha
 
 var stackedModeOptions = exports.stackedModeOptions = [{ value: _constants.VALUES }, { value: _constants.PERCENT }];
 
+var isStackedDimActive = exports.isStackedDimActive = function isStackedDimActive(_ref2) {
+  var data = _ref2.data,
+      type = _ref2.type;
+
+  var _splitDimensions = (0, _.splitDimensions)(data),
+      values = _splitDimensions.values;
+
+  if (R.length(values) < 2) {
+    console.log('niet');
+    return false;
+  }
+  return isStacked(type);
+};
+
 var onChangeStackedMode = exports.onChangeStackedMode = function onChangeStackedMode(value) {
   return R.has(value, stackedModes) ? { stackedMode: value } : {};
 };
@@ -86,17 +102,25 @@ var stackedStateFromNewProps = exports.stackedStateFromNewProps = function stack
 
   var dimension = getStackedDimension(data, state);
   if (R.isNil(dimension)) {
-    var _getGroupedDimensions = (0, _utils.getGroupedDimensions)(data),
-        area = _getGroupedDimensions.area,
-        time = _getGroupedDimensions.time,
-        other = _getGroupedDimensions.other;
-
-    if (!R.isNil(area) && !R.isEmpty(area)) {
-      dimension = R.head(area);
-    } else if (!R.isNil(time) && !R.isEmpty(time)) {
-      dimension = R.head(time);
+    var _splitDimensions2 = (0, _.splitDimensions)(data),
+        value = _splitDimensions2.value,
+        values = _splitDimensions2.values;
+
+    if (R.length(values) === 1) {
+      dimension = R.head(value);
     } else {
-      dimension = R.head(other);
+      var _getGroupedDimensions = (0, _utils.getGroupedDimensions)(data),
+          area = _getGroupedDimensions.area,
+          time = _getGroupedDimensions.time,
+          other = _getGroupedDimensions.other;
+
+      if (!R.isNil(area) && !R.isEmpty(area)) {
+        dimension = R.head(area);
+      } else if (!R.isNil(time) && !R.isEmpty(time)) {
+        dimension = R.head(time);
+      } else {
+        dimension = R.head(other);
+      }
     }
   }
   var _mode = R.prop('stackedMode', state);

package/lib/rules/src/properties/utils.js

@@ -51,7 +51,10 @@ var toState = exports.toState = function toState(artefact) {
 var getPropertyDimension = exports.getPropertyDimension = function getPropertyDimension(property) {
   return function (data, state) {
     var statePropertyDimensionId = (0, _ramda.prop)(property, state);
-    var dimensions = getDimensionsWithValues(data);
+
+    var _extractSdmxArtefacts = (0, _.extractSdmxArtefacts)(data),
+        dimensions = _extractSdmxArtefacts.dimensions;
+
     return (0, _ramda.find)((0, _ramda.propEq)('id', statePropertyDimensionId), dimensions);
   };
 };
@@ -116,5 +119,8 @@ var chartDimensionOptions = exports.chartDimensionOptions = function chartDimens
     return [];
   }
   var dimensions = (0, _ramda.prop)('values', (0, _.splitDimensions)(data));
+  if ((0, _ramda.equals)(type, _constants.STACKED) && (0, _ramda.length)(dimensions) === 1) {
+    return [];
+  }
   return (0, _ramda.map)(artefactToOption(display), dimensions);
 };

package/lib/viewer/src/legends/SeriesLegend.js

@@ -53,7 +53,9 @@ var getSymbolSeriesItems = function getSymbolSeriesItems(_ref) {
   }))(data);
 };
 
-var getStackedSeriesItems = R.pathOr([], ['options', 'serie', 'stacked', 'layerSeries']);
+var getStackedSeriesItems = R.pipe(R.pathOr([], ['options', 'serie', 'stacked', 'layerSeries']), R.when(function (s) {
+  return R.length(s) === 1;
+}, R.always([])));
 
 var stackedLayerRenderer = function stackedLayerRenderer(_ref2) {
   var baseColor = _ref2.baseColor;

package/package.json

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

package/src/rules/src/factories/stacked-dimension.js

@@ -1,20 +1,24 @@
-import { get, head, find, isNil } from 'lodash';
+import * as R from 'ramda';
 import { getRefAreaDimension, getTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
 
 export default (dimensions, singularity) => {
-  const mode = get(singularity, 'mode') === 'percent' ? 'percent' : 'values';
+  const { value, values } = dimensions;
+  const mode = R.prop('mode', singularity) === 'percent' ? 'percent' : 'values';
+  if (R.length(values) === 1) {
+    return ({ mode, id: R.pathOr(null, [0, 'id'], value) });
+  }
   let serieDimension = null;
-  const id = get(singularity, 'id');
-  if (!isNil(id)) {
-    serieDimension = find(dimensions, { id });
+  const id = R.prop('id', singularity);
+  if (!R.isNil(id)) {
+    serieDimension = R.find(R.propEq('id', id), values);
   }
-  const areaDimension = getRefAreaDimension({ dimensions });
-  const timeDimension = getTimePeriodDimension({ dimensions });
+  const areaDimension = getRefAreaDimension({ dimensions: values });
+  const timeDimension = getTimePeriodDimension({ dimensions: values });
 
-  serieDimension = serieDimension || areaDimension || timeDimension || head(dimensions);
+  serieDimension = serieDimension || areaDimension || timeDimension || R.head(values);
 
   return ({
-    mode: mode,
-    id: get(serieDimension, 'id', null)
+    mode,
+    id: R.propOr(null, 'id', serieDimension)
   });
 }

package/src/rules/src/factories/stacked-series.js

@@ -1,139 +1,144 @@
-import { find, get, groupBy, has, head, isUndefined, join, keyBy, map, reduce, split, sortBy, sumBy, take } from 'lodash';
 import { isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
 import { dimensionValueDisplay } from '../dimension-utils';
 import { getObservationFormater } from '../observation-formater';
+import * as R from 'ramda';
 
 const flatDatapoints = (observations, dimensions, dimensionsWithValuesIndexedById, serieDimensionId, display, formaterAttrs) => {
-  return map(
-    observations,
+
+  const datapoints = R.mapObjIndexed(
     (observationValue, observationKey) => {
       let x = null;
-      const y = Number(head(observationValue));
+      const y = Number(R.head(observationValue));
       const formater = getObservationFormater(observationValue, formaterAttrs);
-      const splittedKey = split(observationKey, ':');
+      const splittedKey = R.split(':', observationKey);
       let layerKey = [];
-      const layerDimensions = reduce(
-        splittedKey,
+      const layerDimensions = R.addIndex(R.reduce)(
         (memo, dimensionValueIndex, dimensionIndex) => {
-          const dimension = get(dimensions, `[${dimensionIndex}]`);
-          if (has(dimensionsWithValuesIndexedById, dimension.id)) {
-            const dimensionValue = {
-              ...get(dimension, `values[${dimensionValueIndex}]`, {}),
-              index: dimensionValueIndex,
-              label: dimensionValueDisplay(display)(get(dimension, `values[${dimensionValueIndex}]`, {}))
-            }
-            if (dimension.id === serieDimensionId) {
-              x = dimensionValue;
-            }
-            else {
-              memo.push(dimensionValue);
-              layerKey.push(dimensionValueIndex);
-            }
+          const dimension = R.nth(dimensionIndex, dimensions);
+          const _dimensionValue = R.pathOr({}, ['values', Number(dimensionValueIndex)], dimension);
+          const label = dimensionValueDisplay(display)(_dimensionValue);
+          const dimensionValue = {
+            ..._dimensionValue,
+            index: Number(dimensionValueIndex),
+            label
+          };
+          if (dimension.id === serieDimensionId) {
+            x = dimensionValue;
+          }
+          else if (R.has(dimension.id, dimensionsWithValuesIndexedById)) {
+            memo.push(dimensionValue);
+            layerKey.push(dimensionValueIndex);
           }
           return memo;
         },
-        []
+        [],
+        splittedKey
       );
-      return ({ formater, x, y, layerDimensions, layerKey: join(layerKey, ':') });
-    }
+      return ({ formater, x, y, layerDimensions, layerKey: R.join(':', layerKey) });
+    },
+    observations
   );
+
+  return R.values(datapoints);
 };
 
 const serie = (observations, dimensions, dimensionsWithValuesIndexedById, serieDimensionId, display, formaterAttrs) => {
-  const serieDimension = find(dimensionsWithValuesIndexedById, d => d.id === serieDimensionId);
-  if (isUndefined(serieDimension)) {
-    return [];
+  const serieDimension = R.find(R.propEq('id', serieDimensionId), dimensions);
+  if (R.isNil(serieDimension)) {
+    return { datapoints: [], layerSeries: [] };
   }
   const _flatDatapoints = flatDatapoints(observations, dimensions, dimensionsWithValuesIndexedById, serieDimensionId, display, formaterAttrs);
-  const layeredDatapoints = groupBy(
-    _flatDatapoints,
-    dp => dp.layerKey
+
+  const layeredDatapoints = R.groupBy(
+    R.prop('layerKey'),
+    _flatDatapoints
   ); // { [layeredKey]: [dps] }
-  const layerFullSeries = map(
-    layeredDatapoints,
-    (datapoints, layerKey) => ({ layerDimensions: get(head(datapoints), 'layerDimensions'), layerKey })
+
+  const layerFullSeries = R.map(
+    datapoints => ({
+      layerDimensions: R.prop('layerDimensions', R.head(datapoints)),
+      layerKey: R.prop('layerKey', R.head(datapoints))
+    }),
+    R.values(layeredDatapoints)
   ); // [{ layerDimensions, layerKey }]
-  const layerSeries = take(sortBy(layerFullSeries, layer => layer.layerKey), 5);
-  const layeredDatapointsKeyedByX = reduce(
-    layeredDatapoints,
-    (memo, layerDps, key) => {
-      const dps = keyBy(layerDps, dp => get(dp, 'x.id', ''));
-      return ({
-        ...memo,
-        [`${key}`]: dps
-      });
-    },
-    {}
+  const layerSeries = R.take(5, R.sortBy(R.prop('layerKey'), layerFullSeries));
+  const layeredDatapointsKeyedByX = R.mapObjIndexed(
+    R.indexBy(R.path(['x', 'id'])),
+    layeredDatapoints
   ); // { [layeredKey]: { [x.id]: dp } }
-  const datapoints = map(
-    serieDimension.values,
+  const datapoints = R.addIndex(R.map)(
     (serieValue, index) => {
       const serieValueId = serieValue.id;
       const x = dimensionValueDisplay(display)(serieValue);
-      const y = map(
+      const y = R.map(
+        ({ layerKey }) => R.pathOr(null, [layerKey, serieValueId, 'y'], layeredDatapointsKeyedByX),
         layerSeries,
-        ({ layerKey }) => get(layeredDatapointsKeyedByX, `${layerKey}.${serieValueId}.y`, null)
       );
-      const formaters = map(
+      const formaters = R.map(
+        ({ layerKey }) => R.pathOr(null, [layerKey, serieValueId, 'formater'], layeredDatapointsKeyedByX),
         layerSeries,
-        ({ layerKey }) => get(layeredDatapointsKeyedByX, `${layerKey}.${serieValueId}.formater`, null)
       );
       return ({ category: x, formaters, index, x, y, key: serieValueId });
-    }
+    },
+    serieDimension.values,
+  );
+  const _datapoints = R.when(
+    R.pipe(R.length, R.equals(1)),
+    R.pipe(
+      R.set(R.lensPath([0, 'category']), ''),
+      R.set(R.lensPath([0, 'x']), ''),
+    ),
+    datapoints
   );
   return ({
-    datapoints,
-    layerSeries: map(
-      layerSeries,
+    datapoints: _datapoints,
+    layerSeries: R.map(
       layer => ({
-        id: join(map(layer.layerDimensions, l => l.id), ' - '),
-        label: join(map(layer.layerDimensions, l => l.label), ' - '),
-      })
+        id: R.pipe(R.prop('layerDimensions'), R.pluck('id'), R.join(' - '))(layer),
+        label: R.pipe(R.prop('layerDimensions'), R.pluck('label'), R.join(' - '))(layer),
+      }),
+      layerSeries
     )
   });
 };
 
-const percentSerie = (serie) => {
-  return [{
-    layerSeries: serie.layerSeries,
-    datapoints: map(
-      serie.datapoints,
-      dp => {
-        const total = sumBy(dp.y, val => Math.abs(val));
-        if (!total) {
-          return dp;
-        }
-        return ({
-          ...dp,
-          y: map(dp.y, value => (Math.abs(value) / total) * 100),
-          formaters: null,
-        });
+const percentSerie = R.pipe(
+  R.over(
+    R.lensProp('datapoints'),
+    R.map(dp => {
+      const total = R.pipe(R.map(v => Math.abs(v)), R.sum)(dp.y);
+      if (!total) {
+        return dp;
       }
-    )
-  }];
-};
+      return ({
+        ...dp,
+        y: R.map(v => (Math.abs(v) / total) * 100, dp.y),
+        formaters: null,
+      });
+    })
+  ),
+  R.of
+);
 
-const serieSortedByTotal = (serie) => {
-  return [{
-    layerSeries: serie.layerSeries,
-    datapoints: sortBy(
-      serie.datapoints,
-      dp => sumBy(dp.y, val => val > 0 ? (-1 * val) : 0)
-    )
-  }];
-};
+const serieSortedByTotal = R.pipe(
+  R.over(
+    R.lensProp('datapoints'),
+    R.sortBy(R.pipe(R.prop('y'), R.map(v => v > 0 ? R.negate(v) : 0), R.sum))
+  ),
+  R.of
+);
 
-const serieSortedByDataOrder = (serie) => [{ //to robustize with date generation, as in timeline series
-  layerSeries: serie.layerSeries,
-  datapoints: sortBy(
-    serie.datapoints,
-    dp => dp.index
-  )
-}];
+const serieSortedByDataOrder = R.pipe(
+  R.over(
+    R.lensProp('datapoints'),
+    R.sortBy(R.prop('index'))
+  ),
+  R.of
+);
 
 export default ({ observations, dimensions }, dimensionsWithValuesIndexedById, singularity, display, formaterAttrs) => {
-  const mode = get(singularity, 'mode', 'values');
-  const serieDimensionId = get(singularity, 'id', null);
+  const mode = R.propOr('values', 'mode', singularity);
+  const serieDimensionId = R.propOr(null, 'id', singularity);
   const _serie = serie(observations, dimensions, dimensionsWithValuesIndexedById, serieDimensionId, display, formaterAttrs);
   if (mode === 'percent') {
     return percentSerie(_serie);
@@ -141,5 +146,8 @@ export default ({ observations, dimensions }, dimensionsWithValuesIndexedById, s
   else if (isTimePeriodDimension({ id: serieDimensionId })) {
     return serieSortedByDataOrder(_serie);
   }
-  return serieSortedByTotal(_serie);
+  //console.log('raw serie', _serie);
+  const res = serieSortedByTotal(_serie);
+  //console.log('serie', res);
+  return res;
 };

package/src/rules/src/index.js

@@ -129,8 +129,7 @@ const _symbolDimension = (data, ids) => {
 export const symbolDimension = memoizee(_symbolDimension);
 
 const _stackedDimension = (data, singularity) => {
-  const { values } = splitDimensions(data);
-  return __stackedDimension(values, singularity);
+  return __stackedDimension(splitDimensions(data), singularity);
 }
 export const stackedDimension = memoizee(_stackedDimension);
 

package/src/rules/src/properties/index.js

@@ -40,6 +40,7 @@ import {
 } from './symbol';
 import {
   isStacked,
+  isStackedDimActive,
   onChangeStackedDimension,
   onChangeStackedMode,
   stackedModeOptions,
@@ -404,7 +405,7 @@ export const toProperties = (props, state, onChange) => ({
   },
   stackedDimension: {
     id: 'stackedDimension',
-    isActive: isStacked(props.type),
+    isActive: isStackedDimActive(props),
     options: chartDimensionOptions(props, isStacked),
     onChange: R.pipe(
       optionParser,

package/src/rules/src/properties/stacked.js

@@ -6,6 +6,7 @@ import {
   getPropertyDimension,
   toState
 } from './utils';
+import { splitDimensions } from '../';
 import { focusStateFromNewProps } from './focus';
 
 const getStackedDimension = getPropertyDimension('stackedDimension');
@@ -38,6 +39,15 @@ export const onChangeStackedDimension = ({ data }, state) => (value) => {
 
 export const stackedModeOptions = [{ value: VALUES }, { value: PERCENT }];
 
+export const isStackedDimActive = ({ data, type }) => {
+  const { values } = splitDimensions(data);
+  if (R.length(values) < 2) {
+    console.log('niet');
+    return false;
+  }
+  return isStacked(type);
+};
+
 export const onChangeStackedMode = (value) => R.has(value, stackedModes)
   ? ({ stackedMode: value })
   : ({});
@@ -54,15 +64,21 @@ export const stackedStateFromNewProps = (props, state) => {
 
   let dimension = getStackedDimension(data, state);
   if (R.isNil(dimension)) {
-    const { area, time, other } = getGroupedDimensions(data);
-    if (!R.isNil(area) && !R.isEmpty(area)) {
-      dimension = R.head(area);
-    }
-    else if (!R.isNil(time) && !R.isEmpty(time)) {
-      dimension = R.head(time)
+    const { value, values } = splitDimensions(data);
+    if (R.length(values) === 1) {
+      dimension = R.head(value);
     }
     else {
-      dimension = R.head(other);
+      const { area, time, other } = getGroupedDimensions(data);
+      if (!R.isNil(area) && !R.isEmpty(area)) {
+        dimension = R.head(area);
+      }
+      else if (!R.isNil(time) && !R.isEmpty(time)) {
+        dimension = R.head(time)
+      }
+      else {
+        dimension = R.head(other);
+      }
     }
   }
   const _mode = R.prop('stackedMode', state);

package/src/rules/src/properties/utils.js

@@ -1,10 +1,12 @@
 import {
-  groupBy,
+  equals,
   find,
+  groupBy,
   has,
   head,
   is,
   isNil,
+  length,
   map,
   not,
   omit,
@@ -15,7 +17,7 @@ import {
 } from 'ramda';
 import { isRefAreaDimension, isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
 import { extractSdmxArtefacts, parseDisplay, splitDimensions } from '../';
-import { CHORO, H_SYMBOL, SCATTER, TYPES, V_SYMBOL } from '../constants';
+import { CHORO, H_SYMBOL, SCATTER, STACKED, TYPES, V_SYMBOL } from '../constants';
 import { dimensionValueDisplay } from '../dimension-utils';
 
 export const isNumber = (input) => {
@@ -44,7 +46,7 @@ export const toState = (artefact) => prop('id', artefact);
 
 export const getPropertyDimension = (property) => (data, state) => {
   const statePropertyDimensionId = prop(property, state);
-  const dimensions = getDimensionsWithValues(data);
+  const { dimensions } = extractSdmxArtefacts(data);
   return find(
     propEq('id', statePropertyDimensionId),
     dimensions
@@ -99,6 +101,9 @@ export const chartDimensionOptions = ({ data, type, display }, typeValidator) =>
     return [];
   }
   const dimensions = prop('values', splitDimensions(data));
+  if (equals(type, STACKED) && length(dimensions) === 1) {
+    return [];
+  }
   return map(
     artefactToOption(display),
     dimensions

package/src/viewer/src/legends/SeriesLegend.js

@@ -33,7 +33,10 @@ const getSymbolSeriesItems = ({ data, options }) => {
   )(data);
 };
 
-const getStackedSeriesItems = R.pathOr([], ['options', 'serie', 'stacked', 'layerSeries']);
+const getStackedSeriesItems = R.pipe(
+  R.pathOr([], ['options', 'serie', 'stacked', 'layerSeries']),
+  R.when(s => R.length(s) === 1, R.always([]))
+);
 
 const stackedLayerRenderer = ({ baseColor }) => (
   <svg width="21" height="14">