@sis-cc/dotstatsuite-components 21.0.1 → 21.1.0

package/src/rules2/src/parseMetadataSeries.js

@@ -1,117 +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 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('id', val.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);
-            if (R.isNil(valueIndex) && !(attribute.isPresentational)) {
-              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,73 +0,0 @@
-import * as R from 'ramda';
-import { getObservations } from '../../rules/src';
-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';
-
-export const prepareData = (sdmxJson, { customAttributes, locale, hierarchies, dataflow, display, defaultCombinations, dataquery }) => {
-  const dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
-  const refinedDimensions = refineDimensions(dimensions, dataquery);
-  const attributes = R.pathOr([], ['data', 'structure', 'attributes', 'observation'], sdmxJson);
-  const annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
-  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 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,
-    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,18 +0,0 @@
-import * as R from 'ramda';
-
-export const refineDimensions = (dimensions=[], dataquery='') => {
-  const selectionIds = R.pipe(R.split('.'), R.map(R.split('+')))(dataquery);
-
-  return R.addIndex(R.map)((dim, index) => {
-    const selection = R.nth(index, selectionIds);
-    const values = R.map(val => {
-      if (R.includes(val.id, selection || []) || R.isNil(selection) || R.length(selection) === 0 || R.isEmpty(R.head(selection))) {
-        return R.assoc('isSelected', true, val);
-      }
-      return R.assoc('empty', true, val);
-    }, dim.values || []);
-
-    const size = R.length(values);
-    return { ...dim, values, header: size === 1 || (size > 1 && R.length(selection) === 1 && !R.isEmpty(R.head(selection))) };
-  }, dimensions);
-};

package/src/rules2/src/refineMetadataCoordinates.js

@@ -1,28 +0,0 @@
-import * as R from 'ramda';
-
-export const refineMetadataCoordinates = (metadataCoordinates, layoutIds) => {
-  const relevantIds = R.pipe(R.values, R.unnest)(layoutIds);
-  return R.reduce(
-    (acc, coordinates) => {
-      const refinedCoord = R.pick(relevantIds, coordinates);
-      if (R.isEmpty(refinedCoord)) {
-        return acc;
-      }
-      const removedHeaderCodes = R.omit(layoutIds.header, refinedCoord);
-      if (R.isEmpty(removedHeaderCodes)) {
-        return R.over(R.lensProp('header'), R.append(refinedCoord))(acc);
-      }
-      const removedSectionCodes = R.omit(layoutIds.sections, refinedCoord);
-      if (R.isEmpty(removedSectionCodes)) {
-        return R.over(R.lensProp('sections'), R.append(refinedCoord))(acc);
-      }
-      const removedRowsCodes = R.omit(layoutIds.rows, removedSectionCodes);
-      if (R.isEmpty(removedRowsCodes)) {
-        return R.over(R.lensProp('rows'), R.append(refinedCoord))(acc);
-      }
-      return R.over(R.lensProp('cells'), R.append(refinedCoord))(acc);
-    }, 
-    { cells: [], header: [], sections: [], rows: [] },
-    metadataCoordinates
-  );
-};

package/src/rules2/src/refineTimePeriod.js

@@ -1,127 +0,0 @@
-import * as R from 'ramda';
-import * as dateFns from 'date-fns';
-import { getLocale, dateWithoutTZ } from '../../rules/src/date';
-
-const computeDisplayFreq = (start, duration) => {
-  const startMinute = dateFns.startOfMinute(start);
-  const startHour = dateFns.startOfHour(start);
-  const startDay = dateFns.startOfDay(start);
-  if (!dateFns.isEqual(start, startMinute) || duration === 'S') {
-    return 'S';
-  }
-  else if (!dateFns.isEqual(start, startHour) || !dateFns.isEqual(start, startDay)
-    || duration === 'H' || duration === 'm') {
-    return 'm';
-  }
-  else if (!dateFns.isFirstDayOfMonth(start) || duration === 'D') {
-    return 'D';
-  }
-  else if (dateFns.getMonth(start) !== 0 || duration === 'M') {
-    return 'M';
-  }
-  return 'Y';
-};
-
-const getAdder = (duration) => {
-  if (duration === 'S')
-    return dateFns.addSeconds;
-  if (duration === 'm')
-    return dateFns.addMinutes;
-  if (duration === 'H')
-    return dateFns.addHours;
-  if (duration === 'D')
-    return dateFns.addDays;
-  if (duration === 'M')
-    return dateFns.addMonths;
-  return dateFns.addYears;
-};
-
-const getFormat = (freqDisplay) => {
-  if (freqDisplay === 'Y')
-    return 'YYYY';
-  if (freqDisplay === 'D')
-    return 'YYYY-MM-DD';
-  if (freqDisplay === 'H' || freqDisplay === 'm') {
-    return 'HH:mm';
-  }
-  if (freqDisplay === 'S') {
-    return 'HH:mm:ss';
-  }
-  return '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} ${format}`, opts)} - ${dateFns.format(end, `${dayFormat} ${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 = (start) => {
-  if (!R.includes('T', start) && !R.endsWith('Z', start)) {
-    return dateWithoutTZ(new Date(start));
-  }
-  return new Date(start);
-};
-
-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(start, 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);
-};

package/src/rules2/src/table/getCells.js

@@ -1,93 +0,0 @@
-import * as R from 'ramda';
-import { getFlagsAndNotes } from './getFlagsAndNotes';
-import { hasCellMetadata } from '../hasCellMetadata';
-
-export const getCellRelevantAttributes = (attributes, attributesSeries, cellAttributeIds) => R.filter(
-  (attr) => {
-    if (R.isNil(attr.value)) {
-      return false;
-    }
-    if (R.has(attr.id, cellAttributeIds)) {
-      return true;
-    }
-    const attrInSerie = R.path([attr.serieKey, attr.id], attributesSeries);
-    return R.isNil(attrInSerie);
-  },
-  attributes
-);
-
-export const getCellCombinedSeries = (attributes, combinations) => R.reduce(
-  (acc, comb) => {
-    const values = R.reduce(
-      (acc, concept) => {
-        if (R.has(concept, comb.fixedDimValues || {})) {
-          return R.append(R.prop(concept, comb.fixedDimValues), acc);
-        }
-        if (R.has(concept, attributes || {})) {
-          return R.append(R.path([concept, 'value'], attributes), acc);
-        }
-        return acc;
-      },
-      [],
-      comb.concepts
-    );
-
-    if (R.isEmpty(values)) {
-      return acc;
-    }
-    return R.append({ ...R.pick(['id', 'name'], comb), values }, acc);
-  },
-  [],
-  combinations
-);
-
-// combinations = { cells, layout };
-export const getCells = (customAttributes, cellsAttributesId, combinations, attributesSeries, metadataCoordinates) => observations => {
-  const attributesInLayoutCombination = R.pipe(
-    R.propOr([], 'layout'),
-    R.pluck('concepts'),
-    R.unnest
-  )(combinations);
-
-  const attributesInCellsCombination = R.pipe(
-    R.propOr([], 'cells'),
-    R.pluck('concepts'),
-    R.unnest
-  )(combinations);
-
-  const _customAttributes = R.over(
-    R.lensProp('notes'),
-    notes => R.pipe(R.concat, R.uniq)(notes || [], attributesInLayoutCombination)
-  )(customAttributes);
-
-  return R.mapObjIndexed(
-    obs => {
-      const isAttrCell = R.pathOr('OBS_VAL', ['indexedDimValIds', 'OBS_ATTR'], obs) !== 'OBS_VAL';
-      const relevantAttributes = isAttrCell ? [] : getCellRelevantAttributes(obs.attributes, attributesSeries, cellsAttributesId);
-      const flagsAndNotes = isAttrCell ? [] : getFlagsAndNotes(R.omit(attributesInCellsCombination, relevantAttributes), _customAttributes);
-      const combinedSeries = isAttrCell ? [] : getCellCombinedSeries(relevantAttributes, combinations.cells || []);
-      const hasAdvancedAttributes = isAttrCell
-        ? false : R.pipe(
-        R.omit(R.unnest([_customAttributes.flags || [], _customAttributes.notes || [], attributesInCellsCombination])),
-        res => !R.isEmpty(res)
-      )(relevantAttributes);
-
-      const advancedAttributes = R.omit(
-        R.unnest([_customAttributes.flags || [], _customAttributes.notes || [], attributesInCellsCombination]),
-        R.filter(attr => !R.isNil(attr.value), obs.attributes), 
-      );
-
-      const hasMetadata = isAttrCell ? false : hasCellMetadata(metadataCoordinates, obs.indexedDimValIds);
-
-      return ({
-        ...R.pick(['indexedDimValIds', 'key'], obs),
-        flags: R.concat(flagsAndNotes, combinedSeries),
-        sideProps: hasAdvancedAttributes || hasMetadata
-          ? { hasMetadata, coordinates: obs.indexedDimValIds, advancedAttributes } : null,
-        intValue: R.is(Number, obs.value) ? obs.value : null,
-        value: obs.formattedValue,
-      });
-    },
-    observations
-  );
-};

package/src/rules2/src/table/getCellsAttributesIds.js

@@ -1,38 +0,0 @@
-import * as R from 'ramda';
-
-export const getCellsAttributesIds = (layoutIds, attributes) => {
-  return R.reduce(
-    (acc, attr) => {
-      if (!attr.series) {
-        return acc;
-      }
-      if (R.isEmpty(attr.relationship || [])) {
-        return R.assoc(attr.id, attr.id, acc);
-      }
-      const indexedHeaderIds = R.indexBy(R.identity, layoutIds.header);
-      const indexedSectionsIds = R.indexBy(R.identity, layoutIds.sections);
-      const indexedRowsIds = { ...indexedSectionsIds, ...R.indexBy(R.identity, layoutIds.rows) };
-      const [idsInHeader, rest] = R.partition(
-        id => R.has(id, indexedHeaderIds),
-        attr.relationship,
-      );
-      if (R.isEmpty(rest)) {
-        return acc;
-      } else if (!R.isEmpty(idsInHeader)) {
-        return R.assoc(attr.id, attr.id, acc);
-      } else {
-        const idsNotInSections = R.reject(id => R.has(id, indexedSectionsIds), attr.relationship);
-        if (R.isEmpty(idsNotInSections)) {
-          return acc;
-        }
-        const idsNotInRows = R.reject(id => R.has(id, indexedRowsIds), idsNotInSections);
-        if (R.isEmpty(idsNotInRows)) {
-          return acc;
-        }
-      }
-      return R.assoc(attr.id, attr.id, acc);
-    },
-    {},
-    attributes,
-  );
-};

package/src/rules2/src/table/getCellsMetadataCoordinates.js

@@ -1,13 +0,0 @@
-import * as R from 'ramda';
-
-export const getCellsMetadataCoordinates = (metadataCoordinates, oneValueDimensions, layoutIds) => {
-  const oneValueDimsIds = R.pluck('id', oneValueDimensions);
-  return R.reject(coordinates => {
-    const columnIds = R.concat(layoutIds.header, oneValueDimsIds);
-    if (R.isEmpty(R.omit(columnIds, coordinates))) {
-      return true;
-    }
-    const rowsIds = [...layoutIds.sections, ...layoutIds.rows, ...oneValueDimsIds];
-    return R.isEmpty(R.omit(rowsIds, coordinates));
-  }, metadataCoordinates);
-};

package/src/rules2/src/table/getCombinationDimensionsData.js

@@ -1,39 +0,0 @@
-import * as R from 'ramda';
-import { parseValueHierarchy, isSameValueAsPrevious } from './parseValueHierarchy';
-
-export const getCombinationDimensionsData = (indexes, combination, previous, sameSerie) => {
-  let coordinates = {};
-  let ids = [];
-  let _sameSerie = sameSerie;
-  let hasAdvancedAttributes = false;
-
-  const { dimensions=[] } = combination;
-  const dimValues = R.addIndex(R.reduce)(
-    (acc, valIndex, dimIndex) => {
-      const dimension = R.nth(dimIndex, dimensions);
-      const value = R.nth(Math.abs(valIndex), R.propOr([], 'values', dimension));
-      hasAdvancedAttributes = !hasAdvancedAttributes ? value.hasAdvancedAttributes : true;
-      coordinates = R.assoc(dimension.id, value.id, coordinates);
-      ids = R.append(`${dimension.id}=${value.id}`, ids);
-      const previousValue = R.propOr({}, dimension.id, previous);
-      if (isSameValueAsPrevious(value, previousValue) && _sameSerie) {
-        return R.assoc(dimension.id, previousValue, acc);
-      }
-      else {
-        const _parsedValue = parseValueHierarchy(value, _sameSerie ? previousValue || {} : {}, dimension.indexedValues);
-        const parsedValue = R.over(
-          R.lensProp('display'),
-          (display=true) => display && R.propOr(true, 'display', dimension)
-        )(_parsedValue);
-        if (!R.isNil(previous)) {
-          _sameSerie = false;
-        }
-        return R.assoc(dimension.id, parsedValue, acc);
-      }
-    },
-    {},
-    indexes
-  );
-
-  return ({ dimValues, coordinates, ids, sameSerie: _sameSerie, hasAdvancedAttributes });
-};

package/src/rules2/src/table/getCuratedCells.js

@@ -1,33 +0,0 @@
-import * as R from 'ramda';
-
-export const getCuratedCells = (cells, layout) => {
-  const layoutIds = R.map(
-    R.pipe(
-      R.map(entry =>
-        R.has('dimensions', entry) ? R.pluck('id', entry.dimensions || []) : entry.id,
-      ),
-      R.unnest,
-    ),
-  )(layout);
-  return R.pipe(
-    R.values,
-    R.reduce((acc, cell) => {
-      const keys = R.map(
-        R.pipe(
-          R.map(dim => {
-            const val = R.prop(dim, cell.indexedDimValIds);
-            return `${dim}=${val}`;
-          }),
-          R.join(':'),
-        ),
-        layoutIds,
-      );
-
-      return R.over(
-        R.lensPath(R.props(['header', 'sections', 'rows'], keys)),
-        cells => (R.isNil(cells) ? [cell] : R.append(cell, cells)),
-        acc,
-      );
-    }, {}),
-  )(cells);
-};

package/src/rules2/src/table/getFlagsAndNotes.js

@@ -1,23 +0,0 @@
-import * as R from 'ramda';
-import { REJECTED_VALUE_IDS } from '../constants';
-
-export const getFlagsAndNotes = (attributesValues, customAttributes) => {
-  const flagsIds = R.propOr([], 'flags', customAttributes);
-  const notesIds = R.propOr([], 'notes', customAttributes);
-
-  return R.addIndex(R.reduce)(
-    (acc, id, index) => {
-      if (!R.has(id, attributesValues)) {
-        return acc;
-      }
-      const attr = R.pick(['id', 'name', 'value', 'display'], R.prop(id, attributesValues));
-      if (R.isNil(attr.value) || !R.pathOr(true, ['value', 'display'], attr) || !R.propOr(true, 'display', attr)
-        || R.includes(R.path(['value', 'id'], attr), REJECTED_VALUE_IDS)) {
-        return acc;
-      }
-      return R.append(index < flagsIds.length ? R.assoc('code', R.path(['value', 'id'], attr), attr) : attr, acc);
-    },
-    [],
-    R.concat(flagsIds, notesIds)
-  );
-};