@sis-cc/dotstatsuite-components 23.2.0 → 24.0.1

package/src/rules2/src/table/getTableLayoutIds.js

@@ -1,314 +0,0 @@
-import * as R from 'ramda';
-import { isTimePeriodDimension, isRefAreaDimension } from '@sis-cc/dotstatsuite-sdmxjs';
-
-const getCombinationsNotInLayout = (combinations, layoutIds) => {
-  const { header=[], sections=[], rows=[] } = layoutIds;
-  const idsInLayout = new Set([...header, ...sections, ...rows]);
-  return R.reject(comb => idsInLayout.has(comb.id), combinations);
-};
-
-const indexCombsRelationships = (combinations) => R.reduce((acc, comb) => {
-  const { id, relationship=[] } = comb;
-  return R.assoc(id, relationship, acc);
-}, {}, combinations);
-
-const getLayoutLevelRelationship = indexedRelationships => ids => R.reduce((acc, id) => {
-  if (R.has(id, indexedRelationships)) {
-    return R.concat(acc, R.prop(id, indexedRelationships));
-  }
-  return R.append(id, acc);
-}, [], ids);
-
-const getLayoutRelationships = (indexedRelationships, layoutIds) => R.map(
-  getLayoutLevelRelationship(indexedRelationships),
-  layoutIds
-);
-
-const injectCombination = combination => ids => {
-  const { id, concepts=[] } = combination;
-  const conceptsSet = new Set(concepts);
-  let inject = true;
-  const refined = R.reduce((acc, i) => {
-    if (!conceptsSet.has(i)) {
-      return R.append(i, acc);
-    }
-    if (inject) {
-      inject = false;
-      return R.append(id, acc);
-    }
-    return acc;
-  }, [], ids);
-  return inject ? R.append(id, refined) : refined;
-};
-
-const getCombinationLevelCompatibility = (layoutRelationships, combination) => {
-  const { relationship=[] } = combination;
-  const idsInHeaderSet = new Set(layoutRelationships.header);
-  const idsInSectionsSet = new Set(layoutRelationships.sections);
-  const idsInRowsSet = new Set(layoutRelationships.rows);
-  const [idsInHeader, rest] = R.partition(
-    i => idsInHeaderSet.has(i),
-    relationship
-  );
-  const [idsInSections, idsInRows] = R.reduce((_acc, id) => {
-    if (idsInSectionsSet.has(id))
-      return R.over(R.lensIndex(0), R.append(id), _acc);
-    if (idsInRowsSet.has(id))
-      return R.over(R.lensIndex(1), R.append(id), _acc);
-    return R.over(R.lensIndex(2), R.append(id), _acc);
-  }, [[], [], []], rest);
-  if (!R.isEmpty(idsInHeader) && R.isEmpty(idsInSections) && R.isEmpty(idsInRows)) {
-    return 'header';
-  }
-  if (!R.isEmpty(idsInHeader)) {
-    return null;
-  }
-  if (!R.isEmpty(idsInSections) && R.isEmpty(idsInRows)) {
-    return 'sections';
-  }
-  if (!R.isEmpty(idsInRows)) {
-    return 'rows';
-  }
-  return 'blank';
-}
-
-const filterLayoutIds = (indexedCombinations, layoutDimsIds, obsAttributes) => (layoutIds) => {
-  const layoutConcepts = R.map(
-    R.reduce((acc, id) => {
-      if (R.has(id, indexedCombinations)) {
-        return R.concat(acc, R.path([id, 'concepts'], indexedCombinations));
-      }
-      return R.append(id, acc);
-    }, []),
-    layoutIds
-  );
-
-  return R.mapObjIndexed(
-    (ids, level) => R.filter(id => {
-      if (id === 'OBS_ATTRIBUTES') {
-        return !R.isEmpty(obsAttributes);
-      }
-      if (R.has(id, indexedCombinations)) {
-        const comb = R.prop(id, indexedCombinations);
-        const dims = R.filter(i => layoutDimsIds.has(i), comb.concepts);
-        if (!R.isEmpty(dims)) {
-          return true;
-        }
-        const oppositeIds = level === 'header'
-          ? R.concat(R.prop('sections', layoutConcepts), R.prop('rows', layoutConcepts))
-          : R.prop('header', layoutConcepts);
-        return R.isEmpty(R.intersection(comb.relationship, oppositeIds));
-      }
-      return layoutDimsIds.has(id);
-    }, ids),
-    layoutIds
-  );
-};
-
-export const injectCombinationsInLayout = (combinations, layoutIds, defaultLayoutIds = {}) => {
-  const notInLayoutCombs = getCombinationsNotInLayout(combinations, layoutIds);
-  if (R.isEmpty(notInLayoutCombs)) {
-    return layoutIds;
-  }
-  const indexedCombsRelationships = indexCombsRelationships(combinations);
-  let layoutRelationships = getLayoutRelationships(indexedCombsRelationships, layoutIds);
-  const defaultLayoutRelationships = getLayoutRelationships(indexedCombsRelationships, defaultLayoutIds);
-  return R.reduce((acc, comb) => {
-    let levelCompatibility = getCombinationLevelCompatibility(layoutRelationships, comb);
-    if (R.isNil(levelCompatibility)) {
-      return acc;
-    }
-    if (R.equals('blank', levelCompatibility)) {
-      levelCompatibility = getCombinationLevelCompatibility(defaultLayoutRelationships, comb);
-      if (R.isNil(levelCompatibility)) {
-        return acc;
-      }
-      levelCompatibility = R.equals('blank', levelCompatibility) ? 'rows' : levelCompatibility;
-    }
-
-    layoutRelationships[levelCompatibility] = R.concat(layoutRelationships[levelCompatibility], comb.relationship);
-    const ids = injectCombination(comb)(acc[levelCompatibility]);
-    return R.assoc(levelCompatibility, ids)(acc);
-  }, layoutIds, notInLayoutCombs);
-};
-
-const getLayoutDimsIds = dimensions => R.reduce(
-  (acc, d) => (d.header ? acc : acc.add(d.id)),
-  new Set([]),
-  dimensions,
-);
-
-const getLayoutCombinations = (combinations, layoutDimsIds, attributes) => {
-  const indexedAttributes = R.indexBy(R.prop('id'), attributes);
-  return R.reduce(
-    (acc, comb) => {
-      const { layoutConcepts, relationship } = R.reduce(
-        (_acc, concept) => {
-          if (layoutDimsIds.has(concept)) {
-            return R.map(R.append(concept), _acc);
-          }
-          if (R.has(concept, indexedAttributes)) {
-            const attr = R.prop(concept, indexedAttributes);
-            return attr.series
-              ? {
-                  ..._acc,
-                  relationship: R.concat(_acc.relationship, attr.relationship),
-                }
-              : _acc;
-          }
-          return _acc;
-        },
-        { layoutConcepts: [], relationship: [] },
-        comb.concepts || [],
-      );
-      if (R.isEmpty(relationship)) {
-        return acc;
-      }
-      return R.append({ ...comb, relationship, concepts: layoutConcepts }, acc);
-    },
-    [],
-    combinations,
-  );
-};
-
-const extractConcepts = (ids, indexedCombinations, layoutDimsIds) => {
-  const entry = R.find(id => {
-    if (R.has(id, indexedCombinations)) {
-      const dimId = R.find(i => layoutDimsIds.has(i), R.pathOr([], [id, 'concepts'], indexedCombinations));
-      return !R.isNil(dimId);
-    }
-    return true;
-  }, ids);
-
-  const getRelationship = id => {
-    if (R.has(id, indexedCombinations)) {
-      return R.append(id, R.path([id, 'relationship'], indexedCombinations));
-    }
-    return [id];
-  };
-  let indexedRels = R.reduce((acc, id) =>
-    R.assoc(id, getRelationship(id), acc)
-  , {}, ids);
-  
-  let relationship = [entry];
-  while (!R.isEmpty(indexedRels)) {
-    const related = R.pickBy(rels => !R.isEmpty(R.intersection(relationship, rels)), indexedRels);
-    if (R.isEmpty(related)) {
-      break;
-    }
-    indexedRels = R.omit(R.keys(related), indexedRels);
-    relationship = R.concat(relationship, R.unnest(R.values(related)));
-  }
-  const set = new Set(relationship);
-  return R.partition(id => set.has(id), ids);
-}
-
-const injectRemainingDimensionsInLayout = (layoutIds, remainingDims, indexedCombinations, layoutDimsIds) => {
-  let _layout = layoutIds;
-  let _remaining = remainingDims;
-
-  const dimInRows = R.find(id => {
-    if (layoutDimsIds.has(id)) {
-      return true;
-    }
-    const dimId = R.find(i => layoutDimsIds.has(i), R.pathOr([], [id, 'concepts'], indexedCombinations));
-    return !R.isNil(dimId);
-  }, _layout.rows);
-
-  if (R.isNil(dimInRows)) {
-    if (R.isEmpty(_remaining)) {
-      const toTakeIn = R.isEmpty(_layout.sections) ? 'header' : 'sections';
-      const [extracted, remains] = extractConcepts(R.prop(toTakeIn, _layout), indexedCombinations, layoutDimsIds);
-      _layout = ({ ..._layout, rows: R.concat(_layout.rows, extracted), [toTakeIn]: remains });
-    }
-    else {
-      _layout = R.over(R.lensProp('rows'), R.append(R.head(_remaining)))(_layout);
-      _remaining = R.tail(_remaining)
-    }
-  }
-  if (!R.isEmpty(_remaining)) {
-    const hasNoHeader = R.isEmpty(_layout.header);
-    const firstRemaining = R.head(_remaining);
-    _remaining = hasNoHeader ? R.tail(_remaining) : _remaining;
-    _layout = {
-      ..._layout,
-      sections: R.concat(_layout.sections, _remaining),
-      header: hasNoHeader ? [firstRemaining] : _layout.header,
-    };
-  }
-  return _layout;
-};
-
-export const getTableLayoutIds = (
-  defaultLayoutIds,
-  currentLayoutIds,
-  dimensions,
-  attributes,
-  combinations
-) => {
-  const layoutDimsIds = getLayoutDimsIds(dimensions);
-  const layoutCombinations = getLayoutCombinations(
-    combinations,
-    layoutDimsIds,
-    attributes,
-  );
-  const isBlank = R.pipe(R.values, R.all(R.isEmpty))(currentLayoutIds);
-
-  const combinationsConcepts = R.pipe(R.pluck('_concepts'), R.unnest, ids => new Set(ids))(combinations);
-  const obsAttributes = R.filter(a => 
-    a.series && R.isEmpty(a.relationship || []) && a.display && !combinationsConcepts.has(a)
-  , attributes);
-  const indexedCombinations = R.indexBy(R.prop('id'), layoutCombinations);
-  const filteredLayoutIds = filterLayoutIds(indexedCombinations, layoutDimsIds, obsAttributes)
-    (isBlank ? defaultLayoutIds : currentLayoutIds);
-
-  const layoutWithCombs = injectCombinationsInLayout(layoutCombinations, filteredLayoutIds, defaultLayoutIds);
-  const layoutRelationshipsSets = R.map(R.pipe(
-    ids => R.pick(ids, indexedCombinations),
-    R.values,
-    R.pluck('relationship'),
-    R.unnest,
-    i => new Set(i)
-  ), layoutWithCombs);
-  const layoutConceptsSets = R.pipe(
-    R.map(
-      R.reduce((acc, id) => {
-        if (R.has(id, indexedCombinations)) {
-          return R.concat(acc, R.path([id, 'concepts'], indexedCombinations));
-        }
-        return R.append(id, acc);
-      }, []),
-    ),
-    R.values,
-    R.unnest,
-    ids => new Set(ids)
-  )(layoutWithCombs);
-  const defaultLayoutConceptsSets = R.map(
-    ids => new Set(ids),
-    defaultLayoutIds
-  );
-
-  const { nextLayout, remaining } = R.reduce((acc, dim) => {
-    if (layoutConceptsSets.has(dim.id) || dim.header) {
-      return acc;
-    }
-    if (layoutRelationshipsSets.header.has(dim.id) || defaultLayoutConceptsSets.header.has(dim.id)) {
-      return R.over(R.lensPath(['nextLayout', 'header']), R.append(dim.id))(acc);
-    }
-    if (layoutRelationshipsSets.sections.has(dim.id) || defaultLayoutConceptsSets.sections.has(dim.id)) {
-      return R.over(R.lensPath(['nextLayout', 'sections']), R.append(dim.id))(acc);
-    }
-    if (layoutRelationshipsSets.rows.has(dim.id)  || defaultLayoutConceptsSets.rows.has(dim.id)) {
-      return R.over(R.lensPath(['nextLayout','rows']), R.append(dim.id))(acc);
-    }
-    if (isTimePeriodDimension(dim)) {
-      return R.over(R.lensPath(['nextLayout','header']), R.append(dim.id))(acc);
-    }
-    if (isRefAreaDimension(dim)) {
-      return R.over(R.lensPath(['nextLayout','rows']), R.append(dim.id))(acc);
-    }
-    return R.over(R.lensProp('remaining'), R.append(dim.id))(acc);
-  }, { nextLayout: layoutWithCombs, remaining: [] }, dimensions);
-
-  return injectRemainingDimensionsInLayout(nextLayout, remaining, indexedCombinations, layoutDimsIds);
-};

