@sis-cc/dotstatsuite-components 15.0.21 → 16.1.0

package/src/rules/src/table/preparators/getUniqValuesAttributes.js

@@ -1,24 +0,0 @@
-import * as R from 'ramda';
-
-/*
- for Dataflow attributes and 'single values' dimensions
-*/
-
-export const getUniqValuesAttributes = (attributesIds, attributes, noDisplayIndexes) => R.pipe(
-  R.pick(attributesIds),
-  R.mapObjIndexed(
-    (attribute) => {
-      const value = R.head(attribute.values);
-      const annotationsIndexes = R.propOr([], 'annotations', value);
-      const noDisplayValueIndexes = R.intersection(annotationsIndexes, noDisplayIndexes);
-      if (!R.isEmpty(noDisplayValueIndexes)) {
-        return null;
-      }
-      return ({
-        ...R.pick(['id', 'name'], attribute),
-        value: R.head(attribute.values)
-      });
-    }
-  ),
-  R.filter(R.pipe(R.isNil, R.not))
-)(attributes);

package/src/rules/src/table/preparators/parseAttributes.js

@@ -1,113 +0,0 @@
-import * as R from 'ramda';
-import { REPORTING_YEAR_START_DAY, REPYEARSTART } from '../../constants';
-
-const registerAttrId = (path, id) => R.over(
-  R.lensPath(R.prepend('attributesIdsIndexedByTargets', path)),
-  R.ifElse(R.isNil, R.always([id]), R.append(id))
-);
-
-const _registerAttr = rejected=>(attr) => R.set(
-  R.lensPath(['attributesIndexedByIds', attr.id]),
-  R.over(R.lensProp('values'),R.map(v=> R.includes(R.prop('id')(v),rejected)? null : v))(attr)
-);
-
-const getAttributeRegisters = (attribute, parsedDimensionsIds, customAttributes) => {
-  const registerAttr = _registerAttr(R.propOr([],'rejectedValueIds')(customAttributes))
-  if (R.propEq('id', customAttributes.prefscale, attribute)) {
-    return [registerAttrId(['prefscale'], attribute.id), registerAttr(attribute)];
-  }
-  if (R.propEq('id', customAttributes.decimals, attribute)) {
-    return [registerAttrId(['decimals'], attribute.id), registerAttr(attribute)];
-  }
-  if (R.hasPath(['relationship', 'none'], attribute) || R.hasPath(['relationship', 'dataflow'], attribute)) {
-    return [registerAttrId(['dataflow'], attribute.id), registerAttr(attribute)];
-  }
-  if (R.pathEq(['relationship', 'primaryMeasure'], 'OBS_VALUE', attribute) || R.hasPath(['relationship', 'observation'], attribute)) {
-    return [registerAttrId(['observations'], attribute.id), registerAttr(attribute)];
-  } 
-  const targetDimensions = R.pathOr([], ['relationship', 'dimensions'], attribute);
-  if (R.isEmpty(targetDimensions)) {
-    return [];
-  }
-  if (R.length(targetDimensions) === 1) {
-    return R.ifElse(
-      R.flip(R.has)(parsedDimensionsIds.oneValue),
-      R.always([
-        registerAttrId(['oneValueDimensions', R.head(targetDimensions)], attribute.id),
-        registerAttr(attribute)
-      ]),
-      R.always([
-        registerAttrId(['manyValuesDimensions'], attribute.id),
-        registerAttr(R.assoc(
-          'targetIndex',
-          R.prop(R.head(targetDimensions), parsedDimensionsIds.manyValues),
-          attribute
-        ))
-      ])
-    )(R.head(targetDimensions));
-  }
-  const manyValuesTargetDimensions = R.without(R.keys(parsedDimensionsIds.oneValue), targetDimensions);
-  const size = R.length(manyValuesTargetDimensions);
-  if (size === 0) {
-    return [registerAttrId(['dataflow'], attribute.id), registerAttr(attribute)];
-  }
-  if (size === 1) {
-    return [
-      registerAttrId(['manyValuesDimensions'], attribute.id),
-      registerAttr(R.assoc(
-        'targetIndex',
-        R.prop(R.head(manyValuesTargetDimensions), parsedDimensionsIds.manyValues),
-        attribute
-      ))
-    ];
-  }
-  return [
-    registerAttrId(['series'], attribute.id),
-    registerAttr(
-      R.assoc(
-        'targetIndexes',
-        R.reduce(
-          (acc, dimId) => {
-            const index = R.prop(dimId, parsedDimensionsIds.manyValues);
-            return R.assoc(String(index), index, acc);
-          },
-          {},
-          manyValuesTargetDimensions
-        ),
-        attribute
-      )
-    )
-  ]
-};
-
-export const parseAttributes = ({ attributes, parsedDimensionsIds, customAttributes }) => R.addIndex(R.reduce)(
-  (acc, attribute, attributeIndex) => {
-    const values = R.propOr([], 'values', attribute);
-
-    if (R.isEmpty(values) || !R.propOr(true, 'display', attribute) || R.includes(attribute.id, R.propOr([], 'units', customAttributes))) {
-      return acc;
-    }
-    if (R.includes(attribute.id, [REPORTING_YEAR_START_DAY, REPYEARSTART])) return acc;
-
-    const registers = getAttributeRegisters(
-      R.pipe(
-        R.assoc('index', attributeIndex),
-        R.over(
-          R.lensProp('values'),
-          R.map((value) => {
-            if (!R.propOr(true, 'display', value)) {
-              return null;
-            }
-            return value;
-          })
-        )
-      )(attribute),
-      parsedDimensionsIds,
-      customAttributes,
-    );
-
-    return R.pipeWith(R.flip(R.applyTo), registers)(acc);
-  },
-  { attributesIndexedByIds: {}, attributesIdsIndexedByTargets: {} },
-  attributes
-);

