@sis-cc/dotstatsuite-components 21.0.1 → 21.1.0

package/src/rules2/src/applyHierarchicalCodesToDim.js

@@ -1,149 +0,0 @@
-import * as R from 'ramda';
-
-const addParentId = (id, ids) => {
-  const last = R.last(ids);
-  return R.append(R.isNil(last) ? id : `${last}.${id}`, ids); 
-}
-
-const refineUnconfirmedPaths = (paths) => {
-  let confirmedPaths = R.filter(p => p.length === 1, paths);
-  if (!R.isEmpty(confirmedPaths)) {
-    confirmedPaths = R.reduce((acc, k) => {
-      if (R.has(k, acc)) {
-        return acc;
-      }
-      const ps = R.prop(k, paths);
-      const flatConfirmed = R.unnest(R.values(acc));
-      const filtered = R.filter(p => !!R.find(cP => R.includes(p, cP) || R.includes(cP, p), flatConfirmed), ps);
-      if (!R.isEmpty(filtered)) {
-        return R.assoc(k, [R.head(filtered)], acc);
-      }
-      return acc;
-    }, confirmedPaths, R.keys(paths));
-  }
-  const remainingIds = R.reject(id => R.has(id, confirmedPaths), R.keys(paths));
-  const getCommonPaths = ids => {
-    const { commonPaths, rejectedIds } = R.reduce(
-      (acc, id) => {
-        const ps = R.prop(id, paths);
-        if (R.isEmpty(acc.commonPaths)) {
-          return R.assoc('commonPaths', ps, acc);
-        }
-        const common = R.intersection(acc.commonPaths, ps);
-        return R.isEmpty(common)
-          ? R.assoc('rejectedChildrenIds', id, acc)
-          : R.assoc('commonPaths', common, acc);
-      },
-      { commonPaths: [], rejectedIds: [] }
-    )(ids);
-    if (!R.isEmpty(rejectedIds)) {
-      return R.append(R.head(commonPaths), getCommonPaths(rejectedIds));
-    }
-    return [R.head(commonPaths)];
-  };
-  const commons = getCommonPaths(remainingIds);
-  return R.reduce(
-    (acc, id) => R.assoc(id, R.intersection(commons, R.prop(id, paths)), acc),
-    confirmedPaths,
-    remainingIds
-  );
-};
-
-export const applyHierarchicalCodesToDim = (hCodes, dim) => {
-  const confirmedHierarchisedChilds = new Set([]);
-  let unconfirmedPaths = {};
-
-  const indexedValues = R.reduce((acc, val) => {
-    if (!val.isSelected) {
-      return acc;
-    }
-    return R.assoc(val.id, val, acc);
-  }, {}, dim.values || []);
-
-  const parseHCodes = (parentsDef, parentsInDim) => R.reduce((acc, hC) => {
-    const { codeID, hierarchicalCodes = [] } = hC;
-    const hasInDim = R.has(codeID, indexedValues);
-    const isUnconfirmed = R.length(parentsInDim) !== R.length(parentsDef);
-    const children = parseHCodes(
-      R.append(codeID, parentsDef),
-      hasInDim ? addParentId(codeID, parentsInDim) : parentsInDim
-    )(hierarchicalCodes);
-    if (!hasInDim) {
-      return R.concat(acc, children);
-    }
-    const path = R.join('.', parentsDef);
-    let val = {
-      ...R.prop(codeID, indexedValues),
-      path,
-      parents: parentsInDim,
-      parent: R.last(parentsInDim),
-      children
-    };
-
-    if (isUnconfirmed) {
-      unconfirmedPaths = R.over(R.lensProp(val.id), paths => R.append(path, paths || []), unconfirmedPaths);
-      val = R.assoc('unconfirmed', true, val);
-      return R.append(val, acc);
-    }
-    confirmedHierarchisedChilds.add(codeID);
-    return R.append(val, acc);
-  }, []);
-
-  const parsed = parseHCodes([], [])(hCodes);
-
-  const _unconfirmedPaths = R.pipe(
-    R.reject(id => confirmedHierarchisedChilds.has(id)),
-    ids => R.pick(ids, unconfirmedPaths)
-  )(R.keys(unconfirmedPaths));
-
-  const refinedUnconfirmedPaths = refineUnconfirmedPaths(_unconfirmedPaths);
-
-  const flattenDescendants = R.reduce((acc, val ) => {
-    const children = flattenDescendants(val.children || []);
-    return R.concat(acc, R.prepend(val, children));
-  }, []);
-
-  const isValid = val => !val.unconfirmed || R.includes(val.path, R.propOr([], val.id, refinedUnconfirmedPaths));
-
-  const refineCodes = R.reduce((acc, hC) => {
-    const _flatDescendants = flattenDescendants(hC.children);
-    const flatDescendants = R.prepend(hC, _flatDescendants);
-    const validDescendant = R.find(isValid, flatDescendants);
-    if (!validDescendant) {
-      return acc;
-    }
-    const refined = R.pipe(
-      R.map(v => {
-        confirmedHierarchisedChilds.add(v.id);
-        return R.omit(['unconfirmed', 'children', 'path'], v);
-      })
-    )(flatDescendants);
-    return R.concat(acc, refined);
-  }, []);
-
-  const refined = refineCodes(parsed);
-
-  const missingValues = R.pipe(
-    R.keys,
-    R.filter(id => !confirmedHierarchisedChilds.has(id)),
-    ids => R.props(ids, indexedValues),
-    R.map(v => ({ ...v, parents: [], parent: undefined })),
-    R.sortBy(R.propOr(-1, '__indexPosition')),
-  )(indexedValues);
-
-  let hierarchicalIndexes = {};
-  return R.pipe(
-    R.concat,
-    R.addIndex(R.map)((v, ind) => {
-      const parents = R.props(v.parents, hierarchicalIndexes);
-      const hierId = R.last(v.parents) ? `${R.last(v.parents)}.${v.id}` : v.id;
-      hierarchicalIndexes[hierId] = ind;
-      return {
-        ...v,
-        parents,
-        __indexPosition: ind
-      };
-    }),
-    values => ({ ...dim, values })
-  )(missingValues, refined);
-};

