@sis-cc/dotstatsuite-components 13.0.4 → 13.3.0

package/lib/viewer/src/index.js

@@ -91,15 +91,17 @@ var useStyles = (0, _styles.makeStyles)(function () {
 
 var ViewContent = function ViewContent(_ref3) {
   var loading = _ref3.loading,
+      _ref3$loadingProps = _ref3.loadingProps,
+      loadingProps = _ref3$loadingProps === undefined ? {} : _ref3$loadingProps,
       _ref3$noData = _ref3.noData,
       noData = _ref3$noData === undefined ? 'No Data' : _ref3$noData,
       type = _ref3.type,
       width = _ref3.width,
       errorMessage = _ref3.errorMessage,
-      rest = (0, _objectWithoutProperties3.default)(_ref3, ['loading', 'noData', 'type', 'width', 'errorMessage']);
+      rest = (0, _objectWithoutProperties3.default)(_ref3, ['loading', 'loadingProps', 'noData', 'type', 'width', 'errorMessage']);
 
-  if (loading) return _react2.default.createElement(_dotstatsuiteVisions.Loading, { message: loading });
-  if (!width) return _react2.default.createElement(_dotstatsuiteVisions.Loading, { message: loading });
+  if (loading) return _react2.default.createElement(_dotstatsuiteVisions.Loading, (0, _extends3.default)({ message: loading }, loadingProps));
+  if (!width) return _react2.default.createElement(_dotstatsuiteVisions.Loading, (0, _extends3.default)({ message: loading }, loadingProps));
   if (errorMessage) return _react2.default.createElement(_dotstatsuiteVisions.NoData, { message: errorMessage });
 
   if (type === 'table') {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sis-cc/dotstatsuite-components",
   "description": "Set components based on React.",
-  "version": "13.0.4",
+  "version": "13.3.0",
   "main": "lib/index.js",
   "author": "OECD",
   "license": "MIT",
@@ -37,7 +37,7 @@
   "peerDependencies": {
     "@material-ui/core": "^4.x",
     "@sis-cc/dotstatsuite-visions": "^7.x",
-    "@sis-cc/dotstatsuite-sdmxjs": "^5.x",
+    "@sis-cc/dotstatsuite-sdmxjs": "^6.x",
     "react": "16.x"
   }
 }

package/src/rules/src/factories/choro-series.js

@@ -1,4 +1,4 @@
-import { find, findIndex, get, groupBy, has, head, isUndefined, map, reduce, split, transform } from 'lodash';
+import { get, has, head, isUndefined, map, split, transform } from 'lodash';
 import { getRefAreaDimension } from '@sis-cc/dotstatsuite-sdmxjs';
 import { categoryDisplay, dimensionValueDisplay } from '../dimension-utils';
 

package/src/rules/src/factories/timeline-series.js

@@ -1,47 +1,8 @@
-import {
-  concat, filter, findIndex, get, has, head, isEmpty, isNil, map, reduce, size, sortBy, split, keys, includes
-} from 'lodash';
-import { FREQ_A, FREQ_Q, FREQ_M } from '../constants';
+import { findIndex, get, has, head, isEmpty, isNil, map, reduce, sortBy, split } from 'lodash';
 import { getTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
 import { categoryDisplay, dimensionValueDisplayAt } from '../dimension-utils';
 import { getFormatedObservation } from '../observation-formater';
 
-const getLineCategory = (
-  oDimensionValuesIndexes, dimensions, timePeriodDimensionIndex, dimensionsWithValuesIndexedById
-) => (
-  reduce(
-    oDimensionValuesIndexes,
-    (memo, dimensionValueIndex, dimensionIndex) => {
-      const dimension = get(dimensions, `[${dimensionIndex}]`, {});
-      if ((dimensionIndex !== timePeriodDimensionIndex) && (has(dimensionsWithValuesIndexedById, dimension.id))) {
-        return concat(
-          memo, get(dimensions, `[${dimensionIndex}].values[${dimensionValueIndex}].name`, '')
-        );
-      }
-      return memo;
-    },
-    []
-  ).join(' - ')
-);
-
-const getLineCategoryId = (
-  oDimensionValuesIndexes, dimensions, timePeriodDimensionIndex, dimensionsWithValuesIndexedById
-) => (
-  reduce(
-    oDimensionValuesIndexes,
-    (memo, dimensionValueIndex, dimensionIndex) => {
-      const dimension = get(dimensions, `[${dimensionIndex}]`, {});
-      if ((dimensionIndex !== timePeriodDimensionIndex) && (has(dimensionsWithValuesIndexedById, dimension.id))) {
-        return concat(
-          memo, get(dimensions, `[${dimensionIndex}].values[${dimensionValueIndex}].id`, '')
-        );
-      }
-      return memo;
-    },
-    []
-  ).join(' - ')
-);
-
 const getDimensionValues = (splitObservationKey, dimensions, dimensionsWithValuesIndexedById, rejectedId, display) => (
   reduce(
     splitObservationKey,

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;
   }
 

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/properties/scatter.js

@@ -3,7 +3,6 @@ import { isRefAreaDimension } from '@sis-cc/dotstatsuite-sdmxjs';
 import { SCATTER } from '../constants';
 import {
   artefactToOption,
-  chartDimensionOptions,
   getDimensionsWithValues,
   getPropertyDimension,
   toState,

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,
   });
 
@@ -86,8 +72,6 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
   const options = {
     attachmentSeriesIndexes,
     customAttributes,
-    noDisplayIndexes,
-    notDisplayedCodes,
     attributesIds: R.concat(seriesAttributesIds, observationsAttributesIds),
     unitsIds: obsUnitsIds
   };
@@ -106,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
   );
@@ -128,7 +112,6 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
     )(dimensionsIndexedByIds),
     attributesIdsIndexedByTargets.oneValueDimensions,
     attributesIndexedByIds,
-    _getDisplay
   );
 
   const manyValuesDimensions = getManyValuesDimensions(
@@ -155,7 +138,6 @@ 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

@@ -1,26 +1,47 @@
 import * as R from 'ramda';
 import dateFns from 'date-fns';
-import { getCodeOrder, isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
+import { getCodeOrder, getRefinedName, isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
 import {
-  getRelationnalAnnotations, setAnnotationsLayout, getIsHidden, hiddenFormat } from './sdmx-data';
+  getRelationnalAnnotations, setAnnotationsLayout, getIsHidden } 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());
-  const locale = getLanguage(dataNew);
+  const { locale } = 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: getRefinedName(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 name = getLocalisedProp('names')(value);
+      const isHidden = R.has(`${parent}.${value.id}`, hiddenIds) || getIsHidden(valueAnnotations);
+      const name = getRefinedName(value);
       let __indexPosition = NaN;
       let start = null;
       if (isTimeDimension) {
@@ -31,7 +52,7 @@ export const dataTransformer = (dataNew, options = {}) => {
         __indexPosition = dateFns.getTime(new Date(R.prop('start', value)));
       }
       if (isNaN(__indexPosition)) {
-        __indexPosition = getCodeOrder(locale)({ annotations: valueAnnotations });
+        __indexPosition = getCodeOrder({ annotations: valueAnnotations });
       }
       const timeFormat = R.prop('timeFormat', options);
       return ({
@@ -40,6 +61,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 +78,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);
@@ -71,23 +87,9 @@ export const dataTransformer = (dataNew, options = {}) => {
 
   const resHeader = {
     ...meta,
-    sender: {...sender, name: getLocalisedProp('names', sender)},
+    sender: {...sender, name: getRefinedName(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 +97,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: getRefinedName(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: getRefinedName(observation),
+        values: getValues(attr.values || [], attr.id)
+      });
+    },
     R.propOr([], 'dataSet', attributes)
   )
 
@@ -126,10 +136,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 +168,11 @@ export const dataTransformer = (dataNew, options = {}) => {
     return ({
       observation: R.append({
         ...observation,
+        display: !isHidden,
         __index: obsIndex,
-        name: getLocalisedProp('names', observation),
+        name: getRefinedName(observation),
         values: sortedValues,
         role: R.isNil(observation.roles) ? null : R.head(observation.roles),
-        ...isHidden,
       })(acc.observation),
       dimensionsLayout: setAnnotationsLayout(id, acc.dimensionsLayout)(dimAnnotations),
     });
@@ -172,7 +182,7 @@ export const dataTransformer = (dataNew, options = {}) => {
   const { dimensionsLayout, observation } = getObservations(locale)(dimObservations);
   const resStructure = {
     ...structure,
-    name: getLocalisedProp('names', structure),
+    name: getRefinedName({ ...structure, id: options.dataflowId }),
     annotations,
     attributes: resAttributes,
     dimensions: { observation },

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);
 };