@sis-cc/dotstatsuite-components 14.0.0 → 14.1.0

package/lib/rules/src/preparators/enhanceObservations.js

@@ -74,12 +74,6 @@ var getObservationUnits = function getObservationUnits(observation, dimensions,
   return (0, _extends3.default)({}, dimensionsUnits, attributesUnits, { serieKey: serieKey });
 };
 
-var getOrderedDimensionsIndexes = function getOrderedDimensionsIndexes(dimensions, indexes) {
-  return R.addIndex(R.map)(function (valueIndex, dimensionIndex) {
-    return R.path([dimensionIndex, 'values', valueIndex, '__indexPosition'], dimensions);
-  }, indexes);
-};
-
 var getFormatAttributesIndexes = function getFormatAttributesIndexes(attributes, customAttributes) {
   return R.addIndex(R.reduce)(function (acc, attribute, index) {
     if (R.equals(attribute.id, customAttributes.decimals)) {
@@ -141,7 +135,6 @@ var enhanceObservations = exports.enhanceObservations = function enhanceObservat
     return (0, _extends3.default)({}, observation, {
       attributes: obsAttributes,
       formattedValue: (0, _formatValue.formatValue)(observation, formatAttributesIndexes, attributes),
-      orderedDimIndexes: getOrderedDimensionsIndexes(dimensions, dimValuesIndexes),
       units: getObservationUnits(observation, dimensions, _attributes, options),
       indexedDimValIds: indexedDimValIds
     });

package/lib/rules/src/table/factories/getCells.js

@@ -92,6 +92,6 @@ var getSideProps = function getSideProps(_ref2, customAttributes, metadataCoordi
 
 var getCells = exports.getCells = function getCells(data, display, customAttributes, unitsProps, metadataCoordinates) {
   return R.mapObjIndexed(function (observation) {
-    return R.pipe(R.set(R.lensProp('flags'), getFlags(customAttributes, (0, _dimensionUtils.dimensionValueDisplay)(display), unitsProps)(observation)), R.set(R.lensProp('intValue'), R.prop('value', observation)), R.set(R.lensProp('value'), R.prop('formattedValue', observation)), R.assoc('indexedDimValIds', R.prop('indexedDimValIds', observation)), R.assoc('sideProps', getSideProps(observation, customAttributes, metadataCoordinates)))({});
+    return R.pipe(R.set(R.lensProp('flags'), getFlags(customAttributes, (0, _dimensionUtils.dimensionValueDisplay)(display), unitsProps)(observation)), R.set(R.lensProp('intValue'), R.prop('value', observation)), R.set(R.lensProp('value'), R.prop('formattedValue', observation)), R.assoc('indexedDimValIds', R.prop('indexedDimValIds', observation)), R.assoc('sideProps', getSideProps(observation, customAttributes, metadataCoordinates)), R.set(R.lensProp('key'), R.prop('key', observation)))({});
   }, R.propOr({}, 'observations', data));
 };

package/lib/rules/src/table/factories/getCuratedCells.js

@@ -26,12 +26,11 @@ var getPivots = function getPivots(layout, shape) {
 };
 
 var indexWithPivots = function indexWithPivots(pivots, observations) {
-  return R.pipe(R.keys, R.reduce(function (acc, obsKey) {
-    var splitKey = R.split(':', obsKey);
+  return R.pipe(R.values, R.reduce(function (acc, obs) {
+    var splitKey = R.split(':', obs.key);
     var path = R.map(function (pivot) {
       return pivot(splitKey);
     }, pivots);
-    var obs = R.prop(obsKey, observations);
     return R.over(R.lensPath(path), R.ifElse(R.isNil, R.always([obs]), R.append(obs)))(acc);
   }, {}))(observations);
 };

package/lib/rules/src/table/factories/getTableData.js

@@ -13,8 +13,6 @@ var _ramda = require('ramda');
 
 var R = _interopRequireWildcard(_ramda);
 
-var _dotstatsuiteSdmxjs = require('@sis-cc/dotstatsuite-sdmxjs');
-
 var _getCells = require('./getCells');
 
 var _getConfirmedSeriesAttributesIds = require('./getConfirmedSeriesAttributesIds');
@@ -37,6 +35,8 @@ var _getLayoutData = require('./getLayoutData');
 
 var _refineMetadataCoordinates = require('../../../../rules2/src/refineMetadataCoordinates');
 
+var _invertTime2 = require('../../../../rules2/src/invertTime');
+
 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 }; }
@@ -76,14 +76,9 @@ var getTableProps = exports.getTableProps = function getTableProps(_ref) {
     unitDimension: unitDimension, rejectedValueIds: rejectedValueIds, layoutDimsIds: layoutDimsIds
   }, refinedMetadataCoordinates.cells, data.observationsType);
 
-  var dimensions = R.mapObjIndexed(R.pipe(R.when( // invert TimeDimension Values
-  R.allPass([_dotstatsuiteSdmxjs.isTimePeriodDimension, R.always(isTimeInverted)]), function (dim) {
-    return R.over(R.lensProp('values'), R.map(R.over(R.lensProp('__indexPosition'), R.negate)))(dim);
-  }), function (dim) {
-    return R.over( // sort values
-    R.lensProp('values'), R.sortWith([R.ascend(R.prop('__indexPosition')), R.ascend(R.prop('order'))]))(dim);
-  }, R.when( // refine hierarchy on rows
-  R.pipe(R.prop('id'), R.flip(R.includes)(R.propOr([], 'rows', layoutIds))), _dotstatsuiteSdmxjs.withFlatHierarchy)), R.pathOr({}, ['dimensions', 'many'], data));
+  var _invertTime = (0, _invertTime2.invertTime)(data, isTimeInverted),
+      dimensions = _invertTime.dimensions,
+      observations = _invertTime.observations;
 
   var seriesAttributesValues = R.propOr({}, 'seriesAttributesValues', data);
   var layout = R.pipe(R.mergeRight({ header: [], sections: [], rows: [] }), R.mapObjIndexed(R.flip(R.props)(dimensions)))(layoutIds);
@@ -96,7 +91,7 @@ var getTableProps = exports.getTableProps = function getTableProps(_ref) {
     display: display, unitDimension: unitDimension, unitsDisplay: unitsLevelDisplay, unitsSeries: unitsSeries,
     unitsDefinitionCodes: unitsDefinitionCodes, unitsIndexes: unitsAttachmentIndexesInLayout,
     partialUnitSerieIndexes: partialUnitSerieIndexes, rejectedValueIds: rejectedValueIds, layoutIds: layoutIds
-  }), (0, _getLayoutWithFlags.getLayoutDataWithFlags)(seriesAttributesValues, display, customAttributes, refinedMetadataCoordinates, unitDimension.id), (0, _cleanUnitsInLayoutData.cleanUnitsInLayoutData)({ unitsDisplay: unitsLevelDisplay, unitsLayoutIndexes: unitsIndexesInLayout }))(layout, R.propOr({}, 'observations', data));
+  }), (0, _getLayoutWithFlags.getLayoutDataWithFlags)(seriesAttributesValues, display, customAttributes, refinedMetadataCoordinates, unitDimension.id), (0, _cleanUnitsInLayoutData.cleanUnitsInLayoutData)({ unitsDisplay: unitsLevelDisplay, unitsLayoutIndexes: unitsIndexesInLayout }))(layout, observations);
 
   return (0, _extends3.default)({
     cells: (0, _getCuratedCells.getCuratedCells)({ layout: layout, observations: cells, shape: ['header', 'sections', 'rows'] }),

package/lib/rules/src/table/preparators/prepareData.js

@@ -5,9 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.prepareData = undefined;
 
-var _extends2 = require('babel-runtime/helpers/extends');
+var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
 
-var _extends3 = _interopRequireDefault(_extends2);
+var _defineProperty3 = _interopRequireDefault(_defineProperty2);
+
+var _extends3 = require('babel-runtime/helpers/extends');
+
+var _extends4 = _interopRequireDefault(_extends3);
 
 var _ramda = require('ramda');
 
@@ -49,6 +53,14 @@ var _getMetadataCoordinates = require('../../../../rules2/src/getMetadataCoordin
 
 var _getAdvancedAttributes = require('../../../../rules2/src/getAdvancedAttributes');
 
+var _getDimensionsSimpleHierarchies = require('../../../../rules2/src/getDimensionsSimpleHierarchies');
+
+var _duplicateObservations = require('../../../../rules2/src/duplicateObservations');
+
+var _hierarchiseDimension = require('../../../../rules2/src/hierarchiseDimension');
+
+var _getDimensionValuesIndexes = require('../../../../rules2/src/getDimensionValuesIndexes');
+
 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 }; }
@@ -56,6 +68,8 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 var prepareData = exports.prepareData = function prepareData(sdmxJson, customAttributes) {
   var unitsProps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
 
+  var _options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+
   var _R$pick = R.pick(['defaultCodes', 'annotationsDefinitionCodes', 'rejectedValueIds'], unitsProps),
       _R$pick$defaultCodes = _R$pick.defaultCodes,
       defaultCodes = _R$pick$defaultCodes === undefined ? [] : _R$pick$defaultCodes,
@@ -70,6 +84,8 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, customAtt
   var _customAttributes = R.assoc('units', unitsDefinitionCodes, customAttributes);
   var dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
 
+  var simpleHierarchies = (0, _getDimensionsSimpleHierarchies.getDimensionsSimpleHierarchies)(dimensions);
+  var hierarchies = R.mergeRight(simpleHierarchies, _options.hierarchies || {});
   var dimensionsIndexedByIds = R.indexBy(R.prop('id'), dimensions);
 
   var parsedDimensionsIds = (0, _parseDimensionsIds.parseDimensionsIds)(dimensions);
@@ -150,10 +166,19 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, customAtt
 
   var seriesAdvancedAttributes = (0, _getAdvancedAttributes.getSeriesAdvancedAttributes)(seriesAttributesValues, dimensions, seriesAdvancedAttributesIds);
 
+  var hierarchisedDimensions = R.map(function (dim) {
+    return (0, _hierarchiseDimension.hierarchiseDimension)(dim, R.propOr({}, dim.id, hierarchies));
+  })(manyValuesDimensions);
+  var valuesIndexes = R.reduce(function (acc, dim) {
+    return (0, _extends4.default)({}, acc, (0, _defineProperty3.default)({}, dim.__index, (0, _getDimensionValuesIndexes.getDimensionValuesIndexes)(dim.values)));
+  }, {}, R.values(hierarchisedDimensions));
+
+  var duplicatedObservations = (0, _duplicateObservations.duplicateObservations)(observations, valuesIndexes);
+
   return {
     dimensions: {
       one: oneValueDimensions,
-      many: manyValuesDimensions,
+      many: hierarchisedDimensions,
       length: R.length(dimensions)
     },
     units: {
@@ -164,8 +189,8 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, customAtt
       unitsSeries: unitsSeries
     },
     metadataCoordinates: metadataCoordinates,
-    advancedAttributes: (0, _extends3.default)({}, dataflowAdvancedAttributes, observationsAdvancedAttributes, seriesAdvancedAttributes),
-    observations: observations,
+    advancedAttributes: (0, _extends4.default)({}, dataflowAdvancedAttributes, observationsAdvancedAttributes, seriesAdvancedAttributes),
+    observations: duplicatedObservations,
     observationsType: (0, _getObservationsType.getObservationsType)(sdmxJson.data),
     dataflowAttributes: dataflowAttributes,
     dataflowName: R.path(['data', 'structure', 'name'], sdmxJson),

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

@@ -94,7 +94,9 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
       });
     }), 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 */
