@sis-cc/dotstatsuite-components 23.1.0 → 24.0.0

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

@@ -1,93 +0,0 @@
-import * as R from 'ramda';
-import { getFlagsAndNotes } from './getFlagsAndNotes';
-import { hasCellMetadata } from '../hasCellMetadata';
-
-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
-);
-
-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/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)
-  );
-};

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

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

@@ -1,84 +0,0 @@
-import * as R from 'ramda';
-import { isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
-
-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;
-};
-
-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

@@ -1,203 +0,0 @@
-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)) || {};
-	const coordinates = R.propOr({}, 'coordinates', attr);
-	const isValid = validator(coordinates);
-	if (!isValid && !R.prop('isObs', attr)) {
-		return acc;
-	}
-	const filtered = R.reject(
-		a => !R.propOr(false, 'combined', a) && R.length(a.relationship || []) === 1,
-		attrs
-	);
-	return ({ ...acc, ...filtered });
-}, {}, 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

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

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