@sis-cc/dotstatsuite-components 23.2.0 → 24.0.0

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

@@ -1,92 +0,0 @@
-import * as R from 'ramda';
-import { dimensionValueDisplay } from '../dimension-utils';
-import { getFormatedObservation } from '../observation-formater';
-
-function dimensionValueIsValid(dimensionValue, chartDimension) {
-  return R.includes(
-    R.prop('id', dimensionValue),
-    R.map(k => R.prop(`${k}Id`, chartDimension), ['x', 'y']),
-  );
-};
-
-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,
-  );
-};
-
-function getDimensionValueKey(chartDimension, dimensionValue) {
-  return R.prop('xId', chartDimension,) === R.prop('id', dimensionValue) ? 'x' : 'y';
-};
-
-function datapoints(observations, dimensions, dimensionsWithValuesIndexedById, chartDimension, display, formaterAttrs) {
-  const chartDimensionId = R.prop('id', chartDimension);
-  const chartDimensionIndex = R.findIndex(R.propEq(chartDimensionId, 'id'), 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);
-};
-
-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(R.prop('xId', chartDimension),'id'), values);
-  const yValue = R.find(R.propEq(R.prop('yId', chartDimension), 'id'), 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/series.js

@@ -1,45 +0,0 @@
-import * as R from 'ramda';
-import sampleSeries from './sample-series';
-import scatterSeries from './scatter-series';
-import timelineSeries from './timeline-series';
-import symbolSeries from './symbol-series';
-import stackedSeries from './stacked-series';
-import choroSeries from './choro-series';
-import { getObservationsFormaterAttributes } from '../observation-formater';
-
-export default ({ type, data, options, singularity }) => {
-  const {
-    display,
-    formatterIds,
-    map,
-  } = options;
-
-  const { attributes = [] } = data;
-  const formaterAttributes = getObservationsFormaterAttributes(attributes, formatterIds);
-
-  const indexedDimensions = R.reduce((acc, dim) => {
-    if (dim.header) {
-      return acc;
-    }
-    return R.assoc(dim.id, dim, acc);
-  }, {}, data.dimensions || []);
-
-  switch(type) {
-    case 'BarChart': case 'RowChart':
-      return sampleSeries(type, data, indexedDimensions, display, formaterAttributes);
-    case 'ScatterChart':
-      return scatterSeries(data, indexedDimensions, singularity, display, formaterAttributes);
-    case 'TimelineChart':
-      return timelineSeries(data, indexedDimensions, display, formaterAttributes);
-    case 'HorizontalSymbolChart': case 'VerticalSymbolChart':
-      return symbolSeries(data, type, indexedDimensions, singularity, display, formaterAttributes);
-    case 'StackedBarChart':
-      return stackedSeries(data, indexedDimensions, singularity, display, formaterAttributes, ['y', 'x']);
-    case 'StackedRowChart':
-      return stackedSeries(data, indexedDimensions, singularity, display, formaterAttributes, ['x', 'y']);
-    case 'ChoroplethChart':
-      return choroSeries(data, indexedDimensions, map, display);
-    default:
-      return [];
-  }
-};

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

@@ -1,184 +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(serieDimensionId, 'id'), 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,
-      });
-    })
-  ),
-  res => R.of(Array, res)
-);
-
-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))
-  ),
-  res => R.of(Array, res)
-);
-
-const serieSortedByDataOrder = R.pipe(
-  R.over(
-    R.lensProp('datapoints'),
-    R.sortBy(R.prop('index'))
-  ),
-  res => R.of(Array, res)
-);
-
-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-series.js

