@sis-cc/dotstatsuite-components 17.1.0 → 17.2.0

package/lib/rules/src/layout.js

@@ -11,10 +11,16 @@ var R = _interopRequireWildcard(_ramda);
 
 var _constants = require('./constants');
 
+var _src = require('../../rules2/src');
+
 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 isTableLayoutCompatible = function isTableLayoutCompatible(data, layout) {
-  var multiValuesDimensions = R.pipe(R.pathOr([], ['structure', 'dimensions', 'observation']), R.reject(R.pipe(R.propOr([], 'values'), R.length, R.gte(1))), R.pluck('id'))(data);
+  var dataquery = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+
+  var multiValuesDimensions = R.pipe(R.pathOr([], ['structure', 'dimensions', 'observation']), function (dimensions) {
+    return (0, _src.refineDimensions)(dimensions, dataquery);
+  }, R.reject(R.prop('header')), R.pluck('id'))(data);
   var dimensionsInLayout = R.pipe(R.values, R.unnest)(layout);
 
   var dimensionsLength = R.length(multiValuesDimensions);
@@ -63,7 +69,8 @@ var isSharedLayoutCompatible = exports.isSharedLayoutCompatible = function isSha
   var type = R.prop('type', sharedData);
   if (type === 'table') {
     var layoutIds = R.pathOr({}, ['config', 'table', 'layoutIds'], sharedData);
-    return isTableLayoutCompatible(sdmxData, layoutIds);
+    var dataquery = R.path(['config', 'sdmxSource', 'dataquery'], sharedData);
+    return isTableLayoutCompatible(sdmxData, layoutIds, dataquery);
   }
   var chartDimension = R.pathOr({}, ['config', 'chart', 'chartDimension'], sharedData);
   return isChartLayoutCompatible(sdmxData, type, chartDimension);

package/lib/rules2/src/getManyValuesDimensions.js

@@ -22,7 +22,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 var getManyValuesDimensions = exports.getManyValuesDimensions = function getManyValuesDimensions(dimensions, attributesSeries, customAttributes, combinations) {
   var combConceptsIds = R.pipe(R.pluck('concepts'), R.unnest)(combinations);
   return R.reduce(function (acc, dim) {
-    if (R.length(dim.values || []) < 2) {
+    if (dim.header) {
       return acc;
     }
     var enhancedValues = R.map(function (val) {

package/lib/rules2/src/getOneValueDimensions.js

@@ -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 (!dim.header) {
       return acc;
     }
     var attrValues = R.propOr({}, dim.id, indexedRelevantAttributes);

package/lib/rules2/src/index.js

@@ -157,6 +157,15 @@ Object.defineProperty(exports, 'getCombinationDefinitions', {
   }
 });
 
+var _refineDimensions = require('./refineDimensions');
+
+Object.defineProperty(exports, 'refineDimensions', {
+  enumerable: true,
+  get: function get() {
+    return _refineDimensions.refineDimensions;
+  }
+});
+
 var _parseAttributes = require('./parseAttributes');
 
 Object.defineProperty(exports, 'parseAttributes', {

package/lib/rules2/src/parseAttributes.js

@@ -39,8 +39,8 @@ var parseAttributes = exports.parseAttributes = function parseAttributes(attribu
       return (0, _extends3.default)({}, res, { series: true, relationship: [] });
     }
     var seriesDimensions = R.pipe(R.pathOr([], ['relationship', 'dimensions']), R.filter(function (id) {
-      var values = R.path([id, 'values'], indexedDimensions);
-      return R.length(values) > 1;
+      var dimension = R.prop(id, indexedDimensions);
+      return !dimension.header;
     }))(attr);
     if (R.length(seriesDimensions) > 0) {
       return (0, _extends3.default)({}, res, { series: true, relationship: seriesDimensions });

package/lib/rules2/src/parseCombinations.js

@@ -42,11 +42,11 @@ var parseCombinations = exports.parseCombinations = function parseCombinations(c
         return false;
       }
       if (R.has(concept, indexedDimensions)) {
-        var values = R.path([concept, 'values'], indexedDimensions);
-        relationship = R.length(values) > 1 ? R.append(concept, relationship) : relationship;
+        var dimension = R.prop(concept, indexedDimensions);
+        relationship = !dimension.header ? R.append(concept, relationship) : relationship;
         ids = (0, _extends4.default)({}, ids, (0, _defineProperty3.default)({}, concept, concept));
-        displayable_values_count += R.length(values);
-        return R.length(values) > 1;
+        displayable_values_count += R.length(dimension.values || []);
+        return !dimension.header;
       } else if (!R.has(concept, indexedAttributes)) {
         return false;
       }

package/lib/rules2/src/prepareData.js

@@ -11,6 +11,8 @@ var R = _interopRequireWildcard(_ramda);
 
 var _src = require('../../rules/src');
 
+var _refineDimensions = require('./refineDimensions');
+
 var _enhanceObservations = require('./enhanceObservations');
 
 var _parseAttributes = require('./parseAttributes');
@@ -53,9 +55,11 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, _ref) {
       hierarchies = _ref.hierarchies,
       dataflow = _ref.dataflow,
       display = _ref.display,
-      defaultCombinations = _ref.defaultCombinations;
+      defaultCombinations = _ref.defaultCombinations,
+      dataquery = _ref.dataquery;
 
   var dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
+  var refinedDimensions = (0, _refineDimensions.refineDimensions)(dimensions, dataquery);
   var attributes = R.pathOr([], ['data', 'structure', 'attributes', 'observation'], sdmxJson);
   var annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
   var observations = (0, _src.getObservations)(sdmxJson);
@@ -68,15 +72,15 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, _ref) {
   }
   var metadataCoordinates = (0, _getMetadataCoordinates.getMetadataCoordinates)(sdmxJson);
 
-  var parsedAttributes = (0, _parseAttributes.parseAttributes)(attributes, dimensions, customAttributes);
-  var parsedCombinations = (0, _parseCombinations.parseCombinations)(combinations, parsedAttributes, dimensions);
+  var parsedAttributes = (0, _parseAttributes.parseAttributes)(attributes, refinedDimensions, customAttributes);
+  var parsedCombinations = (0, _parseCombinations.parseCombinations)(combinations, parsedAttributes, refinedDimensions);
   var seriesCombinations = R.filter(R.prop('series'), parsedCombinations);
   var refinedAttributes = (0, _refineAttributes.refineAttributes)(parsedAttributes, seriesCombinations);
 
-  var enhancedObservations = (0, _enhanceObservations.enhanceObservations)(dimensions, observations, refinedAttributes, { customAttributes: customAttributes });
+  var enhancedObservations = (0, _enhanceObservations.enhanceObservations)(refinedDimensions, observations, refinedAttributes, { customAttributes: customAttributes });
   var attributesSeries = (0, _getAttributesSeries.getAttributesSeries)(enhancedObservations);
-  var manyValuesDimensions = (0, _getManyValuesDimensions.getManyValuesDimensions)(dimensions, attributesSeries, customAttributes, seriesCombinations);
-  var oneValueDimensions = (0, _getOneValueDimensions.getOneValueDimensions)(dimensions, parsedAttributes);
+  var manyValuesDimensions = (0, _getManyValuesDimensions.getManyValuesDimensions)(refinedDimensions, attributesSeries, customAttributes, seriesCombinations);
+  var oneValueDimensions = (0, _getOneValueDimensions.getOneValueDimensions)(refinedDimensions, parsedAttributes);
   var headerCoordinates = (0, _getHeaderCoordinates.getHeaderCoordinates)(oneValueDimensions);
   var hierarchisedDimensions = R.map(function (dim) {
     if (R.isEmpty(R.propOr({}, dim.id, hierarchies))) {

package/lib/rules2/src/refineDimensions.js

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.refineDimensions = undefined;
+
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+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 refineDimensions = exports.refineDimensions = function refineDimensions() {
+  var dimensions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var dataquery = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+
+  var selectionIds = R.pipe(R.split('.'), R.map(R.split('+')))(dataquery);
+
+  return R.addIndex(R.map)(function (dim, index) {
+    var selection = R.nth(index, selectionIds);
+    if (R.isNil(selection) || R.length(selection) === 0 || R.isEmpty(R.head(selection))) {
+      return (0, _extends3.default)({}, dim, { header: R.length(dim.values || []) <= 1 });
+    }
+    var values = R.map(function (val) {
+      if (R.includes(val.id, selection)) {
+        return val;
+      }
+      return R.assoc('empty', true, val);
+    }, dim.values || []);
+    return (0, _extends3.default)({}, dim, { values: values, header: R.length(values) <= 1 || R.length(selection) === 1 });
+  }, dimensions);
+};

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

@@ -79,6 +79,9 @@ var getLayout = exports.getLayout = function getLayout(layoutIds, dimensions, co
       if (R.has(id, conceptIds)) {
         return acc;
       }
+      if (!R.has(id, indexedDimensions)) {
+        return acc;
+      }
       return R.append(R.prop(id, indexedDimensions), acc);
     }, [], layoutIds[key]);
     return R.concat(rest, combs);

package/package.json

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

package/src/rules/src/layout.js

@@ -6,11 +6,13 @@ import {
   STACKED_ROW,
   V_SYMBOL
 } from './constants';
+import { refineDimensions } from '../../rules2/src';
 
-const isTableLayoutCompatible = (data, layout) => {
+const isTableLayoutCompatible = (data, layout, dataquery='') => {
   const multiValuesDimensions = R.pipe(
     R.pathOr([], ['structure', 'dimensions', 'observation']),
-    R.reject(R.pipe(R.propOr([], 'values'), R.length, R.gte(1))),
+    dimensions => refineDimensions(dimensions, dataquery),
+    R.reject(R.prop('header')),
     R.pluck('id')
   )(data);
   const dimensionsInLayout = R.pipe(R.values, R.unnest)(layout);
@@ -82,7 +84,8 @@ export const isSharedLayoutCompatible = (sdmxData, sharedData) => {
   const type = R.prop('type', sharedData);
   if (type === 'table') {
     const layoutIds = R.pathOr({}, ['config', 'table', 'layoutIds'], sharedData);
-    return isTableLayoutCompatible(sdmxData, layoutIds);
+    const dataquery = R.path(['config', 'sdmxSource', 'dataquery'], sharedData);
+    return isTableLayoutCompatible(sdmxData, layoutIds, dataquery);
   }
   const chartDimension = R.pathOr({}, ['config', 'chart', 'chartDimension'], sharedData);
   return isChartLayoutCompatible(sdmxData, type, chartDimension);

package/src/rules2/src/getManyValuesDimensions.js

@@ -5,7 +5,7 @@ export const getManyValuesDimensions = (dimensions, attributesSeries, customAttr
   const combConceptsIds = R.pipe(R.pluck('concepts'), R.unnest)(combinations);
   return R.reduce(
     (acc, dim) => {
-      if (R.length(dim.values || []) < 2) {
+      if (dim.header) {
         return acc;
       }
       const enhancedValues = R.map(val => {

package/src/rules2/src/getOneValueDimensions.js

@@ -22,7 +22,7 @@ export const getOneValueDimensions = (dimensions, attributes) => {
   );
   return R.reduce(
     (acc, dim) => {
-      if (R.length(dim.values || []) !== 1) {
+      if (!dim.header) {
         return acc;
       }
       const attrValues = R.propOr({}, dim.id, indexedRelevantAttributes);

package/src/rules2/src/index.js

@@ -18,6 +18,7 @@ export { hierarchiseDimensionWithAdvancedHierarchy } from './hierarchiseDimensio
 export { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy';
 export { getDimensionValuesIndexes } from './getDimensionValuesIndexes';
 export { getCombinationDefinitions } from './getCombinationDefinitions';
+export { refineDimensions } from './refineDimensions';
 export { parseAttributes } from './parseAttributes';
 export { parseCombinations } from './parseCombinations';
 export { refineAttributes } from './refineAttributes';

package/src/rules2/src/parseAttributes.js

@@ -24,8 +24,8 @@ export const parseAttributes = (attributes, dimensions, customAttributes) => {
     const seriesDimensions = R.pipe(
       R.pathOr([], ['relationship', 'dimensions']),
       R.filter(id => {
-        const values = R.path([id, 'values'], indexedDimensions);
-        return R.length(values) > 1;
+        const dimension = R.prop(id, indexedDimensions);
+        return !dimension.header;
       }),
     )(attr);
     if (R.length(seriesDimensions) > 0) {

package/src/rules2/src/parseCombinations.js

@@ -21,11 +21,11 @@ export const parseCombinations = (combinations, parsedAttributes, dimensions) =>
             return false;
           }
           if (R.has(concept, indexedDimensions)) {
-            const values = R.path([concept, 'values'], indexedDimensions);
-            relationship = R.length(values) > 1 ? R.append(concept, relationship) : relationship;
+            const dimension = R.prop(concept, indexedDimensions);
+            relationship = !dimension.header ? R.append(concept, relationship) : relationship;
             ids = { ...ids, [concept]: concept };
-            displayable_values_count += R.length(values);
-            return R.length(values) > 1;
+            displayable_values_count += R.length(dimension.values || []);
+            return !dimension.header;
           }
           else if (!R.has(concept, indexedAttributes)) {
             return false;

package/src/rules2/src/prepareData.js

@@ -1,5 +1,6 @@
 import * as R from 'ramda';
 import { getObservations } from '../../rules/src';
+import { refineDimensions } from './refineDimensions';
 import { enhanceObservations } from './enhanceObservations';
 import { parseAttributes } from './parseAttributes';
 import { getCombinationDefinitions, parseCombinationDefinition } from './getCombinationDefinitions';
@@ -18,8 +19,9 @@ import { getHeaderSubtitle } from './getHeaderSubtitle';
 import { getHeaderCombinations } from './getHeaderCombinations';
 import { getHeaderCoordinates } from './getHeaderCoordinates';
 
-export const prepareData = (sdmxJson, { customAttributes, locale, hierarchies, dataflow, display, defaultCombinations }) => {
+export const prepareData = (sdmxJson, { customAttributes, locale, hierarchies, dataflow, display, defaultCombinations, dataquery }) => {
   const dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
+  const refinedDimensions = refineDimensions(dimensions, dataquery);
   const attributes = R.pathOr([], ['data', 'structure', 'attributes', 'observation'], sdmxJson);
   const annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
   const observations = getObservations(sdmxJson);
@@ -30,15 +32,15 @@ export const prepareData = (sdmxJson, { customAttributes, locale, hierarchies, d
   }
   const metadataCoordinates = getMetadataCoordinates(sdmxJson);
 
-  const parsedAttributes = parseAttributes(attributes, dimensions, customAttributes);
-  const parsedCombinations = parseCombinations(combinations, parsedAttributes, dimensions);
+  const parsedAttributes = parseAttributes(attributes, refinedDimensions, customAttributes);
+  const parsedCombinations = parseCombinations(combinations, parsedAttributes, refinedDimensions);
   const seriesCombinations = R.filter(R.prop('series'), parsedCombinations);
   const refinedAttributes = refineAttributes(parsedAttributes, seriesCombinations);
 
-  const enhancedObservations = enhanceObservations(dimensions, observations, refinedAttributes, { customAttributes });
+  const enhancedObservations = enhanceObservations(refinedDimensions, observations, refinedAttributes, { customAttributes });
   const attributesSeries = getAttributesSeries(enhancedObservations);
-  const manyValuesDimensions = getManyValuesDimensions(dimensions, attributesSeries, customAttributes, seriesCombinations);
-  const oneValueDimensions = getOneValueDimensions(dimensions, parsedAttributes);
+  const manyValuesDimensions = getManyValuesDimensions(refinedDimensions, attributesSeries, customAttributes, seriesCombinations);
+  const oneValueDimensions = getOneValueDimensions(refinedDimensions, parsedAttributes);
   const headerCoordinates = getHeaderCoordinates(oneValueDimensions);
   const hierarchisedDimensions = R.map(dim => {
     if (R.isEmpty(R.propOr({}, dim.id, hierarchies))) {

package/src/rules2/src/refineDimensions.js

@@ -0,0 +1,19 @@
+import * as R from 'ramda';
+
+export const refineDimensions = (dimensions=[], dataquery='') => {
+  const selectionIds = R.pipe(R.split('.'), R.map(R.split('+')))(dataquery);
+
+  return R.addIndex(R.map)((dim, index) => {
+    const selection = R.nth(index, selectionIds);
+    if (R.isNil(selection) || R.length(selection) === 0 || R.isEmpty(R.head(selection))) {
+      return { ...dim, header: R.length(dim.values || []) <= 1 };
+    }
+    const values = R.map(val => {
+      if (R.includes(val.id, selection)) {
+        return val;
+      }
+      return R.assoc('empty', true, val);
+    }, dim.values || []);
+    return { ...dim, values, header: R.length(values) <= 1 || R.length(selection) === 1 };
+  }, dimensions);
+};

package/src/rules2/src/table/getLayout.js

@@ -59,6 +59,9 @@ export const getLayout = (layoutIds, dimensions, combinations, isTimeInverted) =
           if (R.has(id, conceptIds)) {
             return acc;
           }
+          if (!R.has(id, indexedDimensions)) {
+            return acc;
+          }
           return R.append(R.prop(id, indexedDimensions), acc);
         },
         [],

package/test/getOneValueDimensions.test.js

@@ -13,20 +13,23 @@ describe('getOneValueDimensions tests', () => {
     ];
 
     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' }] },
+      { id: 'd0', header: true, values: [{ id: 'v' }] },
+      { id: 'd1', header: true, values: [{ id: 'v' }] },
+      { id: 'd2', header: true, display: false, values: [{ id: 'v' }] },
+      { id: 'd3', header: true, values: [{ id: 'v', display: false }] },
+      { id: 'd4', header: true, values: [{ id: '_T' }] },
+      { id: 'd5', header: true, values: [{ id: 'v0' }, { id: 'v1' }] },
+      { id: 'd6', header: false, values: [{ id: 'v0' }] },
+      { id: 'd7', header: false, 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: {} },
-      { id: 'd2', values: [{ id: 'v' }], display: false, attrValues: {} },
-      { id: 'd3', values: [{ id: 'v', display: false }], attrValues: {} },
-      { id: 'd4', values: [{ id: '_T' }], attrValues: {} },
+      { id: 'd0', header: true, values: [{ id: 'v' }], attrValues: { a1: { id: 'a1', header: true, values: [{ id: 'v' }], relationship: ['d0'], value: { id: 'v' } } } },
+      { id: 'd1', header: true, values: [{ id: 'v' }], attrValues: {} },
+      { id: 'd2', header: true, values: [{ id: 'v' }], display: false, attrValues: {} },
+      { id: 'd3', header: true, values: [{ id: 'v', display: false }], attrValues: {} },
+      { id: 'd4', header: true, values: [{ id: '_T' }], attrValues: {} },
+      { id: 'd5', header: true, values: [{ id: 'v0' }, { id: 'v1' }], attrValues: {} },
     ])
   });
 });

package/test/parseAttributes.test.js

@@ -12,19 +12,19 @@ const attributes = [
 const customAttributes = {};
 
 const dimensions = [
-  { id: 'd1', values: [{ id: 'v0' }] },
-  { id: 'd2', values: [{ id: 'v0' }] },
-  { id: 'd3', values: [{ id: 'v0' }] },
-  { id: 'd4', values: [{ id: 'v0' }, { id: 'v1' }] },
-  { id: 'd5', values: [{ id: 'v0' }, { id: 'v1' }] },
-  { id: 'd6', values: [{ id: 'v0' }, { id: 'v1' }] },
+  { id: 'd1', header: true, values: [{ id: 'v0' }] },
+  { id: 'd2', header: true, values: [{ id: 'v0' }] },
+  { id: 'd3', header: true, values: [{ id: 'v0' }] },
+  { id: 'd4', header: false, values: [{ id: 'v0' }, { id: 'v1' }] },
+  { id: 'd5', header: false, values: [{ id: 'v0' }, { id: 'v1' }] },
+  { id: 'd6', header: false, values: [{ id: 'v0' }, { id: 'v1' }] },
 ];
 
 describe('parseAttributes test', () => {
   it('complete case', () => {
     expect(parseAttributes(attributes, dimensions, customAttributes)).to.deep.equal([
       { id: 'a6', index: 0, relationship: [], series: true, values: [{ id: 'a6v1' }] },
-      { id: 'a8', index: 1, relationship: ['d1'], header: true,values: [{ id: 'a8v1' }] },
+      { id: 'a8', index: 1, relationship: ['d1'], header: true, values: [{ id: 'a8v1' }] },
       { id: 'a9', index: 2, relationship: ['d4'], series: true, values: [{ id: 'a9v1' }] },
       { id: 'a10', index: 3, relationship: ['d1', 'd2'], header: true, values: [{ id: 'a10v1' }] },
       { id: 'a11', index: 4, relationship: ['d4'], series: true, values: [{ id: 'a11v1' }] },

package/test/parseCombinations.test.js

@@ -17,12 +17,12 @@ describe('parseCombinations tests', () => {
     ];
 
     const dimensions = [
-      { id: 'DIM1', values: [{ id: 'v1' }] },
-      { 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 }] },
-      { id: 'DIM6', values: [{ id: 'v1', display: false }, { id: 'v2', display: false }] }
+      { id: 'DIM1',  header: true, values: [{ id: 'v1' }] },
+      { id: 'DIM2',  header: true, values: [{ id: 'v1' }] },
+      { id: 'DIM3',  header: false, values: [{ id: 'v1' }, { id: 'v2' }] },
+      { id: 'DIM4',  header: false, values: [{ id: 'v1' }, { id: 'v2' }] },
+      { id: 'DIM5',  header: false, values: [{ id: '_Z' }, { id: 'v2', display: false }] },
+      { id: 'DIM6',  header: false, values: [{ id: 'v1', display: false }, { id: 'v2', display: false }] }
     ];
 
     const attributes = [

package/test/refinedDimensions.test.js

@@ -0,0 +1,35 @@
+import { expect } from 'chai';
+import { refineDimensions } from '../src/rules2/src';
+
+describe('refine dimensions tests', () => {
+  it('blank case', () => {
+    expect(refineDimensions([], '')).to.deep.equal([]);
+  });
+  it('complete case', () => {
+    const dimensions = [
+      { id: 'd0', values: [] },
+      { id: 'd1', values: [{ id: 'v0' }] },
+      { id: 'd2', values: [{ id: 'v0' }, { id: 'v1' }, { id: 'v2' }] },
+      { id: 'd3', values: [{ id: 'v0' }, { id: 'v1' }, { id: 'v2' }] },
+      { id: 'd4', values: [{ id: 'v0' }, { id: 'v1' }, { id: 'v2' }] },
+      { id: 'd5', values: [{ id: 'v0' }] },
+      { id: 'd6', values: [{ id: 'v0' }, { id: 'v1' }] },
+      { id: 'd7', values: [{ id: 'v0' }] },
+      { id: 'd8', values: [{ id: 'v0' }, { id: 'v1' }] }
+    ];
+
+    const dataquery = '.v0+v1.v0.v0+v1...';
+
+    expect(refineDimensions(dimensions, dataquery)).to.deep.equal([
+      { id: 'd0', values: [], header: true },
+      { id: 'd1', values: [{ id: 'v0' }], header: true },
+      { id: 'd2', values: [{ id: 'v0' }, { id: 'v1', empty: true }, { id: 'v2', empty: true }], header: true },
+      { id: 'd3', values: [{ id: 'v0' }, { id: 'v1' }, { id: 'v2', empty: true }], header: false },
+      { id: 'd4', values: [{ id: 'v0' }, { id: 'v1' }, { id: 'v2' }], header: false },
+      { id: 'd5', values: [{ id: 'v0' }], header: true },
+      { id: 'd6', values: [{ id: 'v0' }, { id: 'v1' }], header: false },
+      { id: 'd7', values: [{ id: 'v0' }], header: true },
+      { id: 'd8', values: [{ id: 'v0' }, { id: 'v1' }], header: false }
+    ]);
+  })
+});