@sis-cc/dotstatsuite-components 17.11.0 → 17.12.0

package/lib/rules/src/get-values-enhanced.js

@@ -0,0 +1,142 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getValuesEnhanced = undefined;
+
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+var _dateFns = require('date-fns');
+
+var _dateFns2 = _interopRequireDefault(_dateFns);
+
+var _dotstatsuiteSdmxjs = require('@sis-cc/dotstatsuite-sdmxjs');
+
+var _sdmxData = require('./sdmx-data');
+
+var _date = require('./date');
+
+var _refineTimePeriod = require('../../rules2/src/refineTimePeriod');
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var isNonCoded = R.both(R.has('value'), R.pipe(R.has('id'), R.not));
+
+var getId = function getId(value, fallbackId) {
+  var valueId = R.prop('id', value);
+  if (valueId) return valueId;
+  if (isNonCoded(value)) return R.prop('value', value);
+  // Fallback (value has no id but is not a non-coded)
+  return fallbackId;
+};
+
+var getName = function getName(_ref) {
+  var isTimeDimension = _ref.isTimeDimension,
+      options = _ref.options,
+      locale = _ref.locale,
+      start = _ref.start,
+      reportYearStart = _ref.reportYearStart;
+  return function (value) {
+    if (!isTimeDimension) return (0, _dotstatsuiteSdmxjs.getRefinedName)(value);
+    return (0, _date.getReportedTimePeriodLabel)(options.frequency, options.timeFormat, locale)(reportYearStart, {
+      id: value.id,
+      reportedStart: start,
+      start: new Date(value.start)
+    });
+  };
+};
+
+var getValuesEnhanced = exports.getValuesEnhanced = function getValuesEnhanced(_ref2) {
+  var _ref2$locale = _ref2.locale,
+      locale = _ref2$locale === undefined ? '' : _ref2$locale,
+      _ref2$annotations = _ref2.annotations,
+      annotations = _ref2$annotations === undefined ? [] : _ref2$annotations,
+      _ref2$isTimeDimension = _ref2.isTimeDimension,
+      isTimeDimension = _ref2$isTimeDimension === undefined ? false : _ref2$isTimeDimension,
+      _ref2$parent = _ref2.parent,
+      parent = _ref2$parent === undefined ? '' : _ref2$parent,
+      reportYearStart = _ref2.reportYearStart,
+      _ref2$_hiddenIds = _ref2._hiddenIds,
+      _hiddenIds = _ref2$_hiddenIds === undefined ? {} : _ref2$_hiddenIds,
+      _ref2$hiddenIds = _ref2.hiddenIds,
+      hiddenIds = _ref2$hiddenIds === undefined ? {} : _ref2$hiddenIds,
+      _ref2$options = _ref2.options,
+      options = _ref2$options === undefined ? {} : _ref2$options;
+
+  return R.pipe(R.addIndex(R.map)(function (value, __index) {
+    var id = getId(value, parent + '-' + __index);
+
+    var valueAnnotations = R.pipe(R.propOr([], 'annotations'), R.flip(R.props)(annotations))(value);
+
+    var isHidden = _hiddenIds[parent] && R.includes(value.id, _hiddenIds[parent]) || R.has(parent + '.' + value.id, hiddenIds) || (0, _sdmxData.getIsHidden)(valueAnnotations);
+
+    var _ref3 = isTimeDimension ? getTimePeriodAttributes({ reportYearStart: reportYearStart, options: options })(value) : { notes: [] },
+        start = _ref3.start,
+        notes = _ref3.notes;
+
+    var __indexPosition = NaN;
+    if (isNaN(__indexPosition)) {
+      __indexPosition = (0, _dotstatsuiteSdmxjs.getCodeOrder)({ annotations: valueAnnotations });
+    }
+    var res = (0, _extends3.default)({}, R.omit(['names', 'value'], value), {
+      id: id,
+      display: !isHidden,
+      start: start ? start.toISOString() : null,
+      notes: notes,
+      __indexPosition: __indexPosition,
+      __index: __index
+    });
+    if (!isNonCoded(value)) {
+      res = R.assoc('name', getName({ isTimeDimension: isTimeDimension, options: options, locale: locale, start: start, reportYearStart: reportYearStart })(value), res);
+    }
+    if (isTimeDimension) {
+      res = (0, _refineTimePeriod.refineTimePeriod)(res, {
+        locale: locale,
+        monthlyFormat: options.timeFormat
+      });
+    }
+    return res;
+  }),
+  // __indexPosition is used for pre-sorting
+  R.sortWith(isTimeDimension ? timeDimensionSorts : defaultSorts),
+  // __indexPosition is reset after pre-sorting
+  R.addIndex(R.map)(function (val, index) {
+    return R.assoc('__indexPosition', index, val);
+  }),
+  // values are re-sorted by __index after __indexPosition settlement
+  R.sortBy(R.prop('__index')));
+};
+
+var getDateForSort = function getDateForSort(key) {
+  return function (val) {
+    return _dateFns2.default.getTime(new Date(R.prop(key, val)));
+  };
+};
+var byStartDate = R.ascend(getDateForSort('start'));
+var byEndDate = R.descend(getDateForSort('end'));
+var timeDimensionSorts = [byStartDate, byEndDate];
+var byIndexPosition = R.ascend(R.prop('__indexPosition'));
+var byOrder = R.ascend(R.propOr(-1, 'order'));
+var defaultSorts = [byIndexPosition, byOrder];
+
+var getTimePeriodAttributes = function getTimePeriodAttributes(_ref4) {
+  var reportYearStart = _ref4.reportYearStart,
+      options = _ref4.options;
+  return function (value) {
+    var reported = (0, _date.getReportedTimePeriod)(reportYearStart, value, options.frequency);
+    var start = reported.start;
+    var end = reported.end;
+    var reportTimeNote = (0, _date.getReportedTimePeriodNote)(reportYearStart, start, end, options.frequency, options.isRtl);
+    var notes = R.isNil(reportTimeNote) ? [] : R.append(reportTimeNote, []);
+    return { start: start, notes: notes };
+  };
+};

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