+    R.sortBy(R.prop('__index')));
   };
 
   //--------------------------------------------------------------------------------------------Header
@@ -154,33 +156,13 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
       var isHidden = R.has(id, hiddenIds) || (0, _sdmxData.getIsHidden)(dimAnnotations);
       var isTime = observation.id === timePeriodId;
       var values = getValuesEnhanced(locale, annotations, isTime, id)(R.propOr([], 'values', observation));
-      var ids = R.pipe(R.pluck('id'), R.indexBy(R.identity))(values);
-      var groupedByParentsValues = R.groupBy(function (val) {
-        var parentId = R.propOr('##ROOT', 'parent', val);
-        if (parentId !== '##ROOT' && !R.has(parentId, ids)) {
-          return '##ROOT';
-        }
-        return parentId;
-      }, values);
-      var sortedGroupedValues = R.mapObjIndexed(R.sortWith([R.ascend(R.prop('__indexPosition')), R.ascend(R.prop('__index'))]), groupedByParentsValues);
-
-      var getReccursiveChildren = function getReccursiveChildren(parent) {
-        var children = R.propOr([], parent, sortedGroupedValues);
-        return R.map(function (child) {
-          return R.prepend(child, getReccursiveChildren(child.id));
-        }, children);
-      };
-
-      var sortedValues = R.pipe(getReccursiveChildren, R.flatten, R.addIndex(R.map)(function (value, index) {
-        return R.assoc('__indexPosition', index, value);
-      }), R.sortBy(R.prop('__index')))('##ROOT');
 
       return {
         observation: R.append((0, _extends3.default)({}, observation, {
           display: !isHidden,
           __index: obsIndex,
           name: (0, _dotstatsuiteSdmxjs.getRefinedName)(observation),
-          values: sortedValues,
+          values: values,
           role: isTime ? TIME_PERIOD_ID : R.head(R.propOr([], 'roles', observation))
         }))(acc.observation),
         dimensionsLayout: (0, _sdmxData.setAnnotationsLayout)(id, acc.dimensionsLayout)(dimAnnotations)

package/lib/rules2/src/duplicateObservations.js

@@ -0,0 +1,51 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.duplicateObservations = 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 duplicateObservations = exports.duplicateObservations = function duplicateObservations(observations, indexes) {
+  return R.addIndex(R.reduce)(function (acc, obs, i) {
+
+    var orderedIndexes = R.addIndex(R.map)(function (valueIndex, dimIndex) {
+      return R.pathOr([Number(valueIndex)], [dimIndex, valueIndex], indexes);
+    }, R.propOr([], 'dimValuesIndexes', obs));
+
+    var cartesian = void 0;
+
+    if (R.any(function (is) {
+      return R.length(is) > 1;
+    })(orderedIndexes)) {
+      cartesian = R.reduce(function (acc, oInds) {
+        var r = R.map(function (i) {
+          return R.map(function (is) {
+            return R.append(i, is);
+          }, acc);
+        }, oInds);
+        return R.unnest(r);
+      }, R.pipe(R.head, R.map(R.of))(orderedIndexes), R.tail(orderedIndexes));
+    } else {
+      cartesian = [R.unnest(orderedIndexes)];
+    }
+
+    var duplicatedObs = R.reduce(function (acc, orderedDimIndexes) {
+      var key = R.join(':', orderedDimIndexes);
+      return R.assoc(key, (0, _extends3.default)({}, obs, { orderedDimIndexes: orderedDimIndexes }), acc);
+    }, {}, cartesian);
+
+    return R.mergeRight(acc, duplicatedObs);
+  }, {}, R.values(observations));
+};

package/lib/rules2/src/getDimensionValuesIndexes.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDimensionValuesIndexes = undefined;
+
+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; } }
+
+var getDimensionValuesIndexes = exports.getDimensionValuesIndexes = function getDimensionValuesIndexes(values) {
+  return R.addIndex(R.reduce)(function (acc, value, position) {
+    var sdmxIndex = value.__index;
+    return R.over(R.lensProp(String(sdmxIndex)), R.ifElse(R.isNil, R.always([position]), R.append(position)))(acc);
+  }, {}, values);
+};