package/src/rules2/src/combinedValuesDisplay.js

@@ -1,74 +0,0 @@
-import * as R from 'ramda';
-import { dimensionValueDisplay } from '../../rules/src';
-import { REJECTED_VALUE_IDS } from './constants';
-
-const getRefinedMissinParentsLabels = R.pipe(
-  R.propOr([], 'missingParents'),
-  R.reduce((acc, par) => {
-    if (
-      !R.propOr(true, 'display', par) ||
-      R.includes(par.id, REJECTED_VALUE_IDS)
-    ) {
-      return acc;
-    }
-    return R.append(dimensionValueDisplay('label')(par), acc);
-  }, []),
-);
-
-export const singleValueDisplay = (display, value) => {
-  if (display === 'label') {
-    return R.converge(
-      (missingParents, label) =>
-        R.isEmpty(missingParents)
-          ? label
-          : R.join(' > ', R.append(label, missingParents)),
-      [getRefinedMissinParentsLabels, dimensionValueDisplay(display)],
-    )(value);
-  } else if (display === 'both') {
-    return `(${singleValueDisplay('code', value)}) ${singleValueDisplay(
-      'label',
-      value,
-    )}`;
-  }
-  return dimensionValueDisplay(display)(value);
-};
-
-const _combinedValuesDisplay = (_display) => (values) =>
-  R.pipe(
-    R.reduce((acc, val) => {
-      if (R.isNil(val)) return acc;
-      const isDisplayed = R.propOr(true, 'display', val);
-      const isRejected = R.includes(val.id, REJECTED_VALUE_IDS);
-      if ((!isDisplayed || isRejected) && _display === 'label') return acc;
-      return R.append(singleValueDisplay(_display, val), acc);
-    }, []),
-    (labels) => {
-      if (!R.isEmpty(labels) || _display !== 'label') {
-        return R.join(', ', labels);
-      }
-      const totalValue = R.find(R.propEq('id', '_T'), values);
-      if (!R.isNil(totalValue)) {
-        return dimensionValueDisplay('label')(totalValue);
-      }
-      if (R.isEmpty(values)) {
-        return '';
-      }
-      const firstValue = R.head(values);
-      return dimensionValueDisplay('label')(firstValue);
-    },
-  )(values);
-
-export const combinedValuesDisplay = (display, values) => {
-  if (display === 'both') {
-    return R.converge(
-      (_ids, labels) => {
-        return dimensionValueDisplay('both')({
-          id: _ids,
-          name: labels,
-        });
-      },
-      [_combinedValuesDisplay('code'), _combinedValuesDisplay('label')],
-    )(values);
-  }
-  return _combinedValuesDisplay(display)(values);
-};

