@sis-cc/dotstatsuite-components 17.2.0 → 17.4.0

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

@@ -27,6 +27,8 @@ var _getReportingYearStart = require('./preparators/getReportingYearStart');
 
 var _src = require('../../rules2/src');
 
+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 }; }
@@ -78,14 +80,14 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
         end = reported.end;
         var reportTimeNote = (0, _date.getReportedTimePeriodNote)(reportYearStart, start, end, options.frequency, options.isRtl);
         notes = R.isNil(reportTimeNote) ? notes : R.append(reportTimeNote, notes);
-        __indexPosition = _dateFns2.default.getTime(new Date(R.prop('start', value)));
+        //__indexPosition = dateFns.getTime(new Date(R.prop('start', value)));
       }
       if (isNaN(__indexPosition)) {
         __indexPosition = (0, _dotstatsuiteSdmxjs.getCodeOrder)({ annotations: valueAnnotations });
       }
       var timeFormat = R.prop('timeFormat', options);
-      return (0, _extends3.default)({}, value, {
-        id: R.pipe(R.when(R.isNil, R.always(parent + '-' + __index)), R.when(R.always(isTimeDimension), R.replace(/M/g, '')))(value.id),
+      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,
@@ -93,7 +95,14 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
         __indexPosition: __indexPosition,
         __index: __index
       });
