@sis-cc/dotstatsuite-components 15.0.19 → 15.0.21

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright © OECD 2019-2022
+Copyright © OECD 2019-2023
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/lib/rules/src/table/units/getUnitsSeries.js

@@ -27,9 +27,10 @@ var getUnitsSeries = exports.getUnitsSeries = function getUnitsSeries(observatio
   R.map(function (obs) {
     series = R.over(R.lensProp(obs.units.serieKey), R.ifElse(R.isNil, R.always([obs.units]), R.append(obs.units)))(series);
   }, observations);
+  return R.reduce(function (_acc, key) {
+    var serie = series[key];
 
-  return R.map(function (serie) {
-    return R.reduce(function (acc, units) {
+    var _R$reduce = R.reduce(function (acc, units) {
       var unitsKeys = R.keys(units);
       if (R.isEmpty(acc.unitsKeys)) return { units: units, unitsKeys: unitsKeys };
       var communKeys = R.intersection(acc.unitsKeys, unitsKeys);
@@ -37,6 +38,12 @@ var getUnitsSeries = exports.getUnitsSeries = function getUnitsSeries(observatio
         units: getUnits(R.pick(communKeys, acc.units), R.pick(communKeys, units)),
         unitsKeys: communKeys
       };
-    }, { unitsKeys: [], units: {} }, serie).units;
-  })(series);
+    }, { unitsKeys: [], units: {} }, serie),
+        units = _R$reduce.units;
+
+    if (R.isEmpty(R.dissoc('serieKey', units))) {
+      return _acc;
+    }
+    return R.assoc(key, units, _acc);
+  }, {})(R.keys(series));
 };

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