package/lib/rules2/src/getDimensionsSimpleHierarchies.js

@@ -0,0 +1,42 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDimensionsSimpleHierarchies = undefined;
+
+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; } }
+
+var getDimensionSimpleHierarchy = function getDimensionSimpleHierarchy(_ref) {
+  var values = _ref.values;
+
+  var indexed = R.indexBy(R.prop('id'), values);
+  return R.pipe(R.reduce(function (acc, value) {
+    var id = value.id,
+        parent = value.parent;
+
+    var _parent = R.isNil(parent) || !R.has(parent, indexed) ? '#ROOT' : parent;
+    return R.over(R.lensProp(_parent), function (ids) {
+      return R.isNil(ids) ? [id] : R.append(id, ids);
+    })(acc);
+  }, {}), R.map(R.sortBy(function (id) {
+    return R.pathOr(-1, [id, '__indexPosition'], indexed);
+  })))(values);
+};
+
+var getDimensionsSimpleHierarchies = exports.getDimensionsSimpleHierarchies = function getDimensionsSimpleHierarchies(dimensions) {
+  return R.reduce(function (acc, dim) {
+    var id = dim.id,
+        values = dim.values;
+
+    if (R.length(values) < 2) {
+      return acc;
+    }
+    var hierarchy = getDimensionSimpleHierarchy(dim);
+    return R.assoc(id, hierarchy, acc);
+  }, {}, dimensions);
+};