@@ -1,55 +0,0 @@
-import * as R from 'ramda';
-import { categoryDisplay, dimensionValueDisplay } from '../dimension-utils';
-import { getFormatedObservation } from '../observation-formater';
-
-const series = (observations, dimensions, dimensionsWithValuesIndexedById, symbolDimension, sortDirection, display, formaterAttrs) => {
-  const symbolDimensionId = R.propOr(null, 'id', symbolDimension);
-  if (symbolDimensionId === null)
-    return [];
-  const symbolDimIndex = R.findIndex(d => d.id === symbolDimensionId, dimensions);
-  const datapoints = R.pipe(
-    R.keys,
-    R.reduce((acc, obsKey) => {
-      const obs = observations[obsKey];
-      if (R.isNil(R.head(obs)) || R.isEmpty(R.head(obs))) {
-        return acc;
-      }
-      const obsDimsValsIndexes = R.split(':', obsKey);
-      const symbolValIndex = Number(R.nth(symbolDimIndex, obsDimsValsIndexes));
-      const symbolValId = R.path([symbolDimIndex, 'values', symbolValIndex, 'id'], dimensions);
-      const symbolIndex = R.findIndex(R.propEq(symbolValId, 'id'), symbolDimension.serie);
-      if (symbolIndex === -1) {
-        return acc;
-      }
-      const category = categoryDisplay(obsDimsValsIndexes, dimensions, dimensionsWithValuesIndexedById, symbolDimensionId, display);
-      const ids = categoryDisplay(obsDimsValsIndexes, dimensions, dimensionsWithValuesIndexedById, symbolDimensionId, 'code');
-      const key = R.isNil(ids) || R.isEmpty(ids) ? 'uniq-dp' : ids;
-      const dpIndex = R.findIndex(R.propEq(key, 'key'), acc);
-      const dp = R.pipe(
-        dpIndex => dpIndex === -1
-          ? { category, formatedValues: new Array(R.length(symbolDimension.serie)), values: new Array(R.length(symbolDimension.serie)), key }
-          : R.nth(dpIndex, acc),
-        R.set(R.lensPath(['values', symbolValIndex]), R.head(obs)),
-        R.set(R.lensPath(['formatedValues', symbolValIndex]), getFormatedObservation(obs, formaterAttrs)),
-      )(dpIndex);
-      return dpIndex === -1
-        ? R.append(dp, acc)
-        : R.set(R.lensIndex(dpIndex), dp, acc);
-    }, []),
-    R.sortBy(d => R.head(d.values) * sortDirection)
-  )(observations);
-
-  const symbolValues = R.map(dimensionValueDisplay(display), symbolDimension.serie);
-  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,14 +0,0 @@
-import * as R from 'ramda';
-
-export default function focus(series, focusSelections) {
-  const { highlight = [], baseline = [] } = focusSelections || {};
-
-  return R.map(
-    serie => ({
-      ...serie,
-      highlightIndex: R.findIndex(R.propEq(serie.key, 'value'), highlight),
-      baselineIndex: R.path([0, 'value'], baseline) === serie.key ? 0 : -1
-    }),
-    series
-  );
-}

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

@@ -1,87 +0,0 @@
-import * as R from 'ramda';
-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) => (
-  R.addIndex(R.reduce)(
-    (acc, dimensionValueIndex, dimensionIndex) => {
-      const dimension = R.nth(dimensionIndex, dimensions) || {};
-      if (R.has(dimension.id, dimensionsWithValuesIndexedById) && dimension.id !== rejectedId) {
-        const dimensionValue = R.pathOr({}, ['values', dimensionValueIndex], dimension);
-        return R.set(
-          R.lensPath([dimensionValue.id, 'name']),
-          dimensionValueDisplayAt(dimension, dimensionValueIndex, display),
-          acc
-        );
-      }
-      return acc;
-    },
-    {},
-    splitObservationKey,
-  )
-);
-
-const series = (
-  observations, dimensions,
-  dimensionsWithValuesIndexedById,
-  timePeriodDimensionIndex,
-  display, formaterAttrs
-) => {
-  const rawSeries = R.reduce(
-    (acc, k) => {
-      const o = observations[k];
-      const oDimensionValuesIndexes = R.split(':', k);
-
-      const timePeriodDimension = R.nth(timePeriodDimensionIndex, dimensions);
-      const timePeriodDimensionValueIndex = R.nth(timePeriodDimensionIndex, oDimensionValuesIndexes);
-      const timePeriod = R.path(['values', timePeriodDimensionValueIndex], timePeriodDimension);
-
-      const datapoint = {
-        x: timePeriod.start,
-        y: R.head(o),
-        timeLabel: timePeriod.name,
-        formatedValue: getFormatedObservation(o, formaterAttrs),
-        dimensionValues: getDimensionValues(
-          oDimensionValuesIndexes, dimensions, dimensionsWithValuesIndexedById, timePeriodDimension.id, display
-        ),
-      };
-
-      const category = categoryDisplay(
-        oDimensionValuesIndexes, dimensions, dimensionsWithValuesIndexedById, timePeriodDimension.id, display
-      );
-      let key = categoryDisplay(
-        oDimensionValuesIndexes, dimensions, dimensionsWithValuesIndexedById, timePeriodDimension.id, 'code'
-      );
-      if (R.isNil(key) || R.isEmpty(key)) {
-        key = 'uniq-dp';
-      }
-      const serieIndex = R.findIndex(serie => serie.key === key, acc);
-
-      if (serieIndex !== -1)
-        return R.over(R.lensPath([serieIndex, 'datapoints']), R.append(datapoint), acc);
-
-      return R.append({ datapoints: [datapoint], category, key }, acc);
-    },
-    [],
-    R.keys(observations),
-  );
-  return R.map(
-    serie => ({ ...serie, datapoints: R.sortBy(R.prop('x'), serie.datapoints) }),
-    rawSeries,
-  );
-};
-
-export default ({ observations, dimensions }, dimensionsWithValuesIndexedById, display, formaterAttrs) => {
-  const timePeriodDimension = getTimePeriodDimension({ dimensions });
-  const timePeriodDimensionIndex = timePeriodDimension ? timePeriodDimension.__index : -1;
-  const timePeriodDimensionHasManyPeriods = !R.has(R.prop('id', timePeriodDimension), dimensionsWithValuesIndexedById);
-  if (!timePeriodDimensionIndex || (timePeriodDimensionIndex === -1) || timePeriodDimensionHasManyPeriods)
-    return [];
-  
-  return series(
-    observations, dimensions,
-    dimensionsWithValuesIndexedById,
-    timePeriodDimensionIndex, display, formaterAttrs
-  );
-};

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

