@sis-cc/dotstatsuite-components 22.0.1 → 22.0.2

package/src/rules/src/factories/scatter-series.js

@@ -0,0 +1,92 @@
+import * as R from 'ramda';
+import { dimensionValueDisplay } from '../dimension-utils';
+import { getFormatedObservation } from '../observation-formater';
+
+export function dimensionValueIsValid(dimensionValue, chartDimension) {
+  return R.includes(
+    R.prop('id', dimensionValue),
+    R.map(k => R.prop(`${k}Id`, chartDimension), ['x', 'y']),
+  );
+};
+
+export function getDimensionValues(
+  dimensionValuesIndexes, dimensions, dimensionsWithValuesIndexedById, chartDimensionId, display
+) {
+  const dimensionsWithValuesIds = R.keys(dimensionsWithValuesIndexedById);
+  return R.addIndex(R.reduce)(
+    (acc, dvi, i) => {
+      const dimension = R.nth(i, dimensions);
+      const dimensionId = R.prop('id', dimension);
+      const dimensionValue = R.nth(dvi, R.propOr([], 'values', dimension || {}));
+      if (dimensionId !== chartDimensionId && R.includes(dimensionId, dimensionsWithValuesIds)) {
+        return R.assoc(
+          dimensionId,
+          { ...dimensionValue, name: dimensionValueDisplay(display)(dimensionValue) },
+          acc
+        );
+      }
+      return acc;
+    },
+    {},
+    dimensionValuesIndexes,
+  );
+};
+
+export function getDimensionValueKey(chartDimension, dimensionValue) {
+  return R.prop('xId', chartDimension,) === R.prop('id', dimensionValue) ? 'x' : 'y';
+};
+
+export function datapoints(observations, dimensions, dimensionsWithValuesIndexedById, chartDimension, display, formaterAttrs) {
+  const chartDimensionId = R.prop('id', chartDimension);
+  const chartDimensionIndex = R.findIndex(R.propEq('id', chartDimensionId), dimensions);
+  const datapoints = R.reduce(
+    (acc, k) => {
+      const o = R.prop(k, observations);
+      const oDimensionValuesIndexes = R.split(':', k);
+      const oDimensionValueIndex = oDimensionValuesIndexes[chartDimensionIndex];
+      const _chartDimension = R.nth(chartDimensionIndex, dimensions);
+      const oDimensionValue = R.nth(oDimensionValueIndex, R.propOr([], 'values', _chartDimension || {}));
+      if (dimensionValueIsValid(oDimensionValue, chartDimension)) {
+        const oPartialKey = R.pipe(
+          R.addIndex(R.reject)((_, i) => i === chartDimensionIndex),
+          R.join(':'),
+        )(oDimensionValuesIndexes);
+        
+        if (!R.has(oPartialKey, acc)) {
+          const dimensionValues = getDimensionValues(
+            oDimensionValuesIndexes, dimensions, dimensionsWithValuesIndexedById, chartDimensionId, display
+          );
+          acc[oPartialKey] = { dimensionValues };
+        }
+        const dimensionValueKey = getDimensionValueKey(chartDimension, oDimensionValue);
+        acc[oPartialKey][dimensionValueKey] = R.head(o);
+        acc[oPartialKey][`${dimensionValueKey}Format`] = getFormatedObservation(o, formaterAttrs);
+      }
+      return acc;
+    },
+    {},
+    R.keys(observations),
+  );
+  // it is possible to have null observations or incomplete datapoints (just an x or y)
+  return R.pipe(
+    R.filter(dp => ((!R.isNil(dp.x)) && (!R.isNil(dp.y)))),
+    R.values
+  )(datapoints);
+};
+
+export const series = (observations, dimensions, dimensionsWithValuesIndexedById, chartDimension, display, formaterAttrs) => {
+  const values = R.pipe(R.prop(R.prop('id', chartDimension || {})), R.propOr([], 'values'))(dimensionsWithValuesIndexedById);
+  const xValue = R.find(R.propEq('id', R.prop('xId', chartDimension)), values);
+  const yValue = R.find(R.propEq('id', R.prop('yId', chartDimension)), values);
+  return [{
+    dimensionValues: {
+      x: { ...xValue, name: dimensionValueDisplay(display)(xValue) },
+      y: { ...yValue, name: dimensionValueDisplay(display)(yValue) }
+    },
+    datapoints: datapoints(observations, dimensions, dimensionsWithValuesIndexedById, chartDimension, display, formaterAttrs)
+  }]
+};
+
+export default ({ observations, dimensions }, dimensionsWithValuesIndexedById, chartDimension, display, formaterAttrs) => (
+  series(observations, dimensions, dimensionsWithValuesIndexedById, chartDimension, display, formaterAttrs)
+);

