@sis-cc/dotstatsuite-components 9.3.5 → 12.0.0

package/lib/index.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.Viewer = exports.RulesDriver = exports.bridgeD3React = exports.rules = undefined;
+exports.Viewer = exports.RulesDriver = exports.bridgeD3React = exports.rules2 = exports.rules = undefined;
 
 var _src = require('./rules-driver/src');
 
@@ -31,9 +31,13 @@ var _src3 = require('./rules/src');
 
 var rules = _interopRequireWildcard(_src3);
 
-var _src4 = require('./bridge-d3-react/src');
+var _src4 = require('./rules2/src');
 
-var bridgeD3React = _interopRequireWildcard(_src4);
+var rules2 = _interopRequireWildcard(_src4);
+
+var _src5 = require('./bridge-d3-react/src');
+
+var bridgeD3React = _interopRequireWildcard(_src5);
 
 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; } }
 
@@ -42,4 +46,5 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 console.info(_package2.default.name + '@' + _package2.default.version);
 
 exports.rules = rules;
+exports.rules2 = rules2;
 exports.bridgeD3React = bridgeD3React;

package/lib/rules/src/table/factories/getCells.js

@@ -5,14 +5,22 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getCells = exports.getFlags = undefined;
 
+var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');
+
+var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
+
 var _ramda = require('ramda');
 
 var R = _interopRequireWildcard(_ramda);
 
 var _dimensionUtils = require('../../dimension-utils');
 
