@sis-cc/dotstatsuite-components 9.1.3 → 9.2.0

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

@@ -0,0 +1,210 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.refineLayoutSize = exports.truncateHeader = exports.truncateSectionRows = exports.refineHeader = exports.refineSections = exports.getCuratedCells = undefined;
+
+var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
+
+var _defineProperty3 = _interopRequireDefault(_defineProperty2);
+
+var _extends3 = require('babel-runtime/helpers/extends');
+
+var _extends4 = _interopRequireDefault(_extends3);
+
+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 getPivotKey = function getPivotKey(indexes) {
+  return R.pipe(R.props(indexes), R.join(':'));
+};
+
+var getPivots = function getPivots(layout, shape) {
+  return R.pipe(R.props(shape), R.map(R.pipe(R.pluck('__index'), getPivotKey)))(layout);
+};
+
+var indexWithPivots = function indexWithPivots(pivots, observations) {
+  return R.pipe(R.values, R.reduce(function (acc, obs) {
+    var path = R.map(function (pivot) {
+      return pivot(obs.orderedDimIndexes);
+    }, pivots);
+    return R.over(R.lensPath(path), R.ifElse(R.isNil, R.always([obs]), R.append(obs)))(acc);
+  }, {}))(observations);
+};
+
+var getCuratedCells = exports.getCuratedCells = function getCuratedCells(_ref) {
+  var layout = _ref.layout,
+      observations = _ref.observations,
+      shape = _ref.shape;
+
+  var pivots = getPivots(layout, shape);
+  return indexWithPivots(pivots, observations);
+};
+
+var refineSections = exports.refineSections = function refineSections(sections, extractedKeys, curatedObs) {
+  return R.pipe(R.map(function (section) {
+    var sectionKey = R.join(':', R.head(section) || []);
+    return R.over(R.lensIndex(1), R.filter(function (rowData) {
+      var rowKey = R.join(':', rowData);
+      return R.pipe(R.path([sectionKey, rowKey]), R.omit(extractedKeys), R.isEmpty, R.not)(curatedObs);
+    }))(section);
+  }), R.filter(R.pipe(R.nth(1), R.isEmpty, R.not)))(sections);
+};
+
+var refineHeader = exports.refineHeader = function refineHeader(header, extractedKeys, curatedObs) {
+  return R.filter( // extracted : { [sectionKey]: [...rowKeys] }
+  function (header) {
+    var headerKey = R.join(':', header);
+    return R.pipe(R.prop(headerKey), function (sections) {
+      return R.pickBy(function (rows, section) {
+        return R.pipe(R.omit(R.propOr([], section, extractedKeys)), R.isEmpty, R.not)(rows);
+      }, sections);
+    }, R.isEmpty, R.not)(curatedObs);
+  })(header);
+};
+
+var truncateSectionRows = exports.truncateSectionRows = function truncateSectionRows(n, sectionsData) {
+  var _R$pipe = R.pipe(R.last, // last section
+  R.nth(1), // rows
+  R.splitAt(R.negate(n)) // truncate from the end
+  )(sectionsData),
+      _R$pipe2 = (0, _slicedToArray3.default)(_R$pipe, 2),
+      rest = _R$pipe2[0],
+      extracted = _R$pipe2[1];
+
+  var truncatedData = R.isEmpty(rest) ? R.dropLast(1, sectionsData) // remove section if no more rows
+  : R.adjust(-1, R.adjust(1, R.always(rest)), sectionsData);
+
+  var sectionKey = R.join(':', R.pipe(R.last, R.head)(sectionsData) || []);
+  var rowKeys = R.map(R.join(':'), extracted);
+
+  var extractedLength = R.length(extracted);
+  if (extractedLength < n) {
+    var _truncateSectionRows = truncateSectionRows(n - extractedLength, truncatedData),
+        truncated = _truncateSectionRows.truncated,
+        extractedKeys = _truncateSectionRows.extractedKeys;
+
+    return { truncated: truncated, extractedKeys: (0, _extends4.default)({}, extractedKeys, (0, _defineProperty3.default)({}, sectionKey, rowKeys)) };
+  }
+
+  return { truncated: truncatedData, extractedKeys: (0, _defineProperty3.default)({}, sectionKey, rowKeys) };
+};
+
+var truncateHeader = exports.truncateHeader = function truncateHeader(n, headerData) {
+  var _R$splitAt = R.splitAt(R.negate(n))(headerData),
+      _R$splitAt2 = (0, _slicedToArray3.default)(_R$splitAt, 2),
+      truncated = _R$splitAt2[0],
+      extracted = _R$splitAt2[1];
+
+  return { truncated: truncated, extractedKeys: R.map(R.join(':'), extracted) };
+};
+
+var refineLength = function refineLength(length) {
+  return length === 0 ? 1 : length;
+};
+
+var truncateLayout = function truncateLayout(isVertical) {
+  return R.ifElse(R.always(isVertical), truncateSectionRows, truncateHeader);
+};
+
+var refineLayout = function refineLayout(isVertical) {
+  return R.ifElse(R.always(isVertical), refineHeader, refineSections);
+};
+
+var getShape = function getShape(isVertical) {
+  return isVertical ? ['header', 'sections', 'rows'] : ['sections', 'rows', 'header'];
+};
+
+var getRefinedLayout = function getRefinedLayout(isVertical, truncated, refined) {
+  return R.ifElse(R.always(isVertical), R.pipe(R.assoc('sections', truncated), R.assoc('header', refined)), R.pipe(R.assoc('header', truncated), R.assoc('sections', refined)))({});
+};
+
+var segregateLayout = function segregateLayout(isVertical) {
+  return R.ifElse(R.always(isVertical), R.props(['sections', 'header']), R.props(['header', 'sections']));
+};
+
+var refineLayoutSize = exports.refineLayoutSize = function refineLayoutSize(_ref2) {
+  var layout = _ref2.layout,
+      observations = _ref2.observations,
+      limit = _ref2.limit;
+  return function (layoutIndexes) {
+    var header = layoutIndexes.header,
+        sections = layoutIndexes.sections;
+
+    if (R.isNil(limit) || limit === 0 || R.all(R.isEmpty, [header, sections])) {
+      return R.assoc('truncated', false, layoutIndexes);
+    }
+
+    //number of dimensions in header
+    var headerDimCount = R.pipe(R.head, // first column
+    R.when(R.isNil, R.always([])), R.length // number of dims
+    )(header);
+
+    //number of columns for values
+    var headerValuesCount = R.pipe(R.length, R.when(R.equals(0), R.always(1)))(header);
+
+    //total of cells in header
+    var headerCellsCount = headerDimCount * (headerValuesCount + 1);
+
+    // number of dimensions in a row
+    var rowDimCount = R.pipe(R.head, // firstSection
+    R.last, // rows,
+    R.head, // first row
+    R.length)(sections);
+
+    // number of cells in a row
+    var rowCellsCount = rowDimCount + headerValuesCount + 1;
+
+    // number of rows
+    var rowsCount = R.pipe(R.map(R.last), R.unnest, R.length, R.add(1))(sections);
+
+    // total of cells in all rows
+    var rowsCellsCount = rowCellsCount * rowsCount;
+
+    // number of sections cells
+    var sectionsCellsCount = R.ifElse(R.pipe(R.head, R.head, R.length, R.equals(0)), R.always(0), R.length)(sections);
+
+    var total = rowsCellsCount + sectionsCellsCount + headerCellsCount;
+
+    var excess = total - limit;
+    if (excess <= 0) {
+      return R.assoc('truncated', false, layoutIndexes);
+    }
+
+    // total of cells in one column
+    var columnCellsCount = headerDimCount + rowsCount;
+
+    var isVertical = columnCellsCount > rowCellsCount;
+
+    var _segregateLayout = segregateLayout(isVertical)(layoutIndexes),
+        _segregateLayout2 = (0, _slicedToArray3.default)(_segregateLayout, 2),
+        toTruncate = _segregateLayout2[0],
+        toRefine = _segregateLayout2[1];
+
+    var cutLength = R.pipe(R.ifElse(R.identity, R.always(rowCellsCount), R.always(columnCellsCount)), R.divide(excess), Math.ceil)(isVertical);
+
+    var _truncateLayout = truncateLayout(isVertical)(cutLength, toTruncate),
+        truncated = _truncateLayout.truncated,
+        extractedKeys = _truncateLayout.extractedKeys;
+
+    var curatedObs = R.pipe(getShape, function (shape) {
+      return getCuratedCells({ layout: layout, observations: observations, shape: shape });
+    })(isVertical);
+
+    var refined = refineLayout(isVertical)(toRefine, extractedKeys, curatedObs);
+
+    var result = getRefinedLayout(isVertical, truncated, refined);
+
+    return R.assoc('truncated', true, result);
+  };
+};

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