@@ -13,21 +13,15 @@ var _ramda = require('ramda');
 
 var R = _interopRequireWildcard(_ramda);
 
-var _dateFns = require('date-fns');
-
-var _dateFns2 = _interopRequireDefault(_dateFns);
-
 var _dotstatsuiteSdmxjs = require('@sis-cc/dotstatsuite-sdmxjs');
 
 var _sdmxData = require('./sdmx-data');
 
-var _date = require('./date');
-
 var _getReportingYearStart = require('./preparators/getReportingYearStart');
 
 var _src = require('../../rules2/src');
 
-var _refineTimePeriod = require('../../rules2/src/refineTimePeriod');
+var _getValuesEnhanced = require('./get-values-enhanced');
 
 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; } }
 
@@ -54,60 +48,6 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
 
   var hiddenIds = (0, _src.getNotDisplayedIds)(dataSetsAnnotations);
 
-  //--------------------------------------------------------------------------------------------------
-  var getValues = function getValues(values, parent) {
-    return R.map(function (value) {
-      var valAnnotations = R.props(value.annotations || [], annotations);
-      return (0, _extends3.default)({}, value, {
-        display: !R.has(parent + '.' + value.id, hiddenIds) && !(0, _sdmxData.getIsHidden)(valAnnotations),
-        name: (0, _dotstatsuiteSdmxjs.getRefinedName)(value)
-      });
-    }, values);
-  };
-
-  var getValuesEnhanced = function getValuesEnhanced(locale, annotations, isTimeDimension, parent) {
-    return R.pipe(R.addIndex(R.map)(function (value, __index) {
-      var valueAnnotations = R.pipe(R.propOr([], 'annotations'), R.flip(R.props)(annotations))(value);
-      var isHidden = _hiddenIds[parent] && R.includes(value.id, _hiddenIds[parent]) || R.has(parent + '.' + value.id, hiddenIds) || (0, _sdmxData.getIsHidden)(valueAnnotations);
-      var name = (0, _dotstatsuiteSdmxjs.getRefinedName)(value);
-      var __indexPosition = NaN;
-      var notes = [];
-      var start = null;
-      var end = null;
-      if (isTimeDimension) {
-        var reported = (0, _date.getReportedTimePeriod)(reportYearStart, value, options.frequency);
-        start = reported.start;
-        end = reported.end;
-        var reportTimeNote = (0, _date.getReportedTimePeriodNote)(reportYearStart, start, end, options.frequency, options.isRtl);
-        notes = R.isNil(reportTimeNote) ? notes : R.append(reportTimeNote, notes);
-      }
-      if (isNaN(__indexPosition)) {
-        __indexPosition = (0, _dotstatsuiteSdmxjs.getCodeOrder)({ annotations: valueAnnotations });
-      }
-      var timeFormat = R.prop('timeFormat', options);
-      var res = (0, _extends3.default)({}, value, {
-        id: R.when(R.isNil, R.always(parent + '-' + __index))(value.id),
-        display: !isHidden,
-        name: R.when(R.always(isTimeDimension), R.always((0, _date.getReportedTimePeriodLabel)(options.frequency, timeFormat, locale)(reportYearStart, { id: value.id, reportedStart: start, start: new Date(value.start) })))(name),
-        start: start ? start.toISOString() : null,
-        notes: notes,
-        __indexPosition: __indexPosition,
-        __index: __index
-      });
-      return isTimeDimension ? (0, _refineTimePeriod.refineTimePeriod)(res, { locale: locale, monthlyFormat: timeFormat }) : res;
-    }), R.ifElse(R.always(isTimeDimension), R.pipe(R.sortWith([R.ascend(function (val) {
-      return _dateFns2.default.getTime(new Date(R.prop('start', val)));
-    }), R.descend(function (val) {
-      return _dateFns2.default.getTime(new Date(R.prop('end', val)));
-    })]), R.addIndex(R.map)(function (val, ind) {
-      return R.assoc('__indexcPosition', ind, val);
-    })), R.sortWith([R.ascend(R.prop('__indexPosition')), R.ascend(R.propOr(-1, 'order'))])), R.addIndex(R.map)(function (val, index) {
-      return R.assoc('__indexPosition', index, val);
-    }),
-    /* NEW */
-    R.sortBy(R.prop('__index')));
-  };
-
   //--------------------------------------------------------------------------------------------Header
   var getMeta = R.propOr({}, 'meta');
   var meta = getMeta(dataNew);