+var _hasCellMetadata = require('../../../../rules2/src/hasCellMetadata');
+
 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 getAttrLabel = function getAttrLabel(display) {
   return function (attribute) {
     return display(attribute) + ': ' + display(R.propOr({}, 'value', attribute));
@@ -28,7 +36,7 @@ var getFlags = exports.getFlags = function getFlags(customAttributesIds, display
 
     var refinedAttributes = R.omit(R.propOr([], 'rejected', customAttributesIds), attributes);
     var flags = R.pipe(R.pick(R.propOr([], 'flags', customAttributesIds)), R.values)(refinedAttributes);
-    var footnotes = R.pipe(R.omit(R.propOr([], 'flags', customAttributesIds)), R.values)(refinedAttributes);
+    var footnotes = R.pipe(R.pick(R.propOr([], 'footnotes', customAttributesIds)), R.values)(refinedAttributes);
 
     var unitsDisplay = R.prop('unitsDisplay', unitsProps);
     var rejectedUnitsValueIds = R.propOr([], 'rejectedValueIds', unitsProps);
@@ -66,10 +74,20 @@ var getFlags = exports.getFlags = function getFlags(customAttributesIds, display
   };
 };
 
-var isValidNumber = R.both(R.is(Number), R.complement(R.equals(NaN)));
+var getSideProps = function getSideProps(_ref2, customAttributes, metadataCoordinates) {
+  var attributes = _ref2.attributes,
+      indexedDimValIds = _ref2.indexedDimValIds;
+
+  var rejected = [].concat((0, _toConsumableArray3.default)(customAttributes.flags || []), (0, _toConsumableArray3.default)(customAttributes.footnotes || []), (0, _toConsumableArray3.default)(customAttributes.rejected || []));
+  var advancedAttributes = R.omit(rejected, attributes);
+  var hasAdvancedAttributes = !R.isEmpty(advancedAttributes);
+  var hasMetadata = (0, _hasCellMetadata.hasCellMetadata)(metadataCoordinates, indexedDimValIds);
+
+  return hasAdvancedAttributes || hasMetadata ? { hasAdvancedAttributes: hasAdvancedAttributes, hasMetadata: hasMetadata, coordinates: indexedDimValIds } : null;
+};
 
-var getCells = exports.getCells = function getCells(data, display, customAttributes, unitsProps) {
+var getCells = exports.getCells = function getCells(data, display, customAttributes, unitsProps, metadataCoordinates) {
   return R.mapObjIndexed(function (observation) {
-    return R.pipe(R.set(R.lensProp('flags'), getFlags(customAttributes, (0, _dimensionUtils.dimensionValueDisplay)(display), unitsProps)(observation)), R.set(R.lensProp('intValue'), R.prop('value', observation)), R.set(R.lensProp('value'), R.prop('formattedValue', observation)), R.assoc('indexedDimValIds', R.prop('indexedDimValIds', observation)))({});
+    return R.pipe(R.set(R.lensProp('flags'), getFlags(customAttributes, (0, _dimensionUtils.dimensionValueDisplay)(display), unitsProps)(observation)), R.set(R.lensProp('intValue'), R.prop('value', observation)), R.set(R.lensProp('value'), R.prop('formattedValue', observation)), R.assoc('indexedDimValIds', R.prop('indexedDimValIds', observation)), R.assoc('sideProps', getSideProps(observation, customAttributes, metadataCoordinates)))({});
   }, R.propOr({}, 'observations', data));
 };

package/lib/rules/src/table/factories/getLayoutWithFlags.js

@@ -17,6 +17,8 @@ var _getCells = require('./getCells');
 
 var _dimensionUtils = require('../../dimension-utils');
 
+var _hasCellMetadata = require('../../../../rules2/src/hasCellMetadata');
+
 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 }; }
@@ -73,11 +75,36 @@ var getSerieKey = R.pipe(R.reduce(function (acc, entry) {
   return R.append(index, acc);
 }, []), R.join(':'));
 
-var getLayoutDataWithFlags = exports.getLayoutDataWithFlags = function getLayoutDataWithFlags(seriesAttributes, display, customAttributes) {
+var getCoordinates = function getCoordinates(data, unitsId) {
+  return R.reduce(function (acc, entry) {
+    var dimId = R.path(['dimension', 'id'], entry);
+    var valId = R.path(['value', 'id'], entry);
+    if (dimId === unitsId) {
+      return acc;
+    }
+    return R.assoc(dimId, valId, acc);
+  }, {}, data);
+};
+
+var getLayoutDataWithFlags = exports.getLayoutDataWithFlags = function getLayoutDataWithFlags(seriesAttributes, display, customAttributes, metadataCoordinates, unitsId) {
+  var regularAttrsIds = R.concat(customAttributes.flags || [], customAttributes.footnotes || []);
   var formatSublayout = function formatSublayout(getAttributes) {
-    return R.converge(function (data, key, flags) {
-      return { data: data, key: key, flags: flags };
-    }, [getSublayoutDataCells(display, customAttributes), getSerieKey, R.pipe(getAttributes, getFlagsFromSeriesAttributes(display, customAttributes))]);
+    var supplData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    return function (data) {
+      var attributes = getAttributes(data);
+      var key = getSerieKey(data);
+      var cells = getSublayoutDataCells(display, customAttributes)(data);
+      var flags = getFlagsFromSeriesAttributes(display, customAttributes)(attributes);
+      var coordinates = getCoordinates(R.concat(supplData, data), unitsId);
+      var hasMetadata = (0, _hasCellMetadata.hasCellMetadata)(metadataCoordinates, coordinates);
+      var advancedAttributesSeries = R.isNil(attributes) ? {} : R.filter(function (serie) {
+        return !R.isEmpty(R.omit(regularAttrsIds, R.propOr({}, 'attributes', serie)));
+      }, attributes);
+      var hasAdvancedAttributes = !R.isEmpty(advancedAttributesSeries);
+      var sideProps = hasMetadata || hasAdvancedAttributes ? { hasAdvancedAttributes: hasAdvancedAttributes, hasMetadata: hasMetadata, coordinates: coordinates } : null;
+
+      return { data: cells, key: key, flags: flags, sideProps: sideProps };
+    };
   };
 
   return R.evolve({
@@ -91,7 +118,7 @@ var getLayoutDataWithFlags = exports.getLayoutDataWithFlags = function getLayout
         return sectionAttributes;
       })(sectionSerie), R.map(formatSublayout(function (rowData) {
         return getLayoutSerieAttributes(R.concat(sectionSerie, rowData), R.omit(R.keys(sectionAttributes), seriesAttributes));
-      }))(R.last(sectionData))];
+      }, sectionSerie))(R.last(sectionData))];
     })
   });
 };

package/lib/rules/src/table/factories/getTableData.js

@@ -35,6 +35,8 @@ var _refineLayoutSize = require('./refineLayoutSize');
 
 var _getLayoutData = require('./getLayoutData');
 
+var _refineMetadataCoordinates = require('../../../../rules2/src/refineMetadataCoordinates');
+
 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 }; }
