@sis-cc/dotstatsuite-components 17.3.0 → 17.5.0

package/lib/rules2/src/combinedValuesDisplay.js

@@ -0,0 +1,68 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.combinedValuesDisplay = exports.singleValueDisplay = undefined;
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+var _src = require('../../rules/src');
+
+var _constants = require('./constants');
+
+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; } }
+
+var getRefinedMissinParentsLabels = R.pipe(R.propOr([], 'missingParents'), R.reduce(function (acc, par) {
+  if (!R.propOr(true, 'display', par) || R.includes(par.id, _constants.REJECTED_VALUE_IDS)) {
+    return acc;
+  }
+  return R.append((0, _src.dimensionValueDisplay)('label')(par), acc);
+}, []));
+
+var singleValueDisplay = exports.singleValueDisplay = function singleValueDisplay(display, value) {
+  if (display === 'label') {
+    return R.converge(function (missingParents, label) {
+      return R.isEmpty(missingParents) ? label : R.join(' > ', R.append(label, missingParents));
+    }, [getRefinedMissinParentsLabels, (0, _src.dimensionValueDisplay)(display)])(value);
+  } else if (display === 'both') {
+    return '(' + singleValueDisplay('code', value) + ') ' + singleValueDisplay('label', value);
+  }
+  return (0, _src.dimensionValueDisplay)(display)(value);
+};
+
+var _combinedValuesDisplay = function _combinedValuesDisplay(_display) {
+  return function (values) {
+    return R.pipe(R.reduce(function (acc, val) {
+      if ((!R.propOr(true, 'display', val) || R.includes(val.id, _constants.REJECTED_VALUE_IDS)) && _display === 'label') {
+        return acc;
+      }
+      return R.append(singleValueDisplay(_display, val), acc);
+    }, []), function (labels) {
+      if (!R.isEmpty(labels) || _display !== 'label') {
+        return R.join(', ', labels);
+      }
+      var totalValue = R.find(R.propEq('id', '_T'), values);
+      if (!R.isNil(totalValue)) {
+        return (0, _src.dimensionValueDisplay)('label')(totalValue);
+      }
+      if (R.isEmpty(values)) {
+        return '';
+      }
+      var firstValue = R.head(values);
+      return (0, _src.dimensionValueDisplay)('label')(firstValue);
+    })(values);
+  };
+};
+
+var combinedValuesDisplay = exports.combinedValuesDisplay = function combinedValuesDisplay(display, values) {
+  if (display === 'both') {
+    return R.converge(function (_ids, labels) {
+      var ids = R.isEmpty(_ids) ? _ids : '(' + _ids + ')';
+      return R.isEmpty(ids) ? labels : ids + ' ' + labels;
+    }, [_combinedValuesDisplay('code'), _combinedValuesDisplay('label')])(values);
+  }
+  return _combinedValuesDisplay(display)(values);
+};

package/lib/rules2/src/getCombinationDefinitions.js

