@sis-cc/dotstatsuite-components 16.1.1 → 16.1.2

package/src/rules2/src/getDataflowAttributes.js

@@ -0,0 +1,23 @@
+import * as R from 'ramda';
+import { REJECTED_VALUE_IDS } from './constants';
+
+export const getDataflowAttributes = (attributes, combinations) => {
+  const combinationsConceptsIds = R.pipe(R.pluck('concepts'), R.unnest)(combinations);
+  return R.reduce(
+    (acc, attribute) => {
+      if (!R.prop('header', attribute) || !R.isEmpty(attribute.relationship)
+        || R.includes(attribute.id, combinationsConceptsIds)) {
+        return acc;
+      }
+      const value = R.head(attribute.values);
+      if (!R.propOr(true, 'display', attribute) || R.isNil(value)
+        || !R.propOr(true, 'display', value) || R.includes(R.prop('id', value), REJECTED_VALUE_IDS)) {
+        return acc;
+      }
+      return R.assoc(attribute.id, { ...R.pick(['id', 'name'], attribute), value }, acc);
+    },
+    {},
+    attributes,
+  );
+};
+

package/src/rules2/src/getHeaderTitle.js

@@ -0,0 +1,15 @@
+import * as R from 'ramda';
+import { dimensionValueDisplay } from '../../rules/src';
+import { getFlagsAndNotes } from './table/getFlagsAndNotes';
+
+export const getHeaderTitle = (dataflow, attributes, display, customAttributes) => ({
+  label: dimensionValueDisplay(display)(dataflow),
+  flags: R.pipe(
+    getFlagsAndNotes,
+    R.map(entry => ({
+      code: entry.code,
+      header: `${dimensionValueDisplay(display)(entry)}:`,
+      label: dimensionValueDisplay(display)(entry.value),
+    })),
+  )(attributes, customAttributes),
+});

package/src/rules2/src/getOneValueDimensions.js

@@ -1,4 +1,5 @@
 import * as R from 'ramda';