@@ -51,6 +53,10 @@ var getTableProps = exports.getTableProps = function getTableProps(_ref) {
 
   var confirmedSeriesAttributesIds = (0, _getConfirmedSeriesAttributesIds.getConfirmedSeriesAttributesIds)(seriesAttributes, layoutIds);
 
+  var headerDimensionsIds = R.pluck('id', R.concat(R.pathOr([], ['units', 'headerUnits'], data), R.values(R.pathOr({}, ['dimensions', 'one'], data))));
+
+  var refinedMetadataCoordinates = (0, _refineMetadataCoordinates.refineMetadataCoordinates)(data.metadataCoordinates, layoutIds, headerDimensionsIds);
+
   var _R$propOr = R.propOr({}, 'units', data),
       rejectedValueIds = _R$propOr.rejectedValueIds,
       unitDimension = _R$propOr.unitDimension,
@@ -68,7 +74,7 @@ var getTableProps = exports.getTableProps = function getTableProps(_ref) {
   var cells = (0, _getCells.getCells)(data, display, R.assoc('rejected', confirmedSeriesAttributesIds, customAttributes), {
     unitsDefinitionCodes: unitsDefinitionCodes, unitsSeries: unitsSeries, unitsDisplay: unitsLevelDisplay,
     unitDimension: unitDimension, rejectedValueIds: rejectedValueIds, layoutDimsIds: layoutDimsIds
-  }, data.observationsType);
+  }, refinedMetadataCoordinates.cells, data.observationsType);
 
   var dimensions = R.mapObjIndexed(R.pipe(R.when( // invert TimeDimension Values
   R.allPass([_dotstatsuiteSdmxjs.isTimePeriodDimension, R.always(isTimeInverted)]), function (dim) {
@@ -90,7 +96,8 @@ var getTableProps = exports.getTableProps = function getTableProps(_ref) {
     display: display, unitDimension: unitDimension, unitsDisplay: unitsLevelDisplay, unitsSeries: unitsSeries,
     unitsDefinitionCodes: unitsDefinitionCodes, unitsIndexes: unitsAttachmentIndexesInLayout,
     partialUnitSerieIndexes: partialUnitSerieIndexes, rejectedValueIds: rejectedValueIds, layoutIds: layoutIds
-  }), (0, _getLayoutWithFlags.getLayoutDataWithFlags)(seriesAttributesValues, display, customAttributes), (0, _cleanUnitsInLayoutData.cleanUnitsInLayoutData)({ unitsDisplay: unitsLevelDisplay, unitsLayoutIndexes: unitsIndexesInLayout }))(layout, R.propOr({}, 'observations', data));
+  }), (0, _getLayoutWithFlags.getLayoutDataWithFlags)(seriesAttributesValues, display, customAttributes, refinedMetadataCoordinates.layout, unitDimension.id), (0, _cleanUnitsInLayoutData.cleanUnitsInLayoutData)({ unitsDisplay: unitsLevelDisplay, unitsLayoutIndexes: unitsIndexesInLayout }))(layout, R.propOr({}, 'observations', data));
+
   return (0, _extends3.default)({
     cells: (0, _getCuratedCells.getCuratedCells)({ layout: layout, observations: cells, shape: ['header', 'sections', 'rows'] }),
     layout: layout

package/lib/rules/src/table/preparators/prepareData.js

@@ -5,6 +5,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.prepareData = undefined;
 
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
 var _ramda = require('ramda');
 
 var R = _interopRequireWildcard(_ramda);
@@ -47,8 +51,14 @@ var _getObservations = require('../../preparators/getObservations');
 
 var _enhanceObservations = require('../../preparators/enhanceObservations');
 
+var _getMetadataCoordinates = require('../../../../rules2/src/getMetadataCoordinates');
+
+var _getAdvancedAttributes = require('../../../../rules2/src/getAdvancedAttributes');
+
 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 prepareData = exports.prepareData = function prepareData(sdmxJson, customAttributes) {
   var unitsProps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
 
@@ -130,7 +140,30 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, customAtt
 
   var manyValuesDimensions = (0, _getManyValuesDimensions.getManyValuesDimensions)(dimensionsIndexedByIds, parsedDimensionsIds.manyValues, dimensionsAttributesValues.dimensions, attributesIndexedByIds);
 
-  var seriesAttributesValues = (0, _refineSeriesAttributesValues.refineSeriesAttributesValues)(dimensionsAttributesValues.series, attributesIndexedByIds);
+  var seriesAttributesValues = R.map(function (series) {
+    return (0, _refineSeriesAttributesValues.refineSeriesAttributesValues)(series, attributesIndexedByIds);
+  }, dimensionsAttributesValues);
+
+  var metadataCoordinates = (0, _getMetadataCoordinates.getMetadataCoordinates)(sdmxJson);
+  var headerAttributesIds = R.concat(attributesIdsIndexedByTargets.dataflow || [], attributesIdsIndexedByTargets.oneValueDimensions || []);
+  var headerAttributes = R.pick(headerAttributesIds, attributesIndexedByIds);
+  var headerAdvancedAttrIds = R.pipe(R.filter(function (id) {
+    return !R.includes(id, customAttributes.flags || []) && !R.includes(id, customAttributes.footnotes || []);
+  }))(headerAttributesIds);
+
+  var dataflowAdvancedAttributes = (0, _getAdvancedAttributes.getDataflowAdvancedAttributes)(headerAttributes, oneValueDimensions, headerAdvancedAttrIds, R.length(dimensions));
+
+  var observationsAdvancedAttributesIds = R.filter(function (id) {
+    return !R.includes(id, customAttributes.flags || []) && !R.includes(id, customAttributes.footnotes || []);
+  }, attributesIdsIndexedByTargets.observations || []);
+  var observationsAdvancedAttributes = (0, _getAdvancedAttributes.getObservationsAdvancedAttributes)(observations, observationsAdvancedAttributesIds);
+
+  var seriesAdvancedAttributesIds = R.filter(function (id) {
+    return !R.includes(id, customAttributes.flags || []) && !R.includes(id, customAttributes.footnotes || []);
+  }, R.concat(attributesIdsIndexedByTargets.series || [], attributesIdsIndexedByTargets.manyValuesDimensions || []));
+
+  var seriesAdvancedAttributes = (0, _getAdvancedAttributes.getSeriesAdvancedAttributes)(seriesAttributesValues, dimensions, seriesAdvancedAttributesIds);
+
   return {
     dimensions: {
       one: oneValueDimensions,
@@ -144,11 +177,13 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, customAtt
       unitsAttachmentSeriesIds: unitsAttachmentSeriesIds,
       unitsSeries: unitsSeries
     },
+    metadataCoordinates: metadataCoordinates,
+    advancedAttributes: (0, _extends3.default)({}, dataflowAdvancedAttributes, observationsAdvancedAttributes, seriesAdvancedAttributes),
     observations: observations,
     observationsType: (0, _getObservationsType.getObservationsType)(sdmxJson.data),
     dataflowAttributes: dataflowAttributes,
     dataflowName: R.path(['data', 'structure', 'name'], sdmxJson),
     seriesAttributes: R.props(seriesAttributesIds, attributesIndexedByIds),
-    seriesAttributesValues: seriesAttributesValues
+    seriesAttributesValues: seriesAttributesValues.series || {}
   };
 };

package/lib/rules/src/v8-transformer.js

@@ -105,24 +105,20 @@ var dataTransformer = exports.dataTransformer = function dataTransformer(dataNew
   var getAttrObservations = R.propOr([], 'observation');
   var attrObservations = getAttrObservations(attributes);
 
-  var getAttrDataset = R.propOr([], 'dataset');
-  var attrDataset = getAttrDataset(attributes);
-
-  var mergeAttr = R.concat(attrDataset, attrObservations);
-
   var resAttrObservations = R.map(function (observation) {
     return (0, _extends3.default)({}, observation, {
       name: getLocalisedProp('names', observation),
-      values: getValues(observation.values),
+      values: getValues(observation.values || []),
       roles: !R.isNil(observation.role) ? R.head(observation.role) : null
     });
-  }, mergeAttr);
+  }, attrObservations);
 
   var resAttributes = (0, _extends3.default)({}, attributes, {
     observation: resAttrObservations
+  });
 
-    //----------------------------------------------------------------------------------------Dimensions
-  });var getDimensions = R.propOr({}, 'dimensions');
+  //----------------------------------------------------------------------------------------Dimensions
+  var getDimensions = R.propOr({}, 'dimensions');
   var dimensions = getDimensions(structure);
 
   var getDimObservations = R.propOr([], 'observation');

