@sis-cc/dotstatsuite-components 23.2.0 → 24.0.0

package/src/rules2/src/parseAttributes.js

@@ -1,41 +0,0 @@
-import * as R from 'ramda';
-import { REPORTING_YEAR_START_DAY, REPYEARSTART } from './constants';
-
-export const parseAttributes = (attributes, dimensions, customAttributes) => {
-  const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
-  return R.addIndex(R.map)((attr, index) => {
-    let res = R.assoc('index', index, attr);
-    const displayableValuesCount = R.pipe(
-      R.filter(R.propOr(true, 'display')),
-      R.length,
-    )(attr);
-    if (R.isEmpty(attr.values || []) || !R.propOr(true, 'display', attr)
-      || displayableValuesCount < 1 || attr.id === REPORTING_YEAR_START_DAY
-      || attr.id === REPYEARSTART) {
-      return R.assoc('display', false, res);
-    }
-    if (R.propEq(customAttributes.prefscale, 'id', attr)) {
-      return R.assoc('prefscale', true, res);
-    }
-    if (R.propEq(customAttributes.decimals, 'id', attr)) {
-      return R.assoc('decimals', true, res);
-    }
-    if (R.hasPath(['relationship', 'none'], attr) || R.hasPath(['relationship', 'dataflow'], attr)) {
-      return { ...res, header: true, relationship: [] };
-    }
-    if (R.hasPath(['relationship', 'primaryMeasure'], attr) || R.hasPath(['relationship', 'observation'], attr)) {
-      return { ...res, series: true, relationship: [] };
-    }
-    const seriesDimensions = R.pipe(
-      R.pathOr([], ['relationship', 'dimensions']),
-      R.filter(id => {
-        const dimension = R.prop(id, indexedDimensions);
-        return !dimension.header && R.length(dimension.values || []) > 1 && !dimension.rejected;
-      }),
-    )(attr);
-    if (R.length(seriesDimensions) > 0) {
-      return { ...res, series: true, relationship: seriesDimensions };
-    }
-    return { ...res, header: true, relationship: R.prop('dimensions', attr.relationship || []) };
-  }, attributes);
-};

package/src/rules2/src/parseCombinations.js

@@ -1,102 +0,0 @@
-import * as R from 'ramda';
-import { REJECTED_VALUE_IDS } from './constants';
-
-const getDisplayableValues = (values) =>
-  R.filter(
-    (val) =>
-      !R.includes(R.prop('id', val), REJECTED_VALUE_IDS) &&
-      R.propOr(true, 'display', val),
-    values,
-  );
-
-// invalid concepts:
-// - empty/null/undefined/!array values (so far)
-const hasInvalidValues = R.pipe(
-  R.prop('values'),
-  R.anyPass([R.isNil, R.complement(R.is(Array)), R.isEmpty]),
-);
-const isConceptInvalid = R.anyPass([hasInvalidValues /* add more... */]);
-const filterValidConcepts = R.reject(isConceptInvalid);
-// concepts is an array of ids... (misnamed!)
-const rejectInvalidConceptIds =
-  (concepts = []) =>
-  (combinations = []) => {
-    const validConceptIds = R.pluck('id', filterValidConcepts(concepts));
-    return R.reduce((acc, comb) => {
-      const refinedConcepts = R.intersection(validConceptIds, comb.concepts);
-      if (R.length(refinedConcepts) < 1) {
-        return acc;
-      }
-      return R.append({ ...comb, concepts: refinedConcepts }, acc);
-    }, [], combinations);
-  };
-
-export const parseCombinations = (
-  combinations,
-  parsedAttributes,
-  dimensions,
-) => {
-  const concepts = R.concat(dimensions, parsedAttributes);
-
-  const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
-  const indexedAttributes = R.indexBy(R.prop('id'), parsedAttributes);
-
-  return R.pipe(
-    rejectInvalidConceptIds(concepts),
-    R.reduce((acc, comb) => {
-      let relationship = [];
-      let ids = {};
-      let displayable_values_count = 0;
-      const seriesConcepts = R.filter((concept) => {
-        if (R.has(concept, ids)) {
-          return false;
-        }
-        if (R.has(concept, indexedDimensions)) {
-          const dimension = R.prop(concept, indexedDimensions);
-          relationship = !dimension.header
-            ? R.append(concept, relationship)
-            : relationship;
-          ids = { ...ids, [concept]: concept };
-          displayable_values_count += R.length(dimension.values || []);
-          return !dimension.header;
-        } else if (!R.has(concept, indexedAttributes)) {
-          return false;
-        }
-        const attribute = R.prop(concept, indexedAttributes);
-        const displayableValues = getDisplayableValues(attribute.values || []);
-        const isDisplayable =
-          R.length(displayableValues) !== 0 &&
-          R.propOr(true, 'display', attribute);
-        relationship =
-          attribute.series && isDisplayable
-            ? R.pipe(
-                R.reject((id) => R.has(id, ids)),
-                R.concat(relationship),
-              )(attribute.relationship)
-            : relationship;
-        ids = attribute.series  && isDisplayable
-          ? { ...ids, ...R.indexBy(R.identity, attribute.relationship) }
-          : ids;
-        displayable_values_count = isDisplayable
-          ? displayable_values_count + R.length(displayableValues)
-          : displayable_values_count;
-        return attribute.series && isDisplayable;
-      }, comb.concepts);
-      if (R.isEmpty(seriesConcepts)) {
-        return R.append(
-          { ...comb, header: true, display: displayable_values_count > 0 },
-          acc,
-        );
-      }
-      return R.append(
-        {
-          ...comb,
-          series: true,
-          relationship,
-          display: displayable_values_count > 0,
-        },
-        acc,
-      );
-    }, []),
-  )(combinations);
-};