package/lib/rules2/src/getHCodelistsRefsInData.js

@@ -0,0 +1,46 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getHCodelistsRefsInData = exports.getHCodelistsRefs = undefined;
+
+var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
+
+var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
+
+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 getHCodelistsRefs = exports.getHCodelistsRefs = function getHCodelistsRefs(annotations) {
+  return R.reduce(function (acc, annotation) {
+    if (annotation.type !== 'HIER_CONTEXT') {
+      return acc;
+    }
+    var reference = annotation.text || '';
+    var match = reference.match(/([\w@_.]+):([\w@_.]+):([\w@_.]+)\(([\d.]+)\).([\w@_.]+)$/);
+    if (R.isNil(match)) {
+      return acc;
+    }
+
+    var _R$tail = R.tail(match),
+        _R$tail2 = (0, _slicedToArray3.default)(_R$tail, 5),
+        codelistId = _R$tail2[0],
+        agencyId = _R$tail2[1],
+        code = _R$tail2[2],
+        version = _R$tail2[3],
+        hierarchy = _R$tail2[4];
+
+    return R.assoc(codelistId, { agencyId: agencyId, code: code, version: version, hierarchy: hierarchy, codelistId: codelistId }, acc);
+  }, {}, annotations);
+};
+
+var getHCodelistsRefsInData = exports.getHCodelistsRefsInData = function getHCodelistsRefsInData(sdmxJson) {
+  var annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
+  return getHCodelistsRefs(annotations);
+};

