@sis-cc/dotstatsuite-components 16.4.0 → 16.6.0

package/lib/rules2/src/enhanceObservations.js

@@ -44,7 +44,7 @@ var parseAttributesValues = function parseAttributesValues(obs, attributes, inde
       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)) {
+    if (!R.propOr(true, 'display', attribute) || !R.propOr(true, 'display', value)) {
       value = null;
     }
     var relationship = R.propOr([], 'relationship', attribute);

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/parseCombinations.js

@@ -45,20 +45,20 @@ 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;
+        displayable_values_count += R.length(values);
         return R.length(values) > 1;
       } else if (!R.has(concept, indexedAttributes)) {
         return false;
       }
       var attribute = R.prop(concept, indexedAttributes);
-      relationship = attribute.series ? R.pipe(R.reject(function (id) {
+      var displayableValues = getDisplayableValues(attribute.values || []);
+      var isDisplayable = R.length(displayableValues) !== 0 && R.propOr(true, 'display', attribute);
+      relationship = attribute.series && isDisplayable ? R.pipe(R.reject(function (id) {
         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;
+      displayable_values_count = isDisplayable ? displayable_values_count + R.length(displayableValues) : displayable_values_count;
+      return attribute.series && isDisplayable;
     }, comb.concepts);
     if (R.isEmpty(seriesConcepts)) {
       return R.append((0, _extends4.default)({}, comb, { header: true, display: displayable_values_count > 0 }), acc);

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/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.4.0",
+  "version": "16.6.0",
   "main": "lib/index.js",
   "author": "OECD",
   "license": "MIT",

package/src/rules2/src/enhanceObservations.js

@@ -23,7 +23,7 @@ const parseAttributesValues = (obs, attributes, indexedDimensions) => {
       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)) {
+      if ((!R.propOr(true, 'display', attribute) || !R.propOr(true, 'display', value))) {
         value = null;
       }
       const relationship = R.propOr([], 'relationship', attribute);

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/parseCombinations.js

@@ -24,28 +24,26 @@ export const parseCombinations = (combinations, parsedAttributes, dimensions) =>
             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;
+            displayable_values_count += R.length(values);
             return R.length(values) > 1;
           }
           else if (!R.has(concept, indexedAttributes)) {
             return false;
           }
           const attribute = R.prop(concept, indexedAttributes);
-          relationship = attribute.series
-            ? R.pipe(
+          const displayableValues = getDisplayableValues(attribute.values || []);
+          const isDisplayable = R.length(displayableValues) !== 0 && R.propOr(true, 'display', attribute);
+          relationship = attribute.series && isDisplayable
+              ? R.pipe(
                 R.reject(id => R.has(id, ids)),
                 R.concat(relationship),
               )(attribute.relationship)
-            : 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 = isDisplayable
               ? displayable_values_count + R.length(displayableValues)
               : displayable_values_count;
-          return attribute.series;
+          return attribute.series && isDisplayable;
         },
         comb.concepts
       );

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

@@ -245,9 +245,9 @@ describe('enhanceObservations tests', () => {
           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 },
+          A4: { id: 'A4', display: false, value: null, relationship: [], serieKey: null, coordinates: {}, isObs: true },
+          A5: { id: 'A5', value: null, relationship: [], serieKey: null, coordinates: {}, isObs: true },
+          A6: { id: 'A6', value: null, 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/parseCombinations.test.js

@@ -9,7 +9,11 @@ describe('parseCombinations tests', () => {
       { id: 'COMB3', concepts: ['ATTR1', 'ATTR2'] },
       { id: 'COMB4', concepts: ['ATTR3', 'ATTR4'] },
       { id: 'COMB5', concepts: ['DIM1', 'ATTR4'] },
-      { id: 'COMB6', concepts: ['DIM5', 'ATTR5'] }
+      { id: 'COMB6', concepts: ['DIM5', 'ATTR5'] },
+      { id: 'COMB7', concepts: ['ATTR5', 'ATTR6'] },
+      { id: 'COMB8', concepts: ['DIM5', 'DIM6'] },
+      { id: 'COMB9', concepts: ['DIM1', 'ATTR5'] },
+      { id: 'COMB10', concepts: ['DIM4', 'ATTR5'] }
     ];
 
     const dimensions = [
@@ -18,6 +22,7 @@ describe('parseCombinations tests', () => {
       { 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 }] }
     ];
 
     const attributes = [
@@ -26,6 +31,7 @@ describe('parseCombinations tests', () => {
       { 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' }] },
+      { id: 'ATTR6', series: true, relationship: [], values: [{ id: '0', display: false }, { id: '_Z' }] }
     ];
 
     expect(parseCombinations(combinations, attributes, dimensions)).to.deep.equal([
@@ -34,7 +40,11 @@ describe('parseCombinations tests', () => {
       { 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 }
+      { id: 'COMB6', concepts: ['DIM5', 'ATTR5'], series: true, relationship: ['DIM5'], display: true },
+      { id: 'COMB7', concepts: ['ATTR5', 'ATTR6'], header: true, display: false },
+      { id: 'COMB8', concepts: ['DIM5', 'DIM6'], series: true, relationship: ['DIM5', 'DIM6'], display: true },
+      { id: 'COMB9', concepts: ['DIM1', 'ATTR5'], header: true, display: true },
+      { id: 'COMB10', concepts: ['DIM4', 'ATTR5'], series: true, relationship: ['DIM4'], display: true }
     ]);
   });
 });