@sis-cc/dotstatsuite-components 14.0.0 → 14.2.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 _duplicateObservations = require('../../../../rules2/src/duplicateObservations');
+
+var _hierarchiseDimensionWithAdvancedHierarchy = require('../../../../rules2/src/hierarchiseDimensionWithAdvancedHierarchy');
+
+var _hierarchiseDimensionWithNativeHierarchy = require('../../../../rules2/src/hierarchiseDimensionWithNativeHierarchy');
+
+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,7 @@ 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 hierarchies = _options.hierarchies || {};
   var dimensionsIndexedByIds = R.indexBy(R.prop('id'), dimensions);
 
   var parsedDimensionsIds = (0, _parseDimensionsIds.parseDimensionsIds)(dimensions);
@@ -150,10 +165,23 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, customAtt
 
   var seriesAdvancedAttributes = (0, _getAdvancedAttributes.getSeriesAdvancedAttributes)(seriesAttributesValues, dimensions, seriesAdvancedAttributesIds);
 
+  var hierarchisedDimensions = R.map(function (dim) {
+    if (R.isEmpty(R.propOr({}, dim.id, hierarchies))) {
+      return (0, _hierarchiseDimensionWithNativeHierarchy.hierarchiseDimensionWithNativeHierarchy)(dim);
+    }
+    return (0, _hierarchiseDimensionWithAdvancedHierarchy.hierarchiseDimensionWithAdvancedHierarchy)(dim, R.prop(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 +192,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/table/units/getUnitsSeries.js

@@ -15,6 +15,13 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
   observations = { [obsKey]: { units: { serieKey: '', [id]: { id, name, value } } } };
 */
 
+var getIndex = R.path(['value', 'index']);
+var getUnits = function getUnits(keys, acc, units) {
+  return R.pick(keys, R.mergeWith(function (a, b) {
+    return getIndex(a) === getIndex(b) ? a : null;
+  }, acc, units));
+};
+
 var getUnitsSeries = exports.getUnitsSeries = function getUnitsSeries(observations) {
   var series = {};
   R.map(function (obs) {
@@ -23,9 +30,13 @@ var getUnitsSeries = exports.getUnitsSeries = function getUnitsSeries(observatio
 
   return R.map(function (serie) {
     return R.reduce(function (acc, units) {
-      return R.mergeWith(function (a, b) {
-        return R.path(['value', 'index'], a) === R.path(['value', 'index'], b) ? a : null;
-      }, acc, units);
-    }, {}, serie);
+      var unitsKeys = R.keys(units);
+      if (R.isEmpty(acc.unitsKeys)) return { units: getUnits(unitsKeys, acc.units, units), unitsKeys: unitsKeys };
+      var communKeys = R.intersection(acc.unitsKeys, unitsKeys);
+      return {
+        units: getUnits(communKeys, acc.units, units),
+        unitsKeys: unitsKeys
+      };
+    }, { unitsKeys: [], units: {} }, serie).units;
   })(series);
 };

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/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 || annotation.title || '';
+    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/hierarchiseDimensionWithAdvancedHierarchy.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hierarchiseDimensionWithAdvancedHierarchy = 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 hierarchiseDimensionWithAdvancedHierarchy = exports.hierarchiseDimensionWithAdvancedHierarchy = function hierarchiseDimensionWithAdvancedHierarchy(dimension, hierarchy) {
+  var indexed = R.indexBy(R.prop('id'), dimension.values);
+
+  var rest = indexed;
+  var getChildren = function getChildren(parents) {
+    return R.pipe(function (ids) {
+      rest = R.omit(ids, rest);
+      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.isEmpty(parents) ? '#ROOT' : R.join('.', parents), hierarchy));
+  };
+
+  return R.set(R.lensProp('values'), R.pipe(getChildren, R.flatten, function (values) {
+    if (R.isEmpty(rest)) {
+      return values;
+    }
+    var sortedRest = R.pipe(R.values, R.map(function (val) {
+      return (0, _extends3.default)({}, val, { parent: undefined, parents: [] });
+    }), R.sortBy(R.prop('__indexPosition')))(rest);
+    return R.concat(sortedRest, values);
+  })([]))(dimension);
+};

package/lib/rules2/src/hierarchiseDimensionWithNativeHierarchy.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hierarchiseDimensionWithNativeHierarchy = 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 hierarchiseDimensionWithNativeHierarchy = exports.hierarchiseDimensionWithNativeHierarchy = function hierarchiseDimensionWithNativeHierarchy(dimension) {
+  var values = R.sortBy(R.prop('__indexPosition'), dimension.values || []);
+  var grouped = R.groupBy(R.propOr('#ROOT', 'parent'), values);
+
+  var getChildren = function getChildren(parents) {
+    var childs = R.propOr([], R.last(parents) || '#ROOT', grouped);
+    return R.reduce(function (acc, child) {
+      var refined = R.assoc('parents', parents, child);
+      var children = getChildren(R.append(child.id, parents));
+      return R.concat(acc, R.prepend(refined, children));
+    }, [], childs);
+  };
+
+  return R.set(R.lensProp('values'), 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,57 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseHierarchicalCodelist = undefined;
+
+var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
+
+var _defineProperty3 = _interopRequireDefault(_defineProperty2);
+
+var _extends4 = require('babel-runtime/helpers/extends');
+
+var _extends5 = _interopRequireDefault(_extends4);
+
+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 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 || []);
+
+  var getParentedCodes = function getParentedCodes(codes, parent) {
+    var ids = R.pluck('codeID', codes);
+
+    var siblings = R.reduce(function (acc, code) {
+      if (R.isEmpty(code.hierarchicalCodes || [])) {
+        return acc;
+      }
+      return R.mergeRight(acc, getParentedCodes(code.hierarchicalCodes, code.id));
+    }, {}, codes);
+
+    return (0, _extends5.default)({}, siblings, (0, _defineProperty3.default)({}, parent, ids));
+  };
+
+  var getChildren = function getChildren(codes, parents) {
+    var ids = R.pluck('codeID', codes);
+
+    var children = R.reduce(function (acc, code) {
+      if (R.isEmpty(code.hierarchicalCodes || [])) {
+        return acc;
+      }
+      return (0, _extends5.default)({}, acc, getChildren(code.hierarchicalCodes, R.append(code.codeID, parents)));
+    }, {}, codes);
+    var key = R.isEmpty(parents) ? '#ROOT' : R.join('.', parents);
+    return (0, _extends5.default)({}, children, (0, _defineProperty3.default)({}, key, ids));
+  };
+
+  return R.pipe(R.propOr([], 'hierarchicalCodes'), function (codes) {
+    return getChildren(codes, []);
+  })(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.2.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))