package/src/rules/src/table/preparators/parseAttributesValuesFromObservations.js

@@ -1,16 +0,0 @@
-import * as R from 'ramda';
-
-export const parseAttributesValuesFromObservations = (observations, registers) => R.pipe(
-  R.values,
-  R.reduce(
-    (acc, observation) => {
-      const observationRegisters = R.map(
-        getRegister => getRegister(observation),
-        registers
-      );
-
-      return R.pipeWith(R.flip(R.applyTo), observationRegisters)(acc);
-    },
-    {}
-  )
-)(observations);

package/src/rules/src/table/preparators/parseDimensionsIds.js

@@ -1,17 +0,0 @@
-import * as R from 'ramda';
-
-export const parseDimensionsIds = R.addIndex(R.reduce)(
-  (acc, dimension, dimensionIndex) => {
-    const values = R.propOr([], 'values', dimension);
-    const size = R.length(values);
-    if (R.equals(0, size)) {
-      return acc;
-    }
-    const target = R.equals(1, size) ? 'oneValue' : 'manyValues';
-    return R.set(
-      R.lensPath([target, dimension.id]),
-      dimensionIndex
-    )(acc);
-  },
-  { manyValues: {}, oneValue: {} }
-);

package/src/rules/src/table/preparators/prepareData.js