package/src/rules2/src/parseHierarchicalCodelist.js

@@ -1,48 +0,0 @@
-import * as R from 'ramda';
-
-export const parseHierarchicalCodelist = (sdmxJson, hierarchyId) => {
-  const hCodelist = R.pathOr({}, ['data', 'hierarchicalCodelists', 0], sdmxJson);
-  const hierarchy = R.find(R.propEq(hierarchyId, 'id'), hCodelist.hierarchies || []);
-
-  const getParentedCodes = (codes, parent) => {
-    const ids = R.pluck('codeID', codes);
-
-    const siblings = R.reduce(
-      (acc, code) => {
-        if (R.isEmpty(code.hierarchicalCodes || [])) {
-          return acc;
-        }
-        return R.mergeRight(acc, getParentedCodes(code.hierarchicalCodes, code.id));
-      },
-      {},
-      codes
-    );
-
-    return ({ ...siblings, [parent]: ids });
-  };
-
-  const getChildren = (codes, parents) => {
-    const ids = R.pluck('codeID', codes);
-
-    const children = R.reduce(
-      (acc, code) => {
-        if (R.isEmpty(code.hierarchicalCodes || [])) {
-          return acc;
-        }
-        return ({
-          ...acc,
-          ...getChildren(code.hierarchicalCodes, R.append(code.codeID, parents))
-        });
-      },
-      {},
-      codes
-    );
-    const key = R.isEmpty(parents) ? '#ROOT' : R.join('.', parents);
-    return ({ ...children, [key]: ids });
-  }
-
-  return R.pipe(
-    R.propOr([], 'hierarchicalCodes'),
-    codes => getChildren(codes, []),
-  )(hierarchy);
-};

package/src/rules2/src/parseMetadataSeries.js