@@ -1,140 +0,0 @@
-import * as R from 'ramda';
-import getTime from 'date-fns/getTime'
-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 = {},
-  selection = []
-}) => {
-  const selectionSet = new Set(selection);
-  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 });
-      }
-      const isSelected = selectionSet.has(value.id) || R.isNil(selection)
-        || R.isEmpty(selection) || R.isEmpty(R.head(selection));
-      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,
-        isSelected,
-        empty: !isSelected,
-        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) => 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/index.js

@@ -1,23 +0,0 @@
-export { dimensionValueDisplay, parseDisplay } from './dimension-utils';
-export {
-  stateFromNewProps,
-  toChartOptions,
-  toProperties,
-  toSingularity
-} from './properties';
-export { parseFocus } from './properties/focus';
-export {
-  getFullName,
-} from './sdmx-data';
-export { getTimePeriodLabel } from './date';
-export { getFooterProps  } from './properties/getHeaderProps';
-export { getAvailableChartTypes } from './properties/getAvailableChartTypes';
-export { isSharedLayoutCompatible } from './layout';
-
-export { getObservations } from './preparators/getObservations';
-
-
-export { getCellValue } from './table';
-export { getChartOptions } from './chart/getChartOptions';
-export { getReportingYearStart } from './preparators/getReportingYearStart';
-export { getChartSeries } from './factories/getChartSeries';