@sis-cc/dotstatsuite-components 16.3.0 → 16.5.0

package/lib/rules2/src/enhanceObservations.js

@@ -39,7 +39,14 @@ var parseAttributesValues = function parseAttributesValues(obs, attributes, inde
     if (R.isNil(attribute) || !R.prop('series', attribute)) {
       return acc;
     }
-    var value = R.nth(valueIndex, attribute.values || []);
+    var _value = R.nth(valueIndex, attribute.values || []);
+    var value = R.isNil(_value) ? _value : R.over(R.lensProp('display'), function () {
+      var display = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      return display && !R.includes(_value.id, _constants.REJECTED_VALUE_IDS);
+    })(_value);
+    if ((!R.propOr(true, 'display', attribute) || !R.propOr(true, 'display', value)) && !R.prop('combined', attribute)) {
+      value = null;
+    }
     var relationship = R.propOr([], 'relationship', attribute);
     var coordinates = {};
     var serieKey = R.pipe(function (dims) {
@@ -51,7 +58,7 @@ var parseAttributesValues = function parseAttributesValues(obs, attributes, inde
       return dim.id + '=' + valueId;
     }), R.ifElse(R.isEmpty, R.always(null), R.join(':')))(indexedDimensions);
 
-    return R.assoc(attribute.id, (0, _extends3.default)({}, R.pick(['id', 'name', 'relationship'], attribute), { value: value, serieKey: serieKey, coordinates: coordinates, isObs: R.isEmpty(relationship) }), acc);
+    return R.assoc(attribute.id, (0, _extends3.default)({}, R.pick(['id', 'name', 'relationship', 'display'], attribute), { value: value, serieKey: serieKey, coordinates: coordinates, isObs: R.isEmpty(relationship) }), acc);
   }, {}, attrValuesIndexes);
 };
 

package/lib/rules2/src/getHeaderCoordinates.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getHeaderCoordinates = undefined;
+
+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; } }
+
+var getHeaderCoordinates = exports.getHeaderCoordinates = function getHeaderCoordinates(oneValueDimensions) {
+  return R.reduce(function (acc, dim) {
+    return R.assoc(dim.id, R.path(['values', 0, 'id'], dim), acc);
+  }, {}, oneValueDimensions);
+};

package/lib/rules2/src/index.js

@@ -265,6 +265,15 @@ Object.defineProperty(exports, 'getHeaderCombinations', {
   }
 });
 