@@ -1,121 +0,0 @@
-import * as R from 'ramda';
-import { EMPTY_ATTACHMENT_LEVEL_CHAR } from './constants';
-
-const dimensionValueDisplay = (display) => data => {
-  if (display === 'code') {
-    return R.prop('id', data);
-  }
-  const name = R.prop('name')(data);
-  if (display === 'both') {
-    return `${R.prop('id', data)}: ${name}`;
-  }
-  return name;
-};
-// options = { locale, display, dimensions = [], attributes = { [id]: { format, parent } } };
-export const parseMetadataSeries = (metadataJson, options) => {
-  const metadataAttributes = R.pathOr([], ['data', 'structures', 0, 'attributes', 'dimensionGroup'], metadataJson);
-  const metaAttrLength = R.length(metadataAttributes);
-
-  if (!metaAttrLength) {
-    return ({});
-  }
-
-  const dimensions = R.pipe(
-    R.pathOr([], ['data', 'structures', 0, 'dimensions']),
-    ({ series = [], observation = [] }) => R.concat(series, observation),
-    dims => R.isEmpty(options.dimensions || [])
-      ? dims
-      : R.props(R.pluck('id', options.dimensions), R.indexBy(R.prop('id'), dims))
-  )(metadataJson);
-
-  const { notDisplayedIds = {} } = options;
-
-  const metadataSeries = R.pipe(
-    R.pathOr({}, ['data', 'dataSets', 0, 'dimensionGroupAttributes']),
-    series => R.reduce((acc, serieKey) => {
-      const indexes = series[serieKey];
-      const metaIndexes = R.take(metaAttrLength, indexes);
-
-
-      const evolvedKey = R.pipe(
-        R.split(':'),
-        R.addIndex(R.map)((vInd, dInd) => {
-          if (R.isEmpty(vInd) || R.equals(EMPTY_ATTACHMENT_LEVEL_CHAR, vInd)) {
-            return '';
-          }
-          const dim = R.nth(dInd, dimensions);
-          const val = R.nth(Number(vInd), dim.values || []);
-
-          const originalVal = R.find(
-            R.propEq(val.id, 'id'),
-          )(R.propOr([], 'values', R.nth(dInd, options.dimensions)));
-          return R.propOr('', '__index', originalVal);
-        }),
-        R.join(':')
-      )(serieKey);
-
-      const attributes = R.pipe(
-        R.addIndex(R.reduce)(
-          (acc, valueIndex, attrIndex) => {
-            const attribute = R.nth(attrIndex, metadataAttributes);
-            const isHidden = R.has(attribute.id, notDisplayedIds);
-            if ((R.isNil(valueIndex) && !(attribute.isPresentational)) || isHidden) {
-              return acc;
-            }
-            const attrOptions = R.pathOr({}, ['attributes', attribute.id], options);
-            const id = attrOptions.id;
-            const label = dimensionValueDisplay(options.display)({ ...attribute, id });
-
-            const _value = R.prop('value', R.nth(valueIndex, attribute.values || []));
-            const value = R.is(Object, _value) ? R.prop(options.locale, _value) : _value;
-
-            return R.append({
-              ...(R.isNil(value) ? {} : { value }),
-              id: attribute.id,
-              label,
-              handlerProps: R.omit(['id'], R.pathOr({}, ['attributes', attribute.id], options))
-            }, acc);
-          },
-          [],
-        ),
-        attributes => { // missing parents in metadata response 
-          const groupedAttrs = R.groupBy(R.pathOr('#ROOT', ['handlerProps', 'parent']), attributes);
-          const indexedAttrs = R.indexBy(R.prop('id'), attributes);
-
-          return R.reduce(
-            (acc, id) => {
-              if (R.has(id, indexedAttrs) || id === '#ROOT') {
-                return acc;
-              }
-              return R.append({
-                id,
-                label: dimensionValueDisplay(options.display)({ id, name: R.path(['attributes', id, 'name'], options) }),
-                handlerProps: R.omit(['id'], R.pathOr({}, ['attributes', id], options))
-              }, acc);
-            },
-            attributes,
-            R.keys(groupedAttrs)
-          );
-        },
-        attributes => {
-          const groupedAttrs = R.groupBy(R.pathOr('#ROOT', ['handlerProps', 'parent']), attributes);
-          const makeTree = R.map(attr => {
-            if (R.has(attr.id, groupedAttrs)) {
-              const children = makeTree(R.prop(attr.id, groupedAttrs));
-              return R.assoc('children', children, attr);
-            }
-            return attr;
-          });
-
-          return makeTree(R.propOr([], '#ROOT', groupedAttrs));
-        },
-      )(metaIndexes);
-
-      return R.assoc(evolvedKey, attributes, acc);
-    },
-      {},
-      R.keys(series)
-    ))(metadataJson);
-
-  return metadataSeries;
-};

package/src/rules2/src/prepareData.js

