@sis-cc/dotstatsuite-components 16.1.4 → 16.1.6

package/lib/rules/src/preparators/formatValue.js

@@ -77,5 +77,7 @@ var formatValue = exports.formatValue = function formatValue(observation, format
     })(decimals));
   }, formatSeparator);
 
-  return R.ifElse(isValidNumber, R.pipe(formatScale, formatDecimals), R.always('..'))(observation.value);
+  return R.ifElse(isValidNumber, R.pipe(formatScale, formatDecimals, function (res) {
+    return res === 'NaN' ? String(value) : res;
+  }), R.always('..'))(observation.value);
 };

package/lib/rules2/src/getHeaderCombinations.js

@@ -17,7 +17,7 @@ var getHeaderCombinations = exports.getHeaderCombinations = function getHeaderCo
   var indexedDimensions = R.indexBy(R.prop('id'), dimensions);
   var indexedAttributes = R.indexBy(R.prop('id'), attributes);
   return R.reduce(function (acc, comb) {
-    if (!R.prop('header', comb)) {
+    if (!R.prop('header', comb) || !R.propOr(true, 'display', comb)) {
       return acc;
     }
 
@@ -25,11 +25,11 @@ var getHeaderCombinations = exports.getHeaderCombinations = function getHeaderCo
 
     var values = 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.prop('display', artefact || {})) {
+      if (R.isNil(artefact) || !R.propOr(true, 'display', artefact || {})) {
         return _acc;
       }
       var value = R.path(['values', 0], artefact);
-      if (R.isNil(value) || !R.prop('display', value || {})) {
+      if (R.isNil(value) || !R.propOr(true, 'display', value || {})) {
         return _acc;
       }
       return R.append((0, _src.dimensionValueDisplay)(display)(value), _acc);

package/lib/rules2/src/getOneValueDimensions.js

@@ -25,11 +25,11 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 
 var getOneValueDimensions = exports.getOneValueDimensions = function getOneValueDimensions(dimensions, attributes) {
   var indexedRelevantAttributes = R.reduce(function (acc, attr) {
-    if (!attr.header || !attr.display || R.length(attr.relationship || []) !== 1) {
+    if (!attr.header || !R.propOr(true, 'display', attr) || R.length(attr.relationship || []) !== 1) {
       return acc;
     }
     var value = R.path(['values', 0], attr);
-    if (R.isNil(value) || !R.prop('display', value) || R.includes(R.prop('id', value), _constants.REJECTED_VALUE_IDS)) {
+    if (R.isNil(value) || !R.propOr(true, 'display', value) || R.includes(R.prop('id', value), _constants.REJECTED_VALUE_IDS)) {
       return acc;
     }
     var dim = R.head(attr.relationship);
@@ -39,7 +39,7 @@ var getOneValueDimensions = exports.getOneValueDimensions = function getOneValue
     })(acc);
   }, {}, attributes);
   return R.reduce(function (acc, dim) {
-    if (R.length(dim.values || []) !== 1) {
+    if (R.length(dim.values || []) !== 1 || !R.propOr(true, 'display', dim) || !R.pathOr(true, ['values', 0, 'display'], dim) || R.includes(R.path(['values', 0, 'id'], dim), _constants.REJECTED_VALUE_IDS)) {
       return acc;
     }
     var attrValues = R.propOr({}, dim.id, indexedRelevantAttributes);

package/lib/rules2/src/parseCombinations.js

@@ -17,17 +17,26 @@ var _ramda = require('ramda');
 
 var R = _interopRequireWildcard(_ramda);
 
+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; } }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+var getDisplayableValues = function getDisplayableValues(values) {
+  return R.filter(function (val) {
+    return !R.includes(R.prop('id', val), _constants.REJECTED_VALUE_IDS) && R.propOr(true, 'display', val);
+  }, values);
+};
+
 var parseCombinations = exports.parseCombinations = function parseCombinations(combinations, parsedAttributes, dimensions) {
   var indexedDimensions = R.indexBy(R.prop('id'), dimensions);
   var indexedAttributes = R.indexBy(R.prop('id'), parsedAttributes);
 
-  return R.map(function (comb) {
+  return R.reduce(function (acc, comb) {
     var relationship = [];
     var ids = {};
+    var displayable_values_count = 0;
     var seriesConcepts = R.filter(function (concept) {
       if (R.has(concept, ids)) {
         return false;
@@ -36,6 +45,8 @@ var parseCombinations = exports.parseCombinations = function parseCombinations(c
         var values = R.path([concept, 'values'], indexedDimensions);
         relationship = R.length(values) > 1 ? R.append(concept, relationship) : relationship;
         ids = (0, _extends4.default)({}, ids, (0, _defineProperty3.default)({}, concept, concept));
+        var _displayableValues = getDisplayableValues(values);
+        displayable_values_count = R.pathOr(true, [concept, 'display'], indexedDimensions) ? displayable_values_count + R.length(_displayableValues) : displayable_values_count;
         return R.length(values) > 1;
       } else if (!R.has(concept, indexedAttributes)) {
         return false;
@@ -45,12 +56,13 @@ var parseCombinations = exports.parseCombinations = function parseCombinations(c
         return R.has(id, ids);
       }), R.concat(relationship))(attribute.relationship) : relationship;
       ids = attribute.series ? (0, _extends4.default)({}, ids, R.indexBy(R.identity, attribute.relationship)) : ids;
+      var displayableValues = getDisplayableValues(attribute.values || []);
+      displayable_values_count = R.propOr(true, 'display', attribute) ? displayable_values_count + R.length(displayableValues) : displayable_values_count;
       return attribute.series;
     }, comb.concepts);
-
     if (R.isEmpty(seriesConcepts)) {
-      return (0, _extends4.default)({}, comb, { header: true });
+      return R.append((0, _extends4.default)({}, comb, { header: true, display: displayable_values_count > 0 }), acc);
     }
-    return (0, _extends4.default)({}, comb, { series: true, relationship: relationship });
-  }, combinations);
+    return R.append((0, _extends4.default)({}, comb, { series: true, relationship: relationship, display: displayable_values_count > 0 }), acc);
+  }, [], combinations);
 };

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

@@ -130,14 +130,17 @@ var getSubLayoutData = function getSubLayoutData(series, _definition, _ref) {
       return isValid ? (0, _extends3.default)({}, acc, R.length(splitKey) === 1 ? R.pick(combinationConceptIds, R.prop(key, attributesSeries)) : R.prop(key, attributesSeries)) : acc;
     }, {}, R.keys(attributesSeries));
 
-    data = R.addIndex(R.map)(function (entry, ind) {
+    data = R.addIndex(R.reduce)(function (acc, entry, ind) {
       if (!R.has('dimValues', entry)) {
-        return entry;
+        return R.append(entry, acc);
       }
       var dimValues = entry.dimValues,
           dimension = entry.dimension;
 
       var def = R.nth(ind, definition);
+      if (!R.propOr(true, 'display', def)) {
+        return acc;
+      }
       var fixedDimValues = R.propOr([], 'fixedDimValues', def);
       var values = R.reduce(function (_acc, id) {
         if (R.has(id, dimValues)) {
@@ -155,8 +158,8 @@ var getSubLayoutData = function getSubLayoutData(series, _definition, _ref) {
         }
         return R.append(R.path([id, 'value'], attributesValues), _acc);
       }, [], def.concepts);
-      return { dimension: dimension, values: values };
-    }, data);
+      return R.append({ dimension: dimension, values: values }, acc);
+    }, [], data);
 
     var layoutAttrValues = R.pipe(R.omit(combinationConceptIds), R.reject(R.prop('isObs')))(attributesValues);
 

package/lib/rules2/src/utils.js

@@ -13,7 +13,7 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 var trimedProps = exports.trimedProps = function trimedProps(properties, obj) {
   return R.reduce(function (acc, prop) {
-    if (!R.has(prop, obj)) {
+    if (R.isNil(R.prop(prop, obj))) {
       return acc;
     }
     return R.append(obj[prop], acc);

package/package.json

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

package/src/rules/src/preparators/formatValue.js

@@ -77,6 +77,7 @@ export const formatValue = (observation, formatAttributesIndexes, attributes) =>
     R.pipe(
       formatScale,
       formatDecimals,
+      res => res === 'NaN' ? String(value) : res
     ),
     R.always('..')
   )(observation.value);

package/src/rules2/src/getHeaderCombinations.js

@@ -6,7 +6,7 @@ export const getHeaderCombinations = (combinations, dimensions, attributes, disp
   const indexedAttributes = R.indexBy(R.prop('id'), attributes);
   return R.reduce(
     (acc, comb) => {
-      if (!R.prop('header', comb)) {
+      if (!R.prop('header', comb) || !R.propOr(true, 'display', comb)) {
         return acc;
       }
 
@@ -17,11 +17,11 @@ export const getHeaderCombinations = (combinations, dimensions, attributes, disp
           const artefact = R.has(concept, indexedDimensions)
             ? R.prop(concept, indexedDimensions)
             : R.prop(concept, indexedAttributes);
-          if (R.isNil(artefact) || !R.prop('display', artefact || {})) {
+          if (R.isNil(artefact) || !R.propOr(true, 'display', artefact || {})) {
             return _acc;
           }
           const value = R.path(['values', 0], artefact);
-          if (R.isNil(value) || !R.prop('display', value || {})) {
+          if (R.isNil(value) || !R.propOr(true, 'display', value || {})) {
             return _acc;
           }
           return R.append(dimensionValueDisplay(display)(value), _acc);

package/src/rules2/src/getOneValueDimensions.js

@@ -4,11 +4,11 @@ import { REJECTED_VALUE_IDS } from './constants';
 export const getOneValueDimensions = (dimensions, attributes) => {
   const indexedRelevantAttributes = R.reduce(
     (acc, attr) => {
-      if (!attr.header || !attr.display || R.length(attr.relationship || []) !== 1) {
+      if (!attr.header || !R.propOr(true, 'display', attr) || R.length(attr.relationship || []) !== 1) {
         return acc;
       }
       const value = R.path(['values', 0], attr);
-      if (R.isNil(value) || !R.prop('display', value) || R.includes(R.prop('id', value), REJECTED_VALUE_IDS)) {
+      if (R.isNil(value) || !R.propOr(true, 'display', value) || R.includes(R.prop('id', value), REJECTED_VALUE_IDS)) {
         return acc;
       }
       const dim = R.head(attr.relationship);
@@ -22,7 +22,8 @@ export const getOneValueDimensions = (dimensions, attributes) => {
   );
   return R.reduce(
     (acc, dim) => {
-      if (R.length(dim.values || []) !== 1) {
+      if (R.length(dim.values || []) !== 1 || !R.propOr(true, 'display', dim) || !R.pathOr(true, ['values', 0, 'display'], dim)
+        || R.includes(R.path(['values', 0, 'id'], dim), REJECTED_VALUE_IDS)) {
         return acc;
       }
       const attrValues = R.propOr({}, dim.id, indexedRelevantAttributes);

package/src/rules2/src/parseCombinations.js

@@ -1,39 +1,60 @@
 import * as R from 'ramda';
+import { REJECTED_VALUE_IDS } from './constants';
+
+const getDisplayableValues = values => R.filter(
+  val => !R.includes(R.prop('id', val), REJECTED_VALUE_IDS) && R.propOr(true, 'display', val),
+  values
+);
 
 export const parseCombinations = (combinations, parsedAttributes, dimensions) => {
   const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
   const indexedAttributes = R.indexBy(R.prop('id'), parsedAttributes);
 
-  return R.map(comb => {
-    let relationship = [];
-    let ids = {};
-    const seriesConcepts = R.filter(concept => {
-      if (R.has(concept, ids)) {
-        return false;
-      }
-      if (R.has(concept, indexedDimensions)) {
-        const values = R.path([concept, 'values'], indexedDimensions);
-        relationship = R.length(values) > 1 ? R.append(concept, relationship) : relationship;
-        ids = { ...ids, [concept]: concept };
-        return R.length(values) > 1;
+  return R.reduce(
+    (acc, comb) => {
+      let relationship = [];
+      let ids = {};
+      let displayable_values_count = 0;
+      const seriesConcepts = R.filter(
+        concept => {
+          if (R.has(concept, ids)) {
+            return false;
+          }
+          if (R.has(concept, indexedDimensions)) {
+            const values = R.path([concept, 'values'], indexedDimensions);
+            relationship = R.length(values) > 1 ? R.append(concept, relationship) : relationship;
+            ids = { ...ids, [concept]: concept };
+            const displayableValues = getDisplayableValues(values);
+            displayable_values_count = R.pathOr(true, [concept, 'display'], indexedDimensions)
+              ? displayable_values_count + R.length(displayableValues)
+              : displayable_values_count;
+            return R.length(values) > 1;
+          }
+          else if (!R.has(concept, indexedAttributes)) {
+            return false;
+          }
+          const attribute = R.prop(concept, indexedAttributes);
+          relationship = attribute.series
+            ? R.pipe(
+                R.reject(id => R.has(id, ids)),
+                R.concat(relationship),
+              )(attribute.relationship)
+            : relationship;
+          ids = attribute.series ? { ...ids, ...R.indexBy(R.identity, attribute.relationship) } : ids;
+          const displayableValues = getDisplayableValues(attribute.values || []);
+          displayable_values_count = R.propOr(true, 'display', attribute)
+              ? displayable_values_count + R.length(displayableValues)
+              : displayable_values_count;
+          return attribute.series;
+        },
+        comb.concepts
+      );
+      if (R.isEmpty(seriesConcepts)) {
+        return R.append({ ...comb, header: true, display: displayable_values_count > 0 }, acc);
       }
-      else if (!R.has(concept, indexedAttributes)) {
-        return false;
-      }
-      const attribute = R.prop(concept, indexedAttributes);
-      relationship = attribute.series
-        ? R.pipe(
-            R.reject(id => R.has(id, ids)),
-            R.concat(relationship),
-          )(attribute.relationship)
-        : relationship;
-      ids = attribute.series ? { ...ids, ...R.indexBy(R.identity, attribute.relationship) } : ids;
-      return attribute.series;
-    }, comb.concepts);
-
-    if (R.isEmpty(seriesConcepts)) {
-      return { ...comb, header: true };
-    }
-    return { ...comb, series: true, relationship };
-  }, combinations);
+      return R.append({ ...comb, series: true, relationship, display: displayable_values_count > 0 }, acc);
+    },
+    [],
+    combinations
+  );
 };

package/src/rules2/src/table/getLayoutData.js

@@ -107,13 +107,16 @@ const getSubLayoutData = (series, _definition, { metadataCoordinates, attributes
         R.keys(attributesSeries)
       );
 
-      data = R.addIndex(R.map)(
-        (entry, ind) => {
+      data = R.addIndex(R.reduce)(
+        (acc, entry, ind) => {
           if (!R.has('dimValues', entry)) {
-            return entry;
+            return R.append(entry, acc);
           }
           const { dimValues, dimension } = entry;
           const def = R.nth(ind, definition);
+          if (!R.propOr(true, 'display', def)) {
+            return acc;
+          }
           const fixedDimValues = R.propOr([], 'fixedDimValues', def);
           const values = R.reduce(
             (_acc, id) => {
@@ -135,8 +138,9 @@ const getSubLayoutData = (series, _definition, { metadataCoordinates, attributes
             [],
             def.concepts
           );
-          return ({ dimension, values });
+          return R.append({ dimension, values }, acc);
         },
+        [],
         data
       );
 

package/src/rules2/src/utils.js

@@ -2,7 +2,7 @@ import * as R from 'ramda';
 
 export const trimedProps = (properties, obj) => R.reduce(
   (acc, prop) => {
-    if (!R.has(prop, obj)) {
+    if (R.isNil(R.prop(prop, obj))) {
       return acc;
     }
     return R.append(obj[prop], acc);

package/test/getHeaderCombinations.test.js

@@ -0,0 +1,26 @@
+import { expect } from 'chai';
+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: 'COMB2', name: 'comb 2', series: true, concepts: ['DIM3', 'ATTR2'] },
+      { id: 'COMB3', name: 'comb 3', header: true, display: false, concepts: ['DIM3', 'ATTR2'] }
+    ];
+
+    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' }] },
+    ];
+
+    const attributes = [
+      { id: 'ATTR1', name: 'attr 1', values: [{ id: 'v', name: 'attr 1 value', display: false }] },
+      { id: 'ATTR2', name: 'attr 2', values: [{ id: 'v', name: 'attr 2 value' }] },
+    ];
+
+    expect(getHeaderCombinations(combinations, dimensions, attributes, 'label')).to.deep.equal([
+      { header: 'comb 1', label: 'dim 1 value' }
+    ]);
+  });
+});

package/test/getLayoutData.test.js

@@ -127,4 +127,59 @@ describe('getLayoutData tests', () => {
       ]
     })
   });
+  it('not displayed combination', () => {
+    const layout = {
+      header: [{ id: 'H', values: [{ id: 'H_V1' }, { id: 'H_V2' }] }],
+      sections: [],
+      rows: [
+        { id: 'R1', values: [{ id: 'R1_V1' }, { id: 'R1_V2' }] },
+        {
+          id: 'COMB',
+          display: false,
+          concepts: ['R2', 'ATTR'],
+          dimensions: [
+            { id: 'R2', values: [{ id: 'R2_V1' }, { id: 'R2_V2' }] },
+          ]
+        }
+      ]
+    };
+
+    const attributesSeries = {
+      'R1=R1_V1:R2=R2_V1': {
+        ATTR: { id: 'ATTR', value: { id: 'ATTR_V1' }, coordinates: { R1: 'R1_V1', R2: 'R2_V1' } },
+      },
+      'R1=R1_V2:R2=R2_V2': {
+        ATTR: { id: 'ATTR', value: { id: 'ATTR_V4' }, coordinates: { R1: 'R1_V2', R2: 'R2_V2' } },
+      },
+    };
+
+    const layoutIndexes = {
+      header: [[0], [1]],
+      sections: [
+        [
+          [],
+          [
+            [0, [0]],
+            [1, [1]]
+          ]
+        ]
+      ]
+    };
+
+    expect(getLayoutData(layoutIndexes, layout, { attributesSeries, metadataCoordinates: [], customAttributes: { flags: [], notes: [] } })).to.deep.equal({
+      headerData: [
+        { data: [{ dimension: { id: 'H' }, value: { id: 'H_V1' } }], key: 'H=H_V1', flags: [], sideProps: null, coordinates: { H: 'H_V1' } },
+        { data: [{ dimension: { id: 'H' }, value: { id: 'H_V2' } }], key: 'H=H_V2', flags: [], sideProps: null, coordinates: { H: 'H_V2' } }
+      ],
+      sectionsData: [
+        [
+          { data: [], key: '', flags: [], sideProps: null, coordinates: {} },
+          [
+            { data: [{ dimension: { id: 'R1' }, value: { id: 'R1_V1' } }], key: 'R1=R1_V1:R2=R2_V1', flags: [], sideProps: null, coordinates: { R1: 'R1_V1', R2: 'R2_V1' } },
+            { data: [{ dimension: { id: 'R1' }, value: { id: 'R1_V2' } }], key: 'R1=R1_V2:R2=R2_V2', flags: [], sideProps: null, coordinates: { R1: 'R1_V2', R2: 'R2_V2' } }
+          ]
+        ]
+      ]
+    });
+  });
 });

package/test/getOneValueDimensions.test.js

@@ -0,0 +1,29 @@
+import { expect } from 'chai';
+import { getOneValueDimensions } from '../src/rules2/src/';
+
+describe('getOneValueDimensions tests', () => {
+  it('basic case', () => {
+    const attributes = [
+      { id: 'a0', header: true, values: [{ id: 'v' }] },
+      { id: 'a1', header: true, values: [{ id: 'v' }], relationship: ['d0'] },
+      { id: 'a2', header: true, values: [{ id: 'v' }], relationship: ['d0', 'd1'] },
+      { id: 'a3', display: false, header: true, values: [{ id: 'v' }], relationship: ['d0'] },
+      { id: 'a4', header: true, values: [{ id: 'v', display: false }], relationship: ['d0'] },
+      { id: 'a5', header: true, values: [{ id: '_Z' }], relationship: ['d0'] },
+    ];
+
+    const dimensions = [
+      { id: 'd0', values: [{ id: 'v' }] },
+      { id: 'd1', values: [{ id: 'v' }] },
+      { id: 'd2', display: false, values: [{ id: 'v' }] },
+      { id: 'd3', values: [{ id: 'v', display: false }] },
+      { id: 'd4', values: [{ id: '_T' }] },
+      { id: 'd5', values: [{ id: 'v0' }, { id: 'v1' }] },
+    ];
+
+    expect(getOneValueDimensions(dimensions, attributes)).to.deep.equal([
+      { id: 'd0', values: [{ id: 'v' }], attrValues: { a1: { id: 'a1', header: true, values: [{ id: 'v' }], relationship: ['d0'], value: { id: 'v' } } } },
+      { id: 'd1', values: [{ id: 'v' }], attrValues: {} },
+    ])
+  });
+});

package/test/parseCombinations.test.js

@@ -9,6 +9,7 @@ describe('parseCombinations tests', () => {
       { id: 'COMB3', concepts: ['ATTR1', 'ATTR2'] },
       { id: 'COMB4', concepts: ['ATTR3', 'ATTR4'] },
       { id: 'COMB5', concepts: ['DIM1', 'ATTR4'] },
+      { id: 'COMB6', concepts: ['DIM5', 'ATTR5'] }
     ];
 
     const dimensions = [
@@ -16,21 +17,24 @@ describe('parseCombinations tests', () => {
       { id: 'DIM2', values: [{ id: 'v1' }] },
       { id: 'DIM3', values: [{ id: 'v1' }, { id: 'v2' }] },
       { id: 'DIM4', values: [{ id: 'v1' }, { id: 'v2' }] },
+      { id: 'DIM5', values: [{ id: '_Z' }, { id: 'v2', display: false }] },
     ];
 
     const attributes = [
-      { id: 'ATTR1', header: true, relationship: [] },
-      { id: 'ATTR2', header: true, relationship: ['DIM1'] },
-      { id: 'ATTR3', header: true, relationship: [] },
-      { id: 'ATTR4', series: true, relationship: ['DIM3', 'DIM4'] },
+      { id: 'ATTR1', header: true, relationship: [], values: [{ id: 'v' }] },
+      { id: 'ATTR2', header: true, relationship: ['DIM1'], values: [{ id: 'v' }] },
+      { id: 'ATTR3', header: true, relationship: [], values: [{ id: 'v' }] },
+      { id: 'ATTR4', series: true, relationship: ['DIM3', 'DIM4'], values: [{ id: 'v' }] },
+      { id: 'ATTR5', series: true, display: false, relationship: ['DIM5'], values: [{ id: 'v' }] },
     ];
 
     expect(parseCombinations(combinations, attributes, dimensions)).to.deep.equal([
-      { id: 'COMB1', concepts: ['DIM1', 'DIM2'], header: true },
-      { id: 'COMB2', concepts: ['DIM3', 'DIM4'], series: true, relationship: ['DIM3', 'DIM4']  },
-      { id: 'COMB3', concepts: ['ATTR1', 'ATTR2'], header: true },
-      { id: 'COMB4', concepts: ['ATTR3', 'ATTR4'], series: true, relationship: ['DIM3', 'DIM4'] },
-      { id: 'COMB5', concepts: ['DIM1', 'ATTR4'] , series: true, relationship: ['DIM3', 'DIM4'] },
+      { id: 'COMB1', concepts: ['DIM1', 'DIM2'], header: true, display: true },
+      { id: 'COMB2', concepts: ['DIM3', 'DIM4'], series: true, relationship: ['DIM3', 'DIM4'], display: true  },
+      { id: 'COMB3', concepts: ['ATTR1', 'ATTR2'], header: true, display: true },
+      { id: 'COMB4', concepts: ['ATTR3', 'ATTR4'], series: true, relationship: ['DIM3', 'DIM4'], display: true },
+      { id: 'COMB5', concepts: ['DIM1', 'ATTR4'], series: true, relationship: ['DIM3', 'DIM4'], display: true },
+      { id: 'COMB6', concepts: ['DIM5', 'ATTR5'], series: true, relationship: ['DIM5'], display: false }
     ]);
   });
 });