package/lib/rules2/src/constants.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var SDMX_3_0_JSON_DATA_FORMAT = exports.SDMX_3_0_JSON_DATA_FORMAT = 'application/vnd.sdmx.data+json;version=2.0';
+var SDMX_3_0_CSV_DATA_FORMAT = exports.SDMX_3_0_CSV_DATA_FORMAT = 'application/vnd.sdmx.data+csv;version=2.0';

package/lib/rules2/src/getAdvAttrSeriesAtCoordinates.js

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAdvAttrSeriesAtCoordinates = 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 attribueValueDisplay = function attribueValueDisplay(display) {
+  return function (data) {
+    if (display === 'code') {
+      return R.prop('id', data);
+    }
+    if (display === 'both') {
+      return R.prop('id', data) + ': ' + R.prop('name', data);
+    }
+    return R.prop('name', data);
+  };
+};
+
+var getAdvAttrSeriesAtCoordinates = exports.getAdvAttrSeriesAtCoordinates = function getAdvAttrSeriesAtCoordinates(coordinates, advancedAttributes, display) {
+  return R.pipe(R.filter(function (serie) {
+    var mergedCoord = R.mergeLeft(serie.coordinates, coordinates);
+    return R.equals(mergedCoord, coordinates);
+  }), R.map(function (serie) {
+    return R.pipe(R.propOr({}, 'attributes'), R.values, R.map(function (attribute) {
+      return {
+        id: attribute.id,
+        label: attribueValueDisplay(display)(attribute),
+        value: attribueValueDisplay(display)(attribute.value)
+      };
+    }))(serie);
+  }))(advancedAttributes);
+};