@@ -1,82 +0,0 @@
-import * as R from 'ramda';
-import { getObservations } from '../../rules/src/preparators/getObservations';
-import { refineDimensions } from './refineDimensions';
-import { enhanceObservations } from './enhanceObservations';
-import { parseAttributes } from './parseAttributes';
-import { getCombinationDefinitions, parseCombinationDefinition } from './getCombinationDefinitions';
-import { parseCombinations } from './parseCombinations';
-import { refineAttributes } from './refineAttributes';
-import { duplicateObs } from './duplicateObservations';
-import { getMetadataCoordinates } from './getMetadataCoordinates';
-import { getAttributesSeries } from './getAttributesSeries';
-import { getManyValuesDimensions } from './getManyValuesDimensions';
-import { getOneValueDimensions } from './getOneValueDimensions';
-import { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy2';
-import { getDataflowAttributes } from './getDataflowAttributes';
-import { getHeaderTitle } from './getHeaderTitle';
-import { getHeaderSubtitle } from './getHeaderSubtitle';
-import { getHeaderCombinations } from './getHeaderCombinations';
-import { getHeaderCoordinates } from './getHeaderCoordinates';
-import { applyHierarchicalCodesToDim } from './applyHierarchicalCodesToDim';
-import { getReportingYearStart } from '../../rules/src/preparators/getReportingYearStart';
-import { getNotDisplayedIds } from './getNotDisplayedIds';
-import { getAttributes } from './getAttributes';
-
-export const prepareData = (sdmxJson, { customAttributes, locale, hierarchies, dataflow, display, defaultCombinations, dataquery }) => {
-  const dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
-  const annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
-  const reportYearStart = getReportingYearStart(sdmxJson);
-  const { hiddenValues, hiddenCombinations } = getNotDisplayedIds(annotations);
-  const options = { dataquery, hiddenCombinations, hiddenValues, locale, reportYearStart };
-  const refinedDimensions = refineDimensions({ annotations, dimensions, options });
-  const _attributes = R.pathOr([], ['data', 'structure', 'attributes'], sdmxJson);
-  const attributes = getAttributes({ attributes: _attributes, annotations, options });
-  const observations = getObservations(sdmxJson);
-  let combinations = getCombinationDefinitions(annotations, locale);
-  if (R.isEmpty(combinations) && !R.isEmpty(defaultCombinations)) {
-    const { concepts, names } = defaultCombinations;
-    combinations = parseCombinationDefinition(locale)(concepts, names);
-  }
-  const metadataCoordinates = getMetadataCoordinates(sdmxJson);
-
-  const parsedAttributes = parseAttributes(attributes, refinedDimensions, customAttributes);
-  const parsedCombinations = parseCombinations(combinations, parsedAttributes, refinedDimensions);
-  const seriesCombinations = R.filter(R.prop('series'), parsedCombinations);
-  const refinedAttributes = refineAttributes(parsedAttributes, seriesCombinations);
-
-  const enhancedObservations = enhanceObservations(refinedDimensions, observations, refinedAttributes, { customAttributes });
-  const attributesSeries = getAttributesSeries(enhancedObservations);
-  const manyValuesDimensions = getManyValuesDimensions(refinedDimensions, attributesSeries, customAttributes, seriesCombinations);
-  const oneValueDimensions = getOneValueDimensions(refinedDimensions, parsedAttributes);
-  const rejectedDimensions = R.filter(R.prop('rejected'), dimensions);
-  const headerCoordinates = getHeaderCoordinates(oneValueDimensions);
-  const hierarchisedDimensions = R.map(dim => {
-    if (R.isEmpty(R.propOr({}, dim.id, hierarchies))) {
-      return hierarchiseDimensionWithNativeHierarchy(dim);
-    }
-    return applyHierarchicalCodesToDim(R.prop(dim.id, hierarchies), dim);
-  }, manyValuesDimensions)
-  const duplicatedObservations = duplicateObs(R.values(hierarchisedDimensions), enhancedObservations);
-
-  const dataflowAttributes = getDataflowAttributes(parsedAttributes, parsedCombinations);
-  const headerTitle = getHeaderTitle(dataflow, dataflowAttributes, display, customAttributes);
-  const headerSubtitle = getHeaderSubtitle(oneValueDimensions, parsedCombinations, customAttributes, display);
-  const headerCombinations = getHeaderCombinations(parsedCombinations, oneValueDimensions, refinedAttributes, display);
-  
-  return ({
-    observations: duplicatedObservations,
-    dimensions: hierarchisedDimensions,
-    combinations: parsedCombinations,
-    oneValueDimensions,
-    attributesSeries,
-    metadataCoordinates,
-    attributes: refinedAttributes,
-    rejectedDimensions,
-    header: {
-      title: headerTitle,
-      subtitle: headerSubtitle,
-      combinations: headerCombinations,
-      coordinates: headerCoordinates
-    }
-  });
-};

package/src/rules2/src/refineAttributes.js

@@ -1,16 +0,0 @@
-import * as R from 'ramda';
-
-export const refineAttributes = (parsedAttributes, seriesCombinations) => {
-  const indexedRelationships = R.reduce(
-    (acc, comb) =>
-      R.reduce((_acc, concept) => R.assoc(concept, comb.relationship, _acc), acc, comb.concepts),
-    {},
-    seriesCombinations,
-  );
-  return R.map(attr => {
-    if (R.has(attr.id, indexedRelationships)) {
-      return { ...attr, series: true, relationship: R.prop(attr.id, indexedRelationships), combined: true };
-    }
-    return attr;
-  }, parsedAttributes);
-};

package/src/rules2/src/refineDimensions.js

@@ -1,63 +0,0 @@
-import * as R from 'ramda';
-import { isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
-import { getValuesEnhanced } from '../../rules/src/get-values-enhanced';
-import { getIsHidden } from '../../rules/src/sdmx-data';
-
-const TIME_PERIOD_ID = 'TIME_PERIOD';
-
-export const refineDimensions = ({
-  annotations = [],
-  dimensions = [],
-  options = {},
-}) => {
-  const {
-    dataquery = '',
-    hiddenCombinations = {},
-    hiddenValues = {},
-    locale = '',
-    reportYearStart,
-    ...restOptions
-  } = options;
-  const selectionIds = R.pipe(R.split('.'), R.map(R.split('+')))(dataquery);
-
-  const getIsAllDimHidden = ({ id, values }) => {
-    if (!R.has(id, hiddenCombinations)) {
-      return false;
-    }
-    const valuesIds = R.pluck('id', values);
-    return R.isEmpty(R.difference(valuesIds, hiddenCombinations[id]));
-  }
-
-  return R.addIndex(R.map)((dim, index) => {
-    const selection = R.nth(index, selectionIds);
-    const isEmptySelection = R.isNil(selection) || R.isEmpty(selection) || R.isEmpty(R.head(selection));
-    const isTimeDimension = isTimePeriodDimension(dim);
-    const dimAnnotations = R.props(dim.annotations || [], annotations);
-    const values =  getValuesEnhanced({
-      annotations,
-      hiddenIds: hiddenValues,
-      isTimeDimension,
-      locale,
-      options: restOptions,
-      parent: dim.id,
-      reportYearStart,
-      selection
-    })(dim.values || []);
-
-    const size = R.length(values);
-    const isAllDimHidden = getIsAllDimHidden({ id: dim.id, values });
-    const isHidden = isAllDimHidden || R.has(dim.id, hiddenValues)
-      || getIsHidden(dimAnnotations);
-    return ({
-      ...dim,
-      display: !isHidden,
-      header: size === 1 || (size > 1 && R.length(selection) === 1 && !isEmptySelection),
-      __index: index,
-      rejected: isAllDimHidden || !size,
-      role: isTimeDimension
-        ? TIME_PERIOD_ID
-        : R.head(dim.roles || []),
-      values,
-    });
-  }, dimensions);
-};

package/src/rules2/src/refineTimePeriod.js

@@ -1,123 +0,0 @@
-import * as R from 'ramda';
-import * as dateFns from 'date-fns';
-import { getLocale } 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.getDate(start) !== 1 || 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 'yyyy-MMM';
-}
-
-const getEndDate = (start, mult, duration) => {
-  const adder = getAdder(duration);
-  const endDate = adder(start, Number(mult));
-  return dateFns.subSeconds(endDate, 1);
-};
-
-const computeName = (start, end, freqDisplay, locale, format) => {
-  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');
-    if (isSameDay)
-      return `${dateFns.format(start, dayFormat, opts)} ${dateFns.format(start, format, opts)} - ${dateFns.format(end, format, opts)}`;
-    return `${dateFns.format(start, dayFormat, opts)} ${dateFns.format(start, format, opts)} - `
-      + `${dateFns.format(end, dayFormat, opts)} ${dateFns.format(end, format, opts)}`;
-  }
-  if (freqDisplay !== 'M') {
-    return `${dateFns.format(start, format, opts)} - ${dateFns.format(end, format, opts)}`;
-  }
-
-  if (isSameYear && !R.includes('-', format)) {
-    const yearFormatMatch = R.match(/([y]+)/, format);
-    const monthFormatMatch = R.match(/([M]+|Mo)/, format);
-    const yearFormat = R.length(yearFormatMatch) >= 2 ? R.nth(1, yearFormatMatch) : null;
-    const monthFormat = R.length(monthFormatMatch) >= 2 ? R.nth(1, monthFormatMatch) : null;
-    const formattedYear = yearFormat ? dateFns.format(start, yearFormat, opts) : null;
-    const formattedMonths = monthFormat ? `${dateFns.format(start, monthFormat, opts)} - ${dateFns.format(end, monthFormat, opts)}` : null;
-    if (monthFormat) {
-      return R.pipe(
-        format => yearFormat ? R.replace(yearFormat, formattedYear, format) : format,
-        R.replace(monthFormat, formattedMonths)
-      )(format);
-    }
-  }
-  return `${dateFns.format(start, format, opts)} - ${dateFns.format(end, format, opts)}`;
-};
-
-export const getStartDate = value =>
-  typeof value === 'string' ? dateFns.parseISO(value) : new Date(value);
-const dateWithTZ = date => dateFns.addMinutes(date, -date.getTimezoneOffset());
-
-export const refineTimePeriod = (timePeriod, { locale, monthlyFormat = 'yyyy-MMM' }) => {
-  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: dateWithTZ(start).toISOString(), end: dateWithTZ(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(startDate, duration);
-  const format = freqDisplay === 'M' ? monthlyFormat : getFormat(freqDisplay);
-  const name = computeName(startDate, endDate, freqDisplay, locale, format);
-
-  return ({
-    ...timePeriod,
-    id,
-    name,
-    start: dateWithTZ(startDate).toISOString(),
-    end: dateWithTZ(endDate).toISOString()
-  })
-};

package/src/rules2/src/sdmx3.0DataFormatPatch.js

@@ -1,9 +0,0 @@
-import * as R from 'ramda';
-
-export const sdmx_3_0_DataFormatPatch = (sdmxJson) => {
-  const dataSet = R.pipe(R.pathOr({}, ['data', 'dataSets']), R.head)(sdmxJson);
-  const structureIndex = R.prop('structure', dataSet);
-  const structure = R.pipe(R.pathOr([], ['data', 'structures']), R.nth(structureIndex))(sdmxJson);
-
-  return R.set(R.lensPath(['data', 'structure']), structure)(sdmxJson);
-};

package/src/rules2/src/table/declineObservationsOverAttributes.js

@@ -1,32 +0,0 @@
-import * as R from 'ramda';
-
-export const declineObservationsOverAttributes = (attrsIds, observations) => {
-  const obsKeys = R.keys(observations);
-  return R.reduce((acc, obsKey) => {
-    const obs = R.prop(obsKey, observations);
-    const enhancedObs = R.pipe(
-      R.over(R.lensProp('orderedDimIndexes'), R.append(0)),
-      R.over(R.lensProp('attributes'), R.omit(attrsIds)),
-      R.assocPath(['indexedDimValIds', 'OBS_ATTRIBUTES'], 'OBS_VALUE')
-    )(obs);
-    return R.addIndex(R.reduce)((_acc, attrId, attrIndex) => {
-      const attr = R.pathOr({}, ['attributes', attrId], obs);
-      if (R.isEmpty(attr) || R.isNil(R.prop('value', attr)) || !R.pathOr(true, ['value', 'display'], attr)) {
-        return _acc;
-      }
-      const declinedKey = `${obsKey}:${attrIndex+1}`;
-      const declined = {
-        ...obs,
-        attributes: {},
-        value: R.prop('value', attr),
-        formattedValue: R.prop('value', attr),
-        orderedDimIndexes: R.append(attrIndex+1, obs.orderedDimIndexes),
-        indexedDimValIds: {
-          ...obs.indexedDimValIds,
-          OBS_ATTRIBUTES: attr.id
-        }
-      };
-      return R.assoc(declinedKey, declined, _acc);
-    }, R.assoc(`${obsKey}:0`, enhancedObs, acc), attrsIds);
-  }, {}, obsKeys);
-};