@@ -17,10 +17,25 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+var parseTexts = function parseTexts(texts) {
+  return R.reduce(function (acc, text) {
+    var splitted = R.split(':', text);
+    if (R.length(splitted) !== 2) {
+      return acc;
+    }
+
+    var _splitted = (0, _slicedToArray3.default)(splitted, 2),
+        id = _splitted[0],
+        name = _splitted[1];
+
+    return R.assoc(id, name, acc);
+  }, {}, texts);
+};
+
 var parseCombinationDefinition = exports.parseCombinationDefinition = function parseCombinationDefinition(locale) {
   return function (title, texts) {
     return R.useWith(function (titles, texts) {
-      return R.addIndex(R.reduce)(function (acc, title, index) {
+      return R.reduce(function (acc, title) {
         var split = R.split(':', title);
         if (R.length(split) !== 2) {
           return acc;
@@ -36,10 +51,10 @@ var parseCombinationDefinition = exports.parseCombinationDefinition = function p
         return R.append({
           id: id,
           concepts: R.split(',', codes),
-          name: R.has(locale, texts) ? R.pipe(R.prop(locale), R.nth(index), R.split(':'), R.last)(texts) : '[' + id + ']'
+          name: R.hasPath([locale, id], texts) ? R.path([locale, id], texts) : '[' + id + ']'
         }, acc);
       }, [], titles);
-    }, [R.split(';'), R.map(R.split(';'))])(title, texts);
+    }, [R.split(';'), R.map(R.pipe(R.split(';'), parseTexts))])(title, texts);
   };
 };
 

package/lib/rules2/src/getHeaderCombinations.js

@@ -11,6 +11,10 @@ var R = _interopRequireWildcard(_ramda);
 
 var _src = require('../../rules/src');
 
+var _combinedValuesDisplay = require('./combinedValuesDisplay');
+
+var _constants = require('./constants');
+
 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; } }
 
 var getHeaderCombinations = exports.getHeaderCombinations = function getHeaderCombinations(combinations, dimensions, attributes, display) {
@@ -23,28 +27,21 @@ var getHeaderCombinations = exports.getHeaderCombinations = function getHeaderCo
 
     var header = (0, _src.dimensionValueDisplay)(display)(comb) + ':';
 
-    var combinedDisplay = function combinedDisplay(_display, values) {
-      if (_display === 'label') {
-        return R.pipe(R.filter(R.propOr(true, 'display')), R.map((0, _src.dimensionValueDisplay)(_display)), R.join(', '))(values);
-      }
-      return R.pipe(R.map((0, _src.dimensionValueDisplay)(_display)), R.join(', '))(values);
-    };
-
     var label = R.pipe(R.reduce(function (_acc, concept) {
       var artefact = R.has(concept, indexedDimensions) ? R.prop(concept, indexedDimensions) : R.prop(concept, indexedAttributes);
-      if (R.isNil(artefact) || !R.propOr(true, 'display', artefact || {})) {
+      if (R.isNil(artefact)) {
         return _acc;
       }
       var value = R.path(['values', 0], artefact);
       if (R.isNil(value)) {
         return _acc;
       }
+      if (R.has(concept, indexedAttributes) && (!R.propOr(true, 'display', value) || !R.propOr(true, 'artefact', value) || R.includes(value.id, _constants.REJECTED_VALUE_IDS))) {
+        return _acc;
+      }
       return R.append(value, _acc);
     }, []), function (values) {
-      if (display === 'both') {
-        return '(' + combinedDisplay('code', values) + ') ' + combinedDisplay('label', values);
-      }
-      return combinedDisplay(display, values);
+      return (0, _combinedValuesDisplay.combinedValuesDisplay)(display, values);
     })(comb.concepts || []);
     if (R.isEmpty(label)) {
       return acc;

package/lib/rules2/src/table/getTableLabelAccessor.js

@@ -9,49 +9,12 @@ var _ramda = require('ramda');
 
 var R = _interopRequireWildcard(_ramda);
 
-var _src = require('../../../rules/src');
-
-var _constants = require('../constants');
+var _combinedValuesDisplay = require('../combinedValuesDisplay');
 
 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; } }
 
-var getRefinedMissinParentsLabels = R.pipe(R.propOr([], 'missingParents'), R.reduce(function (acc, par) {
-  if (!R.propOr(true, 'display', par) || R.includes(par.id, _constants.REJECTED_VALUE_IDS)) {
-    return acc;
-  }
-  return R.append((0, _src.dimensionValueDisplay)('label')(par), acc);
-}, []));
-
-var granularDisplay = function granularDisplay(display, value) {
-  if (display === 'label') {
-    return R.converge(function (missingParents, label) {
-      return R.isEmpty(missingParents) ? label : R.join(' > ', R.append(label, missingParents));
-    }, [getRefinedMissinParentsLabels, (0, _src.dimensionValueDisplay)(display)])(value);
-  } else if (display === 'both') {
-    return '(' + granularDisplay('code', value) + ') ' + granularDisplay('label', value);
-  }
-  return (0, _src.dimensionValueDisplay)(display)(value);
-};
-
-var combinedDisplay = function combinedDisplay(_display) {
-  return R.pipe(R.reduce(function (acc, val) {
-    if ((!R.propOr(true, 'display', val) || R.includes(val.id, _constants.REJECTED_VALUE_IDS)) && _display === 'label') {
-      return acc;
-    }
-    return R.append(granularDisplay(_display, val), acc);
-  }, []), R.join(', '));
-};
-
 var getTableLabelAccessor = exports.getTableLabelAccessor = function getTableLabelAccessor(display) {
-  return function (item) {
-    if (!R.is(Array, item)) {
-      return granularDisplay(display, item);
-    }
-    if (display === 'both') {
-      return R.converge(function (ids, labels) {
-        return '(' + ids + ') ' + labels;
-      }, [combinedDisplay('code'), combinedDisplay('label')])(item);
-    }
-    return combinedDisplay(display)(item);
+  return function (content) {
+    return R.is(Array, content) ? (0, _combinedValuesDisplay.combinedValuesDisplay)(display, content) : (0, _combinedValuesDisplay.singleValueDisplay)(display, content);
   };
 };

package/package.json

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

package/src/rules2/src/combinedValuesDisplay.js

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

package/src/rules2/src/getCombinationDefinitions.js

@@ -1,8 +1,21 @@
 import * as R from 'ramda';
 
+const parseTexts = texts => R.reduce(
+  (acc, text) => {
+    const splitted = R.split(':', text);
+    if (R.length(splitted) !== 2) {
+      return acc;
+    }
+    const [id, name] = splitted;
+    return R.assoc(id, name, acc);
+  },
+  {},
+  texts
+);
+
 export const parseCombinationDefinition = (locale) => (title, texts) => R.useWith(
   (titles, texts) =>
-    R.addIndex(R.reduce)((acc, title, index) => {
+    R.reduce((acc, title) => {
       const split = R.split(':', title);
       if (R.length(split) !== 2) {
         return acc;
@@ -14,12 +27,12 @@ export const parseCombinationDefinition = (locale) => (title, texts) => R.useWit
       return R.append({
         id,
         concepts: R.split(',', codes),
-        name: R.has(locale, texts)
-          ? R.pipe(R.prop(locale), R.nth(index), R.split(':'), R.last)(texts)
+        name: R.hasPath([locale, id], texts)
+          ? R.path([locale, id], texts)
           : `[${id}]`,
       }, acc);
     }, [], titles),
-  [R.split(';'), R.map(R.split(';'))],
+  [R.split(';'), R.map(R.pipe(R.split(';'), parseTexts))],
 )(title, texts);
 
 export const getCombinationDefinitions = (annotations, locale) => {

package/src/rules2/src/getHeaderCombinations.js

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

package/src/rules2/src/table/getTableLabelAccessor.js

@@ -1,53 +1,9 @@
 import * as R from 'ramda';
-import { dimensionValueDisplay } from '../../../rules/src';
-import { REJECTED_VALUE_IDS } from '../constants';
+import { combinedValuesDisplay, singleValueDisplay } from '../combinedValuesDisplay'
 
-const getRefinedMissinParentsLabels = R.pipe(
-  R.propOr([], 'missingParents'),
-  R.reduce((acc, par) => {
-    if (!R.propOr(true, 'display', par) || R.includes(par.id, REJECTED_VALUE_IDS)) {
-      return acc;
-    }
-    return R.append(dimensionValueDisplay('label')(par), acc);
-  }, []),
-);
 
-const granularDisplay = (display, value) => {
-    if (display === 'label') {
-      return R.converge(
-        (missingParents, label) =>
-          R.isEmpty(missingParents) ? label : R.join(' > ', R.append(label, missingParents)),
-        [
-          getRefinedMissinParentsLabels,
-          dimensionValueDisplay(display),
-        ],
-      )(value);
-    } else if (display === 'both') {
-      return `(${granularDisplay('code', value)}) ${granularDisplay('label', value)}`;
-    }
-    return dimensionValueDisplay(display)(value);
-  };
-
-const combinedDisplay = _display => R.pipe(
-  R.reduce((acc, val) => {
-    if ((!R.propOr(true, 'display', val) || R.includes(val.id, REJECTED_VALUE_IDS))
-      && _display === 'label') {
-      return acc;
-    }
-    return R.append(granularDisplay(_display, val), acc);
-  }, []),
-  R.join(', '),
-);
-
-export const getTableLabelAccessor = display => item => {
-  if (!R.is(Array, item)) {
-    return granularDisplay(display, item);
-  }
-  if (display === 'both') {
-    return R.converge((ids, labels) => `(${ids}) ${labels}`, [
-      combinedDisplay('code'),
-      combinedDisplay('label'),
-    ])(item);
-  }
-  return combinedDisplay(display)(item);
+export const getTableLabelAccessor = display => content => {
+  return R.is(Array, content)
+    ? combinedValuesDisplay(display, content)
+    : singleValueDisplay(display, content);
 }; 

package/test/getCombinationDefinitions.test.js

@@ -85,4 +85,20 @@ describe('getCombinationDefinitions tests', () => {
       { id: 'COMB_2', name: '[COMB_2]', concepts: ['D3', 'D4', 'A2', 'A3'] },
     ]);
   });
+  it('mixed order texts', () => {
+    const annotations = [
+      { type: 'random', title: 'test' },
+      { type: 'NOT_DISPLAYED', title: 'FREQ=A'  },
+      {
+        type: 'COMBINED_CONCEPTS',
+        texts: { en: 'COMB_2:Second Combination;COMB_1:First Combination' },
+        title: 'COMB_1:D1,D2,A1;COMB_2:D3,D4,A2,A3'
+      }
+    ];
+
+    expect(getCombinationDefinitions(annotations, 'en')).to.deep.equal([
+      { id: 'COMB_1', name: 'First Combination', concepts: ['D1', 'D2', 'A1'] },
+      { id: 'COMB_2', name: 'Second Combination', concepts: ['D3', 'D4', 'A2', 'A3'] },
+    ]);
+  });
 });

package/test/getHeaderCombinations.test.js

@@ -4,7 +4,7 @@ import { getHeaderCombinations } from '../src/rules2/src/';
 describe('getHeaderCombinations tests', () => {
   it('complete test', () => {
     const combinations = [
-      { id: 'COMB1', name: 'comb 1', header: true, concepts: ['DIM1', 'DIM2', 'ATTR1'] },
+      { id: 'COMB1', name: 'comb 1', header: true, concepts: ['DIM1', 'DIM2', 'DIM4', 'ATTR1'] },
       { id: 'COMB2', name: 'comb 2', series: true, concepts: ['DIM3', 'ATTR2'] },
       { id: 'COMB3', name: 'comb 3', header: true, display: false, concepts: ['DIM3', 'ATTR2'] }
     ];
@@ -12,6 +12,7 @@ describe('getHeaderCombinations tests', () => {
     const dimensions = [
       { id: 'DIM1', name: 'dim 1', values: [{ id: 'v', name: 'dim 1 value' }] },
       { id: 'DIM3', name: 'dim 3', values: [{ id: 'v', name: 'dim 3 value' }] },
+      { id: 'DIM4', name: 'dim 4', values: [{ id: '_Z', name: 'Not applicable' }] },
     ];
 
     const attributes = [
@@ -23,4 +24,39 @@ describe('getHeaderCombinations tests', () => {
       { header: 'comb 1:', label: 'dim 1 value' }
     ]);
   });
+  it('not display usecases', () => {
+    const dimensions = [
+      { id: 'd0', values: [{ id: 'd0v', name: 'd0 value', display: false }] },
+      { id: 'd1', values: [{ id: '_T', name: 'Total' }] },
+      { id: 'd2', values: [{ id: 'd2v', name: 'd2 value', display: false }] },
+    ];
+
+    const attributes = [
+      { id: 'a0', values: [{ id: 'a0v', name: 'a0 value', display: false }] },
+      { id: 'a1', values: [{ id: 'a1v', name: 'a1 value', display: false }] },
+      { id: 'a2', values: [{ id: '_T', name: 'Total' }] },
+    ];
+
+    const combinations = [
+      { id: 'comb0', name: 'combination 0', header: true, concepts: ['a0', 'a1', 'd0'] },
+      { id: 'comb1', name: 'combination 1', header: true, concepts: ['d0', 'd2', 'a3'] },
+      { id: 'comb2', name: 'combination 2', header: true, concepts: ['d0', 'd1', 'd2'] },
+      { id: 'comb3', name: 'combination 3', header: true, concepts: ['a0', 'a1', 'a2'] },
+    ];
+    expect(getHeaderCombinations(combinations, dimensions, attributes, 'label')).to.deep.equal([
+      { header: 'combination 0:', label: 'd0 value' },
+      { header: 'combination 1:', label: 'd0 value' },
+      { header: 'combination 2:', label: 'Total' },
+    ]);
+    expect(getHeaderCombinations(combinations, dimensions, attributes, 'code')).to.deep.equal([
+      { header: 'comb0:', label: 'd0v' },
+      { header: 'comb1:', label: 'd0v, d2v' },
+      { header: 'comb2:', label: 'd0v, _T, d2v' },
+    ]);
+    expect(getHeaderCombinations(combinations, dimensions, attributes, 'both')).to.deep.equal([
+      { header: '(comb0) combination 0:', label: '(d0v) d0 value' },
+      { header: '(comb1) combination 1:', label: '(d0v, d2v) d0 value' },
+      { header: '(comb2) combination 2:', label: '(d0v, _T, d2v) Total' },
+    ]);
+  })
 });

package/test/getTableLabelAccessor.test.js

@@ -22,4 +22,29 @@ describe('getTableLabelAccessor tests', () => {
   it('not displayed single value', () => {
     expect(getTableLabelAccessor('both')(values[0])).to.deep.equal('(V0) Value 0');
   });
+  it('display _T label if all hidden', () => {
+    const _values = [
+        { id: 'v0', name: 'value 0', display: false },
+        { id: 'v1', name: 'value 1', display: false },
+        { id: '_T', name: 'Total' },
+        { id: 'v3', name: 'value 3', display: false },
+    ];
+    expect(getTableLabelAccessor('label')(_values)).to.deep.equal('Total');
+    expect(getTableLabelAccessor('both')(_values)).to.deep.equal('(v0, v1, _T, v3) Total');
+  });
+  it('display label first value if all hidden and no _T', () => {
+    const _values = [
+        { id: 'v0', name: 'value 0', display: false },
+        { id: 'v1', name: 'value 1', display: false },
+        { id: 'v2', name: 'value 2', display: false },
+        { id: 'v3', name: 'value 3', display: false },
+    ];
+    expect(getTableLabelAccessor('label')(_values)).to.deep.equal('value 0');
+    expect(getTableLabelAccessor('both')(_values)).to.deep.equal('(v0, v1, v2, v3) value 0');
+  });
+  it('empty case', () => {
+    expect(getTableLabelAccessor('label')([])).to.deep.equal('');
+    expect(getTableLabelAccessor('code')([])).to.deep.equal('');
+    expect(getTableLabelAccessor('both')([])).to.deep.equal('');
+  });
 });