@@ -1,197 +0,0 @@
-import * as R from 'ramda';
-import { getObservationsType } from '../../properties/getObservationsType';
-import { parseDimensionsIds } from './parseDimensionsIds';
-import { parseAttributes } from './parseAttributes';
-import { getDimensionsAttributesRegisters } from './getDimensionsAttributesRegisters';
-import { parseAttributesValuesFromObservations } from './parseAttributesValuesFromObservations';
-import { getOneValueDimensions } from './getOneValueDimensions';
-import { getManyValuesDimensions } from './getManyValuesDimensions';
-import { getAttributeValue } from './getAttributeValue';
-import { refineSeriesAttributesValues } from './refineSeriesAttributesValues';
-
-import { getUnitsDefinition } from '../units/getUnitsDefinition';
-import { getUnitsArtefacts } from '../units/getUnitsArtefacts';
-import { getHeaderUnits } from '../units/getHeaderUnits';
-import { getAttachmentSeriesIndexes } from '../units/getAttachmentSeriesIndexes';
-import { getUnitsSeries } from '../units/getUnitsSeries';
-
-import { getObservations } from '../../preparators/getObservations';
-import { enhanceObservations } from '../../preparators/enhanceObservations';
-
-import { getMetadataCoordinates } from '../../../../rules2/src/getMetadataCoordinates';
-import {
-  getDataflowAdvancedAttributes,
-  getObservationsAdvancedAttributes,
-  getSeriesAdvancedAttributes
-} from '../../../../rules2/src/getAdvancedAttributes';
-import { duplicateObs } from '../../../../rules2/src/duplicateObservations';
-import { hierarchiseDimensionWithAdvancedHierarchy } from '../../../../rules2/src/hierarchiseDimensionWithAdvancedHierarchy';
-import { hierarchiseDimensionWithNativeHierarchy } from '../../../../rules2/src/hierarchiseDimensionWithNativeHierarchy';
-
-export const prepareData = (sdmxJson, customAttributes, unitsProps={}, _options={}) => {
-  const {
-    defaultCodes=[],
-    annotationsDefinitionCodes={},
-    rejectedValueIds=[],
-  } = R.pick(['defaultCodes', 'annotationsDefinitionCodes', 'rejectedValueIds'], unitsProps);
-  const unitsDefinitionCodes = getUnitsDefinition({
-    defaultCodes, annotationsDefinitionCodes, data: sdmxJson
-  });
-  const _customAttributes = R.assoc('units', unitsDefinitionCodes, customAttributes);
-  const dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
-
-  const hierarchies = _options.hierarchies || {};
-  const dimensionsIndexedByIds = R.indexBy(R.prop('id'), dimensions);
-
-  const parsedDimensionsIds = parseDimensionsIds(dimensions);
-
-  //------------------------------------------------------------------
-    const unitsArtefacts = getUnitsArtefacts({ unitsDefinitionCodes, data: sdmxJson });
-    const headerUnits = getHeaderUnits({ unitsArtefacts, unitsDefinitionCodes, rejectedValueIds });
-    const _dimensions = R.pipe(
-      R.pathOr([], ['data', 'structure', 'dimensions', 'observation']),
-      R.indexBy(R.prop('id'))
-    )(sdmxJson);
-    const attachmentSeriesIndexes = getAttachmentSeriesIndexes({ dimensions: _dimensions, unitsArtefacts });
-  //------------------------------------------------------------------
-
-  const attributes = R.pathOr([], ['data', 'structure', 'attributes', 'observation'], sdmxJson);
-
-  const { attributesIndexedByIds, attributesIdsIndexedByTargets } = parseAttributes({
-    attributes: R.concat(
-      attributes,
-      R.pathOr([], ['data', 'structure', 'attributes', 'dataSet'], sdmxJson),
-    ),
-    parsedDimensionsIds,
-    customAttributes: _customAttributes,
-  });
-
-  const seriesAttributesIds = R.propOr([], 'series', attributesIdsIndexedByTargets);
-  const observationsAttributesIds = R.propOr([], 'observations', attributesIdsIndexedByTargets);
-  const obsUnitsIds = R.pipe(
-    ({ attributes, dimensions }) => R.merge(attributes.series || {}, dimensions.series || {}),
-    R.keys
-  )(unitsArtefacts);
-  const options = {
-    attachmentSeriesIndexes,
-    customAttributes,
-    attributesIds: R.concat(seriesAttributesIds, observationsAttributesIds),
-    unitsIds: obsUnitsIds,
-    rejectedValueIds
-  };
-  
-  const _observations = getObservations(sdmxJson);
-  const observations = enhanceObservations(dimensions, _observations, attributes, options);
-  //------------------------------------------------------------------
-  const unitsSeries = getUnitsSeries(observations);
-  const unitsAttachmentSeriesIds = R.pipe(
-    R.props(attachmentSeriesIndexes),
-    R.pluck('id')
-  )(dimensions);
-  //------------------------------------------------------------------   
-  const attributesRegisters = getDimensionsAttributesRegisters(
-    attributesIdsIndexedByTargets,
-    attributesIndexedByIds
-  );
-
-  const dimensionsAttributesValues = parseAttributesValuesFromObservations( // => { series: { key: { attrId: [...indexes] } }, dimensions: {}   }
-    observations,
-    attributesRegisters
-  );
-
-  const dataflowAttributes = R.mapObjIndexed(
-    attribute => getAttributeValue(attribute, 0),
-    R.pipe(
-      R.pick(
-        R.propOr([], 'dataflow', attributesIdsIndexedByTargets),
-      ),
-      R.filter(R.complement(R.isNil))
-    )(attributesIndexedByIds)
-  );
-
-  const oneValueDimensions = getOneValueDimensions(
-    R.pipe(
-      R.pick(R.keys(parsedDimensionsIds.oneValue)),
-      R.omit(unitsDefinitionCodes)
-    )(dimensionsIndexedByIds),
-    attributesIdsIndexedByTargets.oneValueDimensions,
-    attributesIndexedByIds,
-  );
-
-  const manyValuesDimensions = getManyValuesDimensions(
-    dimensionsIndexedByIds,
-    parsedDimensionsIds.manyValues,
-    dimensionsAttributesValues.dimensions,
-    attributesIndexedByIds,
-  );
-
-  const seriesAttributesValues = R.map(
-    series => refineSeriesAttributesValues(series, attributesIndexedByIds),
-    dimensionsAttributesValues
-  );
-
-  const metadataCoordinates = getMetadataCoordinates(sdmxJson);
-  const headerAttributesIds = R.concat(
-    attributesIdsIndexedByTargets.dataflow || [],
-    R.pipe(R.values, R.unnest)(attributesIdsIndexedByTargets.oneValueDimensions || {})
-  );
-  const headerAttributes = R.pick(headerAttributesIds, attributesIndexedByIds);
-  const headerAdvancedAttrIds = R.pipe(
-    R.filter(id => !R.includes(id, customAttributes.flags || []) && !R.includes(id, customAttributes.notes || [])),
-  )(headerAttributesIds);
-
-  const dataflowAdvancedAttributes = getDataflowAdvancedAttributes(
-    headerAttributes,
-    R.pick(R.keys(parsedDimensionsIds.oneValue), dimensionsIndexedByIds),
-    headerAdvancedAttrIds,
-    R.length(dimensions)
-  );
-
-  const observationsAdvancedAttributesIds = R.filter(
-    id => !R.includes(id, customAttributes.flags || []) && !R.includes(id, customAttributes.notes || []),
-    attributesIdsIndexedByTargets.observations || []
-  );
-  const observationsAdvancedAttributes = getObservationsAdvancedAttributes(observations, observationsAdvancedAttributesIds);
-
-  const seriesAdvancedAttributesIds = R.filter(
-    id => !R.includes(id, customAttributes.flags || []) && !R.includes(id, customAttributes.notes || []),
-    R.concat(attributesIdsIndexedByTargets.series || [], attributesIdsIndexedByTargets.manyValuesDimensions || [])
-  );
-
-  const seriesAdvancedAttributes = getSeriesAdvancedAttributes(
-    seriesAttributesValues,
-    dimensions,
-    seriesAdvancedAttributesIds
-  );
-
-  const hierarchisedDimensions = R.map(dim => {
-    if (R.isEmpty(R.propOr({}, dim.id, hierarchies))) {
-      return hierarchiseDimensionWithNativeHierarchy(dim);
-    }
-    return hierarchiseDimensionWithAdvancedHierarchy(dim, R.prop(dim.id, hierarchies));
-  })(manyValuesDimensions);
-
-  const duplicatedObservations = duplicateObs(R.values(hierarchisedDimensions), observations);
-  return ({
-    dimensions: {
-      one: oneValueDimensions,
-      many: hierarchisedDimensions,
-      length: R.length(dimensions)
-    },
-    units: {
-      headerUnits,
-      rejectedValueIds,
-      unitsDefinitionCodes,
-      unitsAttachmentSeriesIds,
-      unitsSeries,
-    },
-    metadataCoordinates,
-    advancedAttributes: { ...dataflowAdvancedAttributes, ...observationsAdvancedAttributes, ...seriesAdvancedAttributes },
-    observations: duplicatedObservations,
-    observationsType: getObservationsType(sdmxJson.data),
-    dataflowAttributes,
-    dataflowName: R.path(['data', 'structure', 'name'], sdmxJson),
-    seriesAttributes: R.props(seriesAttributesIds, attributesIndexedByIds),
-    seriesAttributesValues: seriesAttributesValues.series || {}
-  });
-};