+import { REJECTED_VALUE_IDS } from './constants';
 
 export const getOneValueDimensions = (dimensions, attributes) => {
   const indexedRelevantAttributes = R.reduce(
@@ -7,7 +8,7 @@ export const getOneValueDimensions = (dimensions, attributes) => {
         return acc;
       }
       const value = R.path(['values', 0], attr);
-      if (R.isNil(value) || !R.prop('display', value)) {
+      if (R.isNil(value) || !R.prop('display', value) || R.includes(R.prop('id', value), REJECTED_VALUE_IDS)) {
         return acc;
       }
       const dim = R.head(attr.relationship);

package/src/rules2/src/getSidebarData.js

@@ -1,15 +1,6 @@
 import * as R from 'ramda';
-
-const dimensionValueDisplay = (display) => data => {
-  const name = R.isNil(data.name) ? `[${data.id}]` : data.name;
-  if (display === 'code') {
-    return R.prop('id', data);
-  }
-  if (display ===  'both') {
-    return `${R.prop('id', data)}: ${name}`;
-  }
-  return name;
-};
+import { dimensionValueDisplay } from '../../rules/src';
+import { REJECTED_VALUE_IDS } from './constants';
 
 const sortByCoordinates = (a, b) => {
   const splitACoord = a.splitCoord;
@@ -50,7 +41,8 @@ export const getSidebarData = (attributesSeries, metadataSeries, dataflow, dimen
           const dim = R.nth(dimIndex, dimensions);
           const values = R.propOr([], 'values', dim || {});
           const value = R.nth(Number(valIndex), values);
-          if (!value || !R.propOr(true, 'display', dim) || !R.propOr(true, 'display', value)) {
+          if (!value || !R.propOr(true, 'display', dim) || !R.propOr(true, 'display', value)
+            || R.includes(R.prop('id', value), REJECTED_VALUE_IDS)) {
             return ({ ...acc, split: R.append('', acc.split) });
           }
           const dimLabel = dimensionValueDisplay(options.display)(dim);

package/src/rules2/src/index.js

@@ -25,6 +25,8 @@ export { enhanceObservations } from './enhanceObservations';
 export { getAttributesSeries } from './getAttributesSeries';
 export { getManyValuesDimensions } from './getManyValuesDimensions';
 export { getOneValueDimensions } from './getOneValueDimensions';
+export { getDataflowAttributes } from './getDataflowAttributes';
+export { getHeaderTitle } from './getHeaderTitle';
 export { getHeaderSubtitle } from './getHeaderSubtitle';
 export { getHeaderCombinations } from './getHeaderCombinations';
 export { getLayout } from './table/getLayout';
@@ -33,6 +35,7 @@ export { refineLayoutSize } from './table/refineLayoutSize';
 export { getFlagsAndNotes } from './table/getFlagsAndNotes';
 export { getLayoutData } from './table/getLayoutData';
 export { getCellsAttributesIds } from './table/getCellsAttributesIds';
+export { getCellsMetadataCoordinates } from './table/getCellsMetadataCoordinates';
 export { getIndexedCombinationsByDisplay } from './table/getIndexedCombinationsByDisplay';
 export { getCells } from './table/getCells';
 export { getCuratedCells } from './table/getCuratedCells';

package/src/rules2/src/parseCombinations.js

@@ -17,6 +17,9 @@ export const parseCombinations = (combinations, parsedAttributes, dimensions) =>
         ids = { ...ids, [concept]: concept };
         return R.length(values) > 1;
       }
+      else if (!R.has(concept, indexedAttributes)) {
+        return false;
+      }
       const attribute = R.prop(concept, indexedAttributes);
       relationship = attribute.series
         ? R.pipe(
@@ -25,10 +28,10 @@ export const parseCombinations = (combinations, parsedAttributes, dimensions) =>
           )(attribute.relationship)
         : relationship;
       ids = attribute.series ? { ...ids, ...R.indexBy(R.identity, attribute.relationship) } : ids;
-      return true;
+      return attribute.series;
     }, comb.concepts);
 
-    if (R.isEmpty(seriesConcepts) || R.isEmpty(relationship)) {
+    if (R.isEmpty(seriesConcepts)) {
       return { ...comb, header: true };
     }
     return { ...comb, series: true, relationship };

package/src/rules2/src/prepareData.js

@@ -2,7 +2,7 @@ import * as R from 'ramda';
 import { getObservations } from '../../rules/src';
 import { enhanceObservations } from './enhanceObservations';
 import { parseAttributes } from './parseAttributes';
-import { getCombinationDefinitions } from './getCombinationDefinitions';
+import { getCombinationDefinitions, parseCombinationDefinition } from './getCombinationDefinitions';
 import { parseCombinations } from './parseCombinations';
 import { refineAttributes } from './refineAttributes';
 import { duplicateObs } from './duplicateObservations';
@@ -12,13 +12,21 @@ import { getManyValuesDimensions } from './getManyValuesDimensions';
 import { getOneValueDimensions } from './getOneValueDimensions';
 import { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy';
 import { hierarchiseDimensionWithAdvancedHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy';
+import { getDataflowAttributes } from './getDataflowAttributes';
+import { getHeaderTitle } from './getHeaderTitle';
+import { getHeaderSubtitle } from './getHeaderSubtitle';
+import { getHeaderCombinations } from './getHeaderCombinations';
 
-export const prepareData = (sdmxJson, customAttributes, locale, hierarchies) => {
+export const prepareData = (sdmxJson, { customAttributes, locale, hierarchies, dataflow, display, defaultCombinations }) => {
   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);
+  let combinations = getCombinationDefinitions(annotations, locale);
+  if (R.isEmpty(combinations) && !R.isEmpty(defaultCombinations)) {
+    const { concepts, names } = defaultCombinations;
+    combinations = parseCombinationDefinition(concepts, names);
+  }
   const metadataCoordinates = getMetadataCoordinates(sdmxJson);
 
   const parsedAttributes = parseAttributes(attributes, dimensions, customAttributes);
@@ -37,6 +45,11 @@ export const prepareData = (sdmxJson, customAttributes, locale, hierarchies) =>
     return hierarchiseDimensionWithAdvancedHierarchy(dim, R.prop(dim.id, hierarchies));
   }, 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,
@@ -45,6 +58,11 @@ export const prepareData = (sdmxJson, customAttributes, locale, hierarchies) =>
     oneValueDimensions,
     attributesSeries,
     metadataCoordinates,
-    attributes: refinedAttributes
+    attributes: refinedAttributes,
+    header: {
+      title: headerTitle,
+      subtitle: headerSubtitle,
+      combinations: headerCombinations
+    }
   });
 };

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

@@ -5,6 +5,9 @@ import { trimedProps } from '../utils';
 
 export const getCellRelevantAttributes = (attributes, attributesSeries, cellAttributeIds) => R.filter(
   (attr) => {
+    if (R.isNil(attr.value)) {
+      return false;
+    }
     if (R.has(attr.id, cellAttributeIds)) {
       return true;
     }
@@ -48,9 +51,8 @@ export const getCells = (customAttributes, cellsAttributesId, combinations, attr
   return R.mapObjIndexed(
     obs => {
       const relevantAttributes = getCellRelevantAttributes(obs.attributes, attributesSeries, cellsAttributesId);
-      const flagsAndNotes = getFlagsAndNotes(relevantAttributes, _customAttributes);
+      const flagsAndNotes = getFlagsAndNotes(R.omit(attributesInCellsCombination, relevantAttributes), _customAttributes);
       const combinedAttributes = getCellCombinedAttributes(relevantAttributes, combinations.cells || []);
-
       const hasAdvancedAttributes = R.pipe(
         R.omit(R.unnest([_customAttributes.flags || [], _customAttributes.notes || [], attributesInCellsCombination])),
         R.isEmpty,

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

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

@@ -13,9 +13,6 @@ export const getCombinationDimensionsData = (indexes, combination, previous, sam
       const dimension = R.nth(dimIndex, dimensions);
       const value = R.nth(Math.abs(valIndex), R.propOr([], 'values', dimension));
       hasAdvancedAttributes = !hasAdvancedAttributes ? value.hasAdvancedAttributes : true;
-      if (!value) {
-        return acc;
-      }
       coordinates = R.assoc(dimension.id, value.id, coordinates);
       ids = R.append(`${dimension.id}=${value.id}`, ids);
       const previousValue = R.propOr({}, dimension.id, previous);
@@ -23,7 +20,11 @@ export const getCombinationDimensionsData = (indexes, combination, previous, sam
         return R.assoc(dimension.id, previousValue, acc);
       }
       else {
-        const parsedValue = parseValueHierarchy(value, _sameSerie ? previousValue || {} : {}, dimension.indexedValues);
+        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;
         }

package/src/rules2/src/table/getLayoutData.js

@@ -3,8 +3,9 @@ import { getFlagsAndNotes } from './getFlagsAndNotes';
 import { hasCellMetadata } from '../hasCellMetadata';
 import { getCombinationDimensionsData } from './getCombinationDimensionsData';
 import { parseValueHierarchy } from './parseValueHierarchy';
+import { REJECTED_VALUE_IDS } from '../constants';
 
-const getSubLayoutData = (series, _definition, { metadataCoordinates, attributesSeries, customAttributes }) => {
+const getSubLayoutData = (series, _definition, { metadataCoordinates, attributesSeries, customAttributes, topCoordinates={} }) => {
   const getHasAdvancedAttributes = (attrValues) => R.pipe(
     R.omit(R.concat(customAttributes.flags, customAttributes.notes)),
     R.isEmpty,
@@ -46,7 +47,7 @@ const getSubLayoutData = (series, _definition, { metadataCoordinates, attributes
       let sameSerie = true;
       let i = 0;
       let hasAdvancedAttributes = false;
-      let coordinates = {};
+      let coordinates = topCoordinates;
       let ids = [];
       while (i < serie.length) {
         const entry = serie[i];
@@ -117,7 +118,11 @@ const getSubLayoutData = (series, _definition, { metadataCoordinates, attributes
           const values = R.reduce(
             (_acc, id) => {
               if (R.has(id, dimValues)) {
-                return R.append(R.prop(id, dimValues), _acc);
+                const value = R.prop(id, dimValues);
+                if (!R.propOr(true, 'display', value) || R.includes(R.prop('id', value), REJECTED_VALUE_IDS)) {
+                  return _acc;
+                }
+                return R.append(R.dissoc('display', value), _acc);
               }
               if (R.has(id, fixedDimValues)) {
                 return R.append(R.prop(id, fixedDimValues), _acc);
@@ -151,7 +156,7 @@ const getSubLayoutData = (series, _definition, { metadataCoordinates, attributes
         ? { hasMetadata, hasAdvancedAttributes, coordinates } : null;
 
       return {
-        res: R.append({ data, key: R.join(':', ids), flags, sideProps }, acc.res),
+        res: R.append({ data, key: R.join(':', ids), flags, sideProps, coordinates }, acc.res),
         previous: next,
       };
     },
@@ -173,7 +178,10 @@ export const getLayoutData = (layoutIndexes, layout, { metadataCoordinates, attr
         return [];
       }
       const _sectionsData = getSubLayoutData(sections, layout.sections, opts);
-      const rowsData = R.map(rows => getSubLayoutData(rows, layout.rows, opts), sectionsRows);
+      const rowsData = R.addIndex(R.map)((rows, sectionIndex) => {
+        const sectionCoordinates = R.path([sectionIndex, 'coordinates'], _sectionsData);
+        return getSubLayoutData(rows, layout.rows, R.assoc('topCoordinates', sectionCoordinates, opts));
+      }, sectionsRows);
 
       return R.transpose([_sectionsData, rowsData]);
     }

package/src/rules2/src/table/parseValueHierarchy.js

@@ -7,17 +7,16 @@ export const parseValueHierarchy = (value, previousValue, indexedValues) => {
   }
   const _previousParentsIds = R.propOr([], 'parentsIds', previousValue);
   const previousParentsIds = R.isNil(previousValue) ? [] : R.append(R.prop('id', previousValue), _previousParentsIds);
-  const [presentIds, missingIds] = R.addIndex(R.splitWhen)((val, ind) => R.nth(ind, previousParentsIds) !== val, parentsIds);
-  //console.log({ presentIds, missingIds });
+  const [presentIds, _missingIds] = R.addIndex(R.splitWhen)((val, ind) => R.nth(ind, previousParentsIds) !== val, parentsIds);
+  const __previousParentsIds = R.pipe(R.propOr([], 'parents'), R.pluck('id'))(previousValue);
+  const missingIds = R.pipe(
+    R.takeLastWhile(id => !R.includes(id, __previousParentsIds) && id !== R.prop('id', previousValue)),
+    ids => R.concat(ids, _missingIds)
+  )(presentIds);
   const _previousParents = R.propOr([], 'parents', previousValue);
   const previousParents = R.isNil(previousValue) ? [] : R.append(R.pick(['id', 'name'], previousValue), _previousParents);
-  //console.log('previousParents', previousParents);
   const parents = R.takeWhile(p => R.includes(p.id, presentIds), previousParents);
-  const missingParents = R.concat(
-    R.includes(R.prop('id', previousValue), presentIds)
-      ? [] : R.takeWhile(p => R.includes(p.id, presentIds), R.propOr([], 'missingParents', previousValue)),
-    R.props(missingIds, indexedValues)
-  );
+  const missingParents = R.props(missingIds, indexedValues);
   return ({
     ...value,
     parents,

package/test/getAttributesSeries.test.js

@@ -8,6 +8,7 @@ describe('getAttributesSeries tests', () => {
         attributes: {
           A: { id: 'A', value: { id: 'A0' }, serieKey: 'd0=v0' },
           B: { id: 'B', value: { id: 'B0' }, serieKey: 'd1=v0' },
+          C: { id: 'C', value: null, serieKey: 'd2=v0' },
         }
       },
       b: {
@@ -38,6 +39,7 @@ describe('getAttributesSeries tests', () => {
         attributes: {
           A: { id: 'A', value: { id: 'A0' }, serieKey: 'd0=v0' },
           B: { id: 'B', value: { id: 'B3' }, serieKey: 'd1=v2' },
+          C: { id: 'C', value: { id: 'C0' }, serieKey: 'd2=v0' },
         }
       }
     };

package/test/getCells.test.js

@@ -14,6 +14,7 @@ describe('getCells tests', () => {
           value: 33,
           formattedValue: '33',
           attributes: {
+            FL1: { id: 'FL1', name: 'Flag 1', Value: null },
             FL2: { id: 'FL2', name: 'Flag 2', value: { id: 'FL2.1', name: 'Flag 2 Value 1' } },
             FT1: { id: 'FT1', name: 'Footnote 1', value: { id: 'FT1.1', name: 'Footnote 1 Value 1' } },
             FT3: { id: 'FT3', name: 'Footnote 3', value: { id: 'FT3.3', name: 'Footnote 3 Value 3' } },

package/test/getCellsMetadataCoordinates.test.js

@@ -0,0 +1,40 @@
+import { expect } from 'chai';
+import { getCellsMetadataCoordinates } from '../src/rules2/src/';
+
+describe('getCellsMetadataCoordinates tests', () => {
+  it('basic tests', () => {
+    const oneValueDimensions = [
+      { id: 'HEADER1' },
+      { id: 'HEADER2' },
+    ];
+
+    const layoutIds = {
+      header: ['COLUMN1', 'COLUMN2'],
+      sections: ['SECTION1', 'SECTION2'],
+      rows: ['ROW1', 'ROW2'],
+    };
+
+    const coordinates = [
+      {},
+      { HEADER1: 'v' },
+      { HEADER1: 'v', HEADER2: 'v' },
+      { COLUMN1: 'v' },
+      { COLUMN1: 'v', COLUMN2: 'v' },
+      { HEADER1: 'v', COLUMN1: 'v', COLUMN2: 'v' },
+      { SECTION1: 'v' },
+      { SECTION1: 'v', SECTION2: 'v' },
+      { HEADER1: 'v', SECTION1: 'v', SECTION2: 'v' },
+      { ROW1: 'v' },
+      { ROW1: 'v', ROW2: 'v' },
+      { HEADER1: 'v', ROW1: 'v', ROW2: 'v' },
+      { HEADER1: 'v', SECTION1: 'v', SECTION2: 'v', ROW1: 'v', ROW2: 'v' },
+      { ROW1: 'v', HEADER2: 'v', COLUMN2: 'v' },
+      { SECTION1: 'v', ROW2: 'v', COLUMN1: 'v' }
+    ];
+
+    expect(getCellsMetadataCoordinates(coordinates, oneValueDimensions, layoutIds)).to.deep.equal([
+      { ROW1: 'v', HEADER2: 'v', COLUMN2: 'v' },
+      { SECTION1: 'v', ROW2: 'v', COLUMN1: 'v' }
+    ]);
+  });
+});

package/test/getCombinationDimensionsData.test.js

@@ -16,6 +16,7 @@ describe('getCombinationDimensionsData', () => {
         },
         {
           id: 'D1',
+          display: false,
           values: [
             { id: 'v0' },
             { id: 'v1', hasAdvancedAttributes: true },
@@ -35,10 +36,14 @@ describe('getCombinationDimensionsData', () => {
 
     const indexes = [0, 1, -2];
 
-    const previous = { D0: { id: 'v0' }, D1: { id: 'v0' }, D2: { id: 'v2' } };
+    const previous = { D0: { id: 'v0', display: true }, D1: { id: 'v0', display: false }, D2: { id: 'v2', display: true } };
 
     expect(getCombinationDimensionsData(indexes, combination, previous, true)).to.deep.equal({
-      dimValues: { D0: { id: 'v0' }, D1: { id: 'v1', hasAdvancedAttributes: true }, D2: { id: 'v2' } },
+      dimValues: {
+        D0: { id: 'v0', display: true },
+        D1: { id: 'v1', hasAdvancedAttributes: true, display: false },
+        D2: { id: 'v2', display: true }
+      },
       sameSerie: false,
       coordinates: { D0: 'v0', D1: 'v1', D2: 'v2' },
       ids: ['D0=v0', 'D1=v1', 'D2=v2'],

package/test/getDataflowAttributes.test.js

@@ -0,0 +1,23 @@
+import { expect } from 'chai';
+import { getDataflowAttributes } from '../src/rules2/src/';
+
+describe('getDataflowAttributes tests', () => {
+  it('complete case', () => {
+    const attributes = [
+      { id: 'HEADER1', header: true, relationship: [], display: false, values: [{ id: 'v' }] },
+      { id: 'HEADER2', header: true, relationship: [], values: [{ id: 'v', display: false }] },
+      { id: 'HEADER3', header: true, relationship: [], values: [{ id: '_Z' }] },
+      { id: 'HEADER4', header: true, relationship: [], values: [] },
+      { id: 'HEADER5', header: true, relationship: [], values: [{ id: 'v' }] },
+      { id: 'HEADER6', header: true, relationship: [], values: [{ id: 'v' }] },
+      { id: 'HEADER7', header: true, relationship: ['DIM1'], values: [{ id: 'v' }] },
+      { id: 'SERIE', series: true, relationship: [], values: [{ id: 'v' }] },
+    ];
+
+    const combinations = [{ id: 'COMB', concepts: ['DIM1', 'DIM2', 'HEADER5'] }];
+
+    expect(getDataflowAttributes(attributes, combinations)).to.deep.equal({
+      HEADER6: { id: 'HEADER6', value: { id: 'v' } }
+    });
+  });
+});

package/test/getHeaderTitle.test.js

@@ -0,0 +1,25 @@
+import { expect } from 'chai';
+import { getHeaderTitle } from '../src/rules2/src/';
+
+describe('getHeaderTitle tests', () => {
+  it('basic case', () => {
+
+    const dataflow = { id: 'DF', name: 'dataflow' };
+
+    const attributes = {
+      FLAG: { id: 'FLAG', name: 'flag', value: { id: 'v', name: 'flag value' } },
+      NOTE: { id: 'NOTE', name: 'note', value: { id: 'v2', name: 'note value' } },
+      OTHER: { id: 'OTHER', name: 'other', value: { id: 'v3', name: 'other value' } },
+    }
+
+    const customAttributes = { flags: ['FLAG'], notes: ['NOTE'] };
+
+    expect(getHeaderTitle(dataflow, attributes, 'label', customAttributes)).to.deep.equal({
+      label: 'dataflow',
+      flags: [
+        { code: 'v', header: 'flag:', label: 'flag value' },
+        { code: undefined, header: 'note:', label: 'note value' },
+      ]
+    });
+  });
+});

package/test/getLayoutData.test.js

@@ -0,0 +1,130 @@
+import { expect } from 'chai';
+import { getLayoutData } from '../src/rules2/src/';
+
+describe('getLayoutData tests', () => {
+  it('basic case with combination', () => {
+    const layout = {
+      header: [],
+      sections: [{ id: 'S', values: [{ id: 'S_V1' }, { id: 'S_V2' }] }],
+      rows: [{
+        id: 'COMB',
+        concepts: ['R1', 'R2', 'ATTR'],
+        dimensions: [
+          { id: 'R1', values: [{ id: 'R1_V1' }, { id: 'R1_V2' }] },
+          { id: 'R2', values: [{ id: 'R2_V1' }, { id: 'R2_V2', display: false }] },
+        ]
+      }]
+    };
+
+    const attributesSeries = {
+      'R1=R1_V1:R2=R2_V1': {
+        ATTR: { id: 'ATTR', value: { id: 'ATTR_V1' }, coordinates: { R1: 'R1_V1', R2: 'R2_V1' } },
+      },
+      'R1=R1_V1:R2=R2_V2': {
+        ATTR: { id: 'ATTR', value: { id: 'ATTR_V2' }, coordinates: { R1: 'R1_V1', R2: 'R2_V2' } },
+      },
+      'R1=R1_V2:R2=R2_V1': {
+        ATTR: { id: 'ATTR', value: { id: 'ATTR_V3' }, coordinates: { R1: 'R1_V2', R2: 'R2_V1' } },
+      },
+      'R1=R1_V2:R2=R2_V2': {
+        ATTR: { id: 'ATTR', value: { id: 'ATTR_V4' }, coordinates: { R1: 'R1_V2', R2: 'R2_V2' } },
+      },
+    };
+
+    const layoutIndexes = {
+      header: [],
+      sections: [
+        [
+          [0],
+          [
+            [[0, 0]],
+            [[0, 1]],
+            [[1, 0]],
+            [[1, 1]],
+          ]
+        ],
+        [
+          [1],
+          [
+            [[0, 0]],
+            [[0, 1]],
+            [[1, 0]],
+            [[1, 1]],
+          ]
+        ]
+      ]
+    };
+
+    expect(getLayoutData(layoutIndexes, layout, { attributesSeries, metadataCoordinates: [], customAttributes: { flags: [], notes: [] } })).to.deep.equal({
+      headerData: [],
+      sectionsData: [
+        [
+          { data: [{ dimension: { id: 'S' }, value: { id: 'S_V1' } }], key: 'S=S_V1', flags: [], sideProps: null, coordinates: { S: 'S_V1' } },
+          [
+            {
+              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V1' }, { id: 'R2_V1' }, { id: 'ATTR_V1' }] }],
+              key: 'R1=R1_V1:R2=R2_V1',
+              coordinates: { R1: 'R1_V1', R2: 'R2_V1', S: 'S_V1' },
+              flags: [],
+              sideProps: null
+            },
+            {
+              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V1' }, { id: 'ATTR_V2' }] }],
+              key: 'R1=R1_V1:R2=R2_V2',
+              coordinates: { R1: 'R1_V1', R2: 'R2_V2', S: 'S_V1' },
+              flags: [],
+              sideProps: null
+            },
+            {
+              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V2' }, { id: 'R2_V1' }, { id: 'ATTR_V3' }] }],
+              key: 'R1=R1_V2:R2=R2_V1',
+              coordinates: { R1: 'R1_V2', R2: 'R2_V1', S: 'S_V1' },
+              flags: [],
+              sideProps: null
+            },
+            {
+              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V2' }, { id: 'ATTR_V4' }] }],
+              key: 'R1=R1_V2:R2=R2_V2',
+              coordinates: { R1: 'R1_V2', R2: 'R2_V2', S: 'S_V1' },
+              flags: [],
+              sideProps: null
+            },
+          ]
+        ],
+        [
+          { data: [{ dimension: { id: 'S' }, value: { id: 'S_V2' } }], key: 'S=S_V2', flags: [], sideProps: null, coordinates: { S: 'S_V2' } },
+          [
+            {
+              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V1' }, { id: 'R2_V1' }, { id: 'ATTR_V1' }] }],
+              key: 'R1=R1_V1:R2=R2_V1',
+              coordinates: { R1: 'R1_V1', R2: 'R2_V1', S: 'S_V2' },
+              flags: [],
+              sideProps: null
+            },
+            {
+              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V1' }, { id: 'ATTR_V2' }] }],
+              key: 'R1=R1_V1:R2=R2_V2',
+              coordinates: { R1: 'R1_V1', R2: 'R2_V2', S: 'S_V2' },
+              flags: [],
+              sideProps: null
+            },
+            {
+              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V2' }, { id: 'R2_V1' }, { id: 'ATTR_V3' }] }],
+              key: 'R1=R1_V2:R2=R2_V1',
+              coordinates: { R1: 'R1_V2', R2: 'R2_V1', S: 'S_V2' },
+              flags: [],
+              sideProps: null
+            },
+            {
+              data: [{ dimension: { id: 'COMB' }, values: [{ id: 'R1_V2' }, { id: 'ATTR_V4' }] }],
+              key: 'R1=R1_V2:R2=R2_V2',
+              coordinates: { R1: 'R1_V2', R2: 'R2_V2', S: 'S_V2' },
+              flags: [],
+              sideProps: null
+            },
+          ]
+        ]
+      ]
+    })
+  });
+});

package/test/parseCombinations.test.js

@@ -0,0 +1,36 @@
+import { expect } from 'chai';
+import { parseCombinations } from '../src/rules2/src/';
+
+describe('parseCombinations tests', () => {
+  it('complete case', () => {
+    const combinations = [
+      { id: 'COMB1', concepts: ['DIM1', 'DIM2'] },
+      { id: 'COMB2', concepts: ['DIM3', 'DIM4'] },
+      { id: 'COMB3', concepts: ['ATTR1', 'ATTR2'] },
+      { id: 'COMB4', concepts: ['ATTR3', 'ATTR4'] },
+      { id: 'COMB5', concepts: ['DIM1', 'ATTR4'] },
+    ];
+
+    const dimensions = [
+      { id: 'DIM1', values: [{ id: 'v1' }] },
+      { id: 'DIM2', values: [{ id: 'v1' }] },
+      { id: 'DIM3', values: [{ id: 'v1' }, { id: 'v2' }] },
+      { id: 'DIM4', values: [{ id: 'v1' }, { id: 'v2' }] },
+    ];
+
+    const attributes = [
+      { id: 'ATTR1', header: true, relationship: [] },
+      { id: 'ATTR2', header: true, relationship: ['DIM1'] },
+      { id: 'ATTR3', header: true, relationship: [] },
+      { id: 'ATTR4', series: true, relationship: ['DIM3', 'DIM4'] },
+    ];
+
+    expect(parseCombinations(combinations, attributes, dimensions)).to.deep.equal([
+      { id: 'COMB1', concepts: ['DIM1', 'DIM2'], header: true },
+      { id: 'COMB2', concepts: ['DIM3', 'DIM4'], series: true, relationship: ['DIM3', 'DIM4']  },
+      { id: 'COMB3', concepts: ['ATTR1', 'ATTR2'], header: true },
+      { id: 'COMB4', concepts: ['ATTR3', 'ATTR4'], series: true, relationship: ['DIM3', 'DIM4'] },
+      { id: 'COMB5', concepts: ['DIM1', 'ATTR4'] , series: true, relationship: ['DIM3', 'DIM4'] },
+    ]);
+  });
+});