package/src/rules2/src/constants.js

@@ -1,6 +0,0 @@
-export const SDMX_3_0_JSON_DATA_FORMAT = 'application/vnd.sdmx.data+json;version=2.0';
-export const SDMX_3_0_CSV_DATA_FORMAT = 'application/vnd.sdmx.data+csv;version=2.0';
-export const EMPTY_ATTACHMENT_LEVEL_CHAR = '~';
-export const REPORTING_YEAR_START_DAY = 'REPORTING_YEAR_START_DAY';
-export const REPYEARSTART = 'REPYEARSTART';
-export const REJECTED_VALUE_IDS = ['_L', '_T', '_Z'];

package/src/rules2/src/duplicateObservations.js

@@ -1,35 +0,0 @@
-import * as R from 'ramda';
-
-export const duplicateObs = (dims, observations) => {
-  const obsValues = R.values(observations);
-  if (R.length(dims) === 0) {
-    return observations;
-  }
-  const duplicated = R.reduce(
-    (obs, dim) => {
-      const groupedObs = R.groupBy(o => R.prop(dim.id, o.indexedDimValIds), obs);
-      const enhancedObs = R.addIndex(R.map)(
-        (value, index) => {
-          const matchingObs = R.propOr([], value.id, groupedObs);
-
-          return R.map(
-            obs => R.over(
-              R.lensProp('orderedDimIndexes'),
-              _indexes => {
-                const indexes = R.isNil(_indexes) ? R.map(i => Number(i), obs.dimValuesIndexes) : _indexes;
-                return R.set(R.lensIndex(dim.__index), index)(indexes);
-              }
-            )(obs),
-            matchingObs
-          );
-        },
-        dim.values
-      );
-      return R.unnest(enhancedObs);
-    },
-    obsValues,
-    dims
-  );
-  const res =  R.indexBy(R.pipe(R.prop('orderedDimIndexes'), R.join(':')), duplicated);
-  return res;
-};

package/src/rules2/src/enhanceObservations.js

@@ -1,95 +0,0 @@
-import * as R from 'ramda';
-import { formatValue } from '../../rules/src/preparators/formatValue';
-import { REJECTED_VALUE_IDS } from './constants';
-
-/*
-  options = {
-    customAttributes: {
-      decimals: id,
-      prefscale: id,
-    },
-  }
-*/
-
-const parseAttributesValues = (obs, attributes, indexedDimensions) => {
-  const { attrValuesIndexes, dimValuesIndexes } = obs;
-  return R.addIndex(R.reduce)(
-    (acc, valueIndex, attrIndex) => {
-      const attribute = R.nth(attrIndex, attributes);
-      if (R.isNil(attribute) || !R.prop('series', attribute)) {
-        return acc;
-      }
-      const _value = R.nth(valueIndex, attribute.values || []);
-      let value = R.isNil(_value)
-        ? _value
-        : R.over(R.lensProp('display'), (display=true) => display && !R.includes(_value.id, REJECTED_VALUE_IDS))(_value);
-      if ((!R.propOr(true, 'display', attribute) || !R.propOr(true, 'display', value))) {
-        value = null;
-      }
-      const relationship = R.propOr([], 'relationship', attribute);
-      let coordinates = {};
-      const serieKey = R.pipe(
-        dims => R.isEmpty(relationship) ? R.values(dims) : R.props(relationship, dims),
-        R.map(dim => {
-          const valueIndex = R.nth(dim.__index, dimValuesIndexes);
-          const valueId = R.path(['values', valueIndex, 'id'], dim);
-          coordinates = R.assoc(dim.id, valueId, coordinates);
-          return `${dim.id}=${valueId}`;
-        }),
-        R.ifElse(R.isEmpty, R.always(null), R.join(':'))
-      )(indexedDimensions);
-
-      return R.assoc(
-        attribute.id,
-        { ...R.pick(['id', 'name', 'relationship', 'display', 'combined'], attribute), value, serieKey, coordinates, isObs: R.isEmpty(relationship) },
-        acc
-      );
-    },
-    {},
-    attrValuesIndexes
-  );
-};
-
-const getFormatAttributesIndexes = (attributes, customAttributes) => R.addIndex(R.reduce)(
-  (acc, attribute, index) => {
-    if (R.equals(attribute.id, customAttributes.decimals)) {
-      return ({ ...acc, decimals: index });
-    }
-    if (R.equals(attribute.id, customAttributes.prefscale)) {
-      return ({ ...acc, prefscale: index });
-    }
-    return acc;
-  },
-  { prefscale: null, decimals: null },
-  attributes
-);
-
-export const enhanceObservations = (dimensions = [], observations = {}, attributes = [], options = {}) => {
-  const formatAttributesIndexes = getFormatAttributesIndexes(attributes, R.propOr({}, 'customAttributes', options));
-  const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
-
-  return R.map(
-    (observation) => {
-      const { dimValuesIndexes } = observation;
-
-      const indexedDimValIds = R.addIndex(R.reduce)(
-        (acc, dimension, dimensionIndex) => {
-          const id = dimension.id;
-          const valueIndex = R.nth(dimensionIndex, dimValuesIndexes);
-          const valueId = R.path(['values', Number(valueIndex), 'id'], dimension);
-          return R.assoc(id, valueId, acc);
-        },
-        {},
-        dimensions
-      );
-
-      return ({
-        ...observation,
-        attributes: parseAttributesValues(observation, attributes, indexedDimensions),
-        formattedValue: formatValue(observation, formatAttributesIndexes, attributes),
-        indexedDimValIds,
-      });
-    },
-    observations
-  );
-};