@@ -132,7 +72,15 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
       __index: index,
       display: !R.has(observation.id, hiddenIds) && !(0, _sdmxData.getIsHidden)(obsAnnotations),
       name: (0, _dotstatsuiteSdmxjs.getRefinedName)(observation),
-      values: getValuesEnhanced(locale, annotations, false, observation.id)(R.propOr([], 'values', observation)),
+      values: (0, _getValuesEnhanced.getValuesEnhanced)({
+        locale: locale,
+        annotations: annotations,
+        parent: observation.id,
+        reportYearStart: reportYearStart,
+        _hiddenIds: _hiddenIds,
+        hiddenIds: hiddenIds,
+        options: options
+      })(R.propOr([], 'values', observation)),
       roles: !R.isNil(observation.role) ? R.head(observation.role) : null
     });
   }, attrObservations);
@@ -142,7 +90,14 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
     return (0, _extends3.default)({}, attr, {
       display: !R.has(attr.id, hiddenIds) && !(0, _sdmxData.getIsHidden)(attrAnnotations),
       name: (0, _dotstatsuiteSdmxjs.getRefinedName)(attr),
-      values: getValuesEnhanced(locale, annotations, false, attr.id)(R.propOr([], 'values', attr))
+      values: (0, _getValuesEnhanced.getValuesEnhanced)({
+        locale: locale,
+        annotations: annotations,
+        parent: attr.id,
+        _hiddenIds: _hiddenIds,
+        hiddenIds: hiddenIds,
+        options: options
+      })(R.propOr([], 'values', attr))
     });
   }, R.propOr([], 'dataSet', attributes));
 
@@ -161,8 +116,16 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
     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 isTime = (0, _dotstatsuiteSdmxjs.isTimePeriodDimension)(observation);
-      var values = getValuesEnhanced(locale, annotations, isTime, id)(R.propOr([], 'values', observation));
+      var isTimeDimension = (0, _dotstatsuiteSdmxjs.isTimePeriodDimension)(observation);
+      var values = (0, _getValuesEnhanced.getValuesEnhanced)({
+        locale: locale,
+        annotations: annotations,
+        isTimeDimension: isTimeDimension,
+        parent: id,
+        _hiddenIds: _hiddenIds,
+        hiddenIds: hiddenIds,
+        options: options
+      })(R.propOr([], 'values', observation));
       var _idHidden = _hiddenIds[id] && R.isEmpty(R.difference(R.pluck('id')(values), _hiddenIds[id]));
       var isHidden = _idHidden || R.has(id, hiddenIds) || (0, _sdmxData.getIsHidden)(dimAnnotations);
       return {
@@ -198,5 +161,8 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
     return (0, _sdmxData.setAnnotationsLayout)(title, acc)([dataSetsAnnotation]);
   }, {})(dataSetsAnnotations);
 
-  return { data: { header: resHeader, dataSets: dataSets, structure: resStructure }, layout: R.mergeRight(dimensionsLayout, dataSetsLayout) };
+  return {
+    data: { header: resHeader, dataSets: dataSets, structure: resStructure },
+    layout: R.mergeRight(dimensionsLayout, dataSetsLayout)
+  };
 };

package/lib/rules/test/get-values-enhanced.test.js