package/lib/rules2/src/getAdvancedAttributes.js

@@ -0,0 +1,126 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSeriesAdvancedAttributes = exports.getDataflowAdvancedAttributes = exports.getObservationsAdvancedAttributes = undefined;
+
+var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
+
+var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
+
+var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
+
+var _defineProperty3 = _interopRequireDefault(_defineProperty2);
+
+var _extends3 = require('babel-runtime/helpers/extends');
+
+var _extends4 = _interopRequireDefault(_extends3);
+
+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 getObservationsAdvancedAttributes = exports.getObservationsAdvancedAttributes = function getObservationsAdvancedAttributes(observations, advancedAttributesIds) {
+  return R.pipe(R.map(function (obs) {
+    return { attributes: R.pick(advancedAttributesIds, obs.attributes || {}), coordinates: obs.indexedDimValIds || {} };
+  }), R.filter(function (entry) {
+    return !R.isEmpty(entry.attributes);
+  }))(observations);
+};
+
+var getDataflowAdvancedAttributes = exports.getDataflowAdvancedAttributes = function getDataflowAdvancedAttributes(attributes, dimensions, advancedAttributesIds, dimLength) {
+  var advancedAttributes = R.pick(advancedAttributesIds, attributes);
+  var keyTemplate = R.times(R.always(''), dimLength);
+  return R.reduce(function (acc, attribute) {
+    var value = R.head(attribute.values || []);
+    var attr = (0, _extends4.default)({}, R.pick(['id', 'name'], attribute), { value: value });
+    var coordinates = {};
+    var key = keyTemplate;
+
+    if (!R.isEmpty(R.pathOr([], ['relationship', 'dimensions'], attribute))) {
+      var attrDimensionsIds = R.pathOr([], ['relationship', 'dimensions'], attribute);
+      var attrDimensions = R.props(attrDimensionsIds, dimensions);
+      R.forEach(function (dim) {
+        var dId = dim.id;
+        var dIndex = dim.__index;
+        var vId = R.path(['values', 0, 'id'], dim);
+        coordinates = (0, _extends4.default)({}, coordinates, (0, _defineProperty3.default)({}, dId, vId));
+        key = R.set(R.lensIndex(dIndex), 0)(key);
+      }, attrDimensions);
+    }
+
+    key = R.join(':', key);
+    return R.over(R.lensProp(key), function (entry) {
+      return R.isNil(entry) ? { attributes: (0, _defineProperty3.default)({}, attribute.id, attr), coordinates: coordinates } : R.over(R.lensProp('attributes'), R.assoc(attribute.id, attr))(entry);
+    })(acc);
+  }, {}, R.values(advancedAttributes));
+};
+
+/*
+{
+  series: {
+    '0:0:x:x:x': { attributes: { a2: { id, value } } }
+  },
+  dimensions: {
+    '3:0': { attributes: { a1: { id, value } } },
+  }
+}
+
+*/
+
+var getSeriesAdvancedAttributes = exports.getSeriesAdvancedAttributes = function getSeriesAdvancedAttributes(seriesAttributes, dimensions, advancedAttributesIds) {
+  var seriesAdvancedAttributes = R.pipe(R.propOr({}, 'series'), function (series) {
+    return R.reduce(function (acc, key) {
+      var serie = series[key];
+      var advancedAttributes = R.pick(advancedAttributesIds, serie.attributes);
+      if (R.isEmpty(advancedAttributes)) {
+        return acc;
+      }
+      var splitKey = R.split(':', key);
+
+      var _R$addIndex = R.addIndex(R.reduce)(function (acc, vInd, dInd) {
+        if (vInd === 'x') {
+          return (0, _extends4.default)({}, acc, { refinedKey: R.append('', acc.refinedKey) });
+        }
+        var _refined = R.append(vInd, acc.refinedKey);
+        var dim = R.nth(dInd, dimensions);
+        var valId = R.path(['values', Number(vInd), 'id'], dim);
+        var _coordinates = R.assoc(dim.id, valId, acc.coordinates);
+        return { coordinates: _coordinates, refinedKey: _refined };
+      }, { coordinates: {}, refinedKey: [] }, splitKey),
+          coordinates = _R$addIndex.coordinates,
+          refinedKey = _R$addIndex.refinedKey;
+
+      return R.assoc(R.join(':', refinedKey), { attributes: advancedAttributes, coordinates: coordinates }, acc);
+    }, {}, R.keys(series));
+  })(seriesAttributes);
+  var keyTemplate = R.map(R.always(''), dimensions);
+  var dimensionsAdvancedAttributes = R.pipe(R.propOr({}, 'dimensions'), function (series) {
+    return R.reduce(function (acc, key) {
+      var serie = series[key];
+      var advancedAttributes = R.pick(advancedAttributesIds, serie.attributes);
+      if (R.isEmpty(advancedAttributes)) {
+        return acc;
+      }
+
+      var _R$split = R.split(':', key),
+          _R$split2 = (0, _slicedToArray3.default)(_R$split, 2),
+          dInd = _R$split2[0],
+          vInd = _R$split2[1];
+
+      var dim = R.nth(Number(dInd), dimensions);
+      var valId = R.path(['values', Number(vInd), 'id'], dim);
+      var coordinates = (0, _defineProperty3.default)({}, dim.id, valId);
+      var refinedKey = keyTemplate;
+      refinedKey[Number(dInd)] = vInd;
+      return R.assoc(R.join(':', refinedKey), { attributes: advancedAttributes, coordinates: coordinates }, acc);
+    }, {}, R.keys(series));
+  })(seriesAttributes);
+
+  return R.merge(seriesAdvancedAttributes, dimensionsAdvancedAttributes);
+};