package/src/rules2/src/getAdvAttrSeriesAtCoordinates.js

@@ -1,29 +0,0 @@
-import * as R from 'ramda';
-
-const attribueValueDisplay = (display) => data => {
-  if (display === 'code') {
-    return R.prop('id', data);
-  }
-  if (display ===  'both') {
-    return `${R.prop('id', data)}: ${R.prop('name', data)}`;
-  }
-  return R.prop('name', data);
-};
-
-export const getAdvAttrSeriesAtCoordinates = (coordinates, advancedAttributes, display) => R.pipe(
-  R.filter(serie => {
-    const mergedCoord = R.mergeLeft(serie.coordinates, coordinates);
-    return R.equals(mergedCoord, coordinates);
-  }),
-  R.map(serie => {
-    return R.pipe(
-      R.propOr({}, 'attributes'),
-      R.values,
-      R.map(attribute => ({
-        id: attribute.id,
-        label: attribueValueDisplay(display)(attribute),
-        value: attribueValueDisplay(display)(attribute.value)
-      }))
-    )(serie);
-  }),
-)(advancedAttributes);

package/src/rules2/src/getAttributesSeries.js

@@ -1,36 +0,0 @@
-import * as R from 'ramda';
-
-export const getAttributesSeries = observations => R.pipe(
-  R.values,
-  R.reduce(
-    (acc, { attributes }) => {
-      let res = acc.res;
-      let rejected = acc.rejected;
-      R.forEachObjIndexed(
-        (attribute) => {
-          if (!R.isNil(attribute.serieKey) && !attribute.isObs) {
-            if (R.isNil(attribute.value)) {
-              res = R.dissocPath([attribute.serieKey, attribute.id], res);
-              rejected = R.assocPath([attribute.serieKey, attribute.id], true, rejected);
-            }
-            if (R.path([attribute.serieKey, attribute.id], rejected)) {
-              return ;
-            }
-            const valueInRes = R.path([attribute.serieKey, attribute.id, 'value', 'id'], res);
-            if (!R.isNil(valueInRes) && valueInRes !== R.path(['value', 'id'], attribute)) {
-              res = R.dissocPath([attribute.serieKey, attribute.id], res);
-              rejected = R.assocPath([attribute.serieKey, attribute.id], true, rejected);
-            }
-            else {
-              res = R.assocPath([attribute.serieKey, attribute.id], attribute, res);
-            }
-          }
-        },
-        attributes
-      );
-      return ({ res, rejected });
-    },
-    { res: {}, rejected: {}, }
-  ),
-  R.prop('res')
-)(observations);

package/src/rules2/src/getCombinationDefinitions.js