package/src/rules2/src/table/getTableProps.js

@@ -1,82 +0,0 @@
-import * as R from 'ramda';
-import { declineObservationsOverAttributes } from './declineObservationsOverAttributes';
-import { getLayout } from './getLayout';
-import { getSortedLayoutIndexes } from './getSortedLayoutIndexes';
-import { parseLayoutIndexesHierarchies } from './parseSeriesIndexesHierarchies';
-import { refineLayoutSize } from './refineLayoutSize2';
-import { getLayoutData } from './getLayoutData2';
-import { getCellsAttributesIds } from './getCellsAttributesIds';
-import { getIndexedCombinationsByDisplay } from './getIndexedCombinationsByDisplay';
-import { getCells } from './getCells';
-import { getCuratedCells } from './getCuratedCells';
-import { getSeriesCombinations } from '../getSeriesCombinations';
-import { getCellsMetadataCoordinates } from './getCellsMetadataCoordinates';
-
-export const getTableProps = ({ data, layoutIds, customAttributes, limit, isTimeInverted }) => {
-  const {
-    observations,
-    dimensions,
-    combinations,
-    oneValueDimensions,
-    attributesSeries,
-    metadataCoordinates,
-    attributes,
-    header,
-    rejectedDimensions=[]
-  } = data;
-
-  const obsAttributes = R.filter(
-    a => a.series && R.isEmpty(a.relationship) && a.display && !a.combined,
-    attributes
-  );
-  let dupObs = observations;
-  const hasDuplicatedCells = R.pipe(
-    R.values,
-    R.unnest,
-    R.find(R.equals('OBS_ATTRIBUTES')),
-  )(layoutIds);
-  if (hasDuplicatedCells) {
-    const attrsIds = R.pluck('id', obsAttributes);
-    dupObs = declineObservationsOverAttributes(attrsIds, observations);
-  }
-  const seriesCombinations = getSeriesCombinations(combinations, oneValueDimensions);
-  const _dims =  R.append(
-    {
-      id: 'OBS_ATTRIBUTES',
-      values: R.prepend({ id: 'OBS_VALUE' }, obsAttributes),
-    },
-    dimensions,
-  );
-  const layout = getLayout(layoutIds, _dims, seriesCombinations, isTimeInverted);
-  const layoutDimsIds = R.map(R.reduce((acc, entry) => {
-    if (R.has('dimensions', entry)) {
-      return R.concat(acc, R.pluck('id', entry.dimensions));
-    }
-    return R.append(entry.id, acc);
-  }, []), layout);
-  const layoutIndexes = getSortedLayoutIndexes(layout, dupObs, rejectedDimensions);
-  const enhancedLayoutIndexes = parseLayoutIndexesHierarchies(
-    layoutIndexes,
-    layout,
-  );
-  const refinedLayoutIndexes = refineLayoutSize({ layout, observations: dupObs, limit })(enhancedLayoutIndexes);
-  const layoutData = getLayoutData(refinedLayoutIndexes, layout, {
-    metadataCoordinates,
-    attributesSeries,
-    customAttributes,
-    topCoordinates: header.coordinates,
-    rejectedDimensions
-  });
-
-  const cellsAttributesIds = getCellsAttributesIds(layoutDimsIds, attributes);
-  const indexedCombinations = getIndexedCombinationsByDisplay(layout, seriesCombinations);
-  const cellsMetadataCoordinates = getCellsMetadataCoordinates(metadataCoordinates, oneValueDimensions, layoutDimsIds);
-  const cells = getCells(customAttributes, cellsAttributesIds, indexedCombinations, attributesSeries, cellsMetadataCoordinates)(dupObs);
-
-  return ({
-    ...layoutData,
-    cells: getCuratedCells(cells, layout),
-    layout,
-    combinations: seriesCombinations
-  });
-};