-    }), R.sortWith([R.ascend(R.prop('__indexPosition')), R.ascend(R.propOr(-1, 'order'))]), R.addIndex(R.map)(function (val, index) {
+      return isTimeDimension ? (0, _refineTimePeriod.refineTimePeriod)(res, { locale: locale }) : 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 */

package/lib/rules2/src/getCombinationDefinitions.js

@@ -17,10 +17,25 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+var parseTexts = function parseTexts(texts) {
+  return R.reduce(function (acc, text) {
+    var splitted = R.split(':', text);
+    if (R.length(splitted) !== 2) {
+      return acc;
+    }
+
+    var _splitted = (0, _slicedToArray3.default)(splitted, 2),
+        id = _splitted[0],
+        name = _splitted[1];
+
+    return R.assoc(id, name, acc);
+  }, {}, texts);
+};
+
 var parseCombinationDefinition = exports.parseCombinationDefinition = function parseCombinationDefinition(locale) {
   return function (title, texts) {
     return R.useWith(function (titles, texts) {
-      return R.addIndex(R.reduce)(function (acc, title, index) {
+      return R.reduce(function (acc, title) {
         var split = R.split(':', title);
         if (R.length(split) !== 2) {
           return acc;
@@ -36,10 +51,10 @@ var parseCombinationDefinition = exports.parseCombinationDefinition = function p
         return R.append({
           id: id,
           concepts: R.split(',', codes),
-          name: R.has(locale, texts) ? R.pipe(R.prop(locale), R.nth(index), R.split(':'), R.last)(texts) : '[' + id + ']'
+          name: R.hasPath([locale, id], texts) ? R.path([locale, id], texts) : '[' + id + ']'
         }, acc);
       }, [], titles);
-    }, [R.split(';'), R.map(R.split(';'))])(title, texts);
+    }, [R.split(';'), R.map(R.pipe(R.split(';'), parseTexts))])(title, texts);
   };
 };
 

package/lib/rules2/src/getHeaderCombinations.js

@@ -11,6 +11,8 @@ var R = _interopRequireWildcard(_ramda);
 
 var _src = require('../../rules/src');
 
+var _constants = require('./constants');
+
 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 getHeaderCombinations = exports.getHeaderCombinations = function getHeaderCombinations(combinations, dimensions, attributes, display) {
@@ -25,7 +27,9 @@ var getHeaderCombinations = exports.getHeaderCombinations = function getHeaderCo
 
     var combinedDisplay = function combinedDisplay(_display, values) {
       if (_display === 'label') {
-        return R.pipe(R.filter(R.propOr(true, 'display')), R.map((0, _src.dimensionValueDisplay)(_display)), R.join(', '))(values);
+        return R.pipe(R.filter(function (val) {
+          return R.propOr(true, 'display', val) && !R.includes(val.id, _constants.REJECTED_VALUE_IDS);
+        }), R.map((0, _src.dimensionValueDisplay)(_display)), R.join(', '))(values);
       }
       return R.pipe(R.map((0, _src.dimensionValueDisplay)(_display)), R.join(', '))(values);
     };

package/lib/rules2/src/refineTimePeriod.js

@@ -0,0 +1,146 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.refineTimePeriod = exports.getStartDate = undefined;
+
+var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
+
+var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
+
+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 dateFns = _interopRequireWildcard(_dateFns);
+
+var _date = require('../../rules/src/date');
+
+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 computeDisplayFreq = function computeDisplayFreq(start, duration) {
+  var startMinute = dateFns.startOfMinute(start);
+  var startHour = dateFns.startOfHour(start);
+  var startDay = dateFns.startOfDay(start);
+  if (!dateFns.isEqual(start, startMinute) || duration === 'S') {
+    return 'S';
+  } else if (!dateFns.isEqual(start, startHour) || !dateFns.isEqual(start, startDay) || duration === 'H' || duration === 'm') {
+    return 'm';
+  } else if (!dateFns.isFirstDayOfMonth(start) || duration === 'D') {
+    return 'D';
+  } else if (dateFns.getMonth(start) !== 0 || duration === 'M') {
+    return 'M';
+  }
+  return 'Y';
+};
+
+var getAdder = function getAdder(duration) {
+  if (duration === 'S') return dateFns.addSeconds;
+  if (duration === 'm') return dateFns.addMinutes;
+  if (duration === 'H') return dateFns.addHours;
+  if (duration === 'D') return dateFns.addDays;
+  if (duration === 'M') return dateFns.addMonths;
+  return dateFns.addYears;
+};
+
+var getFormat = function getFormat(freqDisplay) {
+  if (freqDisplay === 'Y') return 'YYYY';
+  if (freqDisplay === 'D') return 'YYYY-MM-DD';
+  if (freqDisplay === 'H' || freqDisplay === 'm') {
+    return 'HH:mm';
+  }
+  if (freqDisplay === 'S') {
+    return 'HH:mm:ss';
+  }
+  return 'MMM';
+};
+
+var getEndDate = function getEndDate(start, mult, duration) {
+  var adder = getAdder(duration);
+  var endDate = adder(start, Number(mult));
+  var startTZ = start.getTimezoneOffset();
+  var endTZ = endDate.getTimezoneOffset();
+  if (startTZ !== endTZ) {
+    endDate = dateFns.addMinutes(endDate, Math.abs(endTZ) - Math.abs(startTZ));
+  }
+  return dateFns.subSeconds(endDate, 1);
+};
+
+var computeName = function computeName(start, end, freqDisplay, locale) {
+  var opts = { locale: (0, _date.getLocale)(locale) };
+  var isSameDay = dateFns.isSameDay(start, end);
+  var isSameYear = dateFns.isSameYear(start, end);
+  if (freqDisplay === 'H' || freqDisplay === 'm' || freqDisplay === 'S') {
+    var dayFormat = getFormat('D');
+    var timeFormat = getFormat(freqDisplay);
+    if (isSameDay) return dateFns.format(start, dayFormat, opts) + ' ' + dateFns.format(start, timeFormat, opts) + ' - ' + dateFns.format(end, timeFormat, opts);
+    return dateFns.format(start, dayFormat + ' ' + timeFormat, opts) + ' - ' + dateFns.format(end, dayFormat + ' ' + timeFormat, opts);
+  }
+  if (freqDisplay === 'D' || freqDisplay === 'Y') {
+    var _format = getFormat(freqDisplay);
+    return dateFns.format(start, _format, opts) + ' - ' + dateFns.format(end, _format, opts);
+  }
+  var yearFormat = getFormat('Y');
+  var monthFormat = getFormat('M');
+  if (isSameYear && locale === 'fr') {
+    return dateFns.format(start, monthFormat, opts) + ' - ' + dateFns.format(end, monthFormat, opts) + ' ' + dateFns.format(start, yearFormat, opts);
+  }
+  var format = locale === 'fr' ? monthFormat + ' ' + yearFormat : yearFormat + '-' + monthFormat;
+  return dateFns.format(start, format, opts) + ' - ' + dateFns.format(end, format, opts);
+};
+
+var getStartDate = exports.getStartDate = function getStartDate(start) {
+  if (!R.includes('T', start) && !R.endsWith('Z', start)) {
+    return new Date(start);
+  }
+  var date = new Date(start);
+  return dateFns.addMinutes(date, -date.getTimezoneOffset());
+};
+
+var refineTimePeriod = exports.refineTimePeriod = function refineTimePeriod(timePeriod, _ref) {
+  var locale = _ref.locale;
+  var id = timePeriod.id;
+
+  var split = R.split('/', id);
+  if (R.length(split) !== 2) {
+    var _start = getStartDate(R.prop('start', timePeriod));
+    var end = getStartDate(R.prop('end', timePeriod));
+    return (0, _extends3.default)({}, timePeriod, { start: _start.toISOString(), end: end.toISOString() });
+  }
+
+  var _split = (0, _slicedToArray3.default)(split, 2),
+      start = _split[0],
+      range = _split[1];
+
+  var startDate = getStartDate(start);
+  var match = R.match(/^P(T?)(\d+)([YMDHS])$/, range);
+  if (R.isEmpty(match) || !dateFns.isValid(startDate)) {
+    return timePeriod;
+  }
+
+  var _R$tail = R.tail(match),
+      _R$tail2 = (0, _slicedToArray3.default)(_R$tail, 3),
+      timeIndicator = _R$tail2[0],
+      mult = _R$tail2[1],
+      _duration = _R$tail2[2];
+
+  var duration = !R.isEmpty(timeIndicator) && _duration === 'M' ? 'm' : _duration;
+  var endDate = getEndDate(startDate, mult, duration);
+  var freqDisplay = computeDisplayFreq(start, duration);
+  var name = computeName((0, _date.dateWithoutTZ)(startDate), (0, _date.dateWithoutTZ)(endDate), freqDisplay, locale);
+  return (0, _extends3.default)({}, timePeriod, {
+    id: id,
+    name: name,
+    start: startDate.toISOString(),
+    end: endDate.toISOString()
+  });
+};

package/package.json

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

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

@@ -7,6 +7,7 @@ import {
 import { getReportedTimePeriodLabel, getReportedTimePeriodNote, getReportedTimePeriod } from './date';
 import { getReportingYearStart } from './preparators/getReportingYearStart';
 import { getNotDisplayedIds } from '../../rules2/src';
+import { refineTimePeriod } from '../../rules2/src/refineTimePeriod';
 
 const TIME_PERIOD_ID = 'TIME_PERIOD';
 
@@ -55,23 +56,17 @@ export const dataTransformer = (dataNew, options = {}) => {
           end = reported.end;
           const reportTimeNote = getReportedTimePeriodNote(reportYearStart, start, end, options.frequency, options.isRtl);
           notes = R.isNil(reportTimeNote) ? notes : R.append(reportTimeNote, notes);
-          __indexPosition = dateFns.getTime(new Date(R.prop('start', value)));
+          //__indexPosition = dateFns.getTime(new Date(R.prop('start', value)));
         }
         if (isNaN(__indexPosition)) {
           __indexPosition = getCodeOrder({ annotations: valueAnnotations });
         }
         const timeFormat = R.prop('timeFormat', options);
-        return ({
+        const res = ({
           ...value,
-          id: R.pipe(
-            R.when(
-              R.isNil,
-              R.always(`${parent}-${__index}`)
-            ),
-            R.when(
-              R.always(isTimeDimension),
-              R.replace(/M/g, '')
-            )
+          id: R.when(
+            R.isNil,
+            R.always(`${parent}-${__index}`)
           )(value.id),
           display: !isHidden,
           name: R.when(
@@ -83,11 +78,22 @@ export const dataTransformer = (dataNew, options = {}) => {
           __indexPosition,
           __index,
         });
+        return isTimeDimension ? refineTimePeriod(res, { locale }) : res;
       }),
-      R.sortWith([
-        R.ascend(R.prop('__indexPosition')),
-        R.ascend(R.propOr(-1, 'order'))
-      ]),
+      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'))

package/src/rules2/src/getCombinationDefinitions.js

@@ -1,8 +1,21 @@
 import * as R from 'ramda';
 
+const parseTexts = texts => R.reduce(
+  (acc, text) => {
+    const splitted = R.split(':', text);
+    if (R.length(splitted) !== 2) {
+      return acc;
+    }
+    const [id, name] = splitted;
+    return R.assoc(id, name, acc);
+  },
+  {},
+  texts
+);
+
 export const parseCombinationDefinition = (locale) => (title, texts) => R.useWith(
   (titles, texts) =>
-    R.addIndex(R.reduce)((acc, title, index) => {
+    R.reduce((acc, title) => {
       const split = R.split(':', title);
       if (R.length(split) !== 2) {
         return acc;
@@ -14,12 +27,12 @@ export const parseCombinationDefinition = (locale) => (title, texts) => R.useWit
       return R.append({
         id,
         concepts: R.split(',', codes),
-        name: R.has(locale, texts)
-          ? R.pipe(R.prop(locale), R.nth(index), R.split(':'), R.last)(texts)
+        name: R.hasPath([locale, id], texts)
+          ? R.path([locale, id], texts)
           : `[${id}]`,
       }, acc);
     }, [], titles),
-  [R.split(';'), R.map(R.split(';'))],
+  [R.split(';'), R.map(R.pipe(R.split(';'), parseTexts))],
 )(title, texts);
 
 export const getCombinationDefinitions = (annotations, locale) => {

package/src/rules2/src/getHeaderCombinations.js

@@ -1,5 +1,6 @@
 import * as R from 'ramda';
 import { dimensionValueDisplay } from '../../rules/src';
+import { REJECTED_VALUE_IDS } from './constants';
 
 export const getHeaderCombinations = (combinations, dimensions, attributes, display) => {
   const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
@@ -14,7 +15,11 @@ export const getHeaderCombinations = (combinations, dimensions, attributes, disp
 
       const combinedDisplay = (_display, values) => {
         if (_display === 'label') {
-          return R.pipe(R.filter(R.propOr(true, 'display')), R.map(dimensionValueDisplay(_display)), R.join(', '))(values);
+          return R.pipe(
+            R.filter(val => R.propOr(true, 'display', val) && !R.includes(val.id, REJECTED_VALUE_IDS)),
+            R.map(dimensionValueDisplay(_display)),
+            R.join(', ')
+          )(values);
         }
         return R.pipe(R.map(dimensionValueDisplay(_display)), R.join(', '))(values);
       };

package/src/rules2/src/refineTimePeriod.js

@@ -0,0 +1,122 @@
+import * as R from 'ramda';
+import * as dateFns from 'date-fns';
+import { getLocale, dateWithoutTZ } from '../../rules/src/date';
+
+const computeDisplayFreq = (start, duration) => {
+  const startMinute = dateFns.startOfMinute(start);
+  const startHour = dateFns.startOfHour(start);
+  const startDay = dateFns.startOfDay(start);
+  if (!dateFns.isEqual(start, startMinute) || duration === 'S') {
+    return 'S';
+  }
+  else if (!dateFns.isEqual(start, startHour) || !dateFns.isEqual(start, startDay)
+    || duration === 'H' || duration === 'm') {
+    return 'm';
+  }
+  else if (!dateFns.isFirstDayOfMonth(start) || duration === 'D') {
+    return 'D';
+  }
+  else if (dateFns.getMonth(start) !== 0 || duration === 'M') {
+    return 'M';
+  }
+  return 'Y';
+};
+
+const getAdder = (duration) => {
+  if (duration === 'S')
+    return dateFns.addSeconds;
+  if (duration === 'm')
+    return dateFns.addMinutes;
+  if (duration === 'H')
+    return dateFns.addHours;
+  if (duration === 'D')
+    return dateFns.addDays;
+  if (duration === 'M')
+    return dateFns.addMonths;
+  return dateFns.addYears;
+};
+
+const getFormat = (freqDisplay) => {
+  if (freqDisplay === 'Y')
+    return 'YYYY';
+  if (freqDisplay === 'D')
+    return 'YYYY-MM-DD';
+  if (freqDisplay === 'H' || freqDisplay === 'm') {
+    return 'HH:mm';
+  }
+  if (freqDisplay === 'S') {
+    return 'HH:mm:ss';
+  }
+  return 'MMM';
+}
+
+const getEndDate = (start, mult, duration) => {
+  const adder = getAdder(duration);
+  let endDate = adder(start, Number(mult));
+  const startTZ = start.getTimezoneOffset();
+  const endTZ = endDate.getTimezoneOffset();
+  if (startTZ !== endTZ) {
+    endDate = dateFns.addMinutes(endDate, (Math.abs(endTZ) - Math.abs(startTZ)));
+  }
+  return dateFns.subSeconds(endDate, 1);
+};
+
+const computeName = (start, end, freqDisplay, locale) => {
+  const opts = { locale: getLocale(locale) };
+  const isSameDay = dateFns.isSameDay(start, end);
+  const isSameYear = dateFns.isSameYear(start, end);
+  if (freqDisplay === 'H' || freqDisplay === 'm' || freqDisplay === 'S') {
+    const dayFormat = getFormat('D');
+    const timeFormat = getFormat(freqDisplay);
+    if (isSameDay)
+      return `${dateFns.format(start, dayFormat, opts)} ${dateFns.format(start, timeFormat, opts)} - ${dateFns.format(end, timeFormat, opts)}`;
+    return `${dateFns.format(start, `${dayFormat} ${timeFormat}`, opts)} - ${dateFns.format(end, `${dayFormat} ${timeFormat}`, opts)}`;
+  }
+  if (freqDisplay === 'D' || freqDisplay === 'Y') {
+    const format = getFormat(freqDisplay);
+    return `${dateFns.format(start, format, opts)} - ${dateFns.format(end, format, opts)}`;
+  }
+  const yearFormat = getFormat('Y');
+  const monthFormat = getFormat('M');
+  if (isSameYear && locale === 'fr') {
+    return `${dateFns.format(start, monthFormat, opts)} - ${dateFns.format(end, monthFormat, opts)} ${dateFns.format(start, yearFormat, opts)}`;
+  }
+  const format = locale === 'fr' ? `${monthFormat} ${yearFormat}` : `${yearFormat}-${monthFormat}`;
+  return `${dateFns.format(start, format, opts)} - ${dateFns.format(end, format, opts)}`;
+};
+
+export const getStartDate = (start) => {
+  if (!R.includes('T', start) && !R.endsWith('Z', start)) {
+    return new Date(start);
+  }
+  const date = new Date(start);
+  return dateFns.addMinutes(date, -date.getTimezoneOffset());
+};
+
+export const refineTimePeriod = (timePeriod, { locale }) => {
+  const { id } = timePeriod;
+  const split = R.split('/', id);
+  if (R.length(split) !== 2) {
+    const start = getStartDate(R.prop('start', timePeriod));
+    const end = getStartDate(R.prop('end', timePeriod))
+    return ({ ...timePeriod, start: start.toISOString(), end: end.toISOString() });
+  }
+  const [start, range] = split;
+  const startDate = getStartDate(start);
+  const match = R.match(/^P(T?)(\d+)([YMDHS])$/, range);
+  if (R.isEmpty(match) || !dateFns.isValid(startDate)) {
+    return timePeriod;
+  }
+  const [timeIndicator, mult, _duration] = R.tail(match);
+  const duration = !R.isEmpty(timeIndicator) && _duration === 'M' ? 'm' : _duration;
+  const endDate = getEndDate(startDate, mult, duration);
+  const freqDisplay = computeDisplayFreq(start, duration);
+  const name = computeName(dateWithoutTZ(startDate), dateWithoutTZ(endDate), freqDisplay, locale);
+  return ({
+    ...timePeriod,
+    id,
+    name,
+    start: startDate.toISOString(),
+    end: endDate.toISOString()
+  })
+};

package/test/getCombinationDefinitions.test.js

@@ -85,4 +85,20 @@ describe('getCombinationDefinitions tests', () => {
       { id: 'COMB_2', name: '[COMB_2]', concepts: ['D3', 'D4', 'A2', 'A3'] },
     ]);
   });
+  it('mixed order texts', () => {
+    const annotations = [
+      { type: 'random', title: 'test' },
+      { type: 'NOT_DISPLAYED', title: 'FREQ=A'  },
+      {
+        type: 'COMBINED_CONCEPTS',
+        texts: { en: 'COMB_2:Second Combination;COMB_1:First Combination' },
+        title: 'COMB_1:D1,D2,A1;COMB_2:D3,D4,A2,A3'
+      }
+    ];
+
+    expect(getCombinationDefinitions(annotations, 'en')).to.deep.equal([
+      { id: 'COMB_1', name: 'First Combination', concepts: ['D1', 'D2', 'A1'] },
+      { id: 'COMB_2', name: 'Second Combination', concepts: ['D3', 'D4', 'A2', 'A3'] },
+    ]);
+  });
 });

package/test/getHeaderCombinations.test.js

@@ -4,7 +4,7 @@ import { getHeaderCombinations } from '../src/rules2/src/';
 describe('getHeaderCombinations tests', () => {
   it('complete test', () => {
     const combinations = [
-      { id: 'COMB1', name: 'comb 1', header: true, concepts: ['DIM1', 'DIM2', 'ATTR1'] },
+      { id: 'COMB1', name: 'comb 1', header: true, concepts: ['DIM1', 'DIM2', 'DIM4', 'ATTR1'] },
       { id: 'COMB2', name: 'comb 2', series: true, concepts: ['DIM3', 'ATTR2'] },
       { id: 'COMB3', name: 'comb 3', header: true, display: false, concepts: ['DIM3', 'ATTR2'] }
     ];
@@ -12,6 +12,7 @@ describe('getHeaderCombinations tests', () => {
     const dimensions = [
       { id: 'DIM1', name: 'dim 1', values: [{ id: 'v', name: 'dim 1 value' }] },
       { id: 'DIM3', name: 'dim 3', values: [{ id: 'v', name: 'dim 3 value' }] },
+      { id: 'DIM4', name: 'dim 4', values: [{ id: '_Z', name: 'Not applicable' }] },
     ];
 
     const attributes = [

package/test/refineTimePeriod.test.js

@@ -0,0 +1,564 @@
+import { expect } from 'chai';
+import { refineTimePeriod } from '../src/rules2/src/refineTimePeriod';
+
+describe('refineTimePeriod tests', () => {
+  it('simple year', () => {
+    expect(refineTimePeriod({ id: '2015', start: '2015-01-01T00:00:00', end: '2016-12-31T23:59:59' }, { locale: 'en' })).to.deep.equal({
+      id: '2015',
+      start: '2015-01-01T00:00:00.000Z',
+      end: '2016-12-31T23:59:59.000Z'
+    });
+  });
+  it('2 years range', () => {
+    expect(refineTimePeriod({ id: '2015/P2Y' }, { locale: 'en' })).to.deep.equal({
+      id: '2015/P2Y',
+      name: '2015 - 2016',
+      start: '2015-01-01T00:00:00.000Z',
+      end: '2016-12-31T23:59:59.000Z'
+    });
+  });
+  it('2 years range on March, en', () => {
+    expect(refineTimePeriod({ id: '2015-03/P2Y' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-03/P2Y',
+      name: '2015-Mar - 2017-Feb',
+      start: '2015-03-01T00:00:00.000Z',
+      end: '2017-02-28T23:59:59.000Z'
+    });
+  });
+  it('2 years range on March, fr', () => {
+    expect(refineTimePeriod({ id: '2015-03/P2Y' }, { locale: 'fr' })).to.deep.equal({
+      id: '2015-03/P2Y',
+      name: 'mars 2015 - févr. 2017',
+      start: '2015-03-01T00:00:00.000Z',
+      end: '2017-02-28T23:59:59.000Z'
+    });
+  });
+  it('4 years range on Jun 17, en', () => {
+    expect(refineTimePeriod({ id: '2015-06-17/P4Y' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-06-17/P4Y',
+      name: '2015-06-17 - 2019-06-16',
+      start: '2015-06-17T00:00:00.000Z',
+      end: '2019-06-16T23:59:59.000Z'
+    });
+  });
+  it('4 years range on Jun 17 15h, en', () => {
+    expect(refineTimePeriod({ id: '2015-06-17T15:00:00/P4Y' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-06-17T15:00:00/P4Y',
+      name: '2015-06-17 15:00 - 2019-06-17 14:59',
+      start: '2015-06-17T15:00:00.000Z',
+      end: '2019-06-17T14:59:59.000Z'
+    });
+  });
+  it('4 years range on Jun 17 15h26, en', () => {
+    expect(refineTimePeriod({ id: '2015-06-17T15:26:00/P4Y' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-06-17T15:26:00/P4Y',
+      name: '2015-06-17 15:26 - 2019-06-17 15:25',
+      start: '2015-06-17T15:26:00.000Z',
+      end: '2019-06-17T15:25:59.000Z'
+    });
+  });
+  it('4 years range on Jun 17 15h26m46, en', () => {
+    expect(refineTimePeriod({ id: '2015-06-17T15:26:46/P4Y' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-06-17T15:26:46/P4Y',
+      name: '2015-06-17 15:26:46 - 2019-06-17 15:26:45',
+      start: '2015-06-17T15:26:46.000Z',
+      end: '2019-06-17T15:26:45.000Z'
+    });
+  });
+  it('3 months range, en', () => {
+    expect(refineTimePeriod({ id: '2015/P3M' }, { locale: 'en' })).to.deep.equal({
+      id: '2015/P3M',
+      name: '2015-Jan - 2015-Mar',
+      start: '2015-01-01T00:00:00.000Z',
+      end: '2015-03-31T23:59:59.000Z'
+    });
+  });
+  it('3 months range, fr', () => {
+    expect(refineTimePeriod({ id: '2015/P3M' }, { locale: 'fr' })).to.deep.equal({
+      id: '2015/P3M',
+      name: 'janv. - mars 2015',
+      start: '2015-01-01T00:00:00.000Z',
+      end: '2015-03-31T23:59:59.000Z'
+    });
+  });
+  it('19 months range, en', () => {
+    expect(refineTimePeriod({ id: '2015/P19M' }, { locale: 'en' })).to.deep.equal({
+      id: '2015/P19M',
+      name: '2015-Jan - 2016-Jul',
+      start: '2015-01-01T00:00:00.000Z',
+      end: '2016-07-31T23:59:59.000Z'
+    });
+  });
+  it('19 months range, fr', () => {
+    expect(refineTimePeriod({ id: '2015/P19M' }, { locale: 'fr' })).to.deep.equal({
+      id: '2015/P19M',
+      name: 'janv. 2015 - juill. 2016',
+      start: '2015-01-01T00:00:00.000Z',
+      end: '2016-07-31T23:59:59.000Z'
+    });
+  });
+  it('4 months range from April, en', () => {
+    expect(refineTimePeriod({ id: '2015-04/P4M' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-04/P4M',
+      name: '2015-Apr - 2015-Jul',
+      start: '2015-04-01T00:00:00.000Z',
+      end: '2015-07-31T23:59:59.000Z'
+    });
+  });
+  it('4 months range from April, fr', () => {
+    expect(refineTimePeriod({ id: '2015-04/P4M' }, { locale: 'fr' })).to.deep.equal({
+      id: '2015-04/P4M',
+      name: 'avr. - juill. 2015',
+      start: '2015-04-01T00:00:00.000Z',
+      end: '2015-07-31T23:59:59.000Z'
+    });
+  });
+  it('2 months range from December, en', () => {
+    expect(refineTimePeriod({ id: '2015-12/P2M' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-12/P2M',
+      name: '2015-Dec - 2016-Jan',
+      start: '2015-12-01T00:00:00.000Z',
+      end: '2016-01-31T23:59:59.000Z'
+    });
+  });
+  it('2 months range from December, fr', () => {
+    expect(refineTimePeriod({ id: '2015-12/P2M' }, { locale: 'fr' })).to.deep.equal({
+      id: '2015-12/P2M',
+      name: 'déc. 2015 - janv. 2016',
+      start: '2015-12-01T00:00:00.000Z',
+      end: '2016-01-31T23:59:59.000Z'
+    });
+  });
+  it('5 months range from Feb 2', () => {
+    expect(refineTimePeriod({ id: '2015-02-02/P5M' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-02-02/P5M',
+      name: '2015-02-02 - 2015-07-01',
+      start: '2015-02-02T00:00:00.000Z',
+      end: '2015-07-01T23:59:59.000Z'
+    });
+  });
+  it('17 months range from Feb 2', () => {
+    expect(refineTimePeriod({ id: '2015-02-02/P17M' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-02-02/P17M',
+      name: '2015-02-02 - 2016-07-01',
+      start: '2015-02-02T00:00:00.000Z',
+      end: '2016-07-01T23:59:59.000Z'
+    });
+  });
+  it('5 months range from Feb 2 18h', () => {
+    expect(refineTimePeriod({ id: '2015-02-02T18:00:00/P5M' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-02-02T18:00:00/P5M',
+      name: '2015-02-02 18:00 - 2015-07-02 17:59',
+      start: '2015-02-02T18:00:00.000Z',
+      end: '2015-07-02T17:59:59.000Z'
+    });
+  });
+  it('17 months range from Feb 2', () => {
+    expect(refineTimePeriod({ id: '2015-02-02T18:00:00/P17M' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-02-02T18:00:00/P17M',
+      name: '2015-02-02 18:00 - 2016-07-02 17:59',
+      start: '2015-02-02T18:00:00.000Z',
+      end: '2016-07-02T17:59:59.000Z'
+    });
+  });
+  it('5 months range from Feb 2 18h25', () => {
+    expect(refineTimePeriod({ id: '2015-02-02T18:25:00/P5M' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-02-02T18:25:00/P5M',
+      name: '2015-02-02 18:25 - 2015-07-02 18:24',
+      start: '2015-02-02T18:25:00.000Z',
+      end: '2015-07-02T18:24:59.000Z'
+    });
+  });
+  it('5 months range from Feb 2 18h25m23', () => {
+    expect(refineTimePeriod({ id: '2015-02-02T18:25:23/P5M' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-02-02T18:25:23/P5M',
+      name: '2015-02-02 18:25:23 - 2015-07-02 18:25:22',
+      start: '2015-02-02T18:25:23.000Z',
+      end: '2015-07-02T18:25:22.000Z'
+    });
+  });
+  it('15 days range from 2015', () => {
+    expect(refineTimePeriod({ id: '2015/P15D' }, { locale: 'en' })).to.deep.equal({
+      id: '2015/P15D',
+      name: '2015-01-01 - 2015-01-15',
+      start: '2015-01-01T00:00:00.000Z',
+      end: '2015-01-15T23:59:59.000Z'
+    });
+  });
+  it('366 days range from 2015', () => {
+    expect(refineTimePeriod({ id: '2015/P366D' }, { locale: 'en' })).to.deep.equal({
+      id: '2015/P366D',
+      name: '2015-01-01 - 2016-01-01',
+      start: '2015-01-01T00:00:00.000Z',
+      end: '2016-01-01T23:59:59.000Z'
+    });
+  });
+  it('31 days range from 2015 May', () => {
+    expect(refineTimePeriod({ id: '2015-05/P31D' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-05/P31D',
+      name: '2015-05-01 - 2015-05-31',
+      start: '2015-05-01T00:00:00.000Z',
+      end: '2015-05-31T23:59:59.000Z'
+    });
+  });
+  it('33 days range from 2015 Dec', () => {
+    expect(refineTimePeriod({ id: '2015-12/P33D' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-12/P33D',
+      name: '2015-12-01 - 2016-01-02',
+      start: '2015-12-01T00:00:00.000Z',
+      end: '2016-01-02T23:59:59.000Z'
+    });
+  });
+  it('31 days range from 2015 May 23', () => {
+    expect(refineTimePeriod({ id: '2015-05-23/P31D' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-05-23/P31D',
+      name: '2015-05-23 - 2015-06-22',
+      start: '2015-05-23T00:00:00.000Z',
+      end: '2015-06-22T23:59:59.000Z'
+    });
+  });
+  it('33 days range from 2015 Dec 19', () => {
+    expect(refineTimePeriod({ id: '2015-12-19/P33D' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-12-19/P33D',
+      name: '2015-12-19 - 2016-01-20',
+      start: '2015-12-19T00:00:00.000Z',
+      end: '2016-01-20T23:59:59.000Z'
+    });
+  });
+  it('31 days range from 2015 May 23 05h', () => {
+    expect(refineTimePeriod({ id: '2015-05-23T05:00:00/P31D' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-05-23T05:00:00/P31D',
+      name: '2015-05-23 05:00 - 2015-06-23 04:59',
+      start: '2015-05-23T05:00:00.000Z',
+      end: '2015-06-23T04:59:59.000Z'
+    });
+  });
+  it('33 days range from 2015 Dec 19 12h', () => {
+    expect(refineTimePeriod({ id: '2015-12-19T12:00:00/P33D' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-12-19T12:00:00/P33D',
+      name: '2015-12-19 12:00 - 2016-01-21 11:59',
+      start: '2015-12-19T12:00:00.000Z',
+      end: '2016-01-21T11:59:59.000Z'
+    });
+  });
+  it('31 days range from 2015 May 23 05h32', () => {
+    expect(refineTimePeriod({ id: '2015-05-23T05:32:00/P31D' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-05-23T05:32:00/P31D',
+      name: '2015-05-23 05:32 - 2015-06-23 05:31',
+      start: '2015-05-23T05:32:00.000Z',
+      end: '2015-06-23T05:31:59.000Z'
+    });
+  });
+  it('33 days range from 2015 Dec 19 12h18', () => {
+    expect(refineTimePeriod({ id: '2015-12-19T12:18:00/P33D' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-12-19T12:18:00/P33D',
+      name: '2015-12-19 12:18 - 2016-01-21 12:17',
+      start: '2015-12-19T12:18:00.000Z',
+      end: '2016-01-21T12:17:59.000Z'
+    });
+  });
+  it('31 days range from 2015 May 23 05h32m15', () => {
+    expect(refineTimePeriod({ id: '2015-05-23T05:32:15/P31D' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-05-23T05:32:15/P31D',
+      name: '2015-05-23 05:32:15 - 2015-06-23 05:32:14',
+      start: '2015-05-23T05:32:15.000Z',
+      end: '2015-06-23T05:32:14.000Z'
+    });
+  });
+  it('33 days range from 2015 Dec 19 12h18m01', () => {
+    expect(refineTimePeriod({ id: '2015-12-19T12:18:01/P33D' }, { locale: 'en' })).to.deep.equal({
+      id: '2015-12-19T12:18:01/P33D',
+      name: '2015-12-19 12:18:01 - 2016-01-21 12:18:00',
+      start: '2015-12-19T12:18:01.000Z',
+      end: '2016-01-21T12:18:00.000Z'
+    });
+  });
+  it('4 hours range from 2016', () => {
+    expect(refineTimePeriod({ id: '2016/PT4H' }, { locale: 'en' })).to.deep.equal({
+      id: '2016/PT4H',
+      name: '2016-01-01 00:00 - 03:59',
+      start: '2016-01-01T00:00:00.000Z',
+      end: '2016-01-01T03:59:59.000Z'
+    });
+  });
+  it('32 hours range from 2016', () => {
+    expect(refineTimePeriod({ id: '2016/PT32H' }, { locale: 'en' })).to.deep.equal({
+      id: '2016/PT32H',
+      name: '2016-01-01 00:00 - 2016-01-02 07:59',
+      start: '2016-01-01T00:00:00.000Z',
+      end: '2016-01-02T07:59:59.000Z'
+    });
+  });
+  it('4 hours range from 2016 Jun', () => {
+    expect(refineTimePeriod({ id: '2016-06/PT4H' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-06/PT4H',
+      name: '2016-06-01 00:00 - 03:59',
+      start: '2016-06-01T00:00:00.000Z',
+      end: '2016-06-01T03:59:59.000Z'
+    });
+  });
+  it('32 hours range from 2016 Jun', () => {
+    expect(refineTimePeriod({ id: '2016-06/PT32H' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-06/PT32H',
+      name: '2016-06-01 00:00 - 2016-06-02 07:59',
+      start: '2016-06-01T00:00:00.000Z',
+      end: '2016-06-02T07:59:59.000Z'
+    });
+  });
+  it('4 hours range from 2016 Jun 28', () => {
+    expect(refineTimePeriod({ id: '2016-06-28/PT4H' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-06-28/PT4H',
+      name: '2016-06-28 00:00 - 03:59',
+      start: '2016-06-28T00:00:00.000Z',
+      end: '2016-06-28T03:59:59.000Z'
+    });
+  });
+  it('32 hours range from 2016 Jun 28', () => {
+    expect(refineTimePeriod({ id: '2016-06-28/PT32H' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-06-28/PT32H',
+      name: '2016-06-28 00:00 - 2016-06-29 07:59',
+      start: '2016-06-28T00:00:00.000Z',
+      end: '2016-06-29T07:59:59.000Z'
+    });
+  });
+  it('4 hours range from 2016 Jun 28 17h', () => {
+    expect(refineTimePeriod({ id: '2016-06-28T17:00:00/PT4H' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-06-28T17:00:00/PT4H',
+      name: '2016-06-28 17:00 - 20:59',
+      start: '2016-06-28T17:00:00.000Z',
+      end: '2016-06-28T20:59:59.000Z'
+    });
+  });
+  it('32 hours range from 2016 Jun 28 17h', () => {
+    expect(refineTimePeriod({ id: '2016-06-28T17:00:00/PT32H' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-06-28T17:00:00/PT32H',
+      name: '2016-06-28 17:00 - 2016-06-30 00:59',
+      start: '2016-06-28T17:00:00.000Z',
+      end: '2016-06-30T00:59:59.000Z'
+    });
+  });
+  it('4 hours range from 2016 Jun 28 17h38', () => {
+    expect(refineTimePeriod({ id: '2016-06-28T17:38:00/PT4H' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-06-28T17:38:00/PT4H',
+      name: '2016-06-28 17:38 - 21:37',
+      start: '2016-06-28T17:38:00.000Z',
+      end: '2016-06-28T21:37:59.000Z'
+    });
+  });
+  it('32 hours range from 2016 Jun 28 17h38', () => {
+    expect(refineTimePeriod({ id: '2016-06-28T17:38:00/PT32H' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-06-28T17:38:00/PT32H',
+      name: '2016-06-28 17:38 - 2016-06-30 01:37',
+      start: '2016-06-28T17:38:00.000Z',
+      end: '2016-06-30T01:37:59.000Z'
+    });
+  });
+  it('4 hours range from 2016 Jun 28 17h38m19', () => {
+    expect(refineTimePeriod({ id: '2016-06-28T17:38:19/PT4H' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-06-28T17:38:19/PT4H',
+      name: '2016-06-28 17:38:19 - 21:38:18',
+      start: '2016-06-28T17:38:19.000Z',
+      end: '2016-06-28T21:38:18.000Z'
+    });
+  });
+  it('32 hours range from 2016 Jun 28 17h38m19', () => {
+    expect(refineTimePeriod({ id: '2016-06-28T17:38:19/PT32H' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-06-28T17:38:19/PT32H',
+      name: '2016-06-28 17:38:19 - 2016-06-30 01:38:18',
+      start: '2016-06-28T17:38:19.000Z',
+      end: '2016-06-30T01:38:18.000Z'
+    });
+  });
+  it('17 minutes range from 2017', () => {
+    expect(refineTimePeriod({ id: '2017/PT17M' }, { locale: 'en' })).to.deep.equal({
+      id: '2017/PT17M',
+      name: '2017-01-01 00:00 - 00:16',
+      start: '2017-01-01T00:00:00.000Z',
+      end: '2017-01-01T00:16:59.000Z'
+    });
+  });
+  it('1446 minutes range from 2017', () => {
+    expect(refineTimePeriod({ id: '2017/PT1446M' }, { locale: 'en' })).to.deep.equal({
+      id: '2017/PT1446M',
+      name: '2017-01-01 00:00 - 2017-01-02 00:05',
+      start: '2017-01-01T00:00:00.000Z',
+      end: '2017-01-02T00:05:59.000Z'
+    });
+  });
+  it('17 minutes range from 2017 Aug', () => {
+    expect(refineTimePeriod({ id: '2017-08/PT17M' }, { locale: 'en' })).to.deep.equal({
+      id: '2017-08/PT17M',
+      name: '2017-08-01 00:00 - 00:16',
+      start: '2017-08-01T00:00:00.000Z',
+      end: '2017-08-01T00:16:59.000Z'
+    });
+  });
+  it('1446 minutes range from 2017 Aug', () => {
+    expect(refineTimePeriod({ id: '2017-08/PT1446M' }, { locale: 'en' })).to.deep.equal({
+      id: '2017-08/PT1446M',
+      name: '2017-08-01 00:00 - 2017-08-02 00:05',
+      start: '2017-08-01T00:00:00.000Z',
+      end: '2017-08-02T00:05:59.000Z'
+    });
+  });
+  it('17 minutes range from 2017 Aug 31', () => {
+    expect(refineTimePeriod({ id: '2017-08-31/PT17M' }, { locale: 'en' })).to.deep.equal({
+      id: '2017-08-31/PT17M',
+      name: '2017-08-31 00:00 - 00:16',
+      start: '2017-08-31T00:00:00.000Z',
+      end: '2017-08-31T00:16:59.000Z'
+    });
+  });
+  it('1446 minutes range from 2017 Aug 31', () => {
+    expect(refineTimePeriod({ id: '2017-08-31/PT1446M' }, { locale: 'en' })).to.deep.equal({
+      id: '2017-08-31/PT1446M',
+      name: '2017-08-31 00:00 - 2017-09-01 00:05',
+      start: '2017-08-31T00:00:00.000Z',
+      end: '2017-09-01T00:05:59.000Z'
+    });
+  });
+  it('17 minutes range from 2017 Aug 31 20h', () => {
+    expect(refineTimePeriod({ id: '2017-08-31T20:00:00/PT17M' }, { locale: 'en' })).to.deep.equal({
+      id: '2017-08-31T20:00:00/PT17M',
+      name: '2017-08-31 20:00 - 20:16',
+      start: '2017-08-31T20:00:00.000Z',
+      end: '2017-08-31T20:16:59.000Z'
+    });
+  });
+  it('1446 minutes range from 2017 Aug 31 20h', () => {
+    expect(refineTimePeriod({ id: '2017-08-31T20:00:00/PT1446M' }, { locale: 'en' })).to.deep.equal({
+      id: '2017-08-31T20:00:00/PT1446M',
+      name: '2017-08-31 20:00 - 2017-09-01 20:05',
+      start: '2017-08-31T20:00:00.000Z',
+      end: '2017-09-01T20:05:59.000Z'
+    });
+  });
+  it('17 minutes range from 2017 Aug 31 20h10', () => {
+    expect(refineTimePeriod({ id: '2017-08-31T20:10:00/PT17M' }, { locale: 'en' })).to.deep.equal({
+      id: '2017-08-31T20:10:00/PT17M',
+      name: '2017-08-31 20:10 - 20:26',
+      start: '2017-08-31T20:10:00.000Z',
+      end: '2017-08-31T20:26:59.000Z'
+    });
+  });
+  it('1446 minutes range from 2017 Aug 31 20h10', () => {
+    expect(refineTimePeriod({ id: '2017-08-31T20:10:00/PT1446M' }, { locale: 'en' })).to.deep.equal({
+      id: '2017-08-31T20:10:00/PT1446M',
+      name: '2017-08-31 20:10 - 2017-09-01 20:15',
+      start: '2017-08-31T20:10:00.000Z',
+      end: '2017-09-01T20:15:59.000Z'
+    });
+  });
+  it('17 minutes range from 2017 Aug 31 20h10m32', () => {
+    expect(refineTimePeriod({ id: '2017-08-31T20:10:32/PT17M' }, { locale: 'en' })).to.deep.equal({
+      id: '2017-08-31T20:10:32/PT17M',
+      name: '2017-08-31 20:10:32 - 20:27:31',
+      start: '2017-08-31T20:10:32.000Z',
+      end: '2017-08-31T20:27:31.000Z'
+    });
+  });
+  it('1446 minutes range from 2017 Aug 31 20h10m32', () => {
+    expect(refineTimePeriod({ id: '2017-08-31T20:10:32/PT1446M' }, { locale: 'en' })).to.deep.equal({
+      id: '2017-08-31T20:10:32/PT1446M',
+      name: '2017-08-31 20:10:32 - 2017-09-01 20:16:31',
+      start: '2017-08-31T20:10:32.000Z',
+      end: '2017-09-01T20:16:31.000Z'
+    });
+  });
+  it('25 seconds range from 2016', () => {
+    expect(refineTimePeriod({ id: '2016/PT25S' }, { locale: 'en' })).to.deep.equal({
+      id: '2016/PT25S',
+      name: '2016-01-01 00:00:00 - 00:00:24',
+      start: '2016-01-01T00:00:00.000Z',
+      end: '2016-01-01T00:00:24.000Z'
+    });
+  });
+  it('86.405 seconds range from 2016', () => {
+    expect(refineTimePeriod({ id: '2016/PT86405S' }, { locale: 'en' })).to.deep.equal({
+      id: '2016/PT86405S',
+      name: '2016-01-01 00:00:00 - 2016-01-02 00:00:04',
+      start: '2016-01-01T00:00:00.000Z',
+      end: '2016-01-02T00:00:04.000Z'
+    });
+  });
+  it('25 seconds range from 2016 Sep', () => {
+    expect(refineTimePeriod({ id: '2016-09/PT25S' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-09/PT25S',
+      name: '2016-09-01 00:00:00 - 00:00:24',
+      start: '2016-09-01T00:00:00.000Z',
+      end: '2016-09-01T00:00:24.000Z'
+    });
+  });
+  it('86.405 seconds range from 2016 Sep', () => {
+    expect(refineTimePeriod({ id: '2016-09/PT86405S' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-09/PT86405S',
+      name: '2016-09-01 00:00:00 - 2016-09-02 00:00:04',
+      start: '2016-09-01T00:00:00.000Z',
+      end: '2016-09-02T00:00:04.000Z'
+    });
+  });
+  it('25 seconds range from 2016 Sep 26', () => {
+    expect(refineTimePeriod({ id: '2016-09-26/PT25S' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-09-26/PT25S',
+      name: '2016-09-26 00:00:00 - 00:00:24',
+      start: '2016-09-26T00:00:00.000Z',
+      end: '2016-09-26T00:00:24.000Z'
+    });
+  });
+  it('86.405 seconds range from 2016 Sep 26', () => {
+    expect(refineTimePeriod({ id: '2016-09-26/PT86405S' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-09-26/PT86405S',
+      name: '2016-09-26 00:00:00 - 2016-09-27 00:00:04',
+      start: '2016-09-26T00:00:00.000Z',
+      end: '2016-09-27T00:00:04.000Z'
+    });
+  });
+  it('25 seconds range from 2016 Sep 26 14h', () => {
+    expect(refineTimePeriod({ id: '2016-09-26T14:00:00/PT25S' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-09-26T14:00:00/PT25S',
+      name: '2016-09-26 14:00:00 - 14:00:24',
+      start: '2016-09-26T14:00:00.000Z',
+      end: '2016-09-26T14:00:24.000Z'
+    });
+  });
+  it('86.405 seconds range from 2016 Sep 26 14h', () => {
+    expect(refineTimePeriod({ id: '2016-09-26T14:00:00/PT86405S' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-09-26T14:00:00/PT86405S',
+      name: '2016-09-26 14:00:00 - 2016-09-27 14:00:04',
+      start: '2016-09-26T14:00:00.000Z',
+      end: '2016-09-27T14:00:04.000Z'
+    });
+  });
+  it('25 seconds range from 2016 Sep 26 14h32', () => {
+    expect(refineTimePeriod({ id: '2016-09-26T14:32:00/PT25S' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-09-26T14:32:00/PT25S',
+      name: '2016-09-26 14:32:00 - 14:32:24',
+      start: '2016-09-26T14:32:00.000Z',
+      end: '2016-09-26T14:32:24.000Z'
+    });
+  });
+  it('86.405 seconds range from 2016 Sep 26 14h32', () => {
+    expect(refineTimePeriod({ id: '2016-09-26T14:32:00/PT86405S' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-09-26T14:32:00/PT86405S',
+      name: '2016-09-26 14:32:00 - 2016-09-27 14:32:04',
+      start: '2016-09-26T14:32:00.000Z',
+      end: '2016-09-27T14:32:04.000Z'
+    });
+  });
+  it('25 seconds range from 2016 Sep 26 14h32m10', () => {
+    expect(refineTimePeriod({ id: '2016-09-26T14:32:10/PT25S' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-09-26T14:32:10/PT25S',
+      name: '2016-09-26 14:32:10 - 14:32:34',
+      start: '2016-09-26T14:32:10.000Z',
+      end: '2016-09-26T14:32:34.000Z'
+    });
+  });
+  it('86.405 seconds range from 2016 Sep 26 14h32m10', () => {
+    expect(refineTimePeriod({ id: '2016-09-26T14:32:10/PT86405S' }, { locale: 'en' })).to.deep.equal({
+      id: '2016-09-26T14:32:10/PT86405S',
+      name: '2016-09-26 14:32:10 - 2016-09-27 14:32:14',
+      start: '2016-09-26T14:32:10.000Z',
+      end: '2016-09-27T14:32:14.000Z'
+    });
+  });
+});