@@ -17,16 +17,12 @@ var _getNoDisplayAnnotationsIndexes = require('./getNoDisplayAnnotationsIndexes'
 
 var _getNoDisplayCodes = require('./getNoDisplayCodes');
 
-var _getDisplay2 = require('./getDisplay');
-
 var _parseAttributes2 = require('./parseAttributes');
 
 var _getDimensionsAttributesRegisters = require('./getDimensionsAttributesRegisters');
 
 var _parseAttributesValuesFromObservations = require('./parseAttributesValuesFromObservations');
 
-var _parseObservations = require('./parseObservations');
-
 var _getOneValueDimensions = require('./getOneValueDimensions');
 
 var _getManyValuesDimensions = require('./getManyValuesDimensions');
@@ -43,9 +39,13 @@ var _getHeaderUnits = require('../units/getHeaderUnits');
 
 var _getAttachmentSeriesIndexes = require('../units/getAttachmentSeriesIndexes');
 
-var _getUnitsSeriesOccurences = require('../units/getUnitsSeriesOccurences');
+var _getUnitsSeries = require('../units/getUnitsSeries');
+
+var _getDisplay2 = require('../../preparators/getDisplay');
 
-var _refineDimSeriesUnits = require('../units/refineDimSeriesUnits');
+var _getObservations = require('../../preparators/getObservations');
+
+var _enhanceObservations = require('../../preparators/enhanceObservations');
 
 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; } }
 