package/lib/rules2/src/hierarchiseDimension.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hierarchiseDimension = 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 hierarchiseDimension = exports.hierarchiseDimension = function hierarchiseDimension(dimension, hierarchy) {
+  var indexed = R.indexBy(R.prop('id'), dimension.values);
+  var _hierarchy = hierarchy;
+  if (!R.has('#ROOT', hierarchy)) {
+    var indexes = R.pluck('id', dimension.values);
+    var refinedHierarchy = R.pick(indexes, _hierarchy);
+    var childrenIds = R.pipe(R.values, R.unnest, R.indexBy(R.identity))(refinedHierarchy);
+    var rootIds = R.pipe(R.reject(function (val) {
+      return R.has(val.id, childrenIds);
+    }), R.sortBy(R.prop('__indexPosition')), R.pluck('id'))(dimension.values);
+    _hierarchy = R.assoc('#ROOT', rootIds, hierarchy);
+  }
+
+  var getChildren = function getChildren(parents) {
+    return R.pipe(function (ids) {
+      return R.props(ids, indexed);
+    }, R.filter(R.identity), R.map(function (val) {
+      var _val = (0, _extends3.default)({}, val, {
+        parent: R.last(parents),
+        parents: parents
+      });
+      var children = getChildren(R.append(val.id, parents));
+      return R.prepend(_val, children);
+    }))(R.propOr([], R.last(parents) || '#ROOT', _hierarchy));
+  };
+
+  return R.set(R.lensProp('values'), R.flatten(getChildren([])))(dimension);
+};

package/lib/rules2/src/index.js

