@sis-cc/dotstatsuite-components 15.0.20 → 16.0.0

package/lib/{rules/src/table/factories → rules2/src/table}/refineLayoutSize.js

@@ -25,12 +25,21 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+var toKey = function toKey(indexes) {
+  return R.reduce(function (acc, _ind) {
+    var ind = R.is(Array, _ind) ? toKey(_ind) : Math.abs(_ind);
+    return R.isEmpty(acc) ? String(ind) : acc + ':' + ind;
+  }, '', indexes);
+};
+
 var getPivotKey = function getPivotKey(indexes) {
   return R.pipe(R.props(indexes), R.join(':'));
 };
 
 var getPivots = function getPivots(layout, shape) {
-  return R.pipe(R.props(shape), R.map(R.pipe(R.pluck('__index'), getPivotKey)))(layout);
+  return R.pipe(R.props(shape), R.map(R.pipe(R.map(function (entry) {
+    return R.has('dimensions', entry) ? R.pluck('__index', entry.dimensions || []) : entry.__index;
+  }), R.unnest, getPivotKey)))(layout);
 };
 
 var indexWithPivots = function indexWithPivots(pivots, observations) {
@@ -53,9 +62,9 @@ var getCuratedCells = exports.getCuratedCells = function getCuratedCells(_ref) {
 
 var refineSections = exports.refineSections = function refineSections(sections, extractedKeys, curatedObs) {
   return R.pipe(R.map(function (section) {
-    var sectionKey = R.join(':', R.head(section) || []);
+    var sectionKey = toKey(R.head(section) || []);
     return R.over(R.lensIndex(1), R.filter(function (rowData) {
-      var rowKey = R.join(':', rowData);
+      var rowKey = toKey(rowData);
       return R.pipe(R.path([sectionKey, rowKey]), R.omit(extractedKeys), R.isEmpty, R.not)(curatedObs);
     }))(section);
   }), R.filter(R.pipe(R.nth(1), R.isEmpty, R.not)))(sections);
@@ -64,7 +73,7 @@ var refineSections = exports.refineSections = function refineSections(sections,
 var refineHeader = exports.refineHeader = function refineHeader(header, extractedKeys, curatedObs) {
   return R.filter( // extracted : { [sectionKey]: [...rowKeys] }
   function (header) {
-    var headerKey = R.join(':', header);
+    var headerKey = toKey(header);
     return R.pipe(R.prop(headerKey), function (sections) {
       return R.pickBy(function (rows, section) {
         return R.pipe(R.omit(R.propOr([], section, extractedKeys)), R.isEmpty, R.not)(rows);
@@ -81,7 +90,7 @@ var truncateSectionRows = exports.truncateSectionRows = function truncateSection
     var lastSection = R.last(truncated);
     var rows = lastSection[1];
     var rowsLength = R.length(rows);
-    var sectionKey = R.join(':', R.head(lastSection));
+    var sectionKey = toKey(R.head(lastSection));
     if (rowsLength > _n) {
       var _R$splitAt = R.splitAt(R.negate(_n), rows),
           _R$splitAt2 = (0, _slicedToArray3.default)(_R$splitAt, 2),
@@ -90,11 +99,11 @@ var truncateSectionRows = exports.truncateSectionRows = function truncateSection
 
       var updatedSection = R.set(R.lensIndex(1), rest)(lastSection);
       truncated = R.set(R.lensIndex(-1), updatedSection)(truncated);
-      extractedKeys = (0, _extends5.default)({}, extractedKeys, (0, _defineProperty3.default)({}, sectionKey, R.map(R.join(':'), extracted)));
+      extractedKeys = (0, _extends5.default)({}, extractedKeys, (0, _defineProperty3.default)({}, sectionKey, R.map(toKey, extracted)));
       _n = 0;
     } else {
       truncated = R.dropLast(1, truncated);
-      extractedKeys = (0, _extends5.default)({}, extractedKeys, (0, _defineProperty3.default)({}, sectionKey, R.map(R.join(':'), rows)));
+      extractedKeys = (0, _extends5.default)({}, extractedKeys, (0, _defineProperty3.default)({}, sectionKey, R.map(toKey, rows)));
       _n = _n - rowsLength;
     }
   }
@@ -107,7 +116,7 @@ var truncateHeader = exports.truncateHeader = function truncateHeader(n, headerD
       truncated = _R$splitAt4[0],
       extracted = _R$splitAt4[1];
 
-  return { truncated: truncated, extractedKeys: R.map(R.join(':'), extracted) };
+  return { truncated: truncated, extractedKeys: R.map(toKey, extracted) };
 };
 
 var truncateLayout = function truncateLayout(isVertical) {

package/lib/rules2/src/{hasLayoutEntryMetadata.js → utils.js}

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getLayoutEntryMetadataCoordinates = undefined;
+exports.trimedProps = undefined;
 
 var _ramda = require('ramda');
 
@@ -11,8 +11,11 @@ var R = _interopRequireWildcard(_ramda);
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
 
-/*
-const layoutData = [{ dimension: { id: 'D1', __index: 2 }, value: { id: 'V', __index: 0 } }];
-*/
-
-var getLayoutEntryMetadataCoordinates = exports.getLayoutEntryMetadataCoordinates = function getLayoutEntryMetadataCoordinates(layoutData, metadataSeries) {};
+var trimedProps = exports.trimedProps = function trimedProps(properties, obj) {
+  return R.reduce(function (acc, prop) {
+    if (!R.has(prop, obj)) {
+      return acc;
+    }
+    return R.append(obj[prop], acc);
+  }, [], properties);
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sis-cc/dotstatsuite-components",
   "description": "Set components based on React.",
-  "version": "15.0.20",
+  "version": "16.0.0",
   "main": "lib/index.js",
   "author": "OECD",
   "license": "MIT",

package/src/rules/src/index.js

@@ -381,10 +381,7 @@ export {
 } from './properties';
 export { dataTransformer as v8Transformer } from './v8-transformer';
 export {
-  prepareData,
   getCellValue,
-  getTableProps,
-  getFlags,
 } from './table';
 export {
   getFullName,
@@ -396,20 +393,5 @@ export { getObservationsType } from './properties/getObservationsType';
 export { getAvailableChartTypes } from './properties/getAvailableChartTypes';
 export { isSharedLayoutCompatible } from './layout';
 
-export { parseDimensionsIds } from './table/preparators/parseDimensionsIds';
-export { parseAttributes } from './table/preparators/parseAttributes';
-export { getDimensionsAttributesRegisters } from './table/preparators/getDimensionsAttributesRegisters';
-export { parseAttributesValuesFromObservations } from './table/preparators/parseAttributesValuesFromObservations';
-export { getOneValueDimensions } from './table/preparators/getOneValueDimensions';
-export { getManyValuesDimensions } from './table/preparators/getManyValuesDimensions';
-export { getAttributeValue } from './table/preparators/getAttributeValue';
-export { refineSeriesAttributesValues } from './table/preparators/refineSeriesAttributesValues';
-
-export { getUnitsDefinition } from './table/units/getUnitsDefinition';
-export { getUnitsArtefacts } from './table/units/getUnitsArtefacts';
-export { getHeaderUnits } from './table/units/getHeaderUnits';
-export { getAttachmentSeriesIndexes } from './table/units/getAttachmentSeriesIndexes';
-export { getUnitsSeries } from './table/units/getUnitsSeries';
-
 export { getObservations } from './preparators/getObservations';
-export { enhanceObservations } from './preparators/enhanceObservations';
+

package/src/rules/src/table/index.js

@@ -1,5 +1 @@
-export { prepareData } from './preparators/prepareData';
-export { getCells, getFlags } from './factories/getCells';
-export { getTableCells } from './factories/getTableCells';
-export { getTableProps } from './factories/getTableData';
 export { getCellValue } from './factories/getCellValue';

package/src/rules/src/v8-transformer.js

@@ -2,7 +2,8 @@ import * as R from 'ramda';
 import dateFns from 'date-fns';
 import { getCodeOrder, getRefinedName, isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
 import {
-  getRelationnalAnnotations, setAnnotationsLayout, getIsHidden } from './sdmx-data';
+  getRelationnalAnnotations, setAnnotationsLayout, getIsHidden
+} from './sdmx-data';
 import { getReportedTimePeriodLabel, getReportedTimePeriodNote, getReportedTimePeriod } from './date';
 import { getReportingYearStart } from './preparators/getReportingYearStart';
 import { getNotDisplayedIds } from '../../rules2/src';
@@ -10,18 +11,18 @@ import { getNotDisplayedIds } from '../../rules2/src';
 const TIME_PERIOD_ID = 'TIME_PERIOD';
 
 export const dataTransformer = (dataNew, options = {}) => {
-  const { locale } = options;
+  const { locale, hiddenIds: _hiddenIds } = options;
   const reportYearStart = getReportingYearStart(dataNew);
 
   //---------------------------------------------------------------------------------------Annotations
-  const getStructure = R.pathOr({},['data', 'structure']);
+  const getStructure = R.pathOr({}, ['data', 'structure']);
   const structure = getStructure(dataNew);
   const getAnnotations = R.propOr([], 'annotations');
   const annotations = getAnnotations(structure);
-  const getDataSets = R.pathOr({},['data', 'dataSets']);
+  const getDataSets = R.pathOr({}, ['data', 'dataSets']);
   const dataSets = getDataSets(dataNew);
 
-  const dataSetsAnnotations = R.props(R.pathOr([],[0, 'annotations'], dataSets), annotations);
+  const dataSetsAnnotations = R.props(R.pathOr([], [0, 'annotations'], dataSets), annotations);
 
   const hiddenIds = getNotDisplayedIds(dataSetsAnnotations);
 
@@ -35,64 +36,64 @@ export const dataTransformer = (dataNew, options = {}) => {
     });
   }, values);
 
-  const getValuesEnhanced = (locale, annotations, isTimeDimension, parent) => 
-  R.pipe(
-    R.addIndex(R.map)((value, __index) => {
-      const valueAnnotations = R.pipe(
-        R.propOr([], 'annotations'),
-        R.flip(R.props)(annotations)
-      )(value);
-      const isHidden = R.has(`${parent}.${value.id}`, hiddenIds) || getIsHidden(valueAnnotations);
-      const name = getRefinedName(value);
-      let __indexPosition = NaN;
-      let notes = [];
-      let start = null;
-      let end = null;
-      if (isTimeDimension) {
-        const reported = getReportedTimePeriod(reportYearStart, value, options.frequency);
-        start = reported.start;
-        end = reported.end;
-        const reportTimeNote = getReportedTimePeriodNote(reportYearStart, start, end, options.frequency, options.isRtl);
-        notes = R.isNil(reportTimeNote) ? notes : R.append(reportTimeNote, notes);
-        __indexPosition = dateFns.getTime(new Date(R.prop('start', value)));
-      }
-      if (isNaN(__indexPosition)) {
-        __indexPosition = getCodeOrder({ annotations: valueAnnotations });
-      }
-      const timeFormat = R.prop('timeFormat', options);
-      return ({
-        ...value,
-        id: R.pipe(
-          R.when(
-            R.isNil,
-            R.always(`${parent}-${__index}`)
-          ),
-          R.when(
+  const getValuesEnhanced = (locale, annotations, isTimeDimension, parent) =>
+    R.pipe(
+      R.addIndex(R.map)((value, __index) => {
+        const valueAnnotations = R.pipe(
+          R.propOr([], 'annotations'),
+          R.flip(R.props)(annotations)
+        )(value);
+        const isHidden = (_hiddenIds[parent] && R.includes(value.id, _hiddenIds[parent])) || R.has(`${parent}.${value.id}`, hiddenIds) || getIsHidden(valueAnnotations);
+        const name = getRefinedName(value);
+        let __indexPosition = NaN;
+        let notes = [];
+        let start = null;
+        let end = null;
+        if (isTimeDimension) {
+          const reported = getReportedTimePeriod(reportYearStart, value, options.frequency);
+          start = reported.start;
+          end = reported.end;
+          const reportTimeNote = getReportedTimePeriodNote(reportYearStart, start, end, options.frequency, options.isRtl);
+          notes = R.isNil(reportTimeNote) ? notes : R.append(reportTimeNote, notes);
+          __indexPosition = dateFns.getTime(new Date(R.prop('start', value)));
+        }
+        if (isNaN(__indexPosition)) {
+          __indexPosition = getCodeOrder({ annotations: valueAnnotations });
+        }
+        const timeFormat = R.prop('timeFormat', options);
+        return ({
+          ...value,
+          id: R.pipe(
+            R.when(
+              R.isNil,
+              R.always(`${parent}-${__index}`)
+            ),
+            R.when(
+              R.always(isTimeDimension),
+              R.replace(/M/g, '')
+            )
+          )(value.id),
+          display: !isHidden,
+          name: R.when(
             R.always(isTimeDimension),
-            R.replace(/M/g, '')
-          )
-        )(value.id),
-        display: !isHidden,
-        name: R.when(
-          R.always(isTimeDimension),
-          R.always(getReportedTimePeriodLabel(options.frequency, timeFormat, locale)(reportYearStart, { id: value.id, reportedStart: start, start: new Date(value.start) }))
-        )(name),
-        start: start ? start.toISOString() : null,
-        notes,
-        __indexPosition,
-        __index,
-      });
-    }),
-    R.sortWith([
-      R.ascend(R.prop('__indexPosition')),
-      R.ascend(R.propOr(-1, 'order'))
-    ]),
-    R.addIndex(R.map)((val, index) => R.assoc('__indexPosition', index, val)),
-    /* NEW */
-    R.sortBy(R.prop('__index'))
-  );
-
-//--------------------------------------------------------------------------------------------Header
+            R.always(getReportedTimePeriodLabel(options.frequency, timeFormat, locale)(reportYearStart, { id: value.id, reportedStart: start, start: new Date(value.start) }))
+          )(name),
+          start: start ? start.toISOString() : null,
+          notes,
+          __indexPosition,
+          __index,
+        });
+      }),
+      R.sortWith([
+        R.ascend(R.prop('__indexPosition')),
+        R.ascend(R.propOr(-1, 'order'))
+      ]),
+      R.addIndex(R.map)((val, index) => R.assoc('__indexPosition', index, val)),
+      /* NEW */
+      R.sortBy(R.prop('__index'))
+    );
+
+  //--------------------------------------------------------------------------------------------Header
   const getMeta = R.propOr({}, 'meta');
   const meta = getMeta(dataNew);
 
@@ -101,10 +102,10 @@ export const dataTransformer = (dataNew, options = {}) => {
 
   const resHeader = {
     ...meta,
-    sender: {...sender, name: getRefinedName(sender)},
+    sender: { ...sender, name: getRefinedName(sender) },
   };
 
-//----------------------------------------------------------------------------------------Attributes
+  //----------------------------------------------------------------------------------------Attributes
   const getAttributes = R.propOr({}, 'attributes');
   const attributes = getAttributes(structure);
 
@@ -140,7 +141,7 @@ export const dataTransformer = (dataNew, options = {}) => {
     observation: R.concat(resAttrObservations, datasetAttributes)
   };
 
-//----------------------------------------------------------------------------------------Dimensions
+  //----------------------------------------------------------------------------------------Dimensions
   const getDimensions = R.propOr({}, 'dimensions');
   const dimensions = getDimensions(structure);
 
@@ -149,25 +150,25 @@ export const dataTransformer = (dataNew, options = {}) => {
 
   const getObservations = locale => R.addIndex(R.reduce)((acc, observation, obsIndex) => {
     const id = R.prop('id')(observation);
-    const dimAnnotations = getRelationnalAnnotations(R.propOr([],'annotations')(observation))(annotations)
-    const isHidden = R.has(id, hiddenIds) || getIsHidden(dimAnnotations);
+    const dimAnnotations = getRelationnalAnnotations(R.propOr([], 'annotations')(observation))(annotations)
     const isTime = isTimePeriodDimension(observation);
-    const values = getValuesEnhanced(locale, annotations, isTime, id)(R.propOr([],'values', observation));
-
+    const values = getValuesEnhanced(locale, annotations, isTime, id)(R.propOr([], 'values', observation));
+    const _idHidden = _hiddenIds[id] && R.isEmpty(R.difference(_hiddenIds[id], R.pluck('id')(values)))
+    const isHidden = _idHidden || R.has(id, hiddenIds) || getIsHidden(dimAnnotations);
     return ({
       observation: R.append({
         ...observation,
         display: !isHidden,
         __index: obsIndex,
         name: getRefinedName(observation),
-        values,
+        values: _idHidden ? [] : values,
         role: isTime ? TIME_PERIOD_ID : R.head(R.propOr([], 'roles', observation)),
       })(acc.observation),
       dimensionsLayout: setAnnotationsLayout(id, acc.dimensionsLayout)(dimAnnotations),
     });
-  }, { observation: [], dimensionsLayout: {}});
+  }, { observation: [], dimensionsLayout: {} });
 
-//-----------------------------------------------------------------------------------------Structure
+  //-----------------------------------------------------------------------------------------Structure
   const { dimensionsLayout, observation } = getObservations(locale)(dimObservations);
   const resStructure = {
     ...structure,
@@ -177,12 +178,12 @@ export const dataTransformer = (dataNew, options = {}) => {
     dimensions: { observation },
   };
 
-//------------------------------------------------------------------------------------------------------Layout
+  //------------------------------------------------------------------------------------------------------Layout
   const dataSetsLayout = R.reduce((acc, dataSetsAnnotation) => {
     const title = R.propOr('', 'title')(dataSetsAnnotation);
     if (R.isEmpty(title)) return acc;
     return setAnnotationsLayout(title, acc)([dataSetsAnnotation])
   }, {})(dataSetsAnnotations);
 
-  return ({ data: { header: resHeader, dataSets, structure: resStructure }, layout: R.mergeRight(dimensionsLayout, dataSetsLayout)});
+  return ({ data: { header: resHeader, dataSets, structure: resStructure }, layout: R.mergeRight(dimensionsLayout, dataSetsLayout) });
 };

package/src/rules2/src/constants.js

@@ -1,2 +1,4 @@
 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 REPORTING_YEAR_START_DAY = 'REPORTING_YEAR_START_DAY';
+export const REPYEARSTART = 'REPYEARSTART';

package/src/rules2/src/enhanceObservations.js

@@ -0,0 +1,88 @@
+import * as R from 'ramda';
+import { formatValue } from '../../rules/src/preparators/formatValue';
+
+/*
+  options = {
+    customAttributes: {
+      decimals: id,
+      prefscale: id,
+    },
+    rejectedValueIds,
+  }
+*/
+
+const parseAttributesValues = (obs, attributes, indexedDimensions, rejectedValueIds) => {
+  const { attrValuesIndexes, dimValuesIndexes } = obs;
+  return R.addIndex(R.reduce)(
+    (acc, valueIndex, attrIndex) => {
+      const attribute = R.nth(attrIndex, attributes);
+      if (R.isNil(attribute) || !R.propOr(true, 'display', attribute) || !R.prop('series', attribute)) {
+        return acc;
+      }
+      let value = R.nth(valueIndex, attribute.values || []);
+      if (!R.propOr(true, 'display', value) || R.includes(R.prop('id', value), rejectedValueIds)) {
+        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'], 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.mapObjIndexed(
+    (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, R.propOr([], 'rejectedValueIds', options)),
+        formattedValue: formatValue(observation, formatAttributesIndexes, attributes),
+        indexedDimValIds,
+      });
+    },
+    observations
+  );
+};

package/src/rules2/src/getAttributesSeries.js

@@ -0,0 +1,29 @@
+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)) {
+            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

@@ -0,0 +1,29 @@
+import * as R from 'ramda';
+
+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 R.useWith(
+    (titles, texts) =>
+      R.addIndex(R.map)((title, index) => {
+        const split = R.split(':', title);
+        if (R.length(split !== 2)) {
+          return null;
+        }
+        const [id, codes] = split;
+        return {
+          id,
+          concepts: R.split(',', codes),
+          name: R.has(locale, texts)
+            ? R.pipe(R.prop(locale), R.nth(index), R.split(':'), R.last)(texts)
+            : `[${id}]`,
+        };
+      }, titles),
+    [R.split(';'), R.map(R.split(';'))],
+  )(title, texts);
+};

package/src/rules2/src/getHeaderCombinations.js

@@ -0,0 +1,39 @@
+import * as R from 'ramda';
+import { dimensionValueDisplay } from '../../rules/src';
+
+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)) {
+        return acc;
+      }
+
+      const header = dimensionValueDisplay(display)(comb);
+
+      const values = R.pipe(
+        R.reduce((_acc, concept) => {
+          const artefact = R.has(concept, indexedDimensions)
+            ? R.prop(concept, indexedDimensions)
+            : R.prop(concept, indexedAttributes);
+          if (R.isNil(artefact) || !R.prop('display', artefact || {})) {
+            return _acc;
+          }
+          const value = R.path(['values', 0], artefact);
+          if (R.isNil(value) || !R.prop('display', value || {})) {
+            return _acc;
+          }
+          return R.append(dimensionValueDisplay(display)(value), _acc);
+        }, []),
+        R.join(', '),
+      )(comb.concepts || []);
+      if (R.isEmpty(values)) {
+        return acc;
+      }
+      return R.append({ header, label: values }, acc);
+    },
+    [],
+    combinations,
+  );
+};

package/src/rules2/src/getHeaderSubtitle.js

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

package/src/rules2/src/getManyValuesDimensions.js

@@ -0,0 +1,34 @@
+import * as R from 'ramda';
+import { getFlagsAndNotes } from './table/getFlagsAndNotes';
+
+export const getManyValuesDimensions = (dimensions, attributesSeries, customAttributes, combinations) => {
+  const combConceptsIds = R.pipe(R.pluck('concepts'), R.unnest)(combinations);
+  return R.reduce(
+    (acc, dim) => {
+      if (R.length(dim.values || []) < 2) {
+        return acc;
+      }
+      const enhancedValues = R.map(val => {
+        const attrSeries = R.propOr({}, `${dim.id}=${val.id}`, attributesSeries);
+        if (R.isEmpty(attrSeries)) {
+          return val;
+        }
+        const flags = getFlagsAndNotes(attrSeries, customAttributes);
+        const hasAdvancedAttributes = R.pipe(
+          R.omit(
+            R.unnest([
+              customAttributes.flags || [],
+              customAttributes.notes || [],
+              combConceptsIds,
+            ]),
+          ),
+          R.complement(R.isEmpty),
+        )(attrSeries);
+        return { ...val, flags, hasAdvancedAttributes };
+      }, dim.values);
+      return R.append(R.assoc('values', enhancedValues, dim), acc);
+    },
+    [],
+    dimensions,
+  );
+};

package/src/rules2/src/getNotDisplayedIds.js

@@ -23,10 +23,14 @@ export const getNotDisplayedIds = (annotations) => R.pipe(
         }
         return R.reduce(
           (_acc, val) => {
+            let _val = val
             if (R.isEmpty(val)) {
               return _acc;
             }
-            const key = `${dimensionId}.${val}`;
+            if (R.test('/[()]/')) {
+              _val = R.replace(/[()]/g, '')(val)
+            }
+            const key = R.isEmpty(_val) ? dimensionId : `${dimensionId}.${_val}`;
             return R.assoc(key, key, _acc);
           },
           acc,