@sis-cc/dotstatsuite-components 21.0.1 → 21.1.0

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

@@ -1,94 +0,0 @@
-import {
-  get, reject, map, reduce, head, findIndex, split, includes, has, each, size, find, keys,
-  isNil, filter
-} from 'lodash';
-import { dimensionValueDisplay } from '../dimension-utils';
-import { getFormatedObservation } from '../observation-formater';
-
-export function dimensionValueIsValid(dimensionValue, chartDimension) {
-  return includes(
-    map(['x', 'y'], k => get(chartDimension, `${k}Id`)),
-    get(dimensionValue, 'id')
-  );
-};
-
-export function getDimensionValues(
-  dimensionValuesIndexes, dimensions, dimensionsWithValuesIndexedById, chartDimensionId, display
-) {
-  const dimensionsWithValuesIds = keys(dimensionsWithValuesIndexedById);
-  return reduce(
-    dimensionValuesIndexes,
-    (m, dvi, i) => {
-      const dimension = get(dimensions, `[${i}]`);
-      const dimensionId = get(dimension, 'id');
-      const dimensionValue = get(dimension, `values[${dvi}]`);
-      if (dimensionId !== chartDimensionId && includes(dimensionsWithValuesIds, dimensionId)) {
-        m[dimensionId] = { ...dimensionValue, name: dimensionValueDisplay(display)(dimensionValue) };
-      }
-      return m;
-    },
-    {}
-  );
-};
-
-export function getDimensionValueKey(chartDimension, dimensionValue) {
-  return get(chartDimension, 'xId') === get(dimensionValue, 'id') ? 'x' : 'y';
-};
-
-export function datapoints(observations, dimensions, dimensionsWithValuesIndexedById, chartDimension, display, formaterAttrs) {
-  const chartDimensionId = get(chartDimension, 'id');
-  const chartDimensionIndex = findIndex(dimensions, { id: chartDimensionId });
-  const datapoints = reduce(
-    observations,
-    (m, o, k) => {
-      const oDimensionValuesIndexes = split(k, ':');
-      const oDimensionValueIndex = oDimensionValuesIndexes[chartDimensionIndex];
-      const oDimensionValue = get(
-        dimensions,
-        `[${chartDimensionIndex}].values[${oDimensionValueIndex}]`
-      );
-      if (dimensionValueIsValid(oDimensionValue, chartDimension)) {
-        const oPartialKey = reject(
-          oDimensionValuesIndexes,
-          (o, i) => i === chartDimensionIndex
-        ).join('');
-        if (!has(m, oPartialKey)) {
-          const dimensionValues = getDimensionValues(
-            oDimensionValuesIndexes, dimensions, dimensionsWithValuesIndexedById, chartDimensionId, display
-          );
-          m[oPartialKey] = { dimensionValues };
-        }
-        const dimensionValueKey = getDimensionValueKey(chartDimension, oDimensionValue);
-        m[oPartialKey][dimensionValueKey] = head(o);
-        m[oPartialKey][`${dimensionValueKey}Format`] = getFormatedObservation(o, formaterAttrs);
-      }
-      return m;
-    },
-    {}
-  );
-  // it is possible to have null observations or incomplete datapoints (just an x or y)
-  return filter(
-    datapoints,
-    dp => ((!isNil(dp.x)) && (!isNil(dp.y)))
-  );
-};
-
-export const series = (observations, dimensions, dimensionsWithValuesIndexedById, chartDimension, display, formaterAttrs) => {
-  // the 2 following lines may sound absurd but we could have 2 dimensions involved
-  // and not only 1 as first specified...
-  const xValues = get(dimensionsWithValuesIndexedById, `${get(chartDimension, 'id')}.values`, []);
-  const yValues = get(dimensionsWithValuesIndexedById, `${get(chartDimension, 'id')}.values`, []);
-  const xValue = find(xValues, { id: get(chartDimension, 'xId') });
-  const yValue = find(yValues, { id: get(chartDimension, 'yId') });
-  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

@@ -1,29 +0,0 @@
-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

@@ -1,185 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

@@ -1,134 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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);
-};