package/src/rules2/src/table/parseSeriesIndexesHierarchies.js

@@ -1,79 +0,0 @@
-import * as R from 'ramda';
-
-const registerParsedIndexes = ({ isSameSerie, ...parsed }, register) => {
-  const merged = R.mergeWith((a, b) => R.append(a || [], b), parsed, register);
-  return ({ ...merged, isSameSerie });
-};
-
-const parseParentsIndexesWithPrevious = (parentsIndexes, previousParentsIndexes) => {
-  const previousParentsSet = new Set(previousParentsIndexes);
-  const lastParentIndexInPrevious = R.findLastIndex(i => previousParentsSet.has(i), parentsIndexes);
-  const [rawPresentParentsIndexes, missingParentsIndexes] = lastParentIndexInPrevious !== -1
-    ? R.splitAt(lastParentIndexInPrevious + 1, parentsIndexes)
-    : [[], parentsIndexes];
-  const presentParentsIndexes = R.filter(i => previousParentsSet.has(i), rawPresentParentsIndexes);
-  return ({ presentParentsIndexes, missingParentsIndexes });
-};
-
-const parseSerieIndexesHierarchies = (serieIndexes, previousSerie, dimensions, isSameSerie, replicate) => {
-	return R.addIndex(R.reduce)((acc, _valueIndex, dimensionIndex) => {
-		if (R.is(Array, _valueIndex)) {
-      const previous = R.isEmpty(previousSerie) ? {} : R.map(R.nth(dimensionIndex), previousSerie);
-			const parsed = parseSerieIndexesHierarchies(
-        _valueIndex,
-        previous,
-        R.pathOr([], [dimensionIndex, 'dimensions'], dimensions),
-        acc.isSameSerie,
-        replicate
-      );
-      return registerParsedIndexes(parsed, acc);
-		}
-    const valueIndex = Math.abs(_valueIndex);
-    const parents = R.pathOr([], [dimensionIndex, 'values', valueIndex, 'parents'], dimensions);
-    const previousIndex = R.pipe(R.path(['indexes', dimensionIndex]), i => R.isNil(i) ? -1 : Math.abs(i))(previousSerie)
-    const previousParentsIndexes = acc.isSameSerie
-      ? R.pipe(R.pathOr([], ['parentsIndexes', dimensionIndex]), R.append(previousIndex))(previousSerie) : [];
-    const previousMissingIndexes = acc.isSameSerie
-      ? R.pathOr([], ['missingIndexes', dimensionIndex], previousSerie) : [];
-    /*
-      if replicate = true (sections), missing parents insdexes are replicated on each brother nodes not just the first (as empty lines)
-      thats why passing previous missing as previous parents in case replicate = false
-    */
-    const { presentParentsIndexes, missingParentsIndexes } = parseParentsIndexesWithPrevious(
-      parents,
-      replicate ? previousParentsIndexes : R.concat(previousParentsIndexes, previousMissingIndexes),
-    );
-    return registerParsedIndexes({
-      parentsIndexes: presentParentsIndexes,
-      missingIndexes: missingParentsIndexes,
-      isSameSerie: acc.isSameSerie && valueIndex === previousIndex
-    }, acc);
-  }, { parentsIndexes: [], missingIndexes: [], isSameSerie }, serieIndexes);
-};
-
-export const parseSeriesIndexesHierarchies = (seriesIndexes, dimensions, replicateMissing = false) => {
-  return R.reduce((acc, { indexes, ...rest }) => {
-    const previousSerie = R.last(acc) || {};
-    const { isSameSerie, ...parsed } = parseSerieIndexesHierarchies(indexes, previousSerie, dimensions, true, replicateMissing);
-    return R.append({ indexes, ...parsed, ...rest }, acc);
-  }, [], seriesIndexes);
-};
-
-export const parseLayoutIndexesHierarchies = (layoutIndexes, layout) => {
-  const header = parseSeriesIndexesHierarchies(layoutIndexes.header, layout.header);
-  const sections = R.pipe(
-    R.transpose,
-    ([_sections, _sectionsRows]) => {
-      if (R.isNil(_sections)) {
-        return [];
-      }
-      // replicate = true on sections
-      const sections = parseSeriesIndexesHierarchies(_sections, layout.sections, true);
-      const sectionsRows = R.map(rows => parseSeriesIndexesHierarchies(rows, layout.rows), _sectionsRows);
-      return R.transpose([sections, sectionsRows]);
-    }
-  )(layoutIndexes.sections);
-
-
-  return ({ header, sections });
-};

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

@@ -1,26 +0,0 @@
-import * as R from 'ramda';
-
-export const parseValueHierarchy = (value, previousValue, indexedValues) => {
-  const parentsIds = R.propOr([], 'parents', value);
-  if (R.isEmpty(parentsIds)) {
-    return value;
-  }
-  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);
-  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);
-  const parents = R.takeWhile(p => R.includes(p.id, presentIds), previousParents);
-  const missingParents = R.props(missingIds, indexedValues);
-  return ({
-    ...value,
-    parents,
-    parentsIds,
-    missingParents
-  });
-};