@@ -1,47 +0,0 @@
-import * as R from 'ramda';
-
-const parseTexts = texts => R.reduce(
-  (acc, text) => {
-    const splitted = R.split(':', text);
-    if (R.length(splitted) !== 2) {
-      return acc;
-    }
-    const [id, name] = splitted;
-    return R.assoc(id, name, acc);
-  },
-  {},
-  texts
-);
-
-export const parseCombinationDefinition = (locale) => (title, texts) => R.useWith(
-  (titles, texts) =>
-    R.reduce((acc, title) => {
-      const split = R.split(':', title);
-      if (R.length(split) !== 2) {
-        return acc;
-      }
-      const [id, codes] = split;
-      if (R.isEmpty(codes)) {
-        return acc;
-      }
-      return R.append({
-        id,
-        concepts: R.split(',', codes),
-        name: R.hasPath([locale, id], texts)
-          ? R.path([locale, id], texts)
-          : `[${id}]`,
-      }, acc);
-    }, [], titles),
-  [R.split(';'), R.map(R.pipe(R.split(';'), parseTexts))],
-)(title, texts);
-
-export const getCombinationDefinitions = (annotations, locale) => {
-  const annotation = R.find(annot => annot.type === 'COMBINED_CONCEPTS', annotations);
-  if (R.isNil(annotation)) {
-    return [];
-  }
-  const title = R.propOr('', 'title', annotation);
-  const texts = R.propOr({}, 'texts', annotation);
-
-  return parseCombinationDefinition(locale)(title, texts);
-};

package/src/rules2/src/getDataflowAttributes.js

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

package/src/rules2/src/getDataflowTooltipAttributesIds.js

@@ -1,31 +0,0 @@
-import * as R from 'ramda';
-
-export const getDataflowTooltipAttributesIds = (sdmxJson, defaults = {}) => {
-  const dataflowAnnotationsIndexes = R.pathOr([], ['data', 'dataSets', 0, 'annotations'], sdmxJson);
-  const dataflowAnnotations = R.props(dataflowAnnotationsIndexes, R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson));
-
-  const flagsAttrAnnotation = R.find(R.propEq('type', 'LAYOUT_FLAG'), dataflowAnnotations);
-  const footnotesAttrAnnotation = R.find(R.propEq('type', 'LAYOUT_NOTE'), dataflowAnnotations);
-
-  const customFlags = R.pipe(
-    R.propOr('', 'title'),
-    title => R.isNil(title) || R.isEmpty(title) ? [] : R.split(',', title)
-  )(flagsAttrAnnotation || {});
-
-  const customNotes = R.pipe(
-    R.propOr('', 'title'),
-    title => R.isNil(title) || R.isEmpty(title) ? [] : R.split(',', title),
-    notes => R.difference(notes, customFlags)
-  )(footnotesAttrAnnotation || {});
-
-  const flags = R.isNil(flagsAttrAnnotation)
-    ? R.difference(defaults.flags || [], customNotes)
-    : customFlags;
-
-  const notes = R.isNil(footnotesAttrAnnotation)
-    ? R.difference(defaults.notes || [], flags)
-    : customNotes;
-
-  return ({ flags, notes });
-};
-

package/src/rules2/src/getDimensionValuesIndexes.js

@@ -1,13 +0,0 @@
-import * as R from 'ramda';
-
-export const getDimensionValuesIndexes = (values) => R.addIndex(R.reduce)(
-  (acc, value, position) => {
-    const sdmxIndex = value.__index;
-    return R.over(
-      R.lensProp(String(sdmxIndex)),
-      R.ifElse(R.isNil, R.always([position]), R.append(position))
-    )(acc);
-  },
-  {},
-  values
-);

package/src/rules2/src/getHCodelistsRefsInData.js

@@ -1,32 +0,0 @@
-import * as R from 'ramda';
-
-export const getHCodelistsRefs = annotations => R.reduce(
-  (acc, annotation) => {
-    if (annotation.type !== 'HIER_CONTEXT') {
-      return acc;
-    }
-    const references = annotation.text || annotation.title || '';
-    const refs = R.pipe(
-      R.split(','),
-      R.reduce(
-        (acc2, ref) => {
-          const match = ref.match(/([\w@_.]+):([\w@_.]+):([\w@_.]+)\(([\d.]+)\).([\w@_.]+)$/);
-          if (R.isNil(match)) {
-            return acc2;
-          }
-          const [codelistId, agencyId, code, version, hierarchy] = R.tail(match);
-          return R.assoc(codelistId, { agencyId, code, version, hierarchy, codelistId }, acc2);
-        },
-        {}
-      )
-    )(references);
-    return R.mergeRight(acc, refs);
-  },
-  {},
-  annotations,
-);
-
-export const getHCodelistsRefsInData = sdmxJson => {
-  const annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
-  return getHCodelistsRefs(annotations);
-};

