@sis-cc/dotstatsuite-components 13.0.2 → 13.1.0

package/src/rules/src/preparators/enhanceObservations.js

@@ -1,5 +1,4 @@
 import * as R from 'ramda';
-import { getDisplay } from './getDisplay';
 import { formatValue } from './formatValue';
 
 /*
@@ -9,8 +8,6 @@ import { formatValue } from './formatValue';
       decimals: id,
       prefscale: id,
     },
-    noDisplayIndexes,
-    notDisplayedCodes,
     unitsArtefacts,
     obsAttributes,
     rejectedValueIds,
@@ -38,12 +35,12 @@ const getUnitsValues = (indexes, options) => R.reduce(
       return acc;
     }
     const valueIndex = R.prop(codelist.__index, indexes);
-    if (R.isNil(valueIndex) || !getDisplay(options)(codelist)) {
+    if (R.isNil(valueIndex) || !R.propOr(true, 'display', codelist)) {
       return acc;
     }
     const value = R.path(['values', Number(valueIndex)], codelist);
     if (R.isNil(value) || R.includes(value.id, R.propOr([], 'rejectedValueIds', options))
-      || !getDisplay(options)({ ...value, parent: codelist.id })) {
+      || !R.propOr(true, 'display', value)) {
       return acc;
     }
     return R.assoc(
@@ -94,7 +91,7 @@ const getFormatAttributesIndexes = (attributes, customAttributes) => R.addIndex(
 );
 
 const getAttributeValue = (attribute, valueIndex, options) => {
-  if (!getDisplay(options)(attribute)) {
+  if (!R.propOr(true, 'display', attribute)) {
     return null;
   }
   const value = R.pipe(
@@ -102,7 +99,7 @@ const getAttributeValue = (attribute, valueIndex, options) => {
     R.nth(valueIndex)
   )(attribute);
 
-  if (R.isNil(value) || !getDisplay(options)({ ...value, parent: attribute.id })) {
+  if (R.isNil(value) || !R.propOr(true, 'display', value)) {
     return null;
   }
 
@@ -121,8 +118,6 @@ export const enhanceObservations = (dimensions = [], observations = {}, attribut
     R.props(options.attributesIds || [])
   )(_attributes);
 
-  const seriesDimensions = R.filter(R.pipe(R.propOr([], 'values'), R.length, R.lt(1)), dimensions);
-
   return R.mapObjIndexed(
     (observation) => {
       const { attrValuesIndexes, dimValuesIndexes } = observation;
@@ -154,7 +149,7 @@ export const enhanceObservations = (dimensions = [], observations = {}, attribut
         attributes: obsAttributes,
         formattedValue: formatValue(observation, formatAttributesIndexes, attributes),
         orderedDimIndexes: getOrderedDimensionsIndexes(dimensions, dimValuesIndexes),
-        units: getObservationUnits(observation, seriesDimensions, _attributes, options),
+        units: getObservationUnits(observation, dimensions, _attributes, options),
         indexedDimValIds,
       });
     },

package/src/rules/src/properties/getHeaderProps.js

@@ -1,12 +1,11 @@
 import * as R from 'ramda';
 import {
   getDefaultSubtitle,
-  getDefaultTitle,
   getHeaderUnits,
   getSubtitleFlags,
   getTitleFlags
 } from '../header';
-import { dimensionValueDisplay, extractSdmxArtefacts, parseDisplay } from '../';
+import { dimensionValueDisplay, parseDisplay } from '../';
 import { isChart } from './utils';
 
 const isCustomInvalid = ({ type }) => (value) => R.isNil(value) || !isChart(type);

package/src/rules/src/sdmx-data/index.js

@@ -31,7 +31,7 @@ export const getRelationnalAnnotations = annotationIndexes => annotations => R.m
 
 export const hiddenFormat = { isHidden: true }
 
-export const getIsHidden = R.reduce((acc, annotation) => {
-  if (R.equals(getType(annotation), NOT_DISPLAYED)) return hiddenFormat;
-  return acc;
-}, {});
+export const getIsHidden = annotations => R.pipe(
+  R.find(R.propEq('type', NOT_DISPLAYED)),
+  R.complement(R.isNil)
+)(annotations);

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

@@ -1,34 +1,16 @@
 import * as R from 'ramda';
 import { getAttributeValue } from './getAttributeValue';
 
-export const getOneValueDimensions = (dimensions, attributesIds, attributes, getDisplay) => R.map(
+export const getOneValueDimensions = (dimensions, attributesIds, attributes) => R.map(
   (dimension) => {
     const dimensionAttributes = R.pipe(
       R.mapObjIndexed(attr => getAttributeValue(attr, 0)),
       R.filter(R.complement(R.isNil))
     )(R.pick(R.propOr([], dimension.id, attributesIds), attributes));
 
-    const display = getDisplay(dimension);
-
-    const value = R.pipe(
-      R.path(['values', 0]),
-      R.assoc('attributes', dimensionAttributes),
-      (val) => R.assoc(
-        'display',
-        getDisplay({ ...val, parent: dimension.id }),
-        val
-      )
-    )(dimension);
-
-    return R.pipe(
-      R.assoc(
-        'display',
-        display
-      ),
-      R.assocPath(
-        ['values', 0],
-        value
-      )
+    return R.over(
+      R.lensPath(['values', 0]),
+      R.assoc('attributes', dimensionAttributes)
     )(dimension);
   },
   dimensions

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

@@ -78,11 +78,11 @@ const getAttributeRegisters = (attribute, parsedDimensionsIds, customAttributes)
   ]
 };
 
-export const parseAttributes = ({ attributes, parsedDimensionsIds, customAttributes, getDisplay }) => R.addIndex(R.reduce)(
+export const parseAttributes = ({ attributes, parsedDimensionsIds, customAttributes }) => R.addIndex(R.reduce)(
   (acc, attribute, attributeIndex) => {
     const values = R.propOr([], 'values', attribute);
 
-    if (R.isEmpty(values) || !getDisplay(attribute) || R.includes(attribute.id, R.propOr([], 'units', customAttributes))) {
+    if (R.isEmpty(values) || !R.propOr(true, 'display', attribute) || R.includes(attribute.id, R.propOr([], 'units', customAttributes))) {
       return acc;
     }
 
@@ -92,7 +92,7 @@ export const parseAttributes = ({ attributes, parsedDimensionsIds, customAttribu
         R.over(
           R.lensProp('values'),
           R.map((value) => {
-            if (!getDisplay({ ...value, parent: attribute.id })) {
+            if (!R.propOr(true, 'display', value)) {
               return null;
             }
             return value;

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

@@ -1,8 +1,6 @@
 import * as R from 'ramda';
 import { getObservationsType } from '../../properties/getObservationsType';
 import { parseDimensionsIds } from './parseDimensionsIds';
-import { getNoDisplayAnnotationsIndexes } from './getNoDisplayAnnotationsIndexes';
-import { getNoDisplayCodes } from './getNoDisplayCodes';
 import { parseAttributes } from './parseAttributes';
 import { getDimensionsAttributesRegisters } from './getDimensionsAttributesRegisters';
 import { parseAttributesValuesFromObservations } from './parseAttributesValuesFromObservations';
@@ -17,7 +15,6 @@ import { getHeaderUnits } from '../units/getHeaderUnits';
 import { getAttachmentSeriesIndexes } from '../units/getAttachmentSeriesIndexes';
 import { getUnitsSeries } from '../units/getUnitsSeries';
 
-import { getDisplay } from '../../preparators/getDisplay';
 import { getObservations } from '../../preparators/getObservations';
 import { enhanceObservations } from '../../preparators/enhanceObservations';
 
@@ -44,18 +41,8 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
 
   const parsedDimensionsIds = parseDimensionsIds(dimensions);
 
-  const annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
-
-  const noDisplayIndexes = getNoDisplayAnnotationsIndexes(annotations);
-  const notDisplayedCodes = getNoDisplayCodes({
-    noDisplayIndexes,
-    annotations,
-    datasetIndexes: R.pathOr([], ['data', 'dataSets', 0, 'annotations'], sdmxJson)
-  });
-  const _getDisplay = getDisplay({ noDisplayIndexes, notDisplayedCodes });
-
-    //------------------------------------------------------------------
-    const unitsArtefacts = getUnitsArtefacts({ unitsDefinitionCodes, data: sdmxJson, getDisplay: _getDisplay });
+  //------------------------------------------------------------------
+    const unitsArtefacts = getUnitsArtefacts({ unitsDefinitionCodes, data: sdmxJson });
     const headerUnits = getHeaderUnits({ unitsArtefacts, unitsDefinitionCodes, rejectedValueIds });
     const _dimensions = R.pipe(
       R.pathOr([], ['data', 'structure', 'dimensions', 'observation']),
@@ -73,7 +60,6 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
       R.pathOr([], ['data', 'structure', 'attributes', 'dataSet'], sdmxJson),
     ),
     parsedDimensionsIds,
-    getDisplay: _getDisplay,
     customAttributes: _customAttributes,
   });
 
@@ -81,14 +67,11 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
   const observationsAttributesIds = R.propOr([], 'observations', attributesIdsIndexedByTargets);
   const obsUnitsIds = R.pipe(
     ({ attributes, dimensions }) => R.merge(attributes.series || {}, dimensions.series || {}),
-    R.values,
-    R.pluck('id')
+    R.keys
   )(unitsArtefacts);
   const options = {
     attachmentSeriesIndexes,
     customAttributes,
-    noDisplayIndexes,
-    notDisplayedCodes,
     attributesIds: R.concat(seriesAttributesIds, observationsAttributesIds),
     unitsIds: obsUnitsIds
   };
@@ -107,7 +90,7 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
     attributesIndexedByIds
   );
 
-  const dimensionsAttributesValues = parseAttributesValuesFromObservations( // => { series: { key: { attrId: [...indexes] } }, dimensions: {} }
+  const dimensionsAttributesValues = parseAttributesValuesFromObservations( // => { series: { key: { attrId: [...indexes] } }, dimensions: {}   }
     observations,
     attributesRegisters
   );
@@ -129,7 +112,6 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
     )(dimensionsIndexedByIds),
     attributesIdsIndexedByTargets.oneValueDimensions,
     attributesIndexedByIds,
-    _getDisplay
   );
 
   const manyValuesDimensions = getManyValuesDimensions(
@@ -156,7 +138,7 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
 
   const dataflowAdvancedAttributes = getDataflowAdvancedAttributes(
     headerAttributes,
-    oneValueDimensions,
+    R.pick(R.keys(parsedDimensionsIds.oneValue), dimensionsIndexedByIds),
     headerAdvancedAttrIds,
     R.length(dimensions)
   );

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

@@ -1,12 +1,12 @@
 import * as R from 'ramda';
 
-export const getRelevantLength = (getDisplay) => (attr) => R.pipe(
+export const getRelevantLength = (attr) => R.pipe(
   R.propOr([], 'values'),
-  R.filter(val => getDisplay(R.assoc('parent', attr.id, val))),
+  R.filter(R.propOr(true, 'display')),
   R.length
 )(attr);
 
-export const getUnitsArtefacts = ({ unitsDefinitionCodes=[], data, getDisplay }) => {
+export const getUnitsArtefacts = ({ unitsDefinitionCodes=[], data }) => {
   const dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], data);
   const parsedUnitsDimensions = R.addIndex(R.reduce)(
     (acc, dimension, index) => {
@@ -39,7 +39,7 @@ export const getUnitsArtefacts = ({ unitsDefinitionCodes=[], data, getDisplay })
         R.filter(R.pipe(R.propOr([], 'values'), R.length, R.equals(1))),
         R.indexBy(R.prop('id')),
         R.pick(unitsDefinitionCodes),
-        R.filter(getDisplay),
+        R.filter(R.propOr(true, 'display')),
         R.mapObjIndexed(R.assoc('datasetLevel', true))
       ),
       R.pipe(
@@ -47,10 +47,10 @@ export const getUnitsArtefacts = ({ unitsDefinitionCodes=[], data, getDisplay })
         R.addIndex(R.reduce)(
           (acc, attr, index) => {
             if(!R.includes(attr.id, unitsDefinitionCodes) || R.length(R.propOr([], 'values', attr)) === 0
-              || !getDisplay(attr)) {
+              || !R.propOr(true, 'display', attr)) {
               return acc;
             }
-            const length = getRelevantLength(getDisplay)(attr);
+            const length = getRelevantLength(attr);
             if (length === 0) {
               return acc;
             }

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

@@ -5,6 +5,7 @@ import {
   getRelationnalAnnotations, setAnnotationsLayout, getIsHidden, hiddenFormat } from './sdmx-data';
 import { getReportedTimePeriodLabel } from './date';
 import { getReportingYearStart } from './preparators/getReportingYearStart';
+import { getNotDisplayedIds } from '../../rules2/src';
 
 export const dataTransformer = (dataNew, options = {}) => {
   const getLanguage = R.pipe(R.pathOr('', ['meta', 'contentLanguages']), R.head());
@@ -12,14 +13,37 @@ export const dataTransformer = (dataNew, options = {}) => {
   const reportYearStart = getReportingYearStart(dataNew);
   const getProp = (prop, locale) => R.pathOr(null,[prop, locale]);
   const getLocalisedProp = R.curry((prop, collection) => getProp(prop, locale)(collection));
-  const getValues = R.map((value) => ({ ...value, name: getLocalisedProp('names', value) }));
-  const getValuesEnhanced = (locale, annotations, isTimeDimension) => 
+
+  //---------------------------------------------------------------------------------------Annotations
+  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 dataSets = getDataSets(dataNew);
+
+  const dataSetsAnnotations = R.props(R.pathOr([],[0, 'annotations'], dataSets), annotations);
+
+  const hiddenIds = getNotDisplayedIds(dataSetsAnnotations);
+
+  //--------------------------------------------------------------------------------------------------
+  const getValues = (values, parent) => R.map((value) => {
+    const valAnnotations = R.props(value.annotations || [], annotations);
+    return ({
+      ...value,
+      display: !R.has(`${parent}.${value.id}`, hiddenIds) && !getIsHidden(valAnnotations),
+      name: getLocalisedProp('names', value)
+    });
+  }, 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 = getLocalisedProp('names')(value);
       let __indexPosition = NaN;
       let start = null;
@@ -40,6 +64,7 @@ export const dataTransformer = (dataNew, options = {}) => {
           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:value.start }))
@@ -56,12 +81,6 @@ export const dataTransformer = (dataNew, options = {}) => {
     R.addIndex(R.map)((val, index) => R.assoc('__indexPosition', index, val))
   );
 
-  const getDataSets = R.pathOr({},['data', 'dataSets']);
-  const dataSets = getDataSets(dataNew);
-
-  const getStructure = R.pathOr({},['data', 'structure']);
-  const structure = getStructure(dataNew);
-
 //--------------------------------------------------------------------------------------------Header
   const getMeta = R.propOr({}, 'meta');
   const meta = getMeta(dataNew);
@@ -74,20 +93,6 @@ export const dataTransformer = (dataNew, options = {}) => {
     sender: {...sender, name: getLocalisedProp('names', sender)},
   };
 
-//---------------------------------------------------------------------------------------Annotations
-  const getAnnotations = R.propOr([], 'annotations');
-  const annotations = getAnnotations(structure);
-
-  const dataSetsAnnotations = getRelationnalAnnotations(
-    R.pathOr([],[0, 'annotations'])(dataSets)
-  )(annotations);
-
-  const hiddenIds = R.pipe(
-    R.find(R.propEq('type', 'NOT_DISPLAYED')),
-    R.propOr('', 'title'),
-    R.ifElse(R.isEmpty, R.always([]), R.split(','))
-  )(annotations);
-
 //----------------------------------------------------------------------------------------Attributes
   const getAttributes = R.propOr({}, 'attributes');
   const attributes = getAttributes(structure);
@@ -95,19 +100,27 @@ export const dataTransformer = (dataNew, options = {}) => {
   const getAttrObservations = R.propOr([], 'observation');
   const attrObservations = getAttrObservations(attributes);
 
-  const resAttrObservations = R.map((observation) => ({
-    ...observation,
-    name: getLocalisedProp('names', observation),
-    values: getValues(observation.values || []),
-    roles: !R.isNil(observation.role) ? R.head(observation.role) : null,
-  }), attrObservations);
+  const resAttrObservations = R.map((observation) => {
+    const obsAnnotations = R.props(observation.annotations || [], annotations);
+    return ({
+      ...observation,
+      display: !R.has(observation.id, hiddenIds) && !getIsHidden(obsAnnotations),
+      name: getLocalisedProp('names', observation),
+      values: getValues(observation.values || [], observation.id),
+      roles: !R.isNil(observation.role) ? R.head(observation.role) : null,
+    });
+  }, attrObservations);
 
   const datasetAttributes = R.map(
-    (attr) => ({
-      ...attr,
-      name: getLocalisedProp('names', observation),
-      values: getValues(attr.values || [])
-    }),
+    (attr) => {
+      const attrAnnotations = R.props(attr.annotations || [], annotations);
+      return ({
+        ...attr,
+        display: !R.has(attr.id, hiddenIds) && !getIsHidden(attrAnnotations),
+        name: getLocalisedProp('names', observation),
+        values: getValues(attr.values || [], attr.id)
+      });
+    },
     R.propOr([], 'dataSet', attributes)
   )
 
@@ -126,10 +139,10 @@ 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.includes(id)(hiddenIds) ? hiddenFormat : getIsHidden(dimAnnotations);
+    const isHidden = R.has(id, hiddenIds) || getIsHidden(dimAnnotations);
     const isTime = isTimePeriodDimension(observation);
 
-    const values = getValuesEnhanced(locale, annotations, isTime)(R.propOr([],'values', observation));
+    const values = getValuesEnhanced(locale, annotations, isTime, id)(R.propOr([],'values', observation));
     const ids = R.pipe(R.pluck('id'), R.indexBy(R.identity))(values);
     const groupedByParentsValues = R.groupBy(val => {
       const parentId = R.propOr('##ROOT', 'parent', val);
@@ -158,11 +171,11 @@ export const dataTransformer = (dataNew, options = {}) => {
     return ({
       observation: R.append({
         ...observation,
+        display: !isHidden,
         __index: obsIndex,
         name: getLocalisedProp('names', observation),
         values: sortedValues,
         role: R.isNil(observation.roles) ? null : R.head(observation.roles),
-        ...isHidden,
       })(acc.observation),
       dimensionsLayout: setAnnotationsLayout(id, acc.dimensionsLayout)(dimAnnotations),
     });

package/src/rules2/src/getAdvancedAttributes.js

@@ -26,7 +26,7 @@ export const getDataflowAdvancedAttributes = (attributes, dimensions, advancedAt
             coordinates = { ...coordinates, [dId]: vId };
             key = R.set(R.lensIndex(dIndex), 0)(key);
           },
-          attrDimensions
+          R.reject(R.isNil, attrDimensions)
         );
       }
 

package/src/rules2/src/getNotDisplayedIds.js

@@ -0,0 +1,40 @@
+import * as R from 'ramda';
+
+export const getNotDisplayedIds = (annotations) => R.pipe(
+  R.find(R.propEq('type', 'NOT_DISPLAYED')),
+  annot => {
+    if (R.isNil(annot)) {
+      return {};
+    }
+    const ids = R.split(',', annot.title || '');
+    return R.reduce(
+      (acc, entry) => {
+        if (R.isEmpty(entry)) {
+          return acc;
+        }
+        const parsed = R.split('=', entry);
+        const dimensionId = parsed[0];
+        if (R.length(parsed) === 1) {
+          return R.assoc(dimensionId, dimensionId, acc);
+        }
+        const values = R.split('+', parsed[1]);
+        if (R.length(values) === 1 && R.isEmpty(values[0])) {
+          return R.assoc(dimensionId, dimensionId, acc);
+        }
+        return R.reduce(
+          (_acc, val) => {
+            if (R.isEmpty(val)) {
+              return _acc;
+            }
+            const key = `${dimensionId}.${val}`;
+            return R.assoc(key, key, _acc);
+          },
+          acc,
+          values
+        );
+      },
+      {},
+      ids
+    );
+  }
+)(annotations);

package/src/rules2/src/getSidebarData.js

@@ -42,33 +42,51 @@ export const getSidebarData = (attributesSeries, metadataSeries, dataflow, dimen
         R.isNil(metadata) ? [] : metadata,
       );
       const splitCoord = R.split(':', coordinate);
-      let label = null;
-      if (R.all(R.isEmpty, splitCoord)) {
-        label = dimensionValueDisplay(options.display)(dataflow);
-      }
-      else {
-        label = R.pipe(
-          R.addIndex(R.reduce)((acc, valIndex, dimIndex) => {
-            if (R.isEmpty(valIndex)) {
-              return acc;
-            }
-            const dim = R.nth(dimIndex, dimensions);
-            const dimLabel = dimensionValueDisplay(options.display)(dim);
-            const value = R.nth(Number(valIndex), dim.values);
-            const valLabel = dimensionValueDisplay(options.display)(value);
-            return R.append(`${dimLabel}: ${valLabel}`, acc);
-          }, []),
-          R.join(' - ')
-        )(splitCoord);
-      }
-
+      const { split, labels } = R.addIndex(R.reduce)(
+        (acc, valIndex, dimIndex) => {
+          if (R.isEmpty(valIndex)) {
+            return ({ ...acc, split: R.append('', acc.split) });
+          }
+          const dim = R.nth(dimIndex, dimensions);
+          const value = R.nth(Number(valIndex), dim.values);
+          if (!R.propOr(true, 'display', dim) || !R.propOr(true, 'display', value)) {
+            return ({ ...acc, split: R.append('', acc.split) });
+          }
+          const dimLabel = dimensionValueDisplay(options.display)(dim);
+          const valLabel = dimensionValueDisplay(options.display)(value);
+          return ({
+            labels: R.append(`${dimLabel}: ${valLabel}`, acc.labels),
+            split: R.append(valIndex, acc.split)
+          });
+        },
+        { split: [], labels: [] },
+        splitCoord
+      );
+      const label = R.isEmpty(labels)
+        ? dimensionValueDisplay(options.display)(dataflow)
+        : R.join(' - ', labels);
+      
       return ({
-        id: coordinate,
-        splitCoord,
+        id: R.join(':', split),
+        splitCoord: split,
         label,
         children: R.filter(R.identity, children),
       });
     }),
-    R.sort(sortByCoordinates)
+    series => { // after removed non displayed dim vals, some series might be duplicated
+      const grouped = R.groupBy(R.prop('id'), series);
+      return R.pipe(
+        R.map(entries => {
+          if (R.length(entries) === 1) {
+            return R.head(entries);
+          }
+          const head = R.head(entries);
+          const children = R.pipe(R.pluck('children'), R.unnest)(entries);
+          return R.assoc('children', children, head);
+        }),
+        R.values
+      )(grouped);
+    },
+    R.sort(sortByCoordinates),
   )(coordinates);
 };

package/src/rules2/src/index.js

@@ -8,3 +8,4 @@ export { parseMetadataSeries } from './parseMetadataSeries';
 export { sdmx_3_0_DataFormatPatch } from './sdmx3.0DataFormatPatch';
 export { getDataflowTooltipAttributesIds } from './getDataflowTooltipAttributesIds';
 export { getMSDInformations } from './getMSDInformations';
+export { getNotDisplayedIds } from './getNotDisplayedIds';

package/test/enhanceObservations.test.js

@@ -100,7 +100,7 @@ describe('enhanceObservations tests', () => {
       },
       {
         id: 'a4',
-        values: [{ id: 'v0' }, { id: 'v1' }],
+        values: [{ id: 'v0' }, { id: 'v1', display: false }],
       },
     ];
 
@@ -112,7 +112,7 @@ describe('enhanceObservations tests', () => {
           { id: 'v0', __index: 0, __indexPosition: 0 },
           { id: 'v1', __index: 1, __indexPosition: 1 },
           { id: 'v2', __index: 2, __indexPosition: 2 },
-          { id: 'v3', __index: 3, __indexPosition: 3 }
+          { id: 'v3', __index: 3, __indexPosition: 3, display: false }
         ]
       },
       {

package/test/getNotDisplayedIds.test.js

@@ -0,0 +1,31 @@
+import { expect } from 'chai';
+import { getNotDisplayedIds } from '../src/rules2/src/getNotDisplayedIds';
+
+describe('getNotDisplayedIds tests', () => {
+  it('not provided case', () => {
+    const annotations = [
+      { type: 'test0' },
+      { type: 'test1' },
+      { type: 'NOT_DISPLAYED', title: '' },
+      { type: 'test2' },
+    ];
+    expect(getNotDisplayedIds(annotations)).to.deep.equal({});
+  });
+  it('complete case', () => {
+    const annotations = [
+      { type: 'test0' },
+      { type: 'test1' },
+      { type: 'NOT_DISPLAYED', title: 'd0,d1=,d2=v0,d3=v0+,d4=v0+v1' },
+      { type: 'test2' },
+    ];
+    const expected = {
+      d0: 'd0',
+      d1: 'd1',
+      'd2.v0': 'd2.v0',
+      'd3.v0': 'd3.v0',
+      'd4.v0': 'd4.v0',
+      'd4.v1': 'd4.v1'
+    };
+    expect(getNotDisplayedIds(annotations)).to.deep.equal(expected);
+  });
+})

package/test/getOneValueDimensions.test.js

@@ -1,29 +1,24 @@
 import { expect } from 'chai';
 import { getOneValueDimensions } from '../src/rules/src/table/preparators/getOneValueDimensions';
-import { getDisplay } from '../src/rules/src/preparators/getDisplay';
-
-const noDisplayIndexes = [0, 2, 4];
-
-const notDisplayedCodes = { '5': { id: '5' }, '6': { id: '6', values: { '6.1': '6.1' } } }
 
 describe('getOneValueDimensions tests', () => {
   it('no display indexes test', () => {
     const dimensions = [
-      { id: '0', values: [{ id: '0.1' }] },
-      { id: '1', annotations: [1, 3, 5], values: [{ id: '1.1' }] },
-      { id: '2', annotations: [0, 3, 5], values: [{ id: '2.1' }] },
-      { id: '3', values: [{ id: '3.1', annotations: [7, 8] }] },
-      { id: '4', values: [{ id: '4.1', annotations: [2, 7] }] },
-      { id: '5', values: [{ id: '5.1' }] },
-      { id: '6', values: [{ id: '6.1' }] },
+      { id: '0', display: true, values: [{ id: '0.1', display: true }] },
+      { id: '1', display: true, values: [{ id: '1.1', display: true }] },
+      { id: '2', display: false, values: [{ id: '2.1', display: true }] },
+      { id: '3', display: true, values: [{ id: '3.1', display: true }] },
+      { id: '4', display: true, values: [{ id: '4.1', display: false }] },
+      { id: '5', display: false, values: [{ id: '5.1', display: true }] },
+      { id: '6', display: true, values: [{ display: false, id: '6.1' }] },
     ];
 
-    expect(getOneValueDimensions(dimensions, {}, [], getDisplay({ noDisplayIndexes, notDisplayedCodes }))).to.deep.equal([
+    expect(getOneValueDimensions(dimensions, {}, [])).to.deep.equal([
       { id: '0', display: true, values: [{ id: '0.1', attributes: {}, display: true }] },
-      { id: '1', annotations: [1, 3, 5], display: true, values: [{ id: '1.1', attributes: {}, display: true }] },
-      { id: '2', annotations: [0, 3, 5], display: false, values: [{ id: '2.1', attributes: {}, display: true }] },
-      { id: '3', display: true, values: [{ id: '3.1', annotations: [7, 8], attributes: {}, display: true }] },
-      { id: '4', display: true, values: [{ id: '4.1', annotations: [2, 7], attributes: {}, display: false }] },
+      { id: '1', display: true, values: [{ id: '1.1', attributes: {}, display: true }] },
+      { id: '2', display: false, values: [{ id: '2.1', attributes: {}, display: true }] },
+      { id: '3', display: true, values: [{ id: '3.1', attributes: {}, display: true }] },
+      { id: '4', display: true, values: [{ id: '4.1', attributes: {}, display: false }] },
       { id: '5', display: false, values: [{ id: '5.1', attributes: {}, display: true }] },
       { id: '6', display: true, values: [{ id: '6.1', attributes: {}, display: false }] },
     ]);