@sis-cc/dotstatsuite-components 15.0.21 → 16.1.0

package/lib/{rules/src/table/factories → rules2/src/table}/refineLayoutSize.js

@@ -25,12 +25,21 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+var toKey = function toKey(indexes) {
+  return R.reduce(function (acc, _ind) {
+    var ind = R.is(Array, _ind) ? toKey(_ind) : Math.abs(_ind);
+    return R.isEmpty(acc) ? String(ind) : acc + ':' + ind;
+  }, '', indexes);
+};
+
 var getPivotKey = function getPivotKey(indexes) {
   return R.pipe(R.props(indexes), R.join(':'));
 };
 
 var getPivots = function getPivots(layout, shape) {
-  return R.pipe(R.props(shape), R.map(R.pipe(R.pluck('__index'), getPivotKey)))(layout);
+  return R.pipe(R.props(shape), R.map(R.pipe(R.map(function (entry) {
+    return R.has('dimensions', entry) ? R.pluck('__index', entry.dimensions || []) : entry.__index;
+  }), R.unnest, getPivotKey)))(layout);
 };
 
 var indexWithPivots = function indexWithPivots(pivots, observations) {
@@ -53,9 +62,9 @@ var getCuratedCells = exports.getCuratedCells = function getCuratedCells(_ref) {
 
 var refineSections = exports.refineSections = function refineSections(sections, extractedKeys, curatedObs) {
   return R.pipe(R.map(function (section) {
-    var sectionKey = R.join(':', R.head(section) || []);
+    var sectionKey = toKey(R.head(section) || []);
     return R.over(R.lensIndex(1), R.filter(function (rowData) {
-      var rowKey = R.join(':', rowData);
+      var rowKey = toKey(rowData);
       return R.pipe(R.path([sectionKey, rowKey]), R.omit(extractedKeys), R.isEmpty, R.not)(curatedObs);
     }))(section);
   }), R.filter(R.pipe(R.nth(1), R.isEmpty, R.not)))(sections);
@@ -64,7 +73,7 @@ var refineSections = exports.refineSections = function refineSections(sections,
 var refineHeader = exports.refineHeader = function refineHeader(header, extractedKeys, curatedObs) {
   return R.filter( // extracted : { [sectionKey]: [...rowKeys] }
   function (header) {
-    var headerKey = R.join(':', header);
+    var headerKey = toKey(header);
     return R.pipe(R.prop(headerKey), function (sections) {
       return R.pickBy(function (rows, section) {
         return R.pipe(R.omit(R.propOr([], section, extractedKeys)), R.isEmpty, R.not)(rows);
@@ -81,7 +90,7 @@ var truncateSectionRows = exports.truncateSectionRows = function truncateSection
     var lastSection = R.last(truncated);
     var rows = lastSection[1];
     var rowsLength = R.length(rows);
-    var sectionKey = R.join(':', R.head(lastSection));
+    var sectionKey = toKey(R.head(lastSection));
     if (rowsLength > _n) {
       var _R$splitAt = R.splitAt(R.negate(_n), rows),
           _R$splitAt2 = (0, _slicedToArray3.default)(_R$splitAt, 2),
@@ -90,11 +99,11 @@ var truncateSectionRows = exports.truncateSectionRows = function truncateSection
 
       var updatedSection = R.set(R.lensIndex(1), rest)(lastSection);
       truncated = R.set(R.lensIndex(-1), updatedSection)(truncated);
-      extractedKeys = (0, _extends5.default)({}, extractedKeys, (0, _defineProperty3.default)({}, sectionKey, R.map(R.join(':'), extracted)));
+      extractedKeys = (0, _extends5.default)({}, extractedKeys, (0, _defineProperty3.default)({}, sectionKey, R.map(toKey, extracted)));
       _n = 0;
     } else {
       truncated = R.dropLast(1, truncated);
-      extractedKeys = (0, _extends5.default)({}, extractedKeys, (0, _defineProperty3.default)({}, sectionKey, R.map(R.join(':'), rows)));
+      extractedKeys = (0, _extends5.default)({}, extractedKeys, (0, _defineProperty3.default)({}, sectionKey, R.map(toKey, rows)));
       _n = _n - rowsLength;
     }
   }
@@ -107,7 +116,7 @@ var truncateHeader = exports.truncateHeader = function truncateHeader(n, headerD
       truncated = _R$splitAt4[0],
       extracted = _R$splitAt4[1];
 
-  return { truncated: truncated, extractedKeys: R.map(R.join(':'), extracted) };
+  return { truncated: truncated, extractedKeys: R.map(toKey, extracted) };
 };
 
 var truncateLayout = function truncateLayout(isVertical) {

package/lib/rules2/src/{hasLayoutEntryMetadata.js → utils.js}

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getLayoutEntryMetadataCoordinates = undefined;
+exports.trimedProps = undefined;
 
 var _ramda = require('ramda');
 
@@ -11,8 +11,11 @@ var R = _interopRequireWildcard(_ramda);
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
 
-/*
-const layoutData = [{ dimension: { id: 'D1', __index: 2 }, value: { id: 'V', __index: 0 } }];
-*/
-
-var getLayoutEntryMetadataCoordinates = exports.getLayoutEntryMetadataCoordinates = function getLayoutEntryMetadataCoordinates(layoutData, metadataSeries) {};
+var trimedProps = exports.trimedProps = function trimedProps(properties, obj) {
+  return R.reduce(function (acc, prop) {
+    if (!R.has(prop, obj)) {
+      return acc;
+    }
+    return R.append(obj[prop], acc);
+  }, [], properties);
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sis-cc/dotstatsuite-components",
   "description": "Set components based on React.",
-  "version": "15.0.21",
+  "version": "16.1.0",
   "main": "lib/index.js",
   "author": "OECD",
   "license": "MIT",

package/src/rules/src/index.js

@@ -381,10 +381,7 @@ export {
 } from './properties';
 export { dataTransformer as v8Transformer } from './v8-transformer';
 export {
-  prepareData,
   getCellValue,
-  getTableProps,
-  getFlags,
 } from './table';
 export {
   getFullName,
@@ -396,20 +393,5 @@ export { getObservationsType } from './properties/getObservationsType';
 export { getAvailableChartTypes } from './properties/getAvailableChartTypes';
 export { isSharedLayoutCompatible } from './layout';
 
-export { parseDimensionsIds } from './table/preparators/parseDimensionsIds';
-export { parseAttributes } from './table/preparators/parseAttributes';
-export { getDimensionsAttributesRegisters } from './table/preparators/getDimensionsAttributesRegisters';
-export { parseAttributesValuesFromObservations } from './table/preparators/parseAttributesValuesFromObservations';
-export { getOneValueDimensions } from './table/preparators/getOneValueDimensions';
-export { getManyValuesDimensions } from './table/preparators/getManyValuesDimensions';
-export { getAttributeValue } from './table/preparators/getAttributeValue';
-export { refineSeriesAttributesValues } from './table/preparators/refineSeriesAttributesValues';
-
-export { getUnitsDefinition } from './table/units/getUnitsDefinition';
-export { getUnitsArtefacts } from './table/units/getUnitsArtefacts';
-export { getHeaderUnits } from './table/units/getHeaderUnits';
-export { getAttachmentSeriesIndexes } from './table/units/getAttachmentSeriesIndexes';
-export { getUnitsSeries } from './table/units/getUnitsSeries';
-
 export { getObservations } from './preparators/getObservations';
-export { enhanceObservations } from './preparators/enhanceObservations';
+

package/src/rules/src/table/index.js

@@ -1,5 +1 @@
-export { prepareData } from './preparators/prepareData';
-export { getCells, getFlags } from './factories/getCells';
-export { getTableCells } from './factories/getTableCells';
-export { getTableProps } from './factories/getTableData';
 export { getCellValue } from './factories/getCellValue';

package/src/rules2/src/constants.js

@@ -1,2 +1,5 @@
 export const SDMX_3_0_JSON_DATA_FORMAT = 'application/vnd.sdmx.data+json;version=2.0';
 export const SDMX_3_0_CSV_DATA_FORMAT = 'application/vnd.sdmx.data+csv;version=2.0';
+export const EMPTY_ATTACHMENT_LEVEL_CHAR = '~';
+export const REPORTING_YEAR_START_DAY = 'REPORTING_YEAR_START_DAY';
+export const REPYEARSTART = 'REPYEARSTART';

package/src/rules2/src/enhanceObservations.js

@@ -0,0 +1,88 @@
+import * as R from 'ramda';
+import { formatValue } from '../../rules/src/preparators/formatValue';
+
+/*
+  options = {
+    customAttributes: {
+      decimals: id,
+      prefscale: id,
+    },
+    rejectedValueIds,
+  }
+*/
+
+const parseAttributesValues = (obs, attributes, indexedDimensions, rejectedValueIds) => {
+  const { attrValuesIndexes, dimValuesIndexes } = obs;
+  return R.addIndex(R.reduce)(
+    (acc, valueIndex, attrIndex) => {
+      const attribute = R.nth(attrIndex, attributes);
+      if (R.isNil(attribute) || !R.propOr(true, 'display', attribute) || !R.prop('series', attribute)) {
+        return acc;
+      }
+      let value = R.nth(valueIndex, attribute.values || []);
+      if (!R.propOr(true, 'display', value) || R.includes(R.prop('id', value), rejectedValueIds)) {
+        value = null;
+      }
+      const relationship = R.propOr([], 'relationship', attribute);
+      let coordinates = {};
+      const serieKey = R.pipe(
+        dims => R.isEmpty(relationship) ? R.values(dims) : R.props(relationship, dims),
+        R.map(dim => {
+          const valueIndex = R.nth(dim.__index, dimValuesIndexes);
+          const valueId = R.path(['values', valueIndex, 'id'], dim);
+          coordinates = R.assoc(dim.id, valueId, coordinates);
+          return `${dim.id}=${valueId}`;
+        }),
+        R.ifElse(R.isEmpty, R.always(null), R.join(':'))
+      )(indexedDimensions);
+
+      return R.assoc(attribute.id, { ...R.pick(['id', 'name', 'relationship'], attribute), value, serieKey, coordinates, isObs: R.isEmpty(relationship) }, acc);
+    },
+    {},
+    attrValuesIndexes
+  );
+};
+
+const getFormatAttributesIndexes = (attributes, customAttributes) => R.addIndex(R.reduce)(
+  (acc, attribute, index) => {
+    if (R.equals(attribute.id, customAttributes.decimals)) {
+      return ({ ...acc, decimals: index });
+    }
+    if (R.equals(attribute.id, customAttributes.prefscale)) {
+      return ({ ...acc, prefscale: index });
+    }
+    return acc;
+  },
+  { prefscale: null, decimals: null },
+  attributes
+);
+
+export const enhanceObservations = (dimensions = [], observations = {}, attributes = [], options = {}) => {
+  const formatAttributesIndexes = getFormatAttributesIndexes(attributes, R.propOr({}, 'customAttributes', options));
+  const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
+
+  return R.mapObjIndexed(
+    (observation) => {
+      const { dimValuesIndexes } = observation;
+
+      const indexedDimValIds = R.addIndex(R.reduce)(
+        (acc, dimension, dimensionIndex) => {
+          const id = dimension.id;
+          const valueIndex = R.nth(dimensionIndex, dimValuesIndexes);
+          const valueId = R.path(['values', Number(valueIndex), 'id'], dimension);
+          return R.assoc(id, valueId, acc);
+        },
+        {},
+        dimensions
+      );
+
+      return ({
+        ...observation,
+        attributes: parseAttributesValues(observation, attributes, indexedDimensions, R.propOr([], 'rejectedValueIds', options)),
+        formattedValue: formatValue(observation, formatAttributesIndexes, attributes),
+        indexedDimValIds,
+      });
+    },
+    observations
+  );
+};

package/src/rules2/src/getAttributesSeries.js

@@ -0,0 +1,29 @@
+import * as R from 'ramda';
+
+export const getAttributesSeries = observations => R.pipe(
+  R.values,
+  R.reduce(
+    (acc, { attributes }) => {
+      let res = acc.res;
+      let rejected = acc.rejected;
+      R.forEachObjIndexed(
+        (attribute) => {
+          if (!R.isNil(attribute.serieKey)) {
+            const valueInRes = R.path([attribute.serieKey, attribute.id, 'value', 'id'], res);
+            if (!R.isNil(valueInRes) && valueInRes !== R.path(['value', 'id'], attribute)) {
+              res = R.dissocPath([attribute.serieKey, attribute.id], res);
+              rejected = R.assocPath([attribute.serieKey, attribute.id], true, rejected);
+            }
+            else {
+              res = R.assocPath([attribute.serieKey, attribute.id], attribute, res);
+            }
+          }
+        },
+        attributes
+      );
+      return ({ res, rejected });
+    },
+    { res: {}, rejected: {}, }
+  ),
+  R.prop('res')
+)(observations);

package/src/rules2/src/getCombinationDefinitions.js

@@ -0,0 +1,29 @@
+import * as R from 'ramda';
+
+export const getCombinationDefinitions = (annotations, locale) => {
+  const annotation = R.find(annot => annot.type === 'COMBINED_CONCEPTS', annotations);
+  if (R.isNil(annotation)) {
+    return [];
+  }
+  const title = R.propOr('', 'title', annotation);
+  const texts = R.propOr({}, 'texts', annotation);
+
+  return R.useWith(
+    (titles, texts) =>
+      R.addIndex(R.map)((title, index) => {
+        const split = R.split(':', title);
+        if (R.length(split !== 2)) {
+          return null;
+        }
+        const [id, codes] = split;
+        return {
+          id,
+          concepts: R.split(',', codes),
+          name: R.has(locale, texts)
+            ? R.pipe(R.prop(locale), R.nth(index), R.split(':'), R.last)(texts)
+            : `[${id}]`,
+        };
+      }, titles),
+    [R.split(';'), R.map(R.split(';'))],
+  )(title, texts);
+};

package/src/rules2/src/getHeaderCombinations.js

@@ -0,0 +1,39 @@
+import * as R from 'ramda';
+import { dimensionValueDisplay } from '../../rules/src';
+
+export const getHeaderCombinations = (combinations, dimensions, attributes, display) => {
+  const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
+  const indexedAttributes = R.indexBy(R.prop('id'), attributes);
+  return R.reduce(
+    (acc, comb) => {
+      if (!R.prop('header', comb)) {
+        return acc;
+      }
+
+      const header = dimensionValueDisplay(display)(comb);
+
+      const values = R.pipe(
+        R.reduce((_acc, concept) => {
+          const artefact = R.has(concept, indexedDimensions)
+            ? R.prop(concept, indexedDimensions)
+            : R.prop(concept, indexedAttributes);
+          if (R.isNil(artefact) || !R.prop('display', artefact || {})) {
+            return _acc;
+          }
+          const value = R.path(['values', 0], artefact);
+          if (R.isNil(value) || !R.prop('display', value || {})) {
+            return _acc;
+          }
+          return R.append(dimensionValueDisplay(display)(value), _acc);
+        }, []),
+        R.join(', '),
+      )(comb.concepts || []);
+      if (R.isEmpty(values)) {
+        return acc;
+      }
+      return R.append({ header, label: values }, acc);
+    },
+    [],
+    combinations,
+  );
+};

package/src/rules2/src/getHeaderSubtitle.js

@@ -0,0 +1,34 @@
+import * as R from 'ramda';
+import { getFlagsAndNotes } from './table/getFlagsAndNotes';
+import { dimensionValueDisplay } from '../../rules/src/';
+
+export const getHeaderSubtitle = (dimensions, combinations, customAttributes, display, microdataDimension) => {
+  const combinationsConepts = R.pipe(R.pluck('concepts'), R.unnest)(combinations);
+  const DEFAULT_REJECTED_SUBTITLE_IDS = ['_L', '_T', '_Z'];
+
+  return R.reduce(
+    (acc, dim) => {
+      if (!R.propOr(true, 'display', dim) || R.propEq('id', microdataDimension, dim)
+        || R.includes(dim.id, combinationsConepts)) {
+        return acc;
+      }
+      const value = R.path(['values', 0], dim);
+      if (!R.propOr(true, 'display', value) || R.includes(value.id, DEFAULT_REJECTED_SUBTITLE_IDS)) {
+        return acc;
+      }
+      const header = `${dimensionValueDisplay(display)(dim)}:`;
+      const label = dimensionValueDisplay(display)(value);
+      const flags = R.pipe(
+        getFlagsAndNotes,
+        R.map(entry => ({
+          code: entry.code,
+          header: `${dimensionValueDisplay(display)(entry)}:`,
+          label: dimensionValueDisplay(display)(entry.value),
+        })),
+      )(dim.attrValues, customAttributes);
+      return R.append({ header, label, flags }, acc);
+    },
+    [],
+    dimensions,
+  );
+};

package/src/rules2/src/getManyValuesDimensions.js

@@ -0,0 +1,34 @@
+import * as R from 'ramda';
+import { getFlagsAndNotes } from './table/getFlagsAndNotes';
+
+export const getManyValuesDimensions = (dimensions, attributesSeries, customAttributes, combinations) => {
+  const combConceptsIds = R.pipe(R.pluck('concepts'), R.unnest)(combinations);
+  return R.reduce(
+    (acc, dim) => {
+      if (R.length(dim.values || []) < 2) {
+        return acc;
+      }
+      const enhancedValues = R.map(val => {
+        const attrSeries = R.propOr({}, `${dim.id}=${val.id}`, attributesSeries);
+        if (R.isEmpty(attrSeries)) {
+          return val;
+        }
+        const flags = getFlagsAndNotes(attrSeries, customAttributes);
+        const hasAdvancedAttributes = R.pipe(
+          R.omit(
+            R.unnest([
+              customAttributes.flags || [],
+              customAttributes.notes || [],
+              combConceptsIds,
+            ]),
+          ),
+          R.complement(R.isEmpty),
+        )(attrSeries);
+        return { ...val, flags, hasAdvancedAttributes };
+      }, dim.values);
+      return R.append(R.assoc('values', enhancedValues, dim), acc);
+    },
+    [],
+    dimensions,
+  );
+};

package/src/rules2/src/getOneValueDimensions.js

@@ -0,0 +1,33 @@
+import * as R from 'ramda';
+
+export const getOneValueDimensions = (dimensions, attributes) => {
+  const indexedRelevantAttributes = R.reduce(
+    (acc, attr) => {
+      if (!attr.header || !attr.display || R.length(attr.relationship || []) !== 1) {
+        return acc;
+      }
+      const value = R.path(['values', 0], attr);
+      if (R.isNil(value) || !R.prop('display', value)) {
+        return acc;
+      }
+      const dim = R.head(attr.relationship);
+      return R.over(R.lensProp(dim), (values = {}) => ({
+        ...values,
+        [attr.id]: { ...attr, value },
+      }))(acc);
+    },
+    {},
+    attributes,
+  );
+  return R.reduce(
+    (acc, dim) => {
+      if (R.length(dim.values || []) !== 1) {
+        return acc;
+      }
+      const attrValues = R.propOr({}, dim.id, indexedRelevantAttributes);
+      return R.append({ ...dim, attrValues }, acc);
+    },
+    [],
+    dimensions,
+  );
+};

package/src/rules2/src/hasCellMetadata.js

@@ -4,7 +4,7 @@ export const hasCellMetadata = (metadataCoordinates, cellCoordinates) => {
   return R.pipe(
     R.find(coordinates => {
       const mergedCoord = R.mergeLeft(coordinates, cellCoordinates);
-      return R.equals(mergedCoord, cellCoordinates);
+      return !R.isEmpty(coordinates) && R.equals(mergedCoord, cellCoordinates);
     }),
     R.complement(R.isNil)
   )(metadataCoordinates);

package/src/rules2/src/index.js

@@ -13,13 +13,28 @@ export { getHCodelistsRefs, getHCodelistsRefsInData } from './getHCodelistsRefsI
 export { parseHierarchicalCodelist } from './parseHierarchicalCodelist';
 export { refinePartialHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy';
 export { getMetadataCoordinates } from './getMetadataCoordinates';
-export {
-  getDataflowAdvancedAttributes,
-  getObservationsAdvancedAttributes,
-  getSeriesAdvancedAttributes
-} from './getAdvancedAttributes';
 export { duplicateObs } from './duplicateObservations';
 export { hierarchiseDimensionWithAdvancedHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy';
 export { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy';
 export { getDimensionValuesIndexes } from './getDimensionValuesIndexes';
-
+export { getCombinationDefinitions } from './getCombinationDefinitions';
+export { parseAttributes } from './parseAttributes';
+export { parseCombinations } from './parseCombinations';
+export { refineAttributes } from './refineAttributes';
+export { enhanceObservations } from './enhanceObservations';
+export { getAttributesSeries } from './getAttributesSeries';
+export { getManyValuesDimensions } from './getManyValuesDimensions';
+export { getOneValueDimensions } from './getOneValueDimensions';
+export { getHeaderSubtitle } from './getHeaderSubtitle';
+export { getHeaderCombinations } from './getHeaderCombinations';
+export { getLayout } from './table/getLayout';
+export { getSortedLayoutIndexes } from './table/getSortedLayoutIndexes';
+export { refineLayoutSize } from './table/refineLayoutSize';
+export { getFlagsAndNotes } from './table/getFlagsAndNotes';
+export { getLayoutData } from './table/getLayoutData';
+export { getCellsAttributesIds } from './table/getCellsAttributesIds';
+export { getIndexedCombinationsByDisplay } from './table/getIndexedCombinationsByDisplay';
+export { getCells } from './table/getCells';
+export { getCuratedCells } from './table/getCuratedCells';
+export { prepareData } from './prepareData';
+export { getTableProps } from './table/getTableProps';

package/src/rules2/src/parseAttributes.js

@@ -0,0 +1,36 @@
+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);
+    if (R.isEmpty(attr.values || []) || !R.propOr(true, 'display', attr)
+      || attr.id === REPORTING_YEAR_START_DAY || attr.id === REPYEARSTART) {
+      return R.assoc('display', false, res);
+    }
+    if (R.propEq('id', customAttributes.prefscale, attr)) {
+      return R.assoc('prefscale', true, res);
+    }
+    if (R.propEq('id', customAttributes.decimals, 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 values = R.path([id, 'values'], indexedDimensions);
+        return R.length(values) > 1;
+      }),
+    )(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

@@ -0,0 +1,36 @@
+import * as R from 'ramda';
+
+export const parseCombinations = (combinations, parsedAttributes, dimensions) => {
+  const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
+  const indexedAttributes = R.indexBy(R.prop('id'), parsedAttributes);
+
+  return R.map(comb => {
+    let relationship = [];
+    let ids = {};
+    const seriesConcepts = R.filter(concept => {
+      if (R.has(concept, ids)) {
+        return false;
+      }
+      if (R.has(concept, indexedDimensions)) {
+        const values = R.path([concept, 'values'], indexedDimensions);
+        relationship = R.length(values) > 1 ? R.append(concept, relationship) : relationship;
+        ids = { ...ids, [concept]: concept };
+        return R.length(values) > 1;
+      }
+      const attribute = R.prop(concept, indexedAttributes);
+      relationship = attribute.series
+        ? R.pipe(
+            R.reject(id => R.has(id, ids)),
+            R.concat(relationship),
+          )(attribute.relationship)
+        : relationship;
+      ids = attribute.series ? { ...ids, ...R.indexBy(R.identity, attribute.relationship) } : ids;
+      return true;
+    }, comb.concepts);
+
+    if (R.isEmpty(seriesConcepts) || R.isEmpty(relationship)) {
+      return { ...comb, header: true };
+    }
+    return { ...comb, series: true, relationship };
+  }, combinations);
+};

package/src/rules2/src/parseMetadataSeries.js

@@ -1,5 +1,6 @@
 import * as R from 'ramda';
 import { getRefinedName } from '@sis-cc/dotstatsuite-sdmxjs';
+import { EMPTY_ATTACHMENT_LEVEL_CHAR } from './constants';
 
 const dimensionValueDisplay = (display) => data => {
   if (display === 'code') {
@@ -37,8 +38,8 @@ export const parseMetadataSeries = (metadataJson, options) => {
       const evolvedKey = R.pipe(
         R.split(':'),
         R.addIndex(R.map)((vInd, dInd) => {
-          if (R.isEmpty(vInd)) {
-            return vInd;
+          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 || []);

package/src/rules2/src/prepareData.js

@@ -0,0 +1,50 @@
+import * as R from 'ramda';
+import { getObservations } from '../../rules/src';
+import { enhanceObservations } from './enhanceObservations';
+import { parseAttributes } from './parseAttributes';
+import { getCombinationDefinitions } 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 './hierarchiseDimensionWithNativeHierarchy';
+import { hierarchiseDimensionWithAdvancedHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy';
+
+export const prepareData = (sdmxJson, customAttributes, locale, hierarchies) => {
+  const dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
+  const attributes = R.pathOr([], ['data', 'structure', 'attributes', 'observation'], sdmxJson);
+  const annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
+  const observations = getObservations(sdmxJson);
+  const combinations = getCombinationDefinitions(annotations, locale);
+  const metadataCoordinates = getMetadataCoordinates(sdmxJson);
+
+  const parsedAttributes = parseAttributes(attributes, dimensions, customAttributes);
+  const parsedCombinations = parseCombinations(combinations, parsedAttributes, dimensions);
+  const seriesCombinations = R.filter(R.prop('series'), parsedCombinations);
+  const refinedAttributes = refineAttributes(parsedAttributes, seriesCombinations);
+
+  const enhancedObservations = enhanceObservations(dimensions, observations, refinedAttributes, { customAttributes });
+  const attributesSeries = getAttributesSeries(enhancedObservations);
+  const manyValuesDimensions = getManyValuesDimensions(dimensions, attributesSeries, customAttributes, seriesCombinations);
+  const oneValueDimensions = getOneValueDimensions(dimensions, parsedAttributes);
+  const hierarchisedDimensions = R.map(dim => {
+    if (R.isEmpty(R.propOr({}, dim.id, hierarchies))) {
+      return hierarchiseDimensionWithNativeHierarchy(dim);
+    }
+    return hierarchiseDimensionWithAdvancedHierarchy(dim, R.prop(dim.id, hierarchies));
+  }, manyValuesDimensions)
+  const duplicatedObservations = duplicateObs(R.values(hierarchisedDimensions), enhancedObservations);
+  
+  return ({
+    observations: duplicatedObservations,
+    dimensions: hierarchisedDimensions,
+    combinations: parsedCombinations,
+    oneValueDimensions,
+    attributesSeries,
+    metadataCoordinates,
+    attributes: refinedAttributes
+  });
+};

package/src/rules2/src/refineAttributes.js

@@ -0,0 +1,16 @@
+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) };
+    }
+    return attr;
+  }, parsedAttributes);
+};