@sis-cc/dotstatsuite-components 22.0.1 → 22.0.3

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

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

@@ -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

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

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

@@ -0,0 +1,23 @@
+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)
+  );
+};

package/src/rules2/src/table/getIndexedCombinationsByDisplay.js

@@ -0,0 +1,16 @@
+import * as R from 'ramda';
+
+export const getIndexedCombinationsByDisplay = (layout, combinations) => {
+  const layoutIds = R.pipe(
+    R.map(R.pluck('id')),
+    R.values,
+    R.unnest,
+    R.indexBy(R.identity),
+  )(layout);
+
+  const [combsInLayout, combsInCells] = R.partition(
+    comb => R.has(comb.id, layoutIds),
+    combinations,
+  );
+  return { cells: combsInCells, layout: combsInLayout };
+};

package/src/rules2/src/table/getLayout.js

@@ -0,0 +1,84 @@
+import * as R from 'ramda';
+import { isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
+
+export const getConceptsSet = (ids, indexedCombinations, _upper) => {
+  const upper = R.isNil(_upper) ? new Set([]) : _upper;
+  const res = new Set([]);
+  R.forEach(id => {
+    if (!R.has(id, indexedCombinations)) {
+      res.add(id);
+    }
+    else {
+      const comb = R.prop(id, indexedCombinations);
+      R.forEach(c => {
+        if (!upper.has(c)) {
+          res.add(c);
+        }
+      }, comb.concepts);
+    }
+  }, ids);
+  return res;
+};
+
+export const parseCombination = (_upperIds, _excludedIds) => (comb, indexedDimensions) => {
+  const upperIds = R.isNil(_upperIds) ? new Set([]) : _upperIds;
+  const excludedIds = R.isNil(_excludedIds) ? new Set([]) : _excludedIds;
+
+  const { concepts, relationship } = comb;
+  const dimensions = R.reduce((acc, id) => {
+    if (upperIds.has(id) || !R.has(id, indexedDimensions)) {
+      return acc
+    }
+    const dim = R.prop(id, indexedDimensions);
+    return R.append(dim, acc);
+  }, [], concepts);
+  const excludedDep = R.find(i => excludedIds.has(i), relationship);
+  if (excludedDep) {
+    return dimensions;
+  }
+  return R.assoc('dimensions', dimensions, comb);
+};
+
+export const getLayout = (_layoutIds, dimensions, combinations, isTimeInverted) => {
+  const layoutIds = R.mergeRight(
+    { header: [], sections: [], rows: [] },
+    _layoutIds,
+  );
+  const applyInversionOnTimeDim = dim =>
+    isTimePeriodDimension(dim) && isTimeInverted
+      ? R.assoc('isInverted', true, dim)
+      : dim;
+
+  const indexedDimensions = R.reduce(
+    (acc, dim) => R.assoc(dim.id, applyInversionOnTimeDim(dim), acc),
+    {},
+    dimensions,
+  );
+  
+  const indexedCombinations = R.indexBy(R.prop('id'), combinations);
+  const headerConceptsSet = getConceptsSet(layoutIds.header, indexedCombinations);
+  const sectionsConceptsSet = getConceptsSet(layoutIds.sections, indexedCombinations);
+  const rowsConceptsSet = getConceptsSet(R.concat(layoutIds.sections, layoutIds.rows), indexedCombinations);
+
+  const getLayoutLevel = (_upperIds, _excludedIds) => ids => R.reduce((acc, id) => {
+    if (R.has(id, indexedDimensions)) {
+      const dim = R.prop(id, indexedDimensions);
+      return R.append(dim, acc);
+    }
+    if (!R.has(id, indexedCombinations)) {
+      return acc;
+    }
+    const comb = R.prop(id, indexedCombinations);
+    const parsedCombination = parseCombination(_upperIds, _excludedIds)(comb, indexedDimensions);
+    if (R.is(Array, parsedCombination)) {
+      return R.concat(acc, parsedCombination);
+    }
+    return R.append(parsedCombination, acc);
+  }, [], ids);
+  
+  const header = getLayoutLevel(null, rowsConceptsSet)(layoutIds.header);
+  const sections = getLayoutLevel(null, headerConceptsSet)(layoutIds.sections);
+  const rows = getLayoutLevel(sectionsConceptsSet, headerConceptsSet)(layoutIds.rows);
+
+  return ({ header, sections, rows });
+};

package/src/rules2/src/table/getLayoutData2.js

@@ -0,0 +1,202 @@
+import * as R from 'ramda';
+import { getFlagsAndNotes } from './getFlagsAndNotes';
+import { getLayoutCoordinatesValidator } from '../utils';
+
+const getValueData = (index, dimension, parentsIndexes, missingParents = []) => ({
+	dimension: R.pick(['id', 'name', '__index'], dimension),
+	value: {
+		...R.pipe(
+			R.pathOr({}, ['values', index]),
+			R.pick(['id', 'name', 'isNonCoded', 'flags', 'hasAdvancedAttributes', 'display'])
+		)(dimension),
+		parents: parentsIndexes,
+		missingParents
+	}
+});
+
+const addCoordinatesToKey = (key, dimensionId, valueId) =>
+	`${key}${R.isEmpty(key) ? '' : ':'}${dimensionId}=${valueId}`;
+
+const simpleValueDataSetter = (valueData, datas = []) => R.append(valueData, datas);
+
+const combinedValueDataSetter = (valueData, datas = []) =>
+	R.over(R.lensIndex(-1), d => ({ ...d, values: R.append(R.prop('value', valueData), d.values) }), datas);
+
+const addValueToSerieData = (dataSetter) => (index, parentsIndexes, dimension, serieData, missingParents) => {
+	const valueData = getValueData(index, dimension, parentsIndexes, missingParents);
+	const valueId = R.path(['value', 'id'], valueData);
+	return ({
+		...serieData,
+		data: dataSetter(valueData, R.prop('data', serieData)),
+		key: addCoordinatesToKey(R.prop('key', serieData), R.prop('id', dimension), valueId)
+	});
+};
+
+const addSimpleValueToSerieData = addValueToSerieData(simpleValueDataSetter);
+
+const addCombinedValueToSerieData = addValueToSerieData(combinedValueDataSetter);
+
+const getHasAdvancedAttributes = (attrValues, customAttributes) => R.pipe(
+    R.omit(R.concat(customAttributes.flags || [], customAttributes.notes || [])),
+    R.isEmpty,
+    R.not
+  )(attrValues);
+
+const getCoordinates = (indexes, topCoordinates, definition) => R.addIndex(R.reduce)((acc, entry, index) => {
+	if (R.has('dimensions', entry)) {
+		return R.addIndex(R.reduce)((_acc, dim, _index) => {
+			const valInd = R.path([index, _index], indexes);
+			return R.assoc(dim.id, R.path(['values', Math.abs(valInd), 'id'], dim), _acc)
+		}, acc, entry.dimensions);
+	}
+	const valInd = R.nth(index, indexes);
+	if (R.isNil(valInd)) {
+		return acc;
+	}
+	return R.assoc(entry.id, R.path(['values', Math.abs(valInd), 'id'], entry), acc);
+}, topCoordinates, definition);
+
+const getAttributesSeries = (validator, attributesSeries) => R.reduce((acc, attrs) => {
+	const attr = R.head(R.values(attrs)) || {};
+	if (R.length(attr.relationship || []) === 1 && !attr.combined) {
+		return acc;
+	}
+	const coordinates = R.propOr({}, 'coordinates', attr);
+	const isValid = validator(coordinates);
+	if (!isValid && !R.prop('isObs', attr)) {
+		return acc;
+	}
+	return ({ ...acc, ...attrs });
+}, {}, R.values(attributesSeries));
+
+const combineConcepts = (combDimValues, definition, attrValues) => R.over(
+	R.lensProp('data'),
+	R.over(R.lensIndex(-1), data => ({
+		...data,
+		values: R.reduce((acc, conceptId) => {
+			if (R.has(conceptId, combDimValues)) {
+				return R.append(R.prop(conceptId, combDimValues), acc);
+			}
+			if (R.has(conceptId, definition.fixedDimValues || {})) {
+				return R.append(R.prop(conceptId, definition.fixedDimValues), acc);
+			}
+			if (R.has(conceptId, attrValues)) {
+				const value = R.path([conceptId, 'value'], attrValues);
+				return R.append(value, acc);
+			}
+			return acc;
+		}, [], definition.concepts)
+	})));
+
+const getSerieFlagsAndSideProps = (coordinates, validator, attributesValues, customAttributes, metadataCoordinates, data) => {
+	const layoutAttrValues = R.reject(attr => R.prop('isObs', attr) && !validator(attr.coordinates), attributesValues);
+  const flags = getFlagsAndNotes(layoutAttrValues, customAttributes);
+  const hasMetadata = !R.isNil(R.find(validator, metadataCoordinates));
+	const hasDataAdvancedAttributes = R.any(
+		d => R.has('value', d) ? R.prop('hasAdvancedAttributes', d.value) : R.any(R.prop('hasAdvancedAttributes'), d.values)
+	, data);
+  const hasAdvancedAttributes = hasDataAdvancedAttributes || getHasAdvancedAttributes(layoutAttrValues, customAttributes);
+  const sideProps = hasMetadata || hasAdvancedAttributes
+    ? { hasMetadata, hasAdvancedAttributes, coordinates } : null;
+	return { flags, sideProps };
+};
+
+const getSerieDimensionsData = (serie, definition, attributesValues, missingParentsGetter) =>  R.addIndex(R.reduce)(
+	(onGoingSerie, entry, index) => {
+		if (R.has('dimensions', entry)) {
+			const combValuesIndexes = R.pathOr([], ['indexes', index], serie);
+			const combParentsIndexes = R.pathOr([], ['parentsIndexes', index], serie);
+			const combMissingParentsIndexes = R.pathOr([], ['missingIndexes', index], serie);
+			let combDimValues = {};
+			const res = R.addIndex(R.reduce)((combSerie, dimension, dimIndex) => {
+				const valueIndex = Math.abs(R.nth(dimIndex, combValuesIndexes));
+				const _parentsIndexes = R.nth(dimIndex, combParentsIndexes) || [];
+				const missingParentsIndexes = R.nth(dimIndex, combMissingParentsIndexes) || [];
+				const { parentsIndexes, missingParents } = missingParentsGetter(combinedValueDataSetter)(missingParentsIndexes, _parentsIndexes, dimension, combSerie);
+				const next = addCombinedValueToSerieData(valueIndex, parentsIndexes, dimension, combSerie, missingParents);
+				const value = R.pipe(R.prop('data'), R.last, R.prop('values'), R.last)(next);
+				combDimValues = R.assoc(dimension.id, value, combDimValues);
+				return next;
+			},
+			R.over(
+				R.lensProp('data'),
+				R.append({ dimension: R.pick(['id', 'name'], entry), values: [] })
+			)(onGoingSerie),
+			R.propOr([], 'dimensions', entry));
+
+			const combined = combineConcepts(combDimValues, entry, onGoingSerie.attributes)(res);
+			return  R.over(R.lensProp('attributes'), R.omit(entry.concepts), combined);
+		}
+
+		const valueIndex = Math.abs(R.path(['indexes', index], serie));
+		const _parentsIndexes = R.pathOr([], ['parentsIndexes', index], serie);
+		const missingParentsIndexes = R.pathOr([], ['missingIndexes', index], serie);
+		const { parentsIndexes, missingParents } =  missingParentsGetter(simpleValueDataSetter)(missingParentsIndexes, _parentsIndexes, entry, onGoingSerie);
+		return addSimpleValueToSerieData(valueIndex, parentsIndexes, entry, onGoingSerie, missingParents);
+	},
+	{ data: [], key: '', attributes: attributesValues },
+	definition,
+);
+
+export const getSerieDataWithMissingLines = (serie, definition, topCoordinates, attributesSeries, customAttributes, metadataCoordinates, rejectedDims = []) => {
+	const lines = [];
+	const coordinates = getCoordinates(serie.indexes, topCoordinates, definition);
+	const serieCoordinates = getCoordinates(serie.rejected || [], coordinates, rejectedDims);
+	const coordinatesValidator = getLayoutCoordinatesValidator(serieCoordinates, topCoordinates);
+	const attributesValues = getAttributesSeries(coordinatesValidator, attributesSeries);
+
+	const getMissingParents = dataSetter => (missingParentsIndexes, _parentsIndexes, dim, serieData) => R.reduce(
+		(acc, index) => {
+				const missingParentData = addValueToSerieData(dataSetter)(index, acc.parentsIndexes, dim, serieData);
+				lines.push({ ...R.dissoc('attributes', missingParentData), sideProps: null, flags: [], isEmpty: true });
+			return R.over(R.lensProp('parentsIndexes'), R.append(index), acc);
+		},
+	{ parentsIndexes: _parentsIndexes, missingParents: [] }, missingParentsIndexes);
+	const { attributes, ...serieData } = getSerieDimensionsData(serie, definition, attributesValues, getMissingParents);
+	const topCoordinatesValidator = getLayoutCoordinatesValidator(topCoordinates);
+	const flagsValidator = coordinates => coordinatesValidator(coordinates) && !topCoordinatesValidator(coordinates);
+	const { flags, sideProps } = getSerieFlagsAndSideProps(serieCoordinates, flagsValidator, attributes, customAttributes, metadataCoordinates, serieData.data);
+	return R.append({ ...serieData, flags, sideProps, coordinates: serieCoordinates }, lines);
+};
+
+export const getSerieDataWithoutMissingLines = (serie, definition, topCoordinates, attributesSeries, customAttributes, metadataCoordinates, rejectedDims = []) => {
+	const coordinates = getCoordinates(serie.indexes, topCoordinates, definition);
+	const serieCoordinates = getCoordinates(serie.rejected || [], coordinates, rejectedDims);
+	const coordinatesValidator = getLayoutCoordinatesValidator(serieCoordinates, topCoordinates);
+	const attributesValues = getAttributesSeries(coordinatesValidator, attributesSeries);
+
+	const getMissingParents = () => (missingParentsIndexes, _parentsIndexes, dim) => R.reduce(
+		(acc, index) => ({
+			parentsIndexes: R.append(index, acc.parentsIndexes),
+			missingParents: R.append(R.prop('value', getValueData(index, dim, acc.parentsIndexes)), acc.missingParents)
+		}),
+	{ parentsIndexes: _parentsIndexes, missingParents: [] }, missingParentsIndexes);
+
+	const { attributes, ...serieData } = getSerieDimensionsData(serie, definition, attributesValues, getMissingParents);
+	const { flags, sideProps } = getSerieFlagsAndSideProps(serieCoordinates, coordinatesValidator, attributes, customAttributes, metadataCoordinates, serieData.data);
+	return ({ ...serieData, flags, sideProps, coordinates: serieCoordinates });
+};
+
+export const getLayoutData = (layoutIndexes, layout, { metadataCoordinates, attributesSeries, customAttributes, topCoordinates={}, rejectedDimensions=[] }) => {
+  const { header, sections, ...rest } = layoutIndexes;
+  const headerData = R.reduce((acc, serie) => {
+  	const datas = getSerieDataWithMissingLines(serie, layout.header, topCoordinates, attributesSeries, customAttributes, metadataCoordinates, rejectedDimensions);
+  	return R.concat(acc, datas);
+  }, [], header);
+
+  const sectionsData = R.map(
+  	([sectionSerie, rowsSeries]) => {
+  		const sectionData = getSerieDataWithoutMissingLines(sectionSerie, layout.sections, topCoordinates, attributesSeries, customAttributes, metadataCoordinates, rejectedDimensions);
+  		return [
+  			sectionData,
+  			 R.reduce((acc, serie) => {
+  				const datas = getSerieDataWithMissingLines(serie, layout.rows, R.propOr(topCoordinates, 'coordinates', sectionData), attributesSeries, customAttributes, metadataCoordinates, rejectedDimensions);
+  				return R.concat(acc, datas);
+  			}, [], rowsSeries)
+  		];
+  	},
+  	sections
+  );
+
+  return ({ headerData, sectionsData, ...rest });
+};

package/src/rules2/src/table/getSortedLayoutIndexes.js

@@ -0,0 +1,138 @@
+import * as R from 'ramda';
+
+/*
+  const layout = {
+    header: [
+      { id, __index },
+      { id: COMB, dimensions: [{ id, __index }] }
+    ],
+    sections: [],
+    rows: []
+  }
+
+*/
+
+const getLayoutPivots = layoutEntry => {
+  const valIndexGetter = d => R.pipe(
+    R.nth(R.prop('__index', d)),
+    ind => d.isInverted ? R.negate(ind) : ind
+  );
+  return indexes => R.map(
+    R.ifElse(
+      R.has('dimensions'),
+      c => R.map(d => valIndexGetter(d)(indexes), R.prop('dimensions', c)),
+      d => {
+        if (d.id === 'OBS_ATTRIBUTES') {
+          return R.last(indexes);
+        }
+        return valIndexGetter(d)(indexes);
+      }
+    ),
+    layoutEntry
+  );
+};
+
+const comparator = (firstSerie, secondSerie) => {
+  const firstIndexes = firstSerie.indexes;
+  const secondIndexes = secondSerie.indexes;
+  const size = R.length(firstIndexes);
+  let i = 0;
+  while (i < size) {
+    if (R.is(Array, firstIndexes[i])) {
+      const firstSubIndexes = firstIndexes[i];
+      const secondSubIndexes = secondIndexes[i];
+      const _size = R.length(firstSubIndexes);
+      let j = 0;
+      while (firstSubIndexes[j] === secondSubIndexes[j] && j < _size) {
+        j++;
+      }
+      if (firstSubIndexes[j] !== secondSubIndexes[j]) {
+        return firstSubIndexes[j] - secondSubIndexes[j];
+      }
+    }
+    else if (firstIndexes[i] !== secondIndexes[i]) {
+      return firstIndexes[i] - secondIndexes[i];
+    }
+    i++;
+  }
+  return firstIndexes[i] - secondIndexes[i];
+};
+
+const uniqIndexes = R.pipe(
+  R.reduce(
+    (acc, { indexes, rejected }) => {
+      const key = R.join(':', R.unnest(indexes));
+      if (R.has(key, acc)) {
+        return  R.over(
+          R.lensPath([key, 'rejected']),
+          R.addIndex(R.map)((v, i) => v === R.nth(i, rejected) ? v : null)
+        )(acc);
+      }
+      return R.assoc(key, { indexes, rejected, key }, acc);
+    },
+    {},
+  ),
+  R.values
+);
+
+export const getSortedLayoutIndexes = (layout, observations, rejectedDims = []) => {
+  const dimIndexes = R.pipe(R.values, R.map(R.propOr([], 'orderedDimIndexes')))(observations);
+
+  const headerPivots = getLayoutPivots(layout.header);
+  const sectionsPivots = getLayoutPivots(R.concat(layout.sections, layout.rows));
+  const rejectedPivots = getLayoutPivots(rejectedDims);
+
+  const sectionLength = R.length(layout.sections);
+  const { header, sections } = R.pipe(
+    R.reduce(
+      (acc, indexes) => {
+        const headerIndexes = headerPivots(indexes);
+        const sectionsIndexes = sectionsPivots(indexes);
+        const rejectedIndexes = rejectedPivots(indexes);
+
+        return ({
+          header: R.append({ indexes: headerIndexes, rejected: rejectedIndexes }, acc.header),
+          sections: R.append({ indexes: sectionsIndexes, rejected: rejectedIndexes }, acc.sections)
+        });
+      },
+      { header: [], sections: [] },
+    ),
+    R.mapObjIndexed(uniqIndexes),
+    R.evolve({
+      header: R.sort(comparator),
+      sections: R.sort(comparator)
+    }),
+    indexes => ({
+      ...indexes,
+      sections: R.reduce(
+        (acc, { indexes, rejected, key }) => {
+          const [sectionIndexes, rowIndexes] = R.splitAt(sectionLength, indexes);
+          const sectionKey = R.join(':', sectionIndexes);
+          const previousSecKey = R.pipe(R.nth(-1), v => R.isNil(v) ? null : R.head(v).key)(acc);
+          if (R.equals(sectionKey, previousSecKey)) {
+            return R.over(
+              R.lensIndex(-1),
+              R.pipe(
+                R.over(R.lensIndex(1), R.append({ indexes: rowIndexes, rejected, key })),
+                R.over(R.lensIndex(0), v => ({
+                  ...v,
+                  rejected: R.addIndex(R.map)((val, i) =>
+                    val === R.nth(i, rejected) ? val : null, v.rejected)
+                }))
+              )
+            )(acc);
+          }
+
+          return R.append([
+            { indexes: sectionIndexes, rejected, key: sectionKey },
+            [{ indexes: rowIndexes, rejected, key }]
+          ], acc);
+        },
+        [],
+        indexes.sections
+      )
+    })
+  )(dimIndexes);
+
+  return ({ header, sections });
+};

package/src/rules2/src/table/getTableLabelAccessor.js

@@ -0,0 +1,9 @@
+import * as R from 'ramda';
+import { combinedValuesDisplay, singleValueDisplay } from '../combinedValuesDisplay'
+
+
+export const getTableLabelAccessor = display => content => {
+  return R.is(Array, content)
+    ? combinedValuesDisplay(display, content)
+    : singleValueDisplay(display, content);
+};