package/src/rules/src/factories/stacked-dimension.js

@@ -0,0 +1,29 @@
+import * as R from 'ramda';
+import { getRefAreaDimension, getTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
+
+export default (dimensions, singularity) => {
+  const { value, values } = dimensions;
+  const mode = R.prop('mode', singularity) === 'percent' ? 'percent' : 'values';
+  if (R.length(values) === 1) {
+    return ({
+      limit: R.propOr(Infinity, 'limit', singularity),
+      mode,
+      id: R.pathOr(null, [0, 'id'], value)
+    });
+  }
+  let serieDimension = null;
+  const id = R.prop('id', singularity);
+  if (!R.isNil(id)) {
+    serieDimension = R.find(R.propEq('id', id), values);
+  }
+  const areaDimension = getRefAreaDimension({ dimensions: values });
+  const timeDimension = getTimePeriodDimension({ dimensions: values });
+
+  serieDimension = serieDimension || areaDimension || timeDimension || R.head(values);
+
+  return ({
+    limit: R.propOr(Infinity, 'limit', singularity),
+    mode,
+    id: R.propOr(null, 'id', serieDimension)
+  });
+}

package/src/rules/src/factories/stacked-series.js

@@ -0,0 +1,185 @@
+import { isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
+import { dimensionValueDisplay } from '../dimension-utils';
+import { getObservationFormater } from '../observation-formater';
+import * as R from 'ramda';
+
+const flatDatapoints = (
+  observations,
+  dimensions,
+  dimensionsWithValuesIndexedById,
+  serieDimensionId,
+  display,
+  formaterAttrs,
+  [stackKey, categoryKey]
+) => {
+  const datapoints = R.mapObjIndexed(
+    (observationValue, observationKey) => {
+      let category = null;
+      const value = Number(R.head(observationValue));
+      const formater = getObservationFormater(observationValue, formaterAttrs);
+      const splittedKey = R.split(':', observationKey);
+      let layerKey = [];
+      const layerDimensions = R.addIndex(R.reduce)(
+        (memo, dimensionValueIndex, dimensionIndex) => {
+          const dimension = R.nth(dimensionIndex, dimensions);
+          const _dimensionValue = R.pathOr({}, ['values', Number(dimensionValueIndex)], dimension);
+          const label = dimensionValueDisplay(display)(_dimensionValue);
+          const dimensionValue = {
+            ..._dimensionValue,
+            index: Number(dimensionValueIndex),
+            label
+          };
+          if (dimension.id === serieDimensionId) {
+            category = dimensionValue;
+          }
+          else if (R.has(dimension.id, dimensionsWithValuesIndexedById)) {
+            memo.push(dimensionValue);
+            layerKey.push(dimensionValueIndex);
+          }
+          return memo;
+        },
+        [],
+        splittedKey
+      );
+      return ({
+        formater,
+        [categoryKey]: category,
+        [stackKey]: value,
+        layerDimensions,
+        layerKey: R.join(':', layerKey)
+      });
+    },
+    observations
+  );
+
+  return R.values(datapoints);
+};
+
+const serie = (
+  observations,
+  dimensions,
+  dimensionsWithValuesIndexedById,
+  singularity,
+  display,
+  formaterAttrs,
+  [stackKey, categoryKey]
+) => {
+  const serieDimensionId = R.propOr(null, 'id', singularity);
+  const serieDimension = R.find(R.propEq('id', serieDimensionId), dimensions);
+  if (R.isNil(serieDimension)) {
+    return { datapoints: [], layerSeries: [] };
+  }
+  const _flatDatapoints = flatDatapoints(observations, dimensions, dimensionsWithValuesIndexedById, serieDimensionId, display, formaterAttrs, [stackKey, categoryKey]);
+
+  const layeredDatapoints = R.groupBy(
+    R.prop('layerKey'),
+    _flatDatapoints
+  ); // { [layeredKey]: [dps] }
+
+  const layerFullSeries = R.map(
+    datapoints => ({
+      layerDimensions: R.prop('layerDimensions', R.head(datapoints)),
+      layerKey: R.prop('layerKey', R.head(datapoints))
+    }),
+    R.values(layeredDatapoints)
+  ); // [{ layerDimensions, layerKey }]
+
+  const layerLimit = R.propOr(Infinity, 'limit', singularity);
+  const layerSeries = R.take(layerLimit, R.sortBy(R.prop('layerKey'), layerFullSeries));
+
+  const layeredDatapointsKeyedByCategory = R.mapObjIndexed(
+    R.indexBy(R.path([categoryKey, 'id'])),
+    layeredDatapoints
+  ); // { [layeredKey]: { [x.id]: dp } }
+
+  const datapoints = R.addIndex(R.map)(
+    (serieValue, index) => {
+      const serieValueId = serieValue.id;
+      const category = dimensionValueDisplay(display)(serieValue);
+      const values = R.map(
+        ({ layerKey }) => R.pathOr(null, [layerKey, serieValueId, stackKey], layeredDatapointsKeyedByCategory),
+        layerSeries,
+      );
+      const formaters = R.map(
+        ({ layerKey }) => R.pathOr(null, [layerKey, serieValueId, 'formater'], layeredDatapointsKeyedByCategory),
+        layerSeries,
+      );
+      return ({ category, formaters, index, [categoryKey]: category, [stackKey]: values, key: serieValueId });
+    },
+    serieDimension.values
+  );
+
+  const _datapoints = R.when(
+    R.pipe(R.length, R.equals(1)),
+    R.pipe(
+      R.set(R.lensPath([0, 'category']), ''),
+      R.set(R.lensPath([0, categoryKey]), ''),
+    ),
+    datapoints
+  );
+
+  return ({
+    datapoints: _datapoints,
+    layerSeries: R.map(
+      layer => ({
+        id: R.pipe(R.prop('layerDimensions'), R.pluck('id'), R.join(' - '))(layer),
+        label: R.pipe(R.prop('layerDimensions'), R.pluck('label'), R.join(' - '))(layer),
+      }),
+      layerSeries
+    )
+  });
+};
+
+const percentSerie = (stackKey) => R.pipe(
+  R.over(
+    R.lensProp('datapoints'),
+    R.map(dp => {
+      const total = R.pipe(R.map(v => Math.abs(v)), R.sum)(dp[stackKey]);
+      if (!total) {
+        return dp;
+      }
+      return ({
+        ...dp,
+        [stackKey]: R.map(v => (Math.abs(v) / total) * 100, dp[stackKey]),
+        formaters: null,
+      });
+    })
+  ),
+  R.of
+);
+
+const serieSortedByTotal = (stackKey) => R.pipe(
+  R.over(
+    R.lensProp('datapoints'),
+    R.sortBy(R.pipe(R.prop(stackKey), R.map(v => v > 0 ? R.negate(v) : 0), R.sum))
+  ),
+  R.of
+);
+
+const serieSortedByDataOrder = R.pipe(
+  R.over(
+    R.lensProp('datapoints'),
+    R.sortBy(R.prop('index'))
+  ),
+  R.of
+);
+
+export default (
+  { observations, dimensions },
+  dimensionsWithValuesIndexedById,
+  singularity,
+  display,
+  formaterAttrs,
+  [stackKey, categoryKey]
+) => {
+  const mode = R.propOr('values', 'mode', singularity);
+  const serieDimensionId = R.propOr(null, 'id', singularity);
+  const _serie = serie(observations, dimensions, dimensionsWithValuesIndexedById, singularity, display, formaterAttrs, [stackKey, categoryKey]);
+  if (mode === 'percent') {
+    return percentSerie(stackKey)(_serie);
+  }
+  else if (isTimePeriodDimension({ id: serieDimensionId })) {
+    return serieSortedByDataOrder(_serie);
+  }
+  return serieSortedByTotal(stackKey)(_serie);
+};

package/src/rules/src/factories/symbol-dimension.js

@@ -0,0 +1,29 @@
+import { find, get, head, isEmpty, isUndefined, isNil, reject, take } from 'lodash';
+import { isRefAreaDimension, isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
+
+export default (dimensions, ids) => {
+  if (isEmpty(dimensions)) return;
+
+  let symbolDimension = undefined;
+  const id = get(ids, 'id');
+  if (!isNil(id)) symbolDimension = find(dimensions, { id });
+
+  if (isUndefined(symbolDimension)) {
+    const isAreaOrTimeDimension = d => isRefAreaDimension(d) || isTimePeriodDimension(d);
+    const _dimensions1 = reject(dimensions, isAreaOrTimeDimension);
+    const _dimensions2 = reject(dimensions, isRefAreaDimension);
+    if (isEmpty(_dimensions1)) {
+      symbolDimension = head(isEmpty(_dimensions2) ? dimensions : _dimensions2);
+    }
+    else {
+      symbolDimension = head(_dimensions1);
+    }
+  }
+
+  const symbolDimensionId = get(symbolDimension, 'id');
+
+  return {
+    id: symbolDimensionId,
+    serie: take(symbolDimension.values, 5)
+  };
+}

package/src/rules/src/factories/symbol-series.js

@@ -0,0 +1,62 @@
+import { fill, findIndex, get, head, isEmpty, isNil, map, reduce, split, size, sortBy } from 'lodash';
+import { categoryDisplay, dimensionValueDisplay } from '../dimension-utils';
+import { getFormatedObservation } from '../observation-formater';
+
+const series = (observations, dimensions, dimensionsWithValuesIndexedById, symbolDimension, sortDirection, display, formaterAttrs) => {
+  const symbolDimensionId = get(symbolDimension, 'id', null);
+  if (symbolDimensionId === null) return [];
+  const symbolDimensionIndex = findIndex(dimensions, d => d.id === symbolDimensionId);
+  const datapoints = sortBy(
+    reduce(
+      observations,
+      (memo, observationValue, observationKey) => {
+        if (!(head(observationValue))) {
+          // because yes it is possible to have null observations, why not ...
+          return memo;
+        }
+        const oDimensionValuesIndexes = split(observationKey, ':');
+        const oSymbolDimensionValueIndex = Number(oDimensionValuesIndexes[symbolDimensionIndex]);
+        const oSymbolDimensionValueId = dimensions[symbolDimensionIndex].values[oSymbolDimensionValueIndex].id;
+
+        const symbolIndex = findIndex(symbolDimension.serie, v => v.id === oSymbolDimensionValueId);
+        if (symbolIndex === -1) {
+          return memo;
+        }
+        const category = categoryDisplay(oDimensionValuesIndexes, dimensions, dimensionsWithValuesIndexedById, symbolDimensionId, display);
+        const ids = categoryDisplay(oDimensionValuesIndexes, dimensions, dimensionsWithValuesIndexedById, symbolDimensionId, 'code');
+        let dpIndex = findIndex(memo, dp => dp.key === ids);
+        let dpValues = (dpIndex === -1) ? fill(Array(size(symbolDimension.serie)), null) : memo[dpIndex].values;
+        let dpFormatedValues = (dpIndex === -1) ? fill(Array(size(symbolDimension.serie)), null) : memo[dpIndex].formatedValues;
+        dpValues[oSymbolDimensionValueIndex] = head(observationValue);
+        dpFormatedValues[oSymbolDimensionValueIndex] = getFormatedObservation(observationValue, formaterAttrs);
+        let key = ids;
+        if (isNil(ids) || isEmpty(ids)) {
+          key = 'uniq-dp';
+        }
+        if (dpIndex !== -1) {
+          memo[dpIndex].values = dpValues;
+          memo[dpIndex].formatedValues = dpFormatedValues;
+        }
+        else {
+          memo.push({ category, formatedValues: dpFormatedValues, values: dpValues, key });
+        }
+        return memo;
+      },
+      []
+    ),
+    d => head(d.values) * sortDirection
+  );
+  const symbolValues = map(symbolDimension.serie, v => dimensionValueDisplay(display)(v));
+  return [{ datapoints , symbolValues }];
+}
+
+export default ({ observations, dimensions }, chartType, dimensionsWithValuesIndexedById, symbolDimension, display, formaterAttrs) => {
+  switch(chartType) {
+    case 'HorizontalSymbolChart':
+      return series(observations, dimensions, dimensionsWithValuesIndexedById, symbolDimension, -1, display, formaterAttrs);
+    case 'VerticalSymbolChart':
+      return series(observations, dimensions, dimensionsWithValuesIndexedById, symbolDimension, 1, display, formaterAttrs);
+    default:
+      return [];
+  }
+}

package/src/rules/src/factories/timeline-focus.js

@@ -0,0 +1,18 @@
+import { map, each, findIndex, get, omit, isArray, keys } from 'lodash';
+
+export default function focus(series, focusSelections) {
+  return map(
+    series,
+    (serie, index) => {
+      each(focusSelections, (focusSelection, focusKey) => {
+        const _focusKey = `${focusKey}Index`;
+        const res = findIndex(
+          isArray(focusSelection) ? focusSelection : [focusSelection],
+          focus => focus.value === serie.key
+        );
+        serie[`${_focusKey}`] = res;
+      });
+      return serie;
+    }
+  );
+}

package/src/rules/src/factories/timeline-series.js

@@ -0,0 +1,91 @@
+import { findIndex, get, has, head, isEmpty, isNil, map, reduce, sortBy, split } from 'lodash';
+import { getTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
+import { categoryDisplay, dimensionValueDisplayAt } from '../dimension-utils';
+import { getFormatedObservation } from '../observation-formater';
+
+const getDimensionValues = (splitObservationKey, dimensions, dimensionsWithValuesIndexedById, rejectedId, display) => (
+  reduce(
+    splitObservationKey,
+    (memo, dimensionValueIndex, dimensionIndex) => {
+      const dimension = get(dimensions, `[${dimensionIndex}]`, {});
+      if (has(dimensionsWithValuesIndexedById, dimension.id) && dimension.id !== rejectedId) {
+        const dimensionValue = get(dimension, `values[${dimensionValueIndex}]`, {});
+        memo[dimensionValue.id] = {
+          ...dimensionValue,
+          name: dimensionValueDisplayAt(dimension, dimensionValueIndex, display)
+        }
+      }
+      return memo;
+    },
+    {}
+  )
+);
+
+const series = (
+  observations, dimensions,
+  dimensionsWithValuesIndexedById,
+  timePeriodDimensionIndex,
+  display, formaterAttrs
+) => {
+  const rawSeries = reduce(
+    observations,
+    (memo, o, k) => {
+      const oDimensionValuesIndexes = split(k, ':');
+
+      const timePeriodDimension = get(dimensions, `[${timePeriodDimensionIndex}]`);
+      const timePeriodDimensionValueIndex = oDimensionValuesIndexes[timePeriodDimensionIndex];
+      const timePeriod = get(timePeriodDimension, `values[${timePeriodDimensionValueIndex}]`);
+
+      const datapoint = {
+        x: timePeriod.start,
+        y: head(o),
+        timeLabel: timePeriod.name,
+        formatedValue: getFormatedObservation(o, formaterAttrs),
+        dimensionValues: getDimensionValues(
+          oDimensionValuesIndexes, dimensions, dimensionsWithValuesIndexedById, timePeriodDimension.id, display
+        ),
+        //index: Number(timePeriodDimensionValueIndex)
+      };
+
+      const category = categoryDisplay(
+        oDimensionValuesIndexes, dimensions, dimensionsWithValuesIndexedById, timePeriodDimension.id, display
+      );
+      let key = categoryDisplay(
+        oDimensionValuesIndexes, dimensions, dimensionsWithValuesIndexedById, timePeriodDimension.id, 'code'
+      );
+      if (isNil(key) || isEmpty(key)) {
+        key = 'uniq-dp';
+      }
+      const serieIndex = findIndex(memo, serie => serie.key === key);
+
+      if (serieIndex !== -1) memo[serieIndex].datapoints.push(datapoint);
+      else memo.push({ datapoints: [datapoint], category, key });
+
+      return memo;
+    },
+    []
+  );
+  return map(
+    rawSeries,
+    serie => ({
+      ...serie,
+      datapoints: sortBy(
+        serie.datapoints,
+        datapoint => datapoint.x
+      )
+    })
+  );
+};
+
+export default ({ observations, dimensions }, dimensionsWithValuesIndexedById, display, formaterAttrs) => {
+  const timePeriodDimension = getTimePeriodDimension({ dimensions });
+  const timePeriodDimensionIndex = timePeriodDimension ? timePeriodDimension.index : -1;
+  const timePeriodDimensionHasManyPeriods = !has(dimensionsWithValuesIndexedById, get(timePeriodDimension, 'id'));
+  if ((timePeriodDimensionIndex === -1) || timePeriodDimensionHasManyPeriods) return [];
+  
+  return series(
+    observations, dimensions,
+    dimensionsWithValuesIndexedById,
+    timePeriodDimensionIndex, display, formaterAttrs
+  );
+};

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

@@ -0,0 +1,134 @@
+import * as R from 'ramda';
+import dateFns from 'date-fns';
+import { getCodeOrder } 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 R.prop('name')(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 = {},
+  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 = R.has(`${parent}.${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,
+        flags: notes,
+        __indexPosition,
+        __index,
+        isNonCoded: isNonCoded(value),
+      };
+      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) => 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/header/getDefaultSubtitle.js

@@ -0,0 +1,40 @@
+import * as R from 'ramda';
+import { dimensionValueDisplay, getFlags, parseDisplay } from '../';
+import { DEFAULT_REJECTED_SUBTITLE_IDS } from '../constants';
+
+export const getDefaultSubtitle = ({ customAttributes, dimensions, display, units }) =>  {
+  const _display = parseDisplay(display);
+  const formatter = dimensionValueDisplay(_display);
+  const _getFlags =  getFlags(customAttributes, formatter, {});
+  const unitsValuesIds = R.pipe(R.propOr([], 'values'), R.pluck('id'))(units);
+  
+  return R.pipe(
+    R.propOr([], 'one'),
+    R.values,
+    R.sortBy(R.prop('__index')),
+    R.reduce(
+      (acc, dim) => {
+        if (!R.propOr(true, 'display', dim)) {
+          return acc;
+        }
+        if (R.includes(dim.id, unitsValuesIds)) {
+          return acc;
+        }
+        const value = R.path(['values', 0], dim);
+
+        if (R.includes(value.id, DEFAULT_REJECTED_SUBTITLE_IDS) || !R.propOr(true, 'display', value)) {
+          return acc;
+        }
+
+        const flags = _getFlags({ attributes: R.propOr({}, 'attributes', value), notes: R.propOr([], 'notes', value) });
+
+        return R.append({
+          header: `${formatter(dim)}:`,
+          label: formatter(value),
+          flags
+        }, acc);
+      },
+      []
+    )
+  )(dimensions);
+};