package/lib/rules2/src/getMetadataCoordinates.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getMetadataCoordinates = 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 getMetadataCoordinates = exports.getMetadataCoordinates = function getMetadataCoordinates(sdmxJson) {
+  var dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
+  var annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
+  var metadataAvailKeys = R.pipe(R.pathOr([], ['data', 'dataSets', 0, 'dimensionGroupAttributes']), R.map(function (indexes) {
+    return R.props(indexes, annotations);
+  }), R.filter(R.find(R.propEq('type', 'HAS_METADATA'))), R.keys)(sdmxJson);
+
+  return R.map(function (key) {
+    var indexes = R.split(':', key);
+    return R.addIndex(R.reduce)(function (acc, vIndex, dimIndex) {
+      if (R.isNil(vIndex) || R.isEmpty(vIndex)) {
+        return acc;
+      }
+      var dim = R.nth(dimIndex, dimensions);
+      if (R.isNil(dim)) {
+        return acc;
+      }
+      var val = R.path(['values', Number(vIndex)], dim);
+      if (R.isNil(val)) {
+        return acc;
+      }
+      return R.assoc(dim.id, val.id, acc);
+    }, {}, indexes);
+  }, metadataAvailKeys);
+};

package/lib/rules2/src/getMetadataStructureFromData.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDataflowMetadataStructure = 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 getDataflowMetadataStructure = exports.getDataflowMetadataStructure = function getDataflowMetadataStructure(sdmxJson) {
+  var annotations = R.pathOr([], ['data', 'stucture', 'annotations'], sdmxJson);
+  var dataSetAnnotIndexes = R.pathOr([], ['data', 'dataSets', 0, 'annotations'], sdmxJson);
+  var dataSetAnnotations = R.props(dataSetAnnotIndexes, annotations);
+  var metadataAnnotation = R.find(R.propEq('type', 'METADATA'), dataSetAnnotations);
+  if (!metadataAnnotation) {
+    return null;
+  }
+  return R.pipe(R.propOr('', 'title'), R.split('='), R.last)(metadataAnnotation);
+};