package/src/rules/src/table/preparators/refineObservationsAttributesValues.js

@@ -1,22 +0,0 @@
-import * as R from 'ramda';
-import { getAttributeValue } from './getAttributeValue';
-/*
-  After parsing series attributes or 'many values' dimensions attributes from observations,
-  filter to keep only single uniq non null occurences, and return the corresponding attribute value
-*/
-
-
-export const refineObservationsAttributesValues = (attributesByIds) => R.pipe(
-  R.mapObjIndexed(
-    (indexes, attributeId) => {
-      const uniqed = R.uniq(indexes);
-      if (R.length(uniqed) !== 1) {
-        return null;
-      }
-      const valueIndex = R.head(uniqed);
-
-      return getAttributeValue(R.propOr({}, attributeId, attributesByIds), valueIndex);
-    }
-  ),
-  R.filter(R.complement(R.isNil))
-);

package/src/rules/src/table/preparators/refineSeriesAttributesValues.js

@@ -1,11 +0,0 @@
-import * as R from 'ramda';
-import { refineObservationsAttributesValues } from './refineObservationsAttributesValues';
-
-export const refineSeriesAttributesValues = (seriesAttributeIndexes, attributesByIds) => R.pipe(
-  R.mapObjIndexed(
-    (serieAttributes, serieKey) => ({
-      attributes: refineObservationsAttributesValues(attributesByIds)(serieAttributes),
-      serie: R.split(':', serieKey)
-    })
-  ),
-)(seriesAttributeIndexes);