@@ -71,4 +71,28 @@ Object.defineProperty(exports, 'getNotDisplayedIds', {
   get: function get() {
     return _getNotDisplayedIds.getNotDisplayedIds;
   }
+});
+
+var _getHCodelistsRefsInData = require('./getHCodelistsRefsInData');
+
+Object.defineProperty(exports, 'getHCodelistsRefs', {
+  enumerable: true,
+  get: function get() {
+    return _getHCodelistsRefsInData.getHCodelistsRefs;
+  }
+});
+Object.defineProperty(exports, 'getHCodelistsRefsInData', {
+  enumerable: true,
+  get: function get() {
+    return _getHCodelistsRefsInData.getHCodelistsRefsInData;
+  }
+});
+
+var _parseHierarchicalCodelist = require('./parseHierarchicalCodelist');
+
+Object.defineProperty(exports, 'parseHierarchicalCodelist', {
+  enumerable: true,
+  get: function get() {
+    return _parseHierarchicalCodelist.parseHierarchicalCodelist;
+  }
 });

package/lib/rules2/src/invertTime.js

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.invertTime = undefined;
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+var _dotstatsuiteSdmxjs = require('@sis-cc/dotstatsuite-sdmxjs');
+
+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 invertTime = exports.invertTime = function invertTime(data, isTimeInverted) {
+  var dimensions = R.pathOr([], ['dimensions', 'many'], data);
+  var observations = R.propOr({}, 'observations', data);
+  if (!isTimeInverted) {
+    return { dimensions: dimensions, observations: observations };
+  }
+  var timeD = R.find(_dotstatsuiteSdmxjs.isTimePeriodDimension, R.values(dimensions));
+  if (!timeD) {
+    return { dimensions: dimensions, observations: observations };
+  }
+  var timeLength = R.length(timeD.values);
+  var timeIndex = timeD.__index;
+  var invertTimeInObs = R.map(R.over(R.lensProp('orderedDimIndexes'), R.over(R.lensIndex(timeIndex), function (i) {
+    return timeLength - i - 1;
+  })), observations);
+  var invertedTimeInDims = R.over(R.lensProp(timeD.id), R.over(R.lensProp('values'), R.reverse))(dimensions);
+  return { dimensions: invertedTimeInDims, observations: invertTimeInObs };
+};

package/lib/rules2/src/parseHierarchicalCodelist.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseHierarchicalCodelist = undefined;
+
+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; } }
+
+var parseHierarchicalCodelist = exports.parseHierarchicalCodelist = function parseHierarchicalCodelist(sdmxJson, hierarchyId) {
+  var hCodelist = R.pathOr({}, ['data', 'hierarchicalCodelists', 0], sdmxJson);
+  var hierarchy = R.find(R.propEq('id', hierarchyId), hCodelist.hierarchies || []);
+
+  return R.pipe(R.propOr([], 'hierarchicalCodes'), R.reduce(function (acc, parentCode) {
+    var children = R.pluck('id', parentCode.hierarchicalCodes || []);
+    return R.assoc(parentCode.id, children, acc);
+  }, {}))(hierarchy);
+};

package/package.json

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

package/src/rules/src/preparators/enhanceObservations.js

@@ -71,11 +71,6 @@ const getObservationUnits = (observation, dimensions, attributes, options) => {
   return ({ ...dimensionsUnits, ...attributesUnits, serieKey });
 };
 