package/lib/rules2/src/getSidebarData.js

@@ -0,0 +1,76 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSidebarData = 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 dimensionValueDisplay = function dimensionValueDisplay(display) {
+  return function (data) {
+    if (display === 'code') {
+      return R.prop('id', data);
+    }
+    if (display === 'both') {
+      return R.prop('id', data) + ': ' + R.prop('name', data);
+    }
+    return R.prop('name', data);
+  };
+};
+
+var sortByCoordinates = function sortByCoordinates(a, b) {
+  var splitACoord = a.splitCoord;
+  var splitBCoord = b.splitCoord;
+
+  var aWeight = R.pipe(R.reject(R.isEmpty), R.length)(splitACoord);
+  var bWeight = R.pipe(R.reject(R.isEmpty), R.length)(splitBCoord);
+  if (aWeight !== bWeight) {
+    return bWeight - aWeight;
+  }
+
+  var ind = 0;
+  while (splitACoord[ind] === splitBCoord[ind]) {
+    ind++;
+  }
+  var _a = R.isEmpty(splitACoord[ind]) ? 0 : Number(splitACoord[ind]);
+  var _b = R.isEmpty(splitBCoord[ind]) ? 0 : Number(splitBCoord[ind]);
+  return _b - _a;
+};
+
+// options = { display, attributesLabel }
+var getSidebarData = exports.getSidebarData = function getSidebarData(attributesSeries, metadataSeries, dataflow, dimensions, options) {
+  var coordinates = R.uniq(R.concat(R.keys(attributesSeries), R.keys(metadataSeries)));
+  return R.pipe(R.map(function (coordinate) {
+    var attributes = R.prop(coordinate, attributesSeries);
+    var metadata = R.prop(coordinate, metadataSeries);
+    var children = R.concat(R.isNil(attributes) ? [] : [{ id: coordinate + '-attr', label: options.attributesLabel, children: attributes }], R.isNil(metadata) ? [] : metadata);
+    var splitCoord = R.split(':', coordinate);
+    var label = null;
+    if (R.all(R.isEmpty, splitCoord)) {
+      label = dimensionValueDisplay(options.display)(dataflow);
+    } else {
+      label = R.pipe(R.addIndex(R.reduce)(function (acc, valIndex, dimIndex) {
+        if (R.isEmpty(valIndex)) {
+          return acc;
+        }
+        var dim = R.nth(dimIndex, dimensions);
+        var dimLabel = dimensionValueDisplay(options.display)(dim);
+        var value = R.nth(Number(valIndex), dim.values);
+        var valLabel = dimensionValueDisplay(options.display)(value);
+        return R.append(dimLabel + ': ' + valLabel, acc);
+      }, []), R.join(' - '))(splitCoord);
+    }
+
+    return {
+      id: coordinate,
+      splitCoord: splitCoord,
+      label: label,
+      children: R.filter(R.identity, children)
+    };
+  }), R.sort(sortByCoordinates))(coordinates);
+};

package/lib/rules2/src/hasCellMetadata.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasCellMetadata = 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 hasCellMetadata = exports.hasCellMetadata = function hasCellMetadata(metadataCoordinates, cellCoordinates) {
+  return R.pipe(R.find(function (coordinates) {
+    var mergedCoord = R.mergeLeft(coordinates, cellCoordinates);
+    return R.equals(mergedCoord, cellCoordinates);
+  }), R.complement(R.isNil))(metadataCoordinates);
+};

package/lib/rules2/src/hasLayoutEntryMetadata.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLayoutEntryMetadataCoordinates = 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; } }
+
+/*
+const layoutData = [{ dimension: { id: 'D1', __index: 2 }, value: { id: 'V', __index: 0 } }];
+*/
+
+var getLayoutEntryMetadataCoordinates = exports.getLayoutEntryMetadataCoordinates = function getLayoutEntryMetadataCoordinates(layoutData, metadataSeries) {};