package/src/rules/src/table/units/appendUnitsInLayoutData.js

@@ -1,56 +0,0 @@
-import * as R from 'ramda';
-import { appendUnitsInLayoutDataEntry } from './appendUnitsInLayoutDataEntry';
-import { getUnitsSerieIndexes } from './getUnitsSerieIndexes';
-
-export const appendUnitsInLayoutData = ({
-  display, // label || code || both
-  layoutIds,
-  rejectedValueIds,
-  unitDimension,
-  unitsDisplay,
-  unitsSeries,
-  unitsDefinitionCodes,
-  unitsIndexes, // { header: [], sections: [], rows: [] }
-  partialUnitSerieIndexes, // here it is blank (only 'x' in the array)
-}) => (layoutData) => {
-  switch (unitsDisplay) {
-    case 'header':
-      return R.evolve({
-        'headerData': R.map(appendUnitsInLayoutDataEntry({
-          display, unitDimension, unitsSeries, unitsDefinitionCodes,
-          unitsIndexes: unitsIndexes.header, partialUnitSerieIndexes,
-          rejectedValueIds
-        }))
-      }, layoutData);
-    case 'sections':
-      return R.evolve({
-        'sectionsData': R.map(
-          ([section, rows]) => ([
-            appendUnitsInLayoutDataEntry({
-              display, unitDimension, unitsSeries, unitsDefinitionCodes,
-              unitsIndexes: unitsIndexes.sections, partialUnitSerieIndexes,
-              rejectedValueIds
-            })(section),
-          rows])
-        )
-      }, layoutData);
-    case 'rows':
-      return R.evolve({
-        'sectionsData': R.map(([section, rows]) => {
-          const sectionSerieIndexes = getUnitsSerieIndexes({
-            unitsIndexes: unitsIndexes.sections,
-            partialUnitSerieIndexes
-          })(section);
-          const unitsCodes = R.without(layoutIds.sections, unitsDefinitionCodes);
-          const unitsInRows = R.map(appendUnitsInLayoutDataEntry({
-            display, unitDimension, unitsSeries, unitsDefinitionCodes: unitsCodes,
-            unitsIndexes: unitsIndexes.rows, partialUnitSerieIndexes: sectionSerieIndexes,
-            rejectedValueIds
-          }))(rows);
-          return [section, unitsInRows];
-        })
-      }, layoutData);
-    default:
-      return layoutData;
-  }
-};