package/src/rules2/src/getHeaderCombinations.js

@@ -1,48 +0,0 @@
-import * as R from 'ramda';
-import { dimensionValueDisplay } from '../../rules/src';
-import { combinedValuesDisplay } from './combinedValuesDisplay';
-import { REJECTED_VALUE_IDS } from './constants';
-
-export const getHeaderCombinations = (combinations, dimensions, attributes, display) => {
-  const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
-  const indexedAttributes = R.indexBy(R.prop('id'), attributes);
-  return R.reduce(
-    (acc, comb) => {
-      if (!R.prop('header', comb) || !R.propOr(true, 'display', comb)) {
-        return acc;
-      }
-
-      const header = `${dimensionValueDisplay(display)(comb)}:`;
-
-      const label = R.pipe(
-        R.reduce(
-          (_acc, concept) => {
-            const artefact = R.has(concept, indexedDimensions)
-              ? R.prop(concept, indexedDimensions)
-              : R.prop(concept, indexedAttributes);
-            if (R.isNil(artefact)) {
-              return _acc;
-            }
-            const value = R.path(['values', 0], artefact);
-            if (R.isNil(value)) {
-              return _acc;
-            }
-            if (R.has(concept, indexedAttributes) && (!R.propOr(true, 'display', value)
-              || !R.propOr(true, 'artefact', value) || R.includes(value.id, REJECTED_VALUE_IDS))) {
-              return _acc;
-            }
-            return R.append(value, _acc);
-          },
-          []
-        ),
-        values => combinedValuesDisplay(display, values)
-      )(comb.concepts || []);
-      if (R.isEmpty(label)) {
-        return acc;
-      }
-      return R.append({ header, label }, acc);
-    },
-    [],
-    combinations,
-  );
-};

package/src/rules2/src/getHeaderCoordinates.js

@@ -1,7 +0,0 @@
-import * as R from 'ramda';
-
-export const getHeaderCoordinates = (oneValueDimensions) => R.reduce(
-  (acc, dim) => R.assoc(dim.id, R.path(['values', 0, 'id'], dim), acc),
-  {},
-  oneValueDimensions
-);

package/src/rules2/src/getHeaderSubtitle.js

@@ -1,34 +0,0 @@
-import * as R from 'ramda';
-import { getFlagsAndNotes } from './table/getFlagsAndNotes';
-import { dimensionValueDisplay } from '../../rules/src/';
-
-export const getHeaderSubtitle = (dimensions, combinations, customAttributes, display, microdataDimension) => {
-  const combinationsConepts = R.pipe(R.pluck('concepts'), R.unnest)(combinations);
-  const DEFAULT_REJECTED_SUBTITLE_IDS = ['_L', '_T', '_Z'];
-
-  return R.reduce(
-    (acc, dim) => {
-      if (!R.propOr(true, 'display', dim) || R.propEq('id', microdataDimension, dim)
-        || R.includes(dim.id, combinationsConepts)) {
-        return acc;
-      }
-      const value = R.path(['values', 0], dim);
-      if (!R.propOr(true, 'display', value) || R.includes(value.id, DEFAULT_REJECTED_SUBTITLE_IDS)) {
-        return acc;
-      }
-      const header = `${dimensionValueDisplay(display)(dim)}:`;
-      const label = dimensionValueDisplay(display)(value);
-      const flags = R.pipe(
-        getFlagsAndNotes,
-        R.map(entry => ({
-          code: entry.code,
-          header: `${dimensionValueDisplay(display)(entry)}:`,
-          label: dimensionValueDisplay(display)(entry.value),
-        })),
-      )(dim.attrValues, customAttributes);
-      return R.append({ header, label, flags }, acc);
-    },
-    [],
-    dimensions,
-  );
-};