-const getOrderedDimensionsIndexes = (dimensions, indexes) => R.addIndex(R.map)(
-  (valueIndex, dimensionIndex) => R.path([dimensionIndex, 'values', valueIndex, '__indexPosition'], dimensions),
-  indexes
-);
-
 const getFormatAttributesIndexes = (attributes, customAttributes) => R.addIndex(R.reduce)(
   (acc, attribute, index) => {
     if (R.equals(attribute.id, customAttributes.decimals)) {
@@ -148,7 +143,6 @@ export const enhanceObservations = (dimensions = [], observations = {}, attribut
         ...observation,
         attributes: obsAttributes,
         formattedValue: formatValue(observation, formatAttributesIndexes, attributes),
-        orderedDimIndexes: getOrderedDimensionsIndexes(dimensions, dimValuesIndexes),
         units: getObservationUnits(observation, dimensions, _attributes, options),
         indexedDimValIds,
       });

package/src/rules/src/table/factories/getCells.js

@@ -95,7 +95,8 @@ export const getCells = (data, display, customAttributes, unitsProps, metadataCo
     R.set(R.lensProp('intValue'), R.prop('value', observation)),
     R.set(R.lensProp('value'), R.prop('formattedValue', observation)),
     R.assoc('indexedDimValIds', R.prop('indexedDimValIds', observation)),
-    R.assoc('sideProps', getSideProps(observation, customAttributes, metadataCoordinates))
+    R.assoc('sideProps', getSideProps(observation, customAttributes, metadataCoordinates)),
+    R.set(R.lensProp('key'), R.prop('key', observation)),
   )({}),
   R.propOr({}, 'observations', data)
 );

package/src/rules/src/table/factories/getCuratedCells.js

@@ -17,15 +17,14 @@ const getPivots = (layout, shape) => R.pipe(
 )(layout);
 
 const indexWithPivots = (pivots, observations) => R.pipe(
-  R.keys,
+  R.values,
   R.reduce(
-    (acc, obsKey) => {
-      const splitKey = R.split(':', obsKey);
+    (acc, obs) => {
+      const splitKey = R.split(':', obs.key);
       const path = R.map(
         pivot => pivot(splitKey),
         pivots
       );
-      const obs = R.prop(obsKey, observations);
       return R.over(
         R.lensPath(path),
         R.ifElse(R.isNil, R.always([obs]), R.append(obs))

package/src/rules/src/table/factories/getTableData.js

@@ -1,5 +1,4 @@
 import * as R from 'ramda';
-import { withFlatHierarchy, isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
 import { getCells } from './getCells';
 import { getConfirmedSeriesAttributesIds } from './getConfirmedSeriesAttributesIds';
 import { getCuratedCells } from './getCuratedCells';
@@ -14,6 +13,7 @@ import { getSortedLayoutIndexes } from './getSortedLayoutIndexes';
 import { refineLayoutSize } from './refineLayoutSize';
 import { getLayoutData } from './getLayoutData';
 import { refineMetadataCoordinates } from '../../../../rules2/src/refineMetadataCoordinates';
+import { invertTime } from '../../../../rules2/src/invertTime';
 
 export const getTableProps = ({ data, layoutIds, display, customAttributes, limit, isTimeInverted }) => {
   const seriesAttributes = R.propOr({}, 'seriesAttributes', data);
@@ -56,26 +56,7 @@ export const getTableProps = ({ data, layoutIds, display, customAttributes, limi
     data.observationsType,
   );
 
-  const dimensions = R.mapObjIndexed(
-    R.pipe(
-      R.when( // invert TimeDimension Values
-        R.allPass([isTimePeriodDimension, R.always(isTimeInverted)]),
-        (dim) => R.over(
-          R.lensProp('values'),
-          R.map(R.over(R.lensProp('__indexPosition'), R.negate))
-        )(dim), 
-      ),
-      (dim) => R.over( // sort values
-        R.lensProp('values'),
-        R.sortWith([R.ascend(R.prop('__indexPosition')), R.ascend(R.prop('order'))]),
-      )(dim),
-      R.when( // refine hierarchy on rows
-        R.pipe(R.prop('id'), R.flip(R.includes)(R.propOr([], 'rows', layoutIds))),
-        withFlatHierarchy
-      )
-    ),
-    R.pathOr({}, ['dimensions', 'many'], data)
-  );
+  const { dimensions, observations } = invertTime(data, isTimeInverted);
 
   const seriesAttributesValues = R.propOr({}, 'seriesAttributesValues', data);
   const layout = R.pipe(
@@ -99,7 +80,7 @@ export const getTableProps = ({ data, layoutIds, display, customAttributes, limi
     }),
     getLayoutDataWithFlags(seriesAttributesValues, display, customAttributes, refinedMetadataCoordinates, unitDimension.id),
     cleanUnitsInLayoutData({ unitsDisplay: unitsLevelDisplay, unitsLayoutIndexes: unitsIndexesInLayout }),
-  )(layout, R.propOr({}, 'observations', data));
+  )(layout, observations);
   
   return ({
     cells: getCuratedCells({ layout, observations: cells, shape: ['header', 'sections', 'rows'] }),