package/src/rules/src/table/units/appendUnitsInLayoutDataEntry.js

@@ -1,38 +0,0 @@
-import * as R from 'ramda';
-import { getUnitsSerieIndexes } from './getUnitsSerieIndexes';
-import { dimensionValueDisplay } from '../../dimension-utils';
-
-export const appendUnitsInLayoutDataEntry = ({
-  display, // label || code || both
-  rejectedValueIds=[],
-  unitDimension, // { id: 'UNITS', name: 'Units' }; provided y DE
-  unitsSeries, // all the units series parsed through observations
-  unitsDefinitionCodes, // all units dimensions and attributes ids in array (used to guarantee the order of the concatenated data) 
-  unitsIndexes, // indexes of all the dimensions attached to the units in the layout data entry
-  partialUnitSerieIndexes // array of indexes to complete with units values indexes of the layout entry to retrieve tthe corresponding units serie
-}) => (layoutDataEntry) => { // [{ dimension: {}, value: {} }]
-  const unitsSerie = R.pipe(
-    getUnitsSerieIndexes({ unitsIndexes, partialUnitSerieIndexes }),
-    R.join(':'),
-    R.flip(R.propOr({}))(unitsSeries)
-  )(layoutDataEntry);
-
-  const unitsData = {
-    dimension: unitDimension,
-    value: R.pipe(
-      R.props(unitsDefinitionCodes),
-      R.reduce((acc, unit) => {
-        const value = R.prop('value', unit);
-        if (R.isNil(unit) || R.includes(value.id, rejectedValueIds)) {
-          return acc;
-        }
-        const unitLabel = dimensionValueDisplay(display)(R.propOr({}, 'value', unit));
-        return R.isEmpty(acc.id)
-          ? { id: value.id, unitsLabel: unitLabel }
-          : { id: `${acc.id} - ${value.id}` , unitsLabel: `${acc.unitsLabel}, ${unitLabel}` };
-      }, { id: '', unitsLabel: '' })
-    )(unitsSerie)
-  };
-
-  return R.append(unitsData, layoutDataEntry);
-};

package/src/rules/src/table/units/cleanUnitsInLayoutData.js