+var _getHeaderCoordinates = require('./getHeaderCoordinates');
+
+Object.defineProperty(exports, 'getHeaderCoordinates', {
+  enumerable: true,
+  get: function get() {
+    return _getHeaderCoordinates.getHeaderCoordinates;
+  }
+});
+
 var _getLayout = require('./table/getLayout');
 
 Object.defineProperty(exports, 'getLayout', {

package/lib/rules2/src/prepareData.js

@@ -43,6 +43,8 @@ var _getHeaderSubtitle = require('./getHeaderSubtitle');
 
 var _getHeaderCombinations = require('./getHeaderCombinations');
 
+var _getHeaderCoordinates = require('./getHeaderCoordinates');
+
 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 prepareData = exports.prepareData = function prepareData(sdmxJson, _ref) {
@@ -75,6 +77,7 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, _ref) {
   var attributesSeries = (0, _getAttributesSeries.getAttributesSeries)(enhancedObservations);
   var manyValuesDimensions = (0, _getManyValuesDimensions.getManyValuesDimensions)(dimensions, attributesSeries, customAttributes, seriesCombinations);
   var oneValueDimensions = (0, _getOneValueDimensions.getOneValueDimensions)(dimensions, parsedAttributes);
+  var headerCoordinates = (0, _getHeaderCoordinates.getHeaderCoordinates)(oneValueDimensions);
   var hierarchisedDimensions = R.map(function (dim) {
     if (R.isEmpty(R.propOr({}, dim.id, hierarchies))) {
       return (0, _hierarchiseDimensionWithNativeHierarchy.hierarchiseDimensionWithNativeHierarchy)(dim);
@@ -99,7 +102,8 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, _ref) {
     header: {
       title: headerTitle,
       subtitle: headerSubtitle,
-      combinations: headerCombinations
+      combinations: headerCombinations,
+      coordinates: headerCoordinates
     }
   };
 };

package/lib/rules2/src/refineAttributes.js

@@ -25,7 +25,7 @@ var refineAttributes = exports.refineAttributes = function refineAttributes(pars
   }, {}, seriesCombinations);
   return R.map(function (attr) {
     if (R.has(attr.id, indexedRelationships)) {
-      return (0, _extends3.default)({}, attr, { series: true, relationship: R.prop(attr.id, indexedRelationships) });
+      return (0, _extends3.default)({}, attr, { series: true, relationship: R.prop(attr.id, indexedRelationships), combined: true });
     }
     return attr;
   }, parsedAttributes);

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

@@ -21,7 +21,7 @@ var getFlagsAndNotes = exports.getFlagsAndNotes = function getFlagsAndNotes(attr
     if (!R.has(id, attributesValues)) {
       return acc;
     }
-    var attr = R.prop(id, attributesValues);
+    var attr = R.pick(['id', 'name', 'value', 'display'], R.prop(id, attributesValues));
     if (R.isNil(attr.value) || !R.pathOr(true, ['value', 'display'], attr) || !R.propOr(true, 'display', attr) || R.includes(R.path(['value', 'id'], attr), _constants.REJECTED_VALUE_IDS)) {
       return acc;
     }

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

@@ -5,14 +5,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getLayoutData = undefined;
 
-var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');
-
-var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
-
 var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
 
 var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
 
+var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');
+
+var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
+
 var _extends2 = require('babel-runtime/helpers/extends');
 
 var _extends3 = _interopRequireDefault(_extends2);
@@ -23,13 +23,11 @@ var R = _interopRequireWildcard(_ramda);
 
 var _getFlagsAndNotes = require('./getFlagsAndNotes');
 
-var _hasCellMetadata = require('../hasCellMetadata');
-
 var _getCombinationDimensionsData = require('./getCombinationDimensionsData');
 
 var _parseValueHierarchy = require('./parseValueHierarchy');
 
-var _constants = require('../constants');
+var _utils = require('../utils');
 
 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; } }
 
@@ -117,18 +115,16 @@ var getSubLayoutData = function getSubLayoutData(series, _definition, _ref) {
       i++;
     }
 
-    var attributesValues = R.reduce(function (acc, key) {
-      var splitKey = R.split(':', key);
-      var isValid = R.all(function (entry) {
-        var _R$split = R.split('=', entry),
-            _R$split2 = (0, _slicedToArray3.default)(_R$split, 2),
-            d = _R$split2[0],
-            v = _R$split2[1];
-
-        return R.propEq(d, v, coordinates);
-      }, splitKey);
-      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));
+    var coordinatesValidator = (0, _utils.getLayoutCoordinatesValidator)(coordinates, topCoordinates);
+    var attributesValues = R.reduce(function (acc, serie) {
+      var coordinates = R.path([0, 'coordinates'], R.values(serie));
+      var isValid = coordinatesValidator(coordinates);
+      if (!isValid) {
+        return acc;
+      }
+      var isSingleBounded = R.length(R.keys(coordinates)) === 1;
+      return (0, _extends3.default)({}, acc, isSingleBounded ? R.pick(combinationConceptIds, serie) : serie);
+    }, {}, R.values(attributesSeries));
 
     data = R.addIndex(R.reduce)(function (acc, entry, ind) {
       if (!R.has('dimValues', entry)) {
@@ -158,10 +154,10 @@ var getSubLayoutData = function getSubLayoutData(series, _definition, _ref) {
       return R.append({ dimension: dimension, values: values }, acc);
     }, [], data);
 
-    var layoutAttrValues = R.pipe(R.omit(combinationConceptIds), R.reject(R.prop('isObs')))(attributesValues);
+    var layoutAttrValues = R.reject(R.prop('isObs'), R.omit(combinationConceptIds, attributesValues));
 
     var flags = (0, _getFlagsAndNotes.getFlagsAndNotes)(layoutAttrValues, customAttributes);
-    var hasMetadata = (0, _hasCellMetadata.hasCellMetadata)(metadataCoordinates, coordinates);
+    var hasMetadata = !R.isNil(R.find(coordinatesValidator, metadataCoordinates));
 
     if (!hasAdvancedAttributes) {
       hasAdvancedAttributes = getHasAdvancedAttributes(layoutAttrValues);
@@ -182,12 +178,14 @@ var getSubLayoutData = function getSubLayoutData(series, _definition, _ref) {
 var getLayoutData = function getLayoutData(layoutIndexes, layout, _ref2) {
   var metadataCoordinates = _ref2.metadataCoordinates,
       attributesSeries = _ref2.attributesSeries,
-      customAttributes = _ref2.customAttributes;
+      customAttributes = _ref2.customAttributes,
+      _ref2$topCoordinates = _ref2.topCoordinates,
+      topCoordinates = _ref2$topCoordinates === undefined ? {} : _ref2$topCoordinates;
   var header = layoutIndexes.header,
       sections = layoutIndexes.sections,
       rest = (0, _objectWithoutProperties3.default)(layoutIndexes, ['header', 'sections']);
 
-  var opts = { metadataCoordinates: metadataCoordinates, attributesSeries: attributesSeries, customAttributes: customAttributes };
+  var opts = { metadataCoordinates: metadataCoordinates, attributesSeries: attributesSeries, customAttributes: customAttributes, topCoordinates: topCoordinates };
   var headerData = getSubLayoutData(header, layout.header, opts);
   var sectionsData = R.pipe(R.transpose, function (_ref3) {
     var _ref4 = (0, _slicedToArray3.default)(_ref3, 2),

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

@@ -47,14 +47,15 @@ var getTableProps = exports.getTableProps = function getTableProps(_ref) {
       oneValueDimensions = data.oneValueDimensions,
       attributesSeries = data.attributesSeries,
       metadataCoordinates = data.metadataCoordinates,
-      attributes = data.attributes;
+      attributes = data.attributes,
+      header = data.header;
 
 
   var seriesCombinations = (0, _getSeriesCombinations.getSeriesCombinations)(combinations, oneValueDimensions);
   var layout = (0, _getLayout.getLayout)(layoutIds, dimensions, seriesCombinations, isTimeInverted);
   var layoutIndexes = (0, _getSortedLayoutIndexes.getSortedLayoutIndexes)(layout, observations);
   var refinedLayoutIndexes = (0, _refineLayoutSize.refineLayoutSize)({ layout: layout, observations: observations, limit: limit })(layoutIndexes);
-  var layoutData = (0, _getLayoutData.getLayoutData)(refinedLayoutIndexes, layout, { metadataCoordinates: metadataCoordinates, attributesSeries: attributesSeries, customAttributes: customAttributes });
+  var layoutData = (0, _getLayoutData.getLayoutData)(refinedLayoutIndexes, layout, { metadataCoordinates: metadataCoordinates, attributesSeries: attributesSeries, customAttributes: customAttributes, topCoordinates: header.coordinates });
 
   var cellsAttributesIds = (0, _getCellsAttributesIds.getCellsAttributesIds)(layoutIds, attributes);
   var indexedCombinations = (0, _getIndexedCombinationsByDisplay.getIndexedCombinationsByDisplay)(layout, seriesCombinations);

package/lib/rules2/src/utils.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.trimedProps = undefined;
+exports.getLayoutCoordinatesValidator = exports.trimedProps = undefined;
 
 var _ramda = require('ramda');
 
@@ -18,4 +18,25 @@ var trimedProps = exports.trimedProps = function trimedProps(properties, obj) {
     }
     return R.append(obj[prop], acc);
   }, [], properties);
+};
+
+var getLayoutCoordinatesValidator = exports.getLayoutCoordinatesValidator = function getLayoutCoordinatesValidator(layoutCoordinates) {
+  var topCoordinates = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return function (coordinates) {
+    if (R.isEmpty(coordinates)) {
+      return false;
+    }
+    var keys = R.keys(coordinates);
+    var res = true;
+    var notInTop = {};
+    R.forEach(function (key) {
+      if (R.prop(key, layoutCoordinates) !== R.prop(key, coordinates)) {
+        res = false;
+      }
+      if (!R.has(key, topCoordinates)) {
+        notInTop[key] = key;
+      }
+    }, keys);
+    return res && !R.isEmpty(notInTop);
+  };
 };

package/package.json

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

package/src/rules2/src/enhanceObservations.js

@@ -19,7 +19,13 @@ const parseAttributesValues = (obs, attributes, indexedDimensions) => {
       if (R.isNil(attribute) || !R.prop('series', attribute)) {
         return acc;
       }
-      let value = R.nth(valueIndex, attribute.values || []);
+      const _value = R.nth(valueIndex, attribute.values || []);
+      let value = R.isNil(_value)
+        ? _value
+        : R.over(R.lensProp('display'), (display=true) => display && !R.includes(_value.id, REJECTED_VALUE_IDS))(_value);
+      if ((!R.propOr(true, 'display', attribute) || !R.propOr(true, 'display', value)) && !R.prop('combined', attribute)) {
+        value = null;
+      }
       const relationship = R.propOr([], 'relationship', attribute);
       let coordinates = {};
       const serieKey = R.pipe(
@@ -33,7 +39,7 @@ const parseAttributesValues = (obs, attributes, indexedDimensions) => {
         R.ifElse(R.isEmpty, R.always(null), R.join(':'))
       )(indexedDimensions);
 
-      return R.assoc(attribute.id, { ...R.pick(['id', 'name', 'relationship'], attribute), value, serieKey, coordinates, isObs: R.isEmpty(relationship) }, acc);
+      return R.assoc(attribute.id, { ...R.pick(['id', 'name', 'relationship', 'display'], attribute), value, serieKey, coordinates, isObs: R.isEmpty(relationship) }, acc);
     },
     {},
     attrValuesIndexes

package/src/rules2/src/getHeaderCoordinates.js

@@ -0,0 +1,7 @@
+import * as R from 'ramda';
+
+export const getHeaderCoordinates = (oneValueDimensions) => R.reduce(
+  (acc, dim) => R.assoc(dim.id, R.path(['values', 0, 'id'], dim), acc),
+  {},
+  oneValueDimensions
+);

package/src/rules2/src/index.js

@@ -30,6 +30,7 @@ export { getHeaderTitle } from './getHeaderTitle';
 export { getHeaderSubtitle } from './getHeaderSubtitle';
 export { getSeriesCombinations } from './getSeriesCombinations';
 export { getHeaderCombinations } from './getHeaderCombinations';
+export { getHeaderCoordinates } from './getHeaderCoordinates';
 export { getLayout } from './table/getLayout';
 export { getSortedLayoutIndexes } from './table/getSortedLayoutIndexes';
 export { refineLayoutSize } from './table/refineLayoutSize';

package/src/rules2/src/prepareData.js

@@ -16,6 +16,7 @@ import { getDataflowAttributes } from './getDataflowAttributes';
 import { getHeaderTitle } from './getHeaderTitle';
 import { getHeaderSubtitle } from './getHeaderSubtitle';
 import { getHeaderCombinations } from './getHeaderCombinations';
+import { getHeaderCoordinates } from './getHeaderCoordinates';
 
 export const prepareData = (sdmxJson, { customAttributes, locale, hierarchies, dataflow, display, defaultCombinations }) => {
   const dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
@@ -38,6 +39,7 @@ export const prepareData = (sdmxJson, { customAttributes, locale, hierarchies, d
   const attributesSeries = getAttributesSeries(enhancedObservations);
   const manyValuesDimensions = getManyValuesDimensions(dimensions, attributesSeries, customAttributes, seriesCombinations);
   const oneValueDimensions = getOneValueDimensions(dimensions, parsedAttributes);
+  const headerCoordinates = getHeaderCoordinates(oneValueDimensions);
   const hierarchisedDimensions = R.map(dim => {
     if (R.isEmpty(R.propOr({}, dim.id, hierarchies))) {
       return hierarchiseDimensionWithNativeHierarchy(dim);
@@ -62,7 +64,8 @@ export const prepareData = (sdmxJson, { customAttributes, locale, hierarchies, d
     header: {
       title: headerTitle,
       subtitle: headerSubtitle,
-      combinations: headerCombinations
+      combinations: headerCombinations,
+      coordinates: headerCoordinates
     }
   });
 };

package/src/rules2/src/refineAttributes.js

@@ -9,7 +9,7 @@ export const refineAttributes = (parsedAttributes, seriesCombinations) => {
   );
   return R.map(attr => {
     if (R.has(attr.id, indexedRelationships)) {
-      return { ...attr, series: true, relationship: R.prop(attr.id, indexedRelationships) };
+      return { ...attr, series: true, relationship: R.prop(attr.id, indexedRelationships), combined: true };
     }
     return attr;
   }, parsedAttributes);

package/src/rules2/src/table/getFlagsAndNotes.js

@@ -10,7 +10,7 @@ export const getFlagsAndNotes = (attributesValues, customAttributes) => {
       if (!R.has(id, attributesValues)) {
         return acc;
       }
-      const attr = R.prop(id, attributesValues);
+      const attr = R.pick(['id', 'name', 'value', 'display'], R.prop(id, attributesValues));
       if (R.isNil(attr.value) || !R.pathOr(true, ['value', 'display'], attr) || !R.propOr(true, 'display', attr)
         || R.includes(R.path(['value', 'id'], attr), REJECTED_VALUE_IDS)) {
         return acc;

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

@@ -1,9 +1,8 @@
 import * as R from 'ramda';
 import { getFlagsAndNotes } from './getFlagsAndNotes';
-import { hasCellMetadata } from '../hasCellMetadata';
 import { getCombinationDimensionsData } from './getCombinationDimensionsData';
 import { parseValueHierarchy } from './parseValueHierarchy';
-import { REJECTED_VALUE_IDS } from '../constants';
+import { getLayoutCoordinatesValidator } from '../utils';
 
 const getSubLayoutData = (series, _definition, { metadataCoordinates, attributesSeries, customAttributes, topCoordinates={} }) => {
   const getHasAdvancedAttributes = (attrValues) => R.pipe(
@@ -94,17 +93,19 @@ const getSubLayoutData = (series, _definition, { metadataCoordinates, attributes
         i++;
       }
 
+      const coordinatesValidator = getLayoutCoordinatesValidator(coordinates, topCoordinates);
       const attributesValues = R.reduce(
-        (acc, key) => {
-          const splitKey = R.split(':', key);
-          const isValid = R.all(entry => {
-            const [d, v] = R.split('=', entry);
-            return R.propEq(d, v, coordinates);
-          }, splitKey);
-          return isValid ? { ...acc, ...(R.length(splitKey) === 1 ? R.pick(combinationConceptIds, R.prop(key, attributesSeries)) : R.prop(key, attributesSeries)) } : acc;
+        (acc, serie) => {
+          const coordinates = R.path([0, 'coordinates'], R.values(serie));
+          const isValid = coordinatesValidator(coordinates);
+          if (!isValid) {
+            return acc;
+          }
+          const isSingleBounded = R.length(R.keys(coordinates)) === 1;
+          return ({ ...acc, ...(isSingleBounded ? R.pick(combinationConceptIds, serie) : serie) });
         },
         {},
-        R.keys(attributesSeries)
+        R.values(attributesSeries)
       );
 
       data = R.addIndex(R.reduce)(
@@ -141,13 +142,13 @@ const getSubLayoutData = (series, _definition, { metadataCoordinates, attributes
         data
       );
 
-      const layoutAttrValues = R.pipe(
-        R.omit(combinationConceptIds),
-        R.reject(R.prop('isObs'))
-      )(attributesValues);
+      const layoutAttrValues = R.reject(
+        R.prop('isObs'),
+        R.omit(combinationConceptIds, attributesValues)
+      );
 
       const flags = getFlagsAndNotes(layoutAttrValues, customAttributes);
-      const hasMetadata = hasCellMetadata(metadataCoordinates, coordinates);
+      const hasMetadata = !R.isNil(R.find(coordinatesValidator, metadataCoordinates));
 
       if (!hasAdvancedAttributes) {
         hasAdvancedAttributes = getHasAdvancedAttributes(layoutAttrValues);
@@ -168,9 +169,9 @@ const getSubLayoutData = (series, _definition, { metadataCoordinates, attributes
   return res;
 };
 
-export const getLayoutData = (layoutIndexes, layout, { metadataCoordinates, attributesSeries, customAttributes }) => {
+export const getLayoutData = (layoutIndexes, layout, { metadataCoordinates, attributesSeries, customAttributes, topCoordinates={} }) => {
   const { header, sections, ...rest } = layoutIndexes;
-  const opts = { metadataCoordinates, attributesSeries, customAttributes };
+  const opts = { metadataCoordinates, attributesSeries, customAttributes, topCoordinates };
   const headerData = getSubLayoutData(header, layout.header, opts);
   const sectionsData = R.pipe(
     R.transpose,

package/src/rules2/src/table/getTableProps.js

@@ -17,14 +17,15 @@ export const getTableProps = ({ data, layoutIds, customAttributes, limit, isTime
     oneValueDimensions,
     attributesSeries,
     metadataCoordinates,
-    attributes
+    attributes,
+    header
   } = data;
 
   const seriesCombinations = getSeriesCombinations(combinations, oneValueDimensions);
   const layout = getLayout(layoutIds, dimensions, seriesCombinations, isTimeInverted);
   const layoutIndexes = getSortedLayoutIndexes(layout, observations);
   const refinedLayoutIndexes = refineLayoutSize({ layout, observations, limit })(layoutIndexes);
-  const layoutData = getLayoutData(refinedLayoutIndexes, layout, { metadataCoordinates, attributesSeries, customAttributes });
+  const layoutData = getLayoutData(refinedLayoutIndexes, layout, { metadataCoordinates, attributesSeries, customAttributes, topCoordinates: header.coordinates });
 
   const cellsAttributesIds = getCellsAttributesIds(layoutIds, attributes);
   const indexedCombinations = getIndexedCombinationsByDisplay(layout, seriesCombinations);

package/src/rules2/src/utils.js

@@ -10,3 +10,21 @@ export const trimedProps = (properties, obj) => R.reduce(
   [],
   properties,
 );
+
+export const getLayoutCoordinatesValidator = (layoutCoordinates, topCoordinates={}) => (coordinates) => {
+  if (R.isEmpty(coordinates)) {
+    return false;
+  }
+  const keys = R.keys(coordinates);
+  let res = true;
+  let notInTop = {};
+  R.forEach(key => {
+    if (R.prop(key, layoutCoordinates) !== R.prop(key, coordinates)) {
+      res = false;
+    }
+    if (!R.has(key, topCoordinates)) {
+      notInTop[key] = key;
+    }
+  }, keys);
+  return res && !R.isEmpty(notInTop);
+};

package/test/enhanceObservations2.test.js

@@ -74,7 +74,7 @@ describe('enhanceObservations tests', () => {
       },
       {
         id: 'a4',
-        values: [{ id: 'v0' }, { id: 'v1', display: false }],
+        values: [{ id: 'v0' }, { id: 'v1' }],
         relationship: ['d4'],
         series: true
       },
@@ -159,9 +159,9 @@ describe('enhanceObservations tests', () => {
         value: 22,
         formattedValue: '22',
         attributes: {
-          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v0' }, serieKey: 'd0=v0:d1=v0', coordinates: { d0: 'v0', d1: 'v0' }, isObs: false },
-          a3: { id: 'a3', relationship: ['d2', 'd3'], value: { id: 'v0' }, serieKey: 'd2=v0:d3=v0', coordinates: { d2: 'v0', d3: 'v0' }, isObs: false },
-          a4: { id: 'a4', relationship: ['d4'], value: { id: 'v0' }, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
+          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v0', display: true }, serieKey: 'd0=v0:d1=v0', coordinates: { d0: 'v0', d1: 'v0' }, isObs: false },
+          a3: { id: 'a3', relationship: ['d2', 'd3'], value: { id: 'v0', display: true }, serieKey: 'd2=v0:d3=v0', coordinates: { d2: 'v0', d3: 'v0' }, isObs: false },
+          a4: { id: 'a4', relationship: ['d4'], value: { id: 'v0', display: true }, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
         },
         indexedDimValIds: { d0: 'v0', d1: 'v0', d2: 'v0', d3: 'v0', d4: 'v0' }
       },
@@ -171,9 +171,9 @@ describe('enhanceObservations tests', () => {
         value: 17,
         formattedValue: '17',
         attributes: {
-          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v1' }, serieKey: 'd0=v0:d1=v0', coordinates: { d0: 'v0', d1: 'v0' }, isObs: false },
-          a3: { id: 'a3', relationship: ['d2', 'd3'], value: { id: 'v1' }, serieKey: 'd2=v0:d3=v1', coordinates: { d2: 'v0', d3: 'v1' }, isObs: false },
-          a4: { id: 'a4', relationship: ['d4'], value: { id: 'v0' }, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
+          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v1', display: true }, serieKey: 'd0=v0:d1=v0', coordinates: { d0: 'v0', d1: 'v0' }, isObs: false },
+          a3: { id: 'a3', relationship: ['d2', 'd3'], value: { id: 'v1', display: true }, serieKey: 'd2=v0:d3=v1', coordinates: { d2: 'v0', d3: 'v1' }, isObs: false },
+          a4: { id: 'a4', relationship: ['d4'], value: { id: 'v0', display: true }, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
         },
         indexedDimValIds: { d0: 'v0', d1: 'v0', d2: 'v0', d3: 'v1', d4: 'v0' }
       },
@@ -183,9 +183,9 @@ describe('enhanceObservations tests', () => {
         value: 55,
         formattedValue: '55',
         attributes: {
-          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v2' }, serieKey: 'd0=v1:d1=v0', coordinates: { d0: 'v1', d1: 'v0' }, isObs: false },
+          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v2', display: true }, serieKey: 'd0=v1:d1=v0', coordinates: { d0: 'v1', d1: 'v0' }, isObs: false },
           a3: { id: 'a3', relationship: ['d2', 'd3'], value: undefined, serieKey: 'd2=v0:d3=v0', coordinates: { d2: 'v0', d3: 'v0' }, isObs: false },
-          a4: { id: 'a4', relationship: ['d4'], value: { id: 'v0' }, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
+          a4: { id: 'a4', relationship: ['d4'], value: { id: 'v0', display: true }, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
         },
         indexedDimValIds: { d0: 'v1', d1: 'v0', d2: 'v0', d3: 'v0', d4: 'v0' }
       },
@@ -195,7 +195,7 @@ describe('enhanceObservations tests', () => {
         value: 35,
         formattedValue: '35',
         attributes: {
-          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v2' }, serieKey: 'd0=v2:d1=v0', coordinates: { d0: 'v2', d1: 'v0' }, isObs: false },
+          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v2', display: true }, serieKey: 'd0=v2:d1=v0', coordinates: { d0: 'v2', d1: 'v0' }, isObs: false },
           a3: { id: 'a3', relationship: ['d2', 'd3'], value: undefined, serieKey: 'd2=v0:d3=v0', coordinates: { d2: 'v0', d3: 'v0' }, isObs: false },
           a4: { id: 'a4', relationship: ['d4'], value: undefined, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
         },
@@ -207,7 +207,7 @@ describe('enhanceObservations tests', () => {
         value: 35,
         formattedValue: '35',
         attributes: {
-          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v2' }, serieKey: 'd0=v3:d1=v0', coordinates: { d0: 'v3', d1: 'v0' }, isObs: false },
+          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v2', display: true }, serieKey: 'd0=v3:d1=v0', coordinates: { d0: 'v3', d1: 'v0' }, isObs: false },
           a3: { id: 'a3', relationship: ['d2', 'd3'], value: undefined, serieKey: 'd2=v0:d3=v0', coordinates: { d2: 'v0', d3: 'v0' }, isObs: false },
           a4: { id: 'a4', relationship: ['d4'], value: undefined, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
         },
@@ -215,5 +215,43 @@ describe('enhanceObservations tests', () => {
       }
     });
   });
+  it('not displayed attributes and combinations', () => {
+    const attributes = [
+      { id: 'A1', display: false, series: true, values: [{ id: 'A1v' }], relationship: [] },
+      { id: 'A2', series: true, values: [{ id: 'A2v', display: false }], relationship: [] },
+      { id: 'A3', series: true, values: [{ id: '_T', display: true }], relationship: [] },
+      { id: 'A4', display: false, series: true, values: [{ id: 'A4v' }], relationship: [], combined: true },
+      { id: 'A5', series: true, values: [{ id: 'A5v', display: false }], relationship: [], combined: true },
+      { id: 'A6', series: true, values: [{ id: '_T', display: true }], relationship: [], combined: true },
+    ];
+
+    const dimensions = [];
+
+    const observations = {
+      obs: {
+        attrValuesIndexes: [0, 0, 0, 0, 0, 0],
+        dimValuesIndexes: [],
+        value: 22,
+      }
+    };
+
+    expect(enhanceObservations(dimensions, observations, attributes, {})).to.deep.equal({
+      obs: {
+        attrValuesIndexes: [0, 0, 0, 0, 0, 0],
+        dimValuesIndexes: [],
+        value: 22,
+        formattedValue: '22',
+        attributes: {
+          A1: { id: 'A1', display: false, value: null, relationship: [], serieKey: null, coordinates: {}, isObs: true },
+          A2: { id: 'A2', value: null, relationship: [], serieKey: null, coordinates: {}, isObs: true },
+          A3: { id: 'A3', value: null, relationship: [], serieKey: null, coordinates: {}, isObs: true },
+          A4: { id: 'A4', display: false, value: { id: 'A4v', display: true }, relationship: [], serieKey: null, coordinates: {}, isObs: true },
+          A5: { id: 'A5', value: { id: 'A5v', display: false }, relationship: [], serieKey: null, coordinates: {}, isObs: true },
+          A6: { id: 'A6', value: { id: '_T', display: false }, relationship: [], serieKey: null, coordinates: {}, isObs: true },
+        },
+        indexedDimValIds: {}
+      }
+    })
+  });
 });
 

package/test/getCells.test.js

@@ -72,7 +72,7 @@ describe('getCells tests', () => {
         flags: [
           { code: 'A', id: 'FL1', value: { id: 'A' } }, // regular flag
           { id: 'FT1', value: { id: 'V' } }, // regular foot note
-          { id: 'A3', value: { id: 'A3V' }, serieKey: 'D3=v0' }, // rejected layout combination value displayed as a footnote
+          { id: 'A3', value: { id: 'A3V' } }, // rejected layout combination value displayed as a footnote
           { id: 'CELLS_COMB', values: [{ id: 'D1V' }, { id: 'A1V' }] } // cell level combination with fixed dim value
         ]
       }

package/test/getLayoutData.test.js

@@ -182,4 +182,103 @@ describe('getLayoutData tests', () => {
       ]
     });
   });
+  it('flags, advanced attributes and metadata availability', () => {
+    const customAttributes = { flags: ['FL'], notes: ['FT'] };
+    const topCoordinates = { FREQ: 'A' };
+    const layout = {
+      header: [
+        { id: 'TIME_PERIOD', values: [{ id: '2020' }, { id: '2021' }] }
+      ],
+      sections: [
+        { id: 'TRANSACT', values: [{ id: 'TRANSACT1' }, { id: 'TRANSACT2' }] }
+      ],
+      rows: [
+        { id: 'REF_AREA', values: [{ id: 'US' }, { id: 'AUS' }, { id: 'FRA' }] },
+        { id: 'COMB_UNIT', concepts: ['TRANSACT', "MEASURE", 'UNIT_MULT'], dimensions: [{ id: 'MEASURE', values: [{ id: 'USD' }, { id: 'AUSD' }, { id: 'EUR' }] }] }
+      ]
+    };
+
+    const metadataCoordinates = [
+      {},
+      { TIME_PERIOD: '2021', FREQ: 'A' },
+      { TRANSACT: 'TRANSACT1' },
+      { TRANSACT: 'TRANSACT2', REF_AREA: 'AUS', FREQ: 'A' }
+    ];
+
+    const attributesSeries = {
+      'TIME_PERIOD=2020:FREQ=A': {
+        FL: { id: 'FL', serieKey: 'TIME_PERIOD=2020:FREQ=A', coordinates: { TIME_PERIOD: '2020', FREQ: 'A' }, value: { id: 'FL_V' } },
+        FT: { id: 'FT', serieKey: 'TIME_PERIOD=2020:FREQ=A', coordinates: { TIME_PERIOD: '2020', FREQ: 'A' }, value: { id: 'FT_V0' } }
+      },
+      'TRANSACT=TRANSACT1:MEASURE=USD': {
+        UNIT_MULT: { id: 'UNIT_MULT', serieKey: 'TRANSACT=TRANSACT1:MEASURE=USD', coordinates: { TRANSACT: 'TRANSACT1', MEASURE: 'USD' }, value: { id: 'BILL' } }
+      },
+      'TRANSACT=TRANSACT1:MEASURE=AUSD': {
+        UNIT_MULT: { id: 'UNIT_MULT', serieKey: 'TRANSACT=TRANSACT1:MEASURE=AUSD', coordinates: { TRANSACT: 'TRANSACT1', MEASURE: 'AUSD' }, value: { id: '0' } }
+      },
+      'TRANSACT=TRANSACT1:MEASURE=EUR': {
+        UNIT_MULT: { id: 'UNIT_MULT', serieKey: 'TRANSACT=TRANSACT1:MEASURE=EUR', coordinates: { TRANSACT: 'TRANSACT1', MEASURE: 'EUR' }, value: { id: 'MILL' } }
+      },
+      'TRANSACT=TRANSACT2:MEASURE=USD': {
+        UNIT_MULT: { id: 'UNIT_MULT', serieKey: 'TRANSACT=TRANSACT2:MEASURE=USD', coordinates: { TRANSACT: 'TRANSACT2', MEASURE: 'USD' }, value: { id: 'BILL' } }
+      },
+      'TRANSACT=TRANSACT2:MEASURE=AUSD': {
+        UNIT_MULT: { id: 'UNIT_MULT', serieKey: 'TRANSACT=TRANSACT2:MEASURE=AUSD', coordinates: { TRANSACT: 'TRANSACT2', MEASURE: 'AUSD' }, value: { id: '0' } }
+      },
+      'TRANSACT=TRANSACT2:MEASURE=EUR': {
+        UNIT_MULT: { id: 'UNIT_MULT', serieKey: 'TRANSACT=TRANSACT2:MEASURE=EUR', coordinates: { TRANSACT: 'TRANSACT2', MEASURE: 'EUR' }, value: { id: 'MILL' } }
+      },
+      'TRANSACT=TRANSACT1:FREQ=A': {
+        FT: { id: 'FT', serieKey: 'TRANSACT=TRANSACT1:FREQ=A', coordinates: { TRANSACT: 'TRANSACT1', FREQ: 'A' }, value: { id: 'FT_V1' } },
+        ADV: { id: 'ADV', serieKey: 'TRANSACT=TRANSACT1:FREQ=A', coordinates: { TRANSACT: 'TRANSACT1', FREQ: 'A' }, value: { id: 'ADV_V0' } }
+      },
+      'TRANSACT=TRANSACT2:REF_AREA=FRA': {
+        FT: { id: 'FT', serieKey: 'TRANSACT=TRANSACT2:REF_AREA=FRA', coordinates: { TRANSACT: 'TRANSACT2', REF_AREA: 'FRA' }, value: { id: 'FT_V2' } }
+      },
+      'TRANSACT=TRANSACT2:MEASURE=USD:FREQ=A': {
+        ADV: { id: 'ADV', serieKey: 'TRANSACT=TRANSACT2:MEASURE=USD:FREQ=A', coordinates: { TRANSACT: 'TRANSACT2', MEASURE: 'USD', FREQ: 'A' }, value: { id: 'ADV_V1' } }
+      },
+    };
+
+    const layoutIndexes = {
+      header: [[0], [1]],
+      sections: [
+        [
+          [0],
+          [[0, [0]], [1, [1]], [2, [2]]],
+        ],
+        [
+          [1],
+          [[0, [0]], [1, [1]], [2, [2]]],
+        ]
+      ]
+    };
+
+    const layoutData = {
+      headerData: [
+        { data: [{ dimension: { id: 'TIME_PERIOD' }, value: { id: '2020' } }], flags: [{ id: 'FL', code: 'FL_V', value: { id: 'FL_V' } }, { id: 'FT', value: { id: 'FT_V0' } }], key: 'TIME_PERIOD=2020', sideProps: null, coordinates: { TIME_PERIOD: '2020', FREQ: 'A' } },
+        { data: [{ dimension: { id: 'TIME_PERIOD' }, value: { id: '2021' } }], flags: [], key: 'TIME_PERIOD=2021', sideProps: { hasMetadata: true, hasAdvancedAttributes: false, coordinates: { TIME_PERIOD: '2021', FREQ: 'A' } }, coordinates: { TIME_PERIOD: '2021', FREQ: 'A' } },
+      ],
+      sectionsData: [
+        [
+          { data: [{ dimension: { id: 'TRANSACT' }, value: { id: 'TRANSACT1' } }], flags: [{ id: 'FT', value: { id: 'FT_V1' } }], key: 'TRANSACT=TRANSACT1', sideProps: { hasAdvancedAttributes: true, hasMetadata: true, coordinates: { TRANSACT: 'TRANSACT1', FREQ: 'A' } }, coordinates: { TRANSACT: 'TRANSACT1', FREQ: 'A' } },
+          [
+            { data: [{ dimension: { id: 'REF_AREA' }, value: { id: 'US' } }, { dimension: { id: 'COMB_UNIT' }, values: [{ id: 'USD', display: true }, { id: 'BILL' }] }], flags: [], key: 'REF_AREA=US:MEASURE=USD', sideProps: null, coordinates: { TRANSACT: 'TRANSACT1', REF_AREA: 'US', MEASURE: 'USD', FREQ: 'A' } },
+            { data: [{ dimension: { id: 'REF_AREA' }, value: { id: 'AUS' } }, { dimension: { id: 'COMB_UNIT' }, values: [{ id: 'AUSD', display: true }, { id: '0' }] }], flags: [], key: 'REF_AREA=AUS:MEASURE=AUSD', sideProps: null, coordinates: { TRANSACT: 'TRANSACT1', REF_AREA: 'AUS', MEASURE: 'AUSD', FREQ: 'A' } },
+            { data: [{ dimension: { id: 'REF_AREA' }, value: { id: 'FRA' } }, { dimension: { id: 'COMB_UNIT' }, values: [{ id: 'EUR', display: true }, { id: 'MILL' }] }], flags: [], key: 'REF_AREA=FRA:MEASURE=EUR', sideProps: null, coordinates: { TRANSACT: 'TRANSACT1', REF_AREA: 'FRA', MEASURE: 'EUR', FREQ: 'A' } },
+          ]
+        ],
+        [
+          { data: [{ dimension: { id: 'TRANSACT' }, value: { id: 'TRANSACT2' } }], flags: [], key: 'TRANSACT=TRANSACT2', sideProps: null, coordinates: { TRANSACT: 'TRANSACT2', FREQ: 'A' } },
+          [
+            { data: [{ dimension: { id: 'REF_AREA' }, value: { id: 'US' } }, { dimension: { id: 'COMB_UNIT' }, values: [{ id: 'USD', display: true }, { id: 'BILL' }] }], flags: [], key: 'REF_AREA=US:MEASURE=USD', sideProps: { hasAdvancedAttributes: true, hasMetadata: false, coordinates: { TRANSACT: 'TRANSACT2', REF_AREA: 'US', MEASURE: 'USD', FREQ: 'A' } }, coordinates: { TRANSACT: 'TRANSACT2', REF_AREA: 'US', MEASURE: 'USD', FREQ: 'A' } },
+            { data: [{ dimension: { id: 'REF_AREA' }, value: { id: 'AUS' } }, { dimension: { id: 'COMB_UNIT' }, values: [{ id: 'AUSD', display: true }, { id: '0' }] }], flags: [], key: 'REF_AREA=AUS:MEASURE=AUSD', sideProps: { hasAdvancedAttributes: false, hasMetadata: true, coordinates: { TRANSACT: 'TRANSACT2', REF_AREA: 'AUS', MEASURE: 'AUSD', FREQ: 'A' } }, coordinates: { TRANSACT: 'TRANSACT2', REF_AREA: 'AUS', MEASURE: 'AUSD', FREQ: 'A' } },
+            { data: [{ dimension: { id: 'REF_AREA' }, value: { id: 'FRA' } }, { dimension: { id: 'COMB_UNIT' }, values: [{ id: 'EUR', display: true }, { id: 'MILL' }] }], flags: [{ id: 'FT', value: { id: 'FT_V2' } }], key: 'REF_AREA=FRA:MEASURE=EUR', sideProps: null, coordinates: { TRANSACT: 'TRANSACT2', REF_AREA: 'FRA', MEASURE: 'EUR', FREQ: 'A' } },
+          ]
+        ],
+      ]
+    };
+
+     expect(getLayoutData(layoutIndexes, layout, { attributesSeries, metadataCoordinates, customAttributes, topCoordinates })).to.deep.equal(layoutData);
+  });
 });

package/test/refineAttributes.test.js

@@ -0,0 +1,29 @@
+import { expect } from 'chai';
+import { refineAttributes } from '../src/rules2/src';
+
+describe('refineAttributes tests', () => {
+  it('basic test', () => {
+    const attributes = [
+      { id: 'A1', relationship: [] },
+      { id: 'A2', relationship: ['D1', 'D2'] },
+      { id: 'A3', series: true, relationship: [] },
+      { id: 'A4', series: true, relationship: ['D3', 'D4'] },
+      { id: 'A5', header: true, relationship: [] },
+      { id: 'A6', series: true, relationship: ['D3', 'D4'] },
+    ];
+
+    const combinations = [
+      { id: 'COMB1', concepts: ['A1', 'A3', 'A4'], relationship: ['D5', 'D6'] },
+      { id: 'COMB2', concepts: ['A2'], relationship: [] },
+    ];
+
+    expect(refineAttributes(attributes, combinations)).to.deep.equal([
+      { id: 'A1', series: true, relationship: ['D5', 'D6'], combined: true },
+      { id: 'A2', series: true, relationship: [], combined: true },
+      { id: 'A3', series: true, relationship: ['D5', 'D6'], combined: true },
+      { id: 'A4', series: true, relationship: ['D5', 'D6'], combined: true },
+      { id: 'A5', header: true, relationship: [] },
+      { id: 'A6', series: true, relationship: ['D3', 'D4'] },
+    ]);
+  });
+});