@@ -64,9 +64,7 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, customAtt
     defaultCodes: defaultCodes, annotationsDefinitionCodes: annotationsDefinitionCodes, data: sdmxJson
   });
   var _customAttributes = R.assoc('units', unitsDefinitionCodes, customAttributes);
-  var dimensions = R.pipe(R.pathOr([], ['data', 'structure', 'dimensions', 'observation']), R.addIndex(R.map)(function (dim, index) {
-    return R.assoc('__index', index, dim);
-  }))(sdmxJson);
+  var dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
 
   var dimensionsIndexedByIds = R.indexBy(R.prop('id'), dimensions);
 
@@ -91,8 +89,10 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, customAtt
   var attachmentSeriesIndexes = (0, _getAttachmentSeriesIndexes.getAttachmentSeriesIndexes)({ dimensions: _dimensions, unitsArtefacts: unitsArtefacts });
   //------------------------------------------------------------------
 
+  var attributes = R.pathOr([], ['data', 'structure', 'attributes', 'observation'], sdmxJson);
+
   var _parseAttributes = (0, _parseAttributes2.parseAttributes)({
-    attributes: R.concat(R.pathOr([], ['data', 'structure', 'attributes', 'observation'], sdmxJson), R.pathOr([], ['data', 'structure', 'attributes', 'dataSet'], sdmxJson)),
+    attributes: R.concat(attributes, R.pathOr([], ['data', 'structure', 'attributes', 'dataSet'], sdmxJson)),
     parsedDimensionsIds: parsedDimensionsIds,
     getDisplay: _getDisplay,
     customAttributes: _customAttributes
@@ -102,19 +102,19 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, customAtt
 
   var seriesAttributesIds = R.propOr([], 'series', attributesIdsIndexedByTargets);
   var observationsAttributesIds = R.propOr([], 'observations', attributesIdsIndexedByTargets);
-  var observations = (0, _parseObservations.parseObservations)(R.pathOr({}, ['data', 'dataSets', 0, 'observations'], sdmxJson), dimensions, R.pick(R.concat(seriesAttributesIds, observationsAttributesIds), attributesIndexedByIds), R.pipe(R.pick(['prefscale', 'decimals']), R.mapObjIndexed(R.flip(R.prop)(attributesIndexedByIds)))(attributesIdsIndexedByTargets), unitsArtefacts, _getDisplay);
-  //------------------------------------------------------------------
-
-  var _getUnitsSeriesOccure = (0, _getUnitsSeriesOccurences.getUnitsSeriesOccurences)({
-    unitsArtefacts: unitsArtefacts, attachmentSeriesIndexes: attachmentSeriesIndexes
-  })(observations),
-      rawUnitsSeries = _getUnitsSeriesOccure.rawUnitsSeries,
-      obs = _getUnitsSeriesOccure.obs;
+  var options = {
+    attachmentSeriesIndexes: attachmentSeriesIndexes,
+    customAttributes: customAttributes,
+    noDisplayIndexes: noDisplayIndexes,
+    notDisplayedCodes: notDisplayedCodes,
+    attributesIds: R.concat(seriesAttributesIds, observationsAttributesIds),
+    unitsIds: unitsDefinitionCodes
+  };
 
-  var unitsSeries = (0, _refineDimSeriesUnits.refineDimSeriesUnits)({
-    unitsArtefacts: R.merge(R.pathOr({}, ['dimensions', 'series'], unitsArtefacts), R.pathOr({}, ['attributes', 'series'], unitsArtefacts)),
-    rejectedValueIds: rejectedValueIds
-  })(rawUnitsSeries);
+  var _observations = (0, _getObservations.getObservations)(sdmxJson);
+  var observations = (0, _enhanceObservations.enhanceObservations)(dimensions, _observations, attributes, options);
+  //------------------------------------------------------------------
+  var unitsSeries = (0, _getUnitsSeries.getUnitsSeries)(observations);
   var unitsAttachmentSeriesIds = R.pipe(R.props(attachmentSeriesIndexes), R.pluck('id'))(dimensions);
   //------------------------------------------------------------------   
   var attributesRegisters = (0, _getDimensionsAttributesRegisters.getDimensionsAttributesRegisters)(attributesIdsIndexedByTargets, attributesIndexedByIds);
@@ -144,7 +144,7 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, customAtt
       unitsAttachmentSeriesIds: unitsAttachmentSeriesIds,
       unitsSeries: unitsSeries
     },
-    observations: obs,
+    observations: observations,
     observationsType: (0, _getObservationsType.getObservationsType)(sdmxJson.data),
     dataflowAttributes: dataflowAttributes,
     dataflowName: R.path(['data', 'structure', 'name'], sdmxJson),

package/lib/rules/src/table/units/getAttachmentSeriesIndexes.js

@@ -21,5 +21,5 @@ var getAttachmentSeriesIndexes = exports.getAttachmentSeriesIndexes = function g
 
   return R.pipe(R.props(R.concat(unitsDimensionsCodes, targettedDimensionsCodes)), R.filter(function (dim) {
     return !R.isNil(dim);
-  }), R.pluck('index'), R.uniq)(dimensions);
+  }), R.pluck('index'), R.uniq, R.sortBy(R.identity))(dimensions);
 };