@@ -35,7 +35,8 @@ var TIME_PERIOD_ID = 'TIME_PERIOD';
 
 var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew) {
   var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var locale = options.locale;
+  var locale = options.locale,
+      _hiddenIds = options.hiddenIds;
 
   var reportYearStart = (0, _getReportingYearStart.getReportingYearStart)(dataNew);
 
@@ -65,7 +66,7 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
   var getValuesEnhanced = function getValuesEnhanced(locale, annotations, isTimeDimension, parent) {
     return R.pipe(R.addIndex(R.map)(function (value, __index) {
       var valueAnnotations = R.pipe(R.propOr([], 'annotations'), R.flip(R.props)(annotations))(value);
-      var isHidden = R.has(parent + '.' + value.id, hiddenIds) || (0, _sdmxData.getIsHidden)(valueAnnotations);
+      var isHidden = _hiddenIds[parent] && R.includes(value.id, _hiddenIds[parent]) || R.has(parent + '.' + value.id, hiddenIds) || (0, _sdmxData.getIsHidden)(valueAnnotations);
       var name = (0, _dotstatsuiteSdmxjs.getRefinedName)(value);
       var __indexPosition = NaN;
       var notes = [];
@@ -151,16 +152,16 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
     return R.addIndex(R.reduce)(function (acc, observation, obsIndex) {
       var id = R.prop('id')(observation);
       var dimAnnotations = (0, _sdmxData.getRelationnalAnnotations)(R.propOr([], 'annotations')(observation))(annotations);
-      var isHidden = R.has(id, hiddenIds) || (0, _sdmxData.getIsHidden)(dimAnnotations);
       var isTime = (0, _dotstatsuiteSdmxjs.isTimePeriodDimension)(observation);
       var values = getValuesEnhanced(locale, annotations, isTime, id)(R.propOr([], 'values', observation));
-
+      var _idHidden = _hiddenIds[id] && R.isEmpty(R.difference(_hiddenIds[id], R.pluck('id')(values)));
+      var isHidden = _idHidden || R.has(id, hiddenIds) || (0, _sdmxData.getIsHidden)(dimAnnotations);
       return {
         observation: R.append((0, _extends3.default)({}, observation, {
           display: !isHidden,
           __index: obsIndex,
           name: (0, _dotstatsuiteSdmxjs.getRefinedName)(observation),
-          values: values,
+          values: _idHidden ? [] : values,
           role: isTime ? TIME_PERIOD_ID : R.head(R.propOr([], 'roles', observation))
         }))(acc.observation),
         dimensionsLayout: (0, _sdmxData.setAnnotationsLayout)(id, acc.dimensionsLayout)(dimAnnotations)

package/lib/rules2/src/getNotDisplayedIds.js

@@ -31,10 +31,14 @@ var getNotDisplayedIds = exports.getNotDisplayedIds = function getNotDisplayedId
         return R.assoc(dimensionId, dimensionId, acc);
       }
       return R.reduce(function (_acc, val) {
+        var _val = val;
         if (R.isEmpty(val)) {
           return _acc;
         }
-        var key = dimensionId + '.' + val;
+        if (R.test('/[()]/')) {
+          _val = R.replace(/[()]/g, '')(val);
+        }
+        var key = R.isEmpty(_val) ? dimensionId : dimensionId + '.' + _val;
         return R.assoc(key, key, _acc);
       }, acc, values);
     }, {}, ids);

package/package.json

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

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

@@ -15,17 +15,27 @@ export const getUnitsSeries = (observations) => {
       R.ifElse(R.isNil, R.always([obs.units]), R.append(obs.units))
     )(series);
   }, observations);
-
-  return R.map(
-    serie => R.reduce(
-      (acc, units) => {
-        const unitsKeys = R.keys(units);
-        if (R.isEmpty(acc.unitsKeys)) return { units, unitsKeys }
-        const communKeys = R.intersection(acc.unitsKeys, unitsKeys);
-        return {
-          units: getUnits(R.pick(communKeys, acc.units), R.pick(communKeys, units)),
-          unitsKeys: communKeys,
-        };
-      }, { unitsKeys: [], units: {} }, serie).units
-  )(series);
+  return R.reduce(
+    (_acc, key) => {
+      const serie = series[key];
+      const { units } = R.reduce(
+        (acc, units) => {
+          const unitsKeys = R.keys(units);
+          if (R.isEmpty(acc.unitsKeys)) return { units, unitsKeys }
+          const communKeys = R.intersection(acc.unitsKeys, unitsKeys);
+          return {
+            units: getUnits(R.pick(communKeys, acc.units), R.pick(communKeys, units)),
+            unitsKeys: communKeys,
+          };
+        },
+        { unitsKeys: [], units: {} },
+        serie
+      );
+      if (R.isEmpty(R.dissoc('serieKey', units))) {
+        return _acc;
+      }
+      return R.assoc(key, units, _acc);
+    },
+    {}  
+  )(R.keys(series));
 };

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/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,

package/test/getNotDisplayedIds.test.js

@@ -15,7 +15,7 @@ describe('getNotDisplayedIds tests', () => {
     const annotations = [
       { type: 'test0' },
       { type: 'test1' },
-      { type: 'NOT_DISPLAYED', title: 'd0,d1=,d2=v0,d3=v0+,d4=v0+v1' },
+      { type: 'NOT_DISPLAYED', title: 'd0,d1=,d2=v0,d3=v0+,d4=v0+v1,d5=(v0+v1)+v2,d6=(v0+v1),d7=(v0+v1,d8=v0+v1),d9=()' },
       { type: 'test2' },
     ];
     const expected = {
@@ -24,7 +24,20 @@ describe('getNotDisplayedIds tests', () => {
       'd2.v0': 'd2.v0',
       'd3.v0': 'd3.v0',
       'd4.v0': 'd4.v0',
-      'd4.v1': 'd4.v1'
+      'd4.v1': 'd4.v1',
+      'd5.v0': 'd5.v0',
+      'd5.v1': 'd5.v1',
+      'd5.v2': 'd5.v2',
+      'd6.v0': 'd6.v0',
+      'd6.v1': 'd6.v1',
+      'd7.v0': 'd7.v0',
+      'd7.v1': 'd7.v1',
+      'd8.v0': 'd8.v0',
+      'd8.v1': 'd8.v1',
+      d9: 'd9',
+
+
+
     };
     expect(getNotDisplayedIds(annotations)).to.deep.equal(expected);
   });

package/test/getUnitsSeries.test.js

@@ -61,6 +61,31 @@ describe('getUnitsSeries tests', () => {
         '2:0:x:x': { A: { value: { index: 2 } }, B: { value: { index: 0 } }, C: { value: { index: 0 } }, serieKey: '2:0:x:x' }
       });
   });
+  it('empty units test', () => {
+    const obs = {
+      0: {
+        key: '0:0:0:0',
+        units: { serieKey: '0:0:x:x' }
+      },
+      1: {
+        key: '0:0:1:0',
+        units: { serieKey: '0:0:x:x' }
+      },
+      2: {
+        key: '1:0:0:0',
+        units: { serieKey: '1:0:x:x' }
+      },
+      3: {
+        key: '1:0:1:0',
+        units: { serieKey: '1:0:x:x' }
+      },
+      4: {
+        key: '2:0:0:0',
+        units: { serieKey: '2:0:x:x' }
+      }
+    };
+    expect(getUnitsSeries(obs)).to.deep.equal({});
+  });
 });
 
 describe('getUnitsSeries tests keys difference', () => {