@@ -1,65 +0,0 @@
-import * as R from 'ramda';
-
-const formatUnitsInLayoutSerie = R.over(
-  R.lensIndex(-1),
-  (units) => {
-    const label = R.path(['value', 'unitsLabel'], units);
-    return R.assocPath(['value', 'label'], label, units);
-  }
-);
-
-const removeUnitsDimensions = (indexes) =>  R.addIndex(R.reject)(
-  (entry, index) => R.includes(index, indexes)
-);
-
-export const cleanUnitsInLayoutData = ({
-  unitsDisplay, // sections, headers, rows or cells
-  unitsLayoutIndexes, // indexes to remove from the layout data
-}) => (layoutData) => {
-  switch (unitsDisplay) {
-    case 'header':
-      return R.evolve({
-        headerData: R.map(
-          R.over(
-            R.lensProp('data'),
-            R.pipe(
-              removeUnitsDimensions(unitsLayoutIndexes.header),
-              formatUnitsInLayoutSerie
-            )
-          )
-        )
-      })(layoutData);
-    case 'sections':
-      return R.evolve({
-        sectionsData: R.map(
-          ([section, rows]) => {
-            const updatedSection = R.over(
-              R.lensProp('data'),
-              R.pipe(
-                removeUnitsDimensions(unitsLayoutIndexes.sections),
-                formatUnitsInLayoutSerie
-              )
-            )(section);
-            return ([updatedSection, rows]);
-          }
-        )
-      })(layoutData);
-    case 'rows':
-      return R.evolve({
-        sectionsData: R.map(
-          ([section, rows]) => {
-            const updatedRows = R.map(R.over(
-              R.lensProp('data'),
-              R.pipe(
-                removeUnitsDimensions(unitsLayoutIndexes.rows),
-                formatUnitsInLayoutSerie
-              )
-            ), rows);
-            return ([section, updatedRows]);
-          }
-        )
-      })(layoutData);
-    default:
-      return layoutData;
-  }
-};

package/src/rules/src/table/units/getAttachmentSeriesIndexes.js

@@ -1,27 +0,0 @@
-import * as R from 'ramda';
-
-export const getAttachmentSeriesIndexes = ({
-  unitsArtefacts,
-  dimensions // { id: { __index, ...dim } }
-}) => {
-  const targettedDimensionsCodes = R.pipe(
-    R.pathOr({}, ['attributes', 'series']),
-    R.values,
-    R.map(R.pathOr([], ['relationship', 'dimensions'])),
-    R.unnest
-  )(unitsArtefacts);
-
-  const unitsDimensionsCodes = R.pipe(
-    R.pathOr({}, ['dimensions', 'series']),
-    R.reject(R.propOr(false, 'header')),
-    R.keys,
-  )(unitsArtefacts);
-
-  return R.pipe(
-    R.props(R.concat(unitsDimensionsCodes, targettedDimensionsCodes)),
-    R.filter(dim => !R.isNil(dim)),
-    R.pluck('__index'),
-    R.uniq,
-    R.sortBy(R.identity)
-  )(dimensions);
-};

package/src/rules/src/table/units/getHeaderUnits.js

@@ -1,32 +0,0 @@
-import * as R from 'ramda';
-
-export const getHeaderUnits = ({
-  rejectedValueIds=[],
-  unitsArtefacts, // { dimensions: { header: { id: dim, ... }, series: {} }, attributes: { header: {}, series: {} } }
-  unitsDefinitionCodes=[]
-}) => {
-  const artefacts = R.converge(
-    R.merge,
-    [
-      R.pathOr({}, ['dimensions', 'header']),
-      R.pathOr({}, ['attributes', 'header'])
-    ]
-  )(unitsArtefacts);
-
-  return R.pipe(
-    R.props(unitsDefinitionCodes),
-    R.reduce(
-      (acc, entry) => {
-        if (R.isNil(entry) || !(R.propOr(true, 'display', entry)) || !(R.pathOr(true, ['values', 0, 'display'], entry))
-          || R.includes(R.path(['values', 0, 'id'], entry), rejectedValueIds)) {
-          return acc;
-        }
-        return R.append(
-          { ...R.pick(['id', 'name'], entry), value: R.path(['values', 0], entry) },
-          acc
-        );
-      },
-      []
-    )
-  )(artefacts);
-};