package/lib/rules/src/table/units/getUnitsSeries.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getUnitsSeries = 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; } }
+
+/*
+  observations = { [obsKey]: { units: { serieKey: '', [id]: { id, name, value } } } };
+*/
+
+var getUnitsSeries = exports.getUnitsSeries = function getUnitsSeries(observations) {
+  var series = {};
+  R.map(function (obs) {
+    series = R.over(R.lensProp(obs.units.serieKey), R.ifElse(R.isNil, R.always([obs.units]), R.append(obs.units)))(series);
+  }, observations);
+
+  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);
+  })(series);
+};

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

@@ -123,7 +123,7 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
   var dimObservations = getDimObservations(dimensions);
 
   var getObservations = function getObservations(locale) {
-    return R.reduce(function (acc, observation) {
+    return R.addIndex(R.reduce)(function (acc, observation, obsIndex) {
       var id = R.prop('id')(observation);
       var dimAnnotations = (0, _sdmxData.getRelationnalAnnotations)(R.propOr([], 'annotations')(observation))(annotations);
       var isHidden = R.includes(id)(hiddenIds) ? _sdmxData.hiddenFormat : (0, _sdmxData.getIsHidden)(dimAnnotations);
@@ -153,6 +153,7 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
 
       return {
         observation: R.append((0, _extends3.default)({}, observation, {
+          __index: obsIndex,
           name: getLocalisedProp('names', observation),
           values: sortedValues,
           role: R.isNil(observation.roles) ? null : R.head(observation.roles)

package/package.json

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

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

@@ -0,0 +1,163 @@
+import * as R from 'ramda';
+import { getDisplay } from './getDisplay';
+import { formatValue } from './formatValue';
+
+/*
+  options = {
+    attachmentSeriesIndexes, //units
+    customAttributes: {
+      decimals: id,
+      prefscale: id,
+    },
+    noDisplayIndexes,
+    notDisplayedCodes,
+    unitsArtefacts,
+    obsAttributes,
+    rejectedValueIds,
+  }
+*/
+
+const getSerieKey = (dimValuesIndexes, options) => {
+  let indexes = R.propOr([], 'attachmentSeriesIndexes', options);
+  return R.pipe(
+    R.addIndex(R.map)((valueIndex, dimIndex) => {
+      if (dimIndex === R.head(indexes)) {
+        indexes = R.tail(indexes);
+        return valueIndex;
+      }
+      return 'x';
+    }),
+    R.join(':')
+  )(dimValuesIndexes);
+};
+
+const getUnitsValues = (indexes, options) => R.reduce(
+  (acc, codelist) => {
+    const { id } = codelist;
+    if (!R.includes(id, R.propOr([], 'unitsIds', options))) {
+      return acc;
+    }
+    const valueIndex = R.prop(codelist.__index, indexes);
+    if (R.isNil(valueIndex) || !getDisplay(options)(codelist)) {
+      return acc;
+    }
+    const value = R.path(['values', Number(valueIndex)], codelist);
+    if (R.isNil(value) || R.includes(value.id, R.propOr([], 'rejectedValueIds', options))
+      || !getDisplay(options)({ ...value, parent: codelist.id })) {
+      return acc;
+    }
+    return R.assoc(
+      id,
+      {
+        ...R.pick(['id', 'name', '__index'], codelist),
+        value: R.when(R.complement(R.isNil), R.assoc('index', Number(valueIndex)))(value)
+      },
+      acc
+    );
+  },
+  {}
+);
+
+const getObservationUnits = (observation, dimensions, attributes, options) => {
+  const dimensionsUnits = getUnitsValues(
+    R.propOr([], 'dimValuesIndexes', observation),
+    options
+  )(dimensions);
+
+  const attributesUnits = getUnitsValues(
+    R.propOr([], 'attrValuesIndexes', observation),
+    options
+  )(attributes);
+  
+  const serieKey = getSerieKey(R.propOr([], 'dimValuesIndexes', observation), 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)) {
+      return ({ ...acc, decimals: index });
+    }
+    if (R.equals(attribute.id, customAttributes.prefscale)) {
+      return ({ ...acc, prefscale: index });
+    }
+    return acc;
+  },
+  { prefscale: null, decimals: null },
+  attributes
+);
+
+const getAttributeValue = (attribute, valueIndex, options) => {
+  if (!getDisplay(options)(attribute)) {
+    return null;
+  }
+  const value = R.pipe(
+    R.propOr([], 'values'),
+    R.nth(valueIndex)
+  )(attribute);
+
+  if (R.isNil(value) || !getDisplay(options)({ ...value, parent: attribute.id })) {
+    return null;
+  }
+
+  return ({
+    ...R.pick(['id', 'name'], attribute),
+    value: R.pick(['id', 'name'], value)
+  });
+};
+
+
+export const enhanceObservations = (dimensions = [], observations = {}, attributes = [], options = {}) => {
+  const formatAttributesIndexes = getFormatAttributesIndexes(attributes, R.propOr({}, 'customAttributes', options));
+  const _attributes = R.addIndex(R.map)((attr, index) => R.assoc('__index', index, attr), attributes);
+  const _obsAttributes = R.pipe(
+    R.indexBy(R.prop('id')),
+    R.props(options.attributesIds || [])
+  )(_attributes);
+
+  const seriesDimensions = R.filter(R.pipe(R.propOr([], 'values'), R.length, R.lt(1)), dimensions);
+
+  return R.mapObjIndexed(
+    (observation) => {
+      const { attrValuesIndexes, dimValuesIndexes } = observation;
+      const obsAttributes = R.reduce(
+        (acc, attribute) => {
+          const attrValue = getAttributeValue(attribute, R.nth(attribute.__index, attrValuesIndexes), options);
+          if (R.isNil(attrValue)) {
+            return acc;
+          }
+          return R.assoc(attribute.id, attrValue, acc);
+        },
+        {},
+        _obsAttributes
+      );
+
+      const indexedDimValIds = R.addIndex(R.reduce)(
+        (acc, dimension, dimensionIndex) => {
+          const id = dimension.id;
+          const valueIndex = R.nth(dimensionIndex, dimValuesIndexes);
+          const valueId = R.path(['values', Number(valueIndex), 'id'], dimension);
+          return R.assoc(id, valueId, acc);
+        },
+        {},
+        dimensions
+      );
+
+      return ({
+        ...observation,
+        attributes: obsAttributes,
+        formattedValue: formatValue(observation, formatAttributesIndexes, attributes),
+        orderedDimIndexes: getOrderedDimensionsIndexes(dimensions, dimValuesIndexes),
+        units: getObservationUnits(observation, seriesDimensions, _attributes, options),
+        indexedDimValIds,
+      });
+    },
+    observations
+  );
+};

package/src/rules/src/preparators/formatValue.js

@@ -0,0 +1,73 @@
+import * as R from 'ramda';
+import numeral from 'numeral';
+
+const isValidNumber = R.both(R.is(Number), R.complement(R.equals(NaN)));
+
+const getFormatAttributesValues = (observation, formatAttributesIndexes, attributes) => R.mapObjIndexed(
+  attributeIndex => {
+    const valueIndex = R.pipe(
+      R.propOr([], 'attrValuesIndexes'),
+      R.nth(attributeIndex),
+      v => R.isNil(v) ? null : Number(v),
+      v => isNaN(v) ? null : v
+    )(observation);
+
+    return R.pipe(
+      R.path([attributeIndex, 'values', valueIndex, 'id']),
+      v => R.isNil(v) ? null : Number(v),
+      v => isNaN(v) ? null : v
+    )(attributes);
+  },
+  formatAttributesIndexes
+);
+
+export const formatValue = (observation, formatAttributesIndexes, attributes) => {
+  const value = R.prop('value', observation);
+  if (R.is(Boolean, value)) {
+    return value;
+  }
+  if (R.is(String, value)) {    
+    const monthMatch = value.match(/^\-\-([\d]{2})$/);
+    if (R.is(Array, monthMatch)) {
+      return R.nth(1, monthMatch);       
+    }
+    const monthDayMatch = value.match(/^\-\-([\d]{2}\-[\d]{2})$/);
+    if (R.is(Array, monthDayMatch)) {
+      return R.nth(1, monthDayMatch);       
+    }
+    const dayMatch = value.match(/^\-\-\-([\d]{2})$/);
+    if (R.is(Array, dayMatch)) {
+      return R.nth(1, dayMatch);
+    }
+    return value;
+  }
+
+  const { prefscale, decimals } = getFormatAttributesValues(
+    observation,
+    formatAttributesIndexes,
+    attributes
+  );
+
+  const formatScale = R.when(
+    R.always(isValidNumber(prefscale)),
+    value => numeral(value).multiply(Math.pow(10, -1 * Number(prefscale))).value(),
+  );
+
+  const formatSeparator = value => numeral(value).format(`0,0.[0000000]`);
+  const formatDecimals = R.ifElse(
+    R.always(isValidNumber(decimals)),
+    value => numeral(value).format(
+      R.ifElse(R.equals(0), R.always('0,0'), d => `0,0.${R.join('', R.times(R.always('0'), d))}`)(decimals)
+    ),
+    formatSeparator
+  );
+
+  return R.ifElse(
+    isValidNumber,
+    R.pipe(
+      formatScale,
+      formatDecimals,
+    ),
+    R.always('..')
+  )(observation.value);
+};

package/src/rules/src/preparators/getDimensions.js

@@ -0,0 +1,49 @@
+import * as R from 'ramda';
+import {
+  getCodeOrder,
+  isTimePeriodDimension
+} from '@sis-cc/dotstatsuite-sdmxjs';
+
+export const isDisplayedFromOwnAnnotations = artefact => {
+  const artefactAnnotations = R.propOr([], 'annotations', artefact);
+  return R.pipe(
+    R.propOr([], 'annotations'),
+    R.find(R.propEq('type', 'NOT_DISPLAYED')),
+    R.isNil
+  )(artefact);
+};
+
+// sdmxJson
+
+export const getDimensions = sdmxJson => {
+  const annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
+  const locale = R.path([], ['meta', 'contentLanguage'], sdmxJson);
+
+  const enhanceValues = R.addIndex(R.map)((val, __index) => {
+    const annotationsIndexes = R.propOr([], 'annotations', val);
+    const valueAnnotations = R.props(annotationsIndexes, annotations);
+
+    return ({
+      ...value,
+      __index,
+      annotations: valueAnnotations,
+      name: R.pathOr(`[${val.id}]`, ['names', locale], val),
+    });
+  });
+
+  return R.pipe(
+    R.pathOr([], ['data', 'structure', 'dimensions']),
+    R.addIndex(R.map)((dimension, __index) => {
+      const annotationsIndexes = R.propOr([], 'annotations', dimension);
+      const dimensionAnnotations = R.props(annotationsIndexes, annotations);
+
+      return ({
+        ...dimension,
+        __index,
+        name: R.pathOr(`[${val.id}]`, ['names', locale], val),
+        annotations: dimensionAnnotations,
+        values: enhanceValues(R.propOr([], 'values', dimension))
+      });
+    })
+  )(sdmxJson);
+};

package/src/rules/src/preparators/getDisplay.js

@@ -0,0 +1,20 @@
+import * as R from 'ramda';
+
+export const getDisplay = ({ noDisplayIndexes = [], notDisplayedCodes = {} }) => {
+  const annotationsValidator = R.pipe(
+    R.propOr([], 'annotations'),
+    R.intersection(noDisplayIndexes),
+    R.isEmpty
+  );
+
+  const blacklistValidator = R.ifElse(
+    R.has('values'),
+    ({ id }) => R.anyPass([
+      R.complement(R.has)(id),
+      R.hasPath([id, 'values'])
+    ])(notDisplayedCodes),
+    ({ id, parent }) => R.complement(R.hasPath)([parent, 'values', id], notDisplayedCodes)
+  );
+
+  return R.allPass([annotationsValidator, blacklistValidator]);
+};