@@ -0,0 +1,126 @@
+'use strict';
+
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+var _chai = require('chai');
+
+var _getValuesEnhanced = require('../src/get-values-enhanced');
+
+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 values = [{
+  id: 'A',
+  order: 0,
+  name: 'Code A',
+  names: {
+    en: 'Code A'
+  }
+}, {
+  id: 'B',
+  order: 1,
+  name: 'Code B',
+  names: {
+    en: 'Code B'
+  }
+}, {
+  id: 'C',
+  order: 2,
+  name: 'Code C',
+  names: {
+    en: 'Code C'
+  }
+}];
+
+var timeValues = [{
+  start: '2020-01-01T00:00:00',
+  end: '2020-12-31T23:59:59',
+  id: '2020',
+  name: '2020',
+  names: {
+    en: '2020'
+  }
+}, {
+  start: '2021-01-01T00:00:00',
+  end: '2021-12-31T23:59:59',
+  id: '2021',
+  name: '2021',
+  names: {
+    en: '2021'
+  }
+}, {
+  start: '2022-01-01T00:00:00',
+  end: '2022-12-31T23:59:59',
+  id: '2022',
+  name: '2022',
+  names: {
+    en: '2022'
+  }
+}];
+
+var expectedTimeValues = [{
+  start: '2020-01-01T00:00:00.000Z',
+  end: '2020-12-31T23:59:59.000Z',
+  id: '2020',
+  name: '2020'
+}, {
+  start: '2021-01-01T00:00:00.000Z',
+  end: '2021-12-31T23:59:59.000Z',
+  id: '2021',
+  name: '2021'
+}, {
+  start: '2022-01-01T00:00:00.000Z',
+  end: '2022-12-31T23:59:59.000Z',
+  id: '2022',
+  name: '2022'
+}];
+
+var nonCodedValues = [{ value: 'A' }, { value: 'B' }, { value: 'C' }];
+
+var expectedValues = function expectedValues() {
+  var skippedValueEntries = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return R.addIndex(R.map)(function (value, index) {
+    return (0, _extends3.default)({}, R.omit(R.prepend('names', skippedValueEntries), value), {
+      __index: index,
+      __indexPosition: index,
+      display: true,
+      notes: [],
+      start: R.propOr(null, 'start', value)
+    });
+  });
+};
+
+describe('get values enhanced method', function () {
+  it('should pass with coded values', function () {
+    var enhancedValues = (0, _getValuesEnhanced.getValuesEnhanced)({
+      locale: 'en',
+      parent: 'ID'
+    })(values);
+    (0, _chai.expect)(enhancedValues).to.deep.equal(expectedValues()(values));
+  });
+
+  it('should pass with non-coded values', function () {
+    var enhancedValues = (0, _getValuesEnhanced.getValuesEnhanced)({
+      locale: 'en',
+      parent: 'ID'
+    })(nonCodedValues);
+    (0, _chai.expect)(enhancedValues).to.deep.equal(expectedValues(['name', 'order', 'value'])(values));
+  });
+
+  it('should pass with time values', function () {
+    var enhancedValues = (0, _getValuesEnhanced.getValuesEnhanced)({
+      locale: 'en',
+      parent: 'ID',
+      isTimeDimension: true,
+      reportYearStart: { month: '01', day: '01' }
+    })(timeValues);
+    (0, _chai.expect)(enhancedValues).to.deep.equal(expectedValues()(expectedTimeValues));
+  });
+});

package/lib/rules2/src/enhanceObservations.js

@@ -83,7 +83,7 @@ var enhanceObservations = exports.enhanceObservations = function enhanceObservat
   var formatAttributesIndexes = getFormatAttributesIndexes(attributes, R.propOr({}, 'customAttributes', options));
   var indexedDimensions = R.indexBy(R.prop('id'), dimensions);
 
-  return R.mapObjIndexed(function (observation) {
+  return R.map(function (observation) {
     var dimValuesIndexes = observation.dimValuesIndexes;
 
 

package/package.json

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

package/prettier.config.js

@@ -0,0 +1,13 @@
+module.exports = {
+  printWidth: 80,
+  tabWidth: 2,
+  useTabs: false,
+  singleQuote: true,
+  trailingComma: 'all',
+  bracketSameLine: false,
+  bracketSpacing: true,
+  semi: true,
+  arrowParens: 'always',
+  endOfLine: 'lf',
+  jsxSingleQuote: false,
+};

package/src/rules/src/get-values-enhanced.js

@@ -0,0 +1,138 @@
+import * as R from 'ramda';
+import dateFns from 'date-fns';
+import { getCodeOrder, getRefinedName } from '@sis-cc/dotstatsuite-sdmxjs';
+import { getIsHidden } from './sdmx-data';
+import {
+  getReportedTimePeriodLabel,
+  getReportedTimePeriodNote,
+  getReportedTimePeriod,
+} from './date';
+import { refineTimePeriod } from '../../rules2/src/refineTimePeriod';
+
+const isNonCoded = R.both(R.has('value'), R.pipe(R.has('id'), R.not));
+
+const getId = (value, fallbackId) => {
+  const valueId = R.prop('id', value);
+  if (valueId) return valueId;
+  if (isNonCoded(value)) return R.prop('value', value);
+  // Fallback (value has no id but is not a non-coded)
+  return fallbackId;
+};
+
+const getName =
+  ({ isTimeDimension, options, locale, start, reportYearStart }) =>
+  (value) => {
+    if (!isTimeDimension) return getRefinedName(value);
+    return getReportedTimePeriodLabel(
+      options.frequency,
+      options.timeFormat,
+      locale,
+    )(reportYearStart, {
+      id: value.id,
+      reportedStart: start,
+      start: new Date(value.start),
+    });
+  };
+
+export const getValuesEnhanced = ({
+  locale = '',
+  annotations = [],
+  isTimeDimension = false,
+  parent = '',
+  reportYearStart,
+  _hiddenIds = {},
+  hiddenIds = {},
+  options = {},
+}) => {
+  return R.pipe(
+    R.addIndex(R.map)((value, __index) => {
+      const id = getId(value, `${parent}-${__index}`);
+
+      const valueAnnotations = R.pipe(
+        R.propOr([], 'annotations'),
+        R.flip(R.props)(annotations),
+      )(value);
+
+      const isHidden =
+        (_hiddenIds[parent] && R.includes(value.id, _hiddenIds[parent])) ||
+        R.has(`${parent}.${value.id}`, hiddenIds) ||
+        getIsHidden(valueAnnotations);
+
+      const { start, notes } = isTimeDimension
+        ? getTimePeriodAttributes({ reportYearStart, options })(value)
+        : { notes: [] };
+
+      let __indexPosition = NaN;
+      if (isNaN(__indexPosition)) {
+        __indexPosition = getCodeOrder({ annotations: valueAnnotations });
+      }
+      let res = {
+        // names is explicitely skipped because of metadata "standard"
+        // not completely aligned with NSI "standard"
+        // value is explicitely skipped (non-coded) into id
+        ...R.omit(['names', 'value'], value),
+        id,
+        display: !isHidden,
+        start: start ? start.toISOString() : null,
+        notes,
+        __indexPosition,
+        __index,
+      };
+      if (!isNonCoded(value)) {
+        res = R.assoc(
+          'name',
+          getName({ isTimeDimension, options, locale, start, reportYearStart })(
+            value,
+          ),
+          res,
+        );
+      }
+      if (isTimeDimension) {
+        res = refineTimePeriod(res, {
+          locale,
+          monthlyFormat: options.timeFormat,
+        });
+      }
+      return res;
+    }),
+    // __indexPosition is used for pre-sorting
+    R.sortWith(isTimeDimension ? timeDimensionSorts : defaultSorts),
+    // __indexPosition is reset after pre-sorting
+    R.addIndex(R.map)((val, index) => R.assoc('__indexPosition', index, val)),
+    // values are re-sorted by __index after __indexPosition settlement
+    R.sortBy(R.prop('__index')),
+  );
+};
+
+const getDateForSort = (key) => (val) => {
+  return dateFns.getTime(new Date(R.prop(key, val)));
+};
+const byStartDate = R.ascend(getDateForSort('start'));
+const byEndDate = R.descend(getDateForSort('end'));
+const timeDimensionSorts = [byStartDate, byEndDate];
+const byIndexPosition = R.ascend(R.prop('__indexPosition'));
+const byOrder = R.ascend(R.propOr(-1, 'order'));
+const defaultSorts = [byIndexPosition, byOrder];
+
+const getTimePeriodAttributes =
+  ({ reportYearStart, options }) =>
+  (value) => {
+    const reported = getReportedTimePeriod(
+      reportYearStart,
+      value,
+      options.frequency,
+    );
+    const start = reported.start;
+    const end = reported.end;
+    const reportTimeNote = getReportedTimePeriodNote(
+      reportYearStart,
+      start,
+      end,
+      options.frequency,
+      options.isRtl,
+    );
+    const notes = R.isNil(reportTimeNote)
+      ? []
+      : R.append(reportTimeNote, []);
+    return { start, notes };
+  };

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

@@ -1,13 +1,16 @@
 import * as R from 'ramda';
-import dateFns from 'date-fns';
-import { getCodeOrder, getRefinedName, isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
 import {
-  getRelationnalAnnotations, setAnnotationsLayout, getIsHidden
+  getRefinedName,
+  isTimePeriodDimension,
+} from '@sis-cc/dotstatsuite-sdmxjs';
+import {
+  getRelationnalAnnotations,
+  setAnnotationsLayout,
+  getIsHidden,
 } from './sdmx-data';
-import { getReportedTimePeriodLabel, getReportedTimePeriodNote, getReportedTimePeriod } from './date';
 import { getReportingYearStart } from './preparators/getReportingYearStart';
 import { getNotDisplayedIds } from '../../rules2/src';
-import { refineTimePeriod } from '../../rules2/src/refineTimePeriod';
+import { getValuesEnhanced } from './get-values-enhanced';
 
 const TIME_PERIOD_ID = 'TIME_PERIOD';
 
@@ -23,81 +26,13 @@ export const dataTransformer = (dataNew, options = {}) => {
   const getDataSets = R.pathOr({}, ['data', 'dataSets']);
   const dataSets = getDataSets(dataNew);
 
-  const dataSetsAnnotations = R.props(R.pathOr([], [0, 'annotations'], dataSets), annotations);
+  const dataSetsAnnotations = R.props(
+    R.pathOr([], [0, 'annotations'], dataSets),
+    annotations,
+  );
 
   const hiddenIds = getNotDisplayedIds(dataSetsAnnotations);
 
-  //--------------------------------------------------------------------------------------------------
-  const getValues = (values, parent) => R.map((value) => {
-    const valAnnotations = R.props(value.annotations || [], annotations);
-    return ({
-      ...value,
-      display: !R.has(`${parent}.${value.id}`, hiddenIds) && !getIsHidden(valAnnotations),
-      name: getRefinedName(value)
-    });
-  }, values);
-
-  const getValuesEnhanced = (locale, annotations, isTimeDimension, parent) =>
-    R.pipe(
-      R.addIndex(R.map)((value, __index) => {
-        const valueAnnotations = R.pipe(
-          R.propOr([], 'annotations'),
-          R.flip(R.props)(annotations)
-        )(value);
-        const isHidden = (_hiddenIds[parent] && R.includes(value.id, _hiddenIds[parent])) || R.has(`${parent}.${value.id}`, hiddenIds) || getIsHidden(valueAnnotations);
-        const name = getRefinedName(value);
-        let __indexPosition = NaN;
-        let notes = [];
-        let start = null;
-        let end = null;
-        if (isTimeDimension) {
-          const reported = getReportedTimePeriod(reportYearStart, value, options.frequency);
-          start = reported.start;
-          end = reported.end;
-          const reportTimeNote = getReportedTimePeriodNote(reportYearStart, start, end, options.frequency, options.isRtl);
-          notes = R.isNil(reportTimeNote) ? notes : R.append(reportTimeNote, notes);
-        }
-        if (isNaN(__indexPosition)) {
-          __indexPosition = getCodeOrder({ annotations: valueAnnotations });
-        }
-        const timeFormat = R.prop('timeFormat', options);
-        const res = ({
-          ...value,
-          id: R.when(
-            R.isNil,
-            R.always(`${parent}-${__index}`)
-          )(value.id),
-          display: !isHidden,
-          name: R.when(
-            R.always(isTimeDimension),
-            R.always(getReportedTimePeriodLabel(options.frequency, timeFormat, locale)(reportYearStart, { id: value.id, reportedStart: start, start: new Date(value.start) }))
-          )(name),
-          start: start ? start.toISOString() : null,
-          notes,
-          __indexPosition,
-          __index,
-        });
-        return isTimeDimension ? refineTimePeriod(res, { locale, monthlyFormat: timeFormat }) : res;
-      }),
-      R.ifElse(
-        R.always(isTimeDimension),
-        R.pipe(
-          R.sortWith([
-            R.ascend(val => dateFns.getTime(new Date(R.prop('start', val)))),
-            R.descend(val => dateFns.getTime(new Date(R.prop('end', val)))),
-          ]),
-          R.addIndex(R.map)((val, ind) => R.assoc('__indexcPosition', ind, val))
-        ),
-        R.sortWith([
-          R.ascend(R.prop('__indexPosition')),
-          R.ascend(R.propOr(-1, 'order'))
-        ])
-      ),
-      R.addIndex(R.map)((val, index) => R.assoc('__indexPosition', index, val)),
-      /* NEW */
-      R.sortBy(R.prop('__index'))
-    );
-
   //--------------------------------------------------------------------------------------------Header
   const getMeta = R.propOr({}, 'meta');
   const meta = getMeta(dataNew);
@@ -119,32 +54,45 @@ export const dataTransformer = (dataNew, options = {}) => {
 
   const resAttrObservations = R.addIndex(R.map)((observation, index) => {
     const obsAnnotations = R.props(observation.annotations || [], annotations);
-    return ({
+    return {
       ...observation,
       __index: index,
-      display: !R.has(observation.id, hiddenIds) && !getIsHidden(obsAnnotations),
+      display:
+        !R.has(observation.id, hiddenIds) && !getIsHidden(obsAnnotations),
       name: getRefinedName(observation),
-      values: getValuesEnhanced(locale, annotations, false, observation.id)(R.propOr([], 'values', observation)),
+      values: getValuesEnhanced({
+        locale,
+        annotations,
+        parent: observation.id,
+        reportYearStart,
+        _hiddenIds,
+        hiddenIds,
+        options,
+      })(R.propOr([], 'values', observation)),
       roles: !R.isNil(observation.role) ? R.head(observation.role) : null,
-    });
+    };
   }, attrObservations);
 
-  const datasetAttributes = R.map(
-    (attr) => {
-      const attrAnnotations = R.props(attr.annotations || [], annotations);
-      return ({
-        ...attr,
-        display: !R.has(attr.id, hiddenIds) && !getIsHidden(attrAnnotations),
-        name: getRefinedName(attr),
-        values: getValuesEnhanced(locale, annotations, false, attr.id)(R.propOr([], 'values', attr)),
-      });
-    },
-    R.propOr([], 'dataSet', attributes)
-  )
+  const datasetAttributes = R.map((attr) => {
+    const attrAnnotations = R.props(attr.annotations || [], annotations);
+    return {
+      ...attr,
+      display: !R.has(attr.id, hiddenIds) && !getIsHidden(attrAnnotations),
+      name: getRefinedName(attr),
+      values: getValuesEnhanced({
+        locale,
+        annotations,
+        parent: attr.id,
+        _hiddenIds,
+        hiddenIds,
+        options,
+      })(R.propOr([], 'values', attr)),
+    };
+  }, R.propOr([], 'dataSet', attributes));
 
   const resAttributes = {
     ...attributes,
-    observation: R.concat(resAttrObservations, datasetAttributes)
+    observation: R.concat(resAttrObservations, datasetAttributes),
   };
 
   //----------------------------------------------------------------------------------------Dimensions
@@ -154,28 +102,51 @@ export const dataTransformer = (dataNew, options = {}) => {
   const getDimObservations = R.propOr([], 'observation');
   const dimObservations = getDimObservations(dimensions);
 
-  const getObservations = locale => R.addIndex(R.reduce)((acc, observation, obsIndex) => {
-    const id = R.prop('id')(observation);
-    const dimAnnotations = getRelationnalAnnotations(R.propOr([], 'annotations')(observation))(annotations)
-    const isTime = isTimePeriodDimension(observation);
-    const values = getValuesEnhanced(locale, annotations, isTime, id)(R.propOr([], 'values', observation));
-    const _idHidden = _hiddenIds[id] && R.isEmpty(R.difference(R.pluck('id')(values), _hiddenIds[id]))
-    const isHidden = _idHidden || R.has(id, hiddenIds) || getIsHidden(dimAnnotations);
-    return ({
-      observation: R.append({
-        ...observation,
-        display: !isHidden,
-        __index: obsIndex,
-        name: getRefinedName(observation),
-        values: _idHidden ? [] : values,
-        role: isTime ? TIME_PERIOD_ID : R.head(R.propOr([], 'roles', observation)),
-      })(acc.observation),
-      dimensionsLayout: setAnnotationsLayout(id, acc.dimensionsLayout)(dimAnnotations),
-    });
-  }, { observation: [], dimensionsLayout: {} });
+  const getObservations = (locale) =>
+    R.addIndex(R.reduce)(
+      (acc, observation, obsIndex) => {
+        const id = R.prop('id')(observation);
+        const dimAnnotations = getRelationnalAnnotations(
+          R.propOr([], 'annotations')(observation),
+        )(annotations);
+        const isTimeDimension = isTimePeriodDimension(observation);
+        const values = getValuesEnhanced({
+          locale,
+          annotations,
+          isTimeDimension,
+          parent: id,
+          _hiddenIds,
+          hiddenIds,
+          options,
+        })(R.propOr([], 'values', observation));
+        const _idHidden =
+          _hiddenIds[id] &&
+          R.isEmpty(R.difference(R.pluck('id')(values), _hiddenIds[id]));
+        const isHidden =
+          _idHidden || R.has(id, hiddenIds) || getIsHidden(dimAnnotations);
+        return {
+          observation: R.append({
+            ...observation,
+            display: !isHidden,
+            __index: obsIndex,
+            name: getRefinedName(observation),
+            values: _idHidden ? [] : values,
+            role: isTime
+              ? TIME_PERIOD_ID
+              : R.head(R.propOr([], 'roles', observation)),
+          })(acc.observation),
+          dimensionsLayout: setAnnotationsLayout(
+            id,
+            acc.dimensionsLayout,
+          )(dimAnnotations),
+        };
+      },
+      { observation: [], dimensionsLayout: {} },
+    );
 
   //-----------------------------------------------------------------------------------------Structure
-  const { dimensionsLayout, observation } = getObservations(locale)(dimObservations);
+  const { dimensionsLayout, observation } =
+    getObservations(locale)(dimObservations);
   const resStructure = {
     ...structure,
     name: getRefinedName({ ...structure, id: options.dataflowId }),
@@ -188,8 +159,11 @@ export const dataTransformer = (dataNew, options = {}) => {
   const dataSetsLayout = R.reduce((acc, dataSetsAnnotation) => {
     const title = R.propOr('', 'title')(dataSetsAnnotation);
     if (R.isEmpty(title)) return acc;
-    return setAnnotationsLayout(title, acc)([dataSetsAnnotation])
+    return setAnnotationsLayout(title, acc)([dataSetsAnnotation]);
   }, {})(dataSetsAnnotations);
 
-  return ({ data: { header: resHeader, dataSets, structure: resStructure }, layout: R.mergeRight(dimensionsLayout, dataSetsLayout) });
+  return {
+    data: { header: resHeader, dataSets, structure: resStructure },
+    layout: R.mergeRight(dimensionsLayout, dataSetsLayout),
+  };
 };

package/src/rules/test/get-values-enhanced.test.js

@@ -0,0 +1,126 @@
+import * as R from 'ramda';
+import { expect } from 'chai';
+import { getValuesEnhanced } from '../src/get-values-enhanced';
+
+const values = [
+  {
+    id: 'A',
+    order: 0,
+    name: 'Code A',
+    names: {
+      en: 'Code A',
+    },
+  },
+  {
+    id: 'B',
+    order: 1,
+    name: 'Code B',
+    names: {
+      en: 'Code B',
+    },
+  },
+  {
+    id: 'C',
+    order: 2,
+    name: 'Code C',
+    names: {
+      en: 'Code C',
+    },
+  },
+];
+
+const timeValues = [
+  {
+    start: '2020-01-01T00:00:00',
+    end: '2020-12-31T23:59:59',
+    id: '2020',
+    name: '2020',
+    names: {
+      en: '2020',
+    },
+  },
+  {
+    start: '2021-01-01T00:00:00',
+    end: '2021-12-31T23:59:59',
+    id: '2021',
+    name: '2021',
+    names: {
+      en: '2021',
+    },
+  },
+  {
+    start: '2022-01-01T00:00:00',
+    end: '2022-12-31T23:59:59',
+    id: '2022',
+    name: '2022',
+    names: {
+      en: '2022',
+    },
+  },
+];
+
+const expectedTimeValues = [
+  {
+    start: '2020-01-01T00:00:00.000Z',
+    end: '2020-12-31T23:59:59.000Z',
+    id: '2020',
+    name: '2020',
+  },
+  {
+    start: '2021-01-01T00:00:00.000Z',
+    end: '2021-12-31T23:59:59.000Z',
+    id: '2021',
+    name: '2021',
+  },
+  {
+    start: '2022-01-01T00:00:00.000Z',
+    end: '2022-12-31T23:59:59.000Z',
+    id: '2022',
+    name: '2022',
+  },
+];
+
+const nonCodedValues = [{ value: 'A' }, { value: 'B' }, { value: 'C' }];
+
+const expectedValues = (skippedValueEntries = []) => R.addIndex(R.map)((value, index) => {
+  return {
+    ...R.omit(R.prepend('names', skippedValueEntries), value),
+    __index: index,
+    __indexPosition: index,
+    display: true,
+    notes: [],
+    start: R.propOr(null, 'start', value),
+  };
+});
+
+describe('get values enhanced method', () => {
+  it('should pass with coded values', () => {
+    const enhancedValues = getValuesEnhanced({
+      locale: 'en',
+      parent: 'ID',
+    })(values);
+    expect(enhancedValues).to.deep.equal(expectedValues()(values));
+  });
+
+  it('should pass with non-coded values', () => {
+    const enhancedValues = getValuesEnhanced({
+      locale: 'en',
+      parent: 'ID',
+    })(nonCodedValues);
+    expect(enhancedValues).to.deep.equal(
+      expectedValues(['name', 'order', 'value'])(values),
+    );
+  });
+
+  it('should pass with time values', () => {
+    const enhancedValues = getValuesEnhanced({
+      locale: 'en',
+      parent: 'ID',
+      isTimeDimension: true,
+      reportYearStart: { month: '01', day: '01' },
+    })(timeValues);
+    expect(enhancedValues).to.deep.equal(
+      expectedValues()(expectedTimeValues),
+    );
+  });
+});

package/src/rules2/src/enhanceObservations.js

@@ -64,7 +64,7 @@ export const enhanceObservations = (dimensions = [], observations = {}, attribut
   const formatAttributesIndexes = getFormatAttributesIndexes(attributes, R.propOr({}, 'customAttributes', options));
   const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
 
-  return R.mapObjIndexed(
+  return R.map(
     (observation) => {
       const { dimValuesIndexes } = observation;