@sis-cc/dotstatsuite-components 17.12.6 → 17.13.0

package/lib/rules2/src/{hierarchiseDimensionWithAdvancedHierarchy.js → hierarchiseDimensionWithAdvancedHierarchy2.js}

@@ -68,28 +68,33 @@ var hierarchiseDimensionWithAdvancedHierarchy = exports.hierarchiseDimensionWith
   var indexed = R.indexBy(R.prop('id'), dimension.values);
   var hierarchy = refinePartialHierarchy(_hierarchy, indexed);
 
-  var rest = indexed;
-  var getChildren = function getChildren(parents, hier) {
-    return R.pipe(function (ids) {
-      rest = R.omit(ids, rest);
-      return R.props(ids, indexed);
-    }, R.filter(R.identity), R.map(function (val) {
-      var _val = (0, _extends3.default)({}, val, {
-        parent: R.last(parents),
-        parents: parents
-      });
-      var children = getChildren(R.append(val.id, parents), hier);
-      return R.prepend(_val, children);
-    }))(R.propOr([], R.isEmpty(parents) ? '#ROOT' : R.join('.', parents), hier));
+  var rest = R.pipe(R.values, R.unnest, R.flip(R.omit)(indexed), R.values)(hierarchy);
+  var index = R.length(rest) - 1;
+  var getChildren = function getChildren(_ref3) {
+    var parentsIndexes = _ref3.parentsIndexes,
+        parentId = _ref3.parentId;
+
+    var childrenIds = R.propOr([], parentId, hierarchy);
+    var children = R.reduce(function (acc, childId) {
+      if (!R.has(childId, indexed)) {
+        return acc;
+      }
+      index = index + 1;
+      var child = (0, _extends3.default)({}, R.prop(childId, indexed), { __indexPosition: index, parents: parentsIndexes, parent: R.isEmpty(parentsIndexes) ? undefined : R.pipe(R.split('.'), R.last)(parentId) });
+      var descendants = getChildren({ parentsIndexes: R.append(index, parentsIndexes), parentId: R.isEmpty(parentsIndexes) ? child.id : parentId + '.' + child.id });
+      return R.append(R.prepend(child, descendants), acc);
+    }, [], childrenIds);
+
+    return children;
   };
 
   return R.set(R.lensProp('values'), R.pipe(getChildren, R.flatten, function (values) {
     if (R.isEmpty(rest)) {
       return values;
     }
-    var sortedRest = R.pipe(R.values, R.map(function (val) {
-      return (0, _extends3.default)({}, val, { parent: undefined, parents: [] });
-    }), R.sortBy(R.prop('__indexPosition')))(rest);
+    var sortedRest = R.pipe(R.sortBy(R.prop('__indexPosition')), R.addIndex(R.map)(function (val, ind) {
+      return (0, _extends3.default)({}, val, { __indexPosition: ind, parent: undefined, parents: [] });
+    }))(rest);
     return R.concat(sortedRest, values);
-  })([], hierarchy))(dimension);
+  })({ parentsIndexes: [], parentId: '#ROOT' }))(dimension);
 };

package/lib/rules2/src/{hierarchiseDimensionWithNativeHierarchy.js → hierarchiseDimensionWithNativeHierarchy2.js}

@@ -18,14 +18,19 @@ var hierarchiseDimensionWithNativeHierarchy = exports.hierarchiseDimensionWithNa
     return val.parent && R.has(val.parent, indexed) ? val.parent : '#ROOT';
   }, values);
 
-  var getChildren = function getChildren(parents) {
-    var childs = R.propOr([], R.defaultTo('#ROOT', R.last(parents)), grouped);
+  var index = -1;
+  var getChildren = function getChildren(_ref) {
+    var parentsIndexes = _ref.parentsIndexes,
+        parentId = _ref.parentId;
+
+    var childs = R.propOr([], parentId, grouped);
     return R.reduce(function (acc, child) {
-      var refined = R.pipe(R.assoc('parents', parents), R.assoc('parent', R.last(parents)))(child);
-      var children = getChildren(R.append(child.id, parents));
+      index = index + 1;
+      var refined = R.pipe(R.assoc('__indexPosition', index), R.assoc('parents', parentsIndexes), R.assoc('parent', R.isEmpty(parentsIndexes) ? undefined : parentId))(child);
+      var children = getChildren({ parentsIndexes: R.append(index, parentsIndexes), parentId: child.id });
       return R.concat(acc, R.prepend(refined, children));
     }, [], childs);
   };
 
-  return R.set(R.lensProp('values'), getChildren([]))(dimension);
+  return R.set(R.lensProp('values'), getChildren({ parentsIndexes: [], parentId: '#ROOT' }))(dimension);
 };

package/lib/rules2/src/index.js

@@ -97,15 +97,6 @@ Object.defineProperty(exports, 'parseHierarchicalCodelist', {
   }
 });
 
-var _hierarchiseDimensionWithAdvancedHierarchy = require('./hierarchiseDimensionWithAdvancedHierarchy');
-
-Object.defineProperty(exports, 'refinePartialHierarchy', {
-  enumerable: true,
-  get: function get() {
-    return _hierarchiseDimensionWithAdvancedHierarchy.refinePartialHierarchy;
-  }
-});
-
 var _getMetadataCoordinates = require('./getMetadataCoordinates');
 
 Object.defineProperty(exports, 'getMetadataCoordinates', {
@@ -123,6 +114,15 @@ Object.defineProperty(exports, 'duplicateObs', {
     return _duplicateObservations.duplicateObs;
   }
 });
+
+var _hierarchiseDimensionWithAdvancedHierarchy = require('./hierarchiseDimensionWithAdvancedHierarchy2');
+
+Object.defineProperty(exports, 'refinePartialHierarchy', {
+  enumerable: true,
+  get: function get() {
+    return _hierarchiseDimensionWithAdvancedHierarchy.refinePartialHierarchy;
+  }
+});
 Object.defineProperty(exports, 'hierarchiseDimensionWithAdvancedHierarchy', {
   enumerable: true,
   get: function get() {
@@ -130,7 +130,7 @@ Object.defineProperty(exports, 'hierarchiseDimensionWithAdvancedHierarchy', {
   }
 });
 
-var _hierarchiseDimensionWithNativeHierarchy = require('./hierarchiseDimensionWithNativeHierarchy');
+var _hierarchiseDimensionWithNativeHierarchy = require('./hierarchiseDimensionWithNativeHierarchy2');
 
 Object.defineProperty(exports, 'hierarchiseDimensionWithNativeHierarchy', {
   enumerable: true,
@@ -301,7 +301,7 @@ Object.defineProperty(exports, 'getSortedLayoutIndexes', {
   }
 });
 
-var _refineLayoutSize = require('./table/refineLayoutSize');
+var _refineLayoutSize = require('./table/refineLayoutSize2');
 
 Object.defineProperty(exports, 'refineLayoutSize', {
   enumerable: true,
@@ -319,7 +319,7 @@ Object.defineProperty(exports, 'getFlagsAndNotes', {
   }
 });
 
-var _getLayoutData = require('./table/getLayoutData');
+var _getLayoutData = require('./table/getLayoutData2');
 
 Object.defineProperty(exports, 'getLayoutData', {
   enumerable: true,
@@ -407,4 +407,13 @@ Object.defineProperty(exports, 'parseValueHierarchy', {
   get: function get() {
     return _parseValueHierarchy.parseValueHierarchy;
   }
+});
+
+var _parseSeriesIndexesHierarchies = require('./table/parseSeriesIndexesHierarchies');
+
+Object.defineProperty(exports, 'parseLayoutIndexesHierarchies', {
+  enumerable: true,
+  get: function get() {
+    return _parseSeriesIndexesHierarchies.parseLayoutIndexesHierarchies;
+  }
 });

package/lib/rules2/src/prepareData.js

@@ -33,9 +33,9 @@ var _getManyValuesDimensions = require('./getManyValuesDimensions');
 
 var _getOneValueDimensions = require('./getOneValueDimensions');
 
-var _hierarchiseDimensionWithNativeHierarchy = require('./hierarchiseDimensionWithNativeHierarchy');
+var _hierarchiseDimensionWithNativeHierarchy = require('./hierarchiseDimensionWithNativeHierarchy2');
 
-var _hierarchiseDimensionWithAdvancedHierarchy = require('./hierarchiseDimensionWithAdvancedHierarchy');
+var _hierarchiseDimensionWithAdvancedHierarchy = require('./hierarchiseDimensionWithAdvancedHierarchy2');
 
 var _getDataflowAttributes = require('./getDataflowAttributes');
 

package/lib/rules2/src/refineDimensions.js

@@ -25,15 +25,12 @@ var refineDimensions = exports.refineDimensions = function refineDimensions() {
 
   return R.addIndex(R.map)(function (dim, index) {
     var selection = R.nth(index, selectionIds);
-    if (R.isNil(selection) || R.length(selection) === 0 || R.isEmpty(R.head(selection))) {
-      return (0, _extends3.default)({}, dim, { header: R.length(dim.values || []) <= 1 });
-    }
     var values = R.map(function (val) {
-      if (R.includes(val.id, selection)) {
-        return val;
+      if (R.includes(val.id, selection || []) || R.isNil(selection) || R.length(selection) === 0 || R.isEmpty(R.head(selection))) {
+        return R.assoc('isSelected', true, val);
       }
       return R.assoc('empty', true, val);
     }, dim.values || []);
-    return (0, _extends3.default)({}, dim, { values: values, header: R.length(values) <= 1 || R.length(selection) === 1 });
+    return (0, _extends3.default)({}, dim, { values: values, header: R.length(values) <= 1 || R.length(selection) === 1 && !R.isEmpty(R.head(selection)) });
   }, dimensions);
 };

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

@@ -0,0 +1,218 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+	value: true
+});
+exports.getLayoutData = exports.getSerieDatas = undefined;
+
+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);
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+var _getFlagsAndNotes = require('./getFlagsAndNotes');
+
+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; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var getValueData = function getValueData(index, dimension, parentsIndexes) {
+	return {
+		dimension: R.pick(['id', 'name', '__index'], dimension),
+		value: (0, _extends3.default)({}, R.pipe(R.pathOr({}, ['values', index]), R.pick(['id', 'name']))(dimension), {
+			parents: parentsIndexes
+		})
+	};
+};
+
+var addCoordinatesToKey = function addCoordinatesToKey(key, dimensionId, valueId) {
+	return '' + key + (R.isEmpty(key) ? '' : ':') + dimensionId + '=' + valueId;
+};
+
+var simpleValueDataSetter = function simpleValueDataSetter(valueData) {
+	var datas = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+	return R.append(valueData, datas);
+};
+
+var combinedValueDataSetter = function combinedValueDataSetter(valueData) {
+	var datas = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+	return R.over(R.lensIndex(-1), function (d) {
+		return (0, _extends3.default)({}, d, { values: R.append(R.prop('value', valueData), d.values) });
+	}, datas);
+};
+
+var addValueToSerieData = function addValueToSerieData(dataSetter) {
+	return function (index, parentsIndexes, dimension, serieData) {
+		var valueData = getValueData(index, dimension, parentsIndexes);
+		var valueId = R.path(['value', 'id'], valueData);
+		return (0, _extends3.default)({}, serieData, {
+			data: dataSetter(valueData, R.prop('data', serieData)),
+			coordinates: R.assoc(dimension.id, valueId, R.prop('coordinates', serieData)),
+			key: addCoordinatesToKey(R.prop('key', serieData), R.prop('id', dimension), valueId)
+		});
+	};
+};
+
+var addSimpleValueToSerieData = addValueToSerieData(simpleValueDataSetter);
+
+var addCombinedValueToSerieData = addValueToSerieData(combinedValueDataSetter);
+
+var getHasAdvancedAttributes = function getHasAdvancedAttributes(attrValues, customAttributes) {
+	return R.pipe(R.omit(R.concat(customAttributes.flags || [], customAttributes.notes || [])), R.isEmpty, R.not)(attrValues);
+};
+
+var getCoordinates = function getCoordinates(indexes, topCoordinates, definition) {
+	return R.addIndex(R.reduce)(function (acc, entry, index) {
+		if (R.has('dimensions', entry)) {
+			return R.addIndex(R.reduce)(function (_acc, dim, _index) {
+				var valInd = R.path([index, _index], indexes);
+				return R.assoc(dim.id, R.path(['values', valInd, 'id'], dim), _acc);
+			}, acc, entry.dimensions);
+		}
+		var valInd = R.nth(index, indexes);
+		return R.assoc(entry.id, R.path(['values', valInd, 'id'], entry), acc);
+	}, topCoordinates, definition);
+};
+
+var getAttributesSeries = function getAttributesSeries(validator, attributesSeries) {
+	return R.reduce(function (acc, attrs) {
+		var attr = R.head(R.values(attrs));
+		var coordinates = R.propOr({}, 'coordinates', attr);
+		var isValid = validator(coordinates);
+		if (!isValid && !attr.isObs) {
+			return acc;
+		}
+		return (0, _extends3.default)({}, acc, attrs);
+	}, {}, R.values(attributesSeries));
+};
+
+var combineConcepts = function combineConcepts(combDimValues, definition, attrValues) {
+	return R.over(R.lensProp('data'), R.over(R.lensIndex(-1), function (data) {
+		return (0, _extends3.default)({}, data, {
+			values: R.reduce(function (acc, conceptId) {
+				if (R.has(conceptId, combDimValues)) {
+					return R.append(R.prop(conceptId, combDimValues), acc);
+				}
+				if (R.has(conceptId, definition.fixedDimValues || {})) {
+					return R.append(R.prop(conceptId, definition.fixedDimValues), acc);
+				}
+				if (R.has(conceptId, attrValues)) {
+					var value = R.path([conceptId, 'value'], attrValues);
+					return R.append(value, acc);
+				}
+				return acc;
+			}, [], definition.concepts)
+		});
+	}));
+};
+
+var getSerieFlagsAndSideProps = function getSerieFlagsAndSideProps(coordinates, validator, attributesValues, customAttributes, metadataCoordinates) {
+	var layoutAttrValues = R.reject(R.prop('isObs'), attributesValues);
+	var flags = (0, _getFlagsAndNotes.getFlagsAndNotes)(layoutAttrValues, customAttributes);
+	var hasMetadata = !R.isNil(R.find(validator, metadataCoordinates));
+	var hasAdvancedAttributes = getHasAdvancedAttributes(layoutAttrValues, customAttributes);
+	var sideProps = hasMetadata || hasAdvancedAttributes ? { hasMetadata: hasMetadata, hasAdvancedAttributes: hasAdvancedAttributes, coordinates: coordinates } : null;
+	return { flags: flags, sideProps: sideProps };
+};
+
+var getSerieDatas = exports.getSerieDatas = function getSerieDatas(serie, definition, topCoordinates, attributesSeries, customAttributes, metadataCoordinates) {
+	var lines = [];
+
+	var serieCoordinates = getCoordinates(serie.indexes, topCoordinates, definition);
+	var coordinatesValidator = (0, _utils.getLayoutCoordinatesValidator)(serieCoordinates, topCoordinates);
+	var attributesValues = getAttributesSeries(coordinatesValidator, attributesSeries);
+
+	var addMissingParentsLines = function addMissingParentsLines(dataSetter) {
+		return function (missingParentsIndexes, parentsIndexes, dim, serieData) {
+			return R.reduce(function (parents, index) {
+				var missingParentData = addValueToSerieData(dataSetter)(index, parents, dim, serieData);
+				lines.push(R.assoc('isEmpty', true, missingParentData));
+				return R.append(index, parents);
+			}, parentsIndexes, missingParentsIndexes);
+		};
+	};
+
+	var addSimpleMissingParentsLines = addMissingParentsLines(simpleValueDataSetter);
+	var addCombinedMissingParentsLines = addMissingParentsLines(combinedValueDataSetter);
+
+	var serieData = R.addIndex(R.reduce)(function (onGoingSerie, entry, index) {
+		if (R.has('dimensions', entry)) {
+			var combValuesIndexes = R.pathOr([], ['indexes', index], serie);
+			var combParentsIndexes = R.pathOr([], ['parentsIndexes', index], serie);
+			var combMissingParentsIndexes = R.pathOr([], ['missingIndexes', index], serie);
+			var combDimValues = {};
+			var res = R.addIndex(R.reduce)(function (combSerie, dimension, dimIndex) {
+				var valueIndex = Math.abs(R.nth(dimIndex, combValuesIndexes));
+				var _parentsIndexes = R.nth(dimIndex, combParentsIndexes) || [];
+				var missingParentsIndexes = R.nth(dimIndex, combMissingParentsIndexes) || [];
+				var parentsIndexes = addCombinedMissingParentsLines(missingParentsIndexes, _parentsIndexes, dimension, combSerie);
+				var next = addCombinedValueToSerieData(valueIndex, parentsIndexes, dimension, combSerie);
+				var value = R.pipe(R.prop('data'), R.last, R.prop('values'), R.last)(next);
+				combDimValues = R.assoc(dimension.id, value, combDimValues);
+				return next;
+			}, R.over(R.lensProp('data'), R.append({ dimension: R.pick(['id', 'name'], entry), values: [] }))(onGoingSerie), R.propOr([], 'dimensions', entry));
+
+			var combined = combineConcepts(combDimValues, entry, attributesValues)(res);
+			attributesValues = R.omit(entry.concepts, attributesValues);
+			return combined;
+		}
+
+		var valueIndex = Math.abs(R.path(['indexes', index], serie));
+		var _parentsIndexes = R.pathOr([], ['parentsIndexes', index], serie);
+		var missingParentsIndexes = R.pathOr([], ['missingIndexes', index], serie);
+		var parentsIndexes = addSimpleMissingParentsLines(missingParentsIndexes, _parentsIndexes, entry, onGoingSerie);
+		return addSimpleValueToSerieData(valueIndex, parentsIndexes, entry, onGoingSerie);
+	}, { data: [], coordinates: {}, key: '', sideProps: null, flags: [] }, definition);
+
+	var _getSerieFlagsAndSide = getSerieFlagsAndSideProps(serieCoordinates, coordinatesValidator, attributesValues, customAttributes, metadataCoordinates),
+	    flags = _getSerieFlagsAndSide.flags,
+	    sideProps = _getSerieFlagsAndSide.sideProps;
+
+	lines.push((0, _extends3.default)({}, serieData, { flags: flags, sideProps: sideProps }));
+	return lines;
+};
+
+var getLayoutData = function getLayoutData(layoutIndexes, layout, _ref) {
+	var metadataCoordinates = _ref.metadataCoordinates,
+	    attributesSeries = _ref.attributesSeries,
+	    customAttributes = _ref.customAttributes,
+	    _ref$topCoordinates = _ref.topCoordinates,
+	    topCoordinates = _ref$topCoordinates === undefined ? {} : _ref$topCoordinates;
+	var header = layoutIndexes.header,
+	    sections = layoutIndexes.sections,
+	    rest = (0, _objectWithoutProperties3.default)(layoutIndexes, ['header', 'sections']);
+
+
+	var headerData = R.reduce(function (acc, serie) {
+		var datas = getSerieDatas(serie, layout.header, topCoordinates, attributesSeries, customAttributes, metadataCoordinates);
+		return R.concat(acc, datas);
+	}, [], header);
+
+	var sectionsData = R.map(function (_ref2) {
+		var _ref3 = (0, _slicedToArray3.default)(_ref2, 2),
+		    sectionSerie = _ref3[0],
+		    rowsSeries = _ref3[1];
+
+		var sectionData = getSerieDatas(sectionSerie, layout.sections, topCoordinates, attributesSeries, customAttributes, metadataCoordinates);
+		return [R.last(sectionData), R.reduce(function (acc, serie) {
+			var datas = getSerieDatas(serie, layout.rows, sectionData.coordinates, attributesSeries, customAttributes, metadataCoordinates);
+			return R.concat(acc, datas);
+		}, [], rowsSeries)];
+	}, sections);
+
+	return (0, _extends3.default)({ headerData: headerData, sectionsData: sectionsData }, rest);
+};
+exports.getLayoutData = getLayoutData;

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

@@ -9,17 +9,15 @@ var _extends2 = require('babel-runtime/helpers/extends');
 
 var _extends3 = _interopRequireDefault(_extends2);
 
-var _ramda = require('ramda');
-
-var R = _interopRequireWildcard(_ramda);
-
 var _getLayout = require('./getLayout');
 
 var _getSortedLayoutIndexes = require('./getSortedLayoutIndexes');
 
-var _refineLayoutSize = require('./refineLayoutSize');
+var _parseSeriesIndexesHierarchies = require('./parseSeriesIndexesHierarchies');
 
-var _getLayoutData = require('./getLayoutData');
+var _refineLayoutSize = require('./refineLayoutSize2');
+
+var _getLayoutData = require('./getLayoutData2');
 
 var _getCellsAttributesIds = require('./getCellsAttributesIds');
 
@@ -31,8 +29,6 @@ var _getCuratedCells = require('./getCuratedCells');
 
 var _getSeriesCombinations = require('../getSeriesCombinations');
 
-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 getTableProps = exports.getTableProps = function getTableProps(_ref) {
@@ -54,7 +50,8 @@ var getTableProps = exports.getTableProps = function getTableProps(_ref) {
   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 enhancedLayoutIndexes = (0, _parseSeriesIndexesHierarchies.parseLayoutIndexesHierarchies)(layoutIndexes, layout);
+  var refinedLayoutIndexes = (0, _refineLayoutSize.refineLayoutSize)({ layout: layout, observations: observations, limit: limit })(enhancedLayoutIndexes);
   var layoutData = (0, _getLayoutData.getLayoutData)(refinedLayoutIndexes, layout, { metadataCoordinates: metadataCoordinates, attributesSeries: attributesSeries, customAttributes: customAttributes, topCoordinates: header.coordinates });
 
   var cellsAttributesIds = (0, _getCellsAttributesIds.getCellsAttributesIds)(layoutIds, attributes);

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

@@ -0,0 +1,96 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseLayoutIndexesHierarchies = exports.parseSeriesIndexesHierarchies = undefined;
+
+var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
+
+var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
+
+var _set = require('babel-runtime/core-js/set');
+
+var _set2 = _interopRequireDefault(_set);
+
+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 parseSerieIndexesHierarchies = function parseSerieIndexesHierarchies(serieIndexes, previousSerie, dimensions) {
+  var isSameSerie = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+
+  return R.addIndex(R.reduce)(function (acc, _valueIndex, dimensionIndex) {
+    if (R.is(Array, _valueIndex)) {
+      var previous = R.isEmpty(previousSerie) ? {} : {
+        indexes: R.nth(dimensionIndex, previousSerie.indexes || []),
+        parentsIndexes: R.nth(dimensionIndex, previousSerie.parentsIndexes || []),
+        missingIndexes: R.nth(dimensionIndex, previousSerie.missingIndexes || []),
+        registeredIndexes: R.nth(dimensionIndex, previousSerie.registeredIndexes || [])
+      };
+      var parsed = parseSerieIndexesHierarchies(_valueIndex, previous, R.pathOr([], [dimensionIndex, 'dimensions'], dimensions), acc.isSameSerie);
+      return {
+        parentsIndexes: R.append(parsed.parentsIndexes, acc.parentsIndexes),
+        missingIndexes: R.append(parsed.missingIndexes, acc.missingIndexes),
+        registeredIndexes: R.append(parsed.registeredIndexes, acc.registeredIndexes),
+        isSameSerie: parsed.isSameSerie
+      };
+    }
+    var valueIndex = Math.abs(_valueIndex);
+    var _parentsIndexes = R.pathOr([], [dimensionIndex, 'values', valueIndex, 'parents'], dimensions);
+    var previousIndex = acc.isSameSerie ? R.pathOr(-1, ['indexes', dimensionIndex], previousSerie) : -1;
+    var previousRegisteredIndexes = acc.isSameSerie ? R.pathOr(new _set2.default(), ['registeredIndexes', dimensionIndex], previousSerie) : new _set2.default();
+    var registeredIndexes = new _set2.default(previousRegisteredIndexes);
+
+    var _R$reduce = R.reduce(function (_acc, ind) {
+      if (previousRegisteredIndexes.has(ind)) {
+        return R.over(R.lensIndex(0), R.append(ind), _acc);
+      } else if (ind > previousIndex && R.pathOr(false, [dimensionIndex, 'values', ind, 'isSelected'], dimensions)) {
+        registeredIndexes.add(ind);
+        return R.over(R.lensIndex(1), R.append(ind), _acc);
+      }
+      return _acc;
+    }, [[], []], _parentsIndexes),
+        _R$reduce2 = (0, _slicedToArray3.default)(_R$reduce, 2),
+        parentsIndexes = _R$reduce2[0],
+        missingParentsIndexes = _R$reduce2[1];
+
+    registeredIndexes.add(valueIndex);
+    return {
+      parentsIndexes: R.append(parentsIndexes, acc.parentsIndexes),
+      missingIndexes: R.append(missingParentsIndexes, acc.missingIndexes),
+      registeredIndexes: R.append(registeredIndexes, acc.registeredIndexes),
+      isSameSerie: acc.isSameSerie && valueIndex === previousIndex
+    };
+  }, { parentsIndexes: [], missingIndexes: [], registeredIndexes: [], isSameSerie: isSameSerie }, serieIndexes);
+};
+
+var parseSeriesIndexesHierarchies = exports.parseSeriesIndexesHierarchies = function parseSeriesIndexesHierarchies(seriesIndexes, dimensions) {
+  return R.reduce(function (acc, serieIndexes) {
+    var previousSerie = R.last(acc) || {};
+
+    var _parseSerieIndexesHie = parseSerieIndexesHierarchies(serieIndexes, previousSerie, dimensions),
+        parentsIndexes = _parseSerieIndexesHie.parentsIndexes,
+        missingIndexes = _parseSerieIndexesHie.missingIndexes,
+        registeredIndexes = _parseSerieIndexesHie.registeredIndexes;
+
+    return R.append({ indexes: serieIndexes, parentsIndexes: parentsIndexes, missingIndexes: missingIndexes, registeredIndexes: registeredIndexes }, acc);
+  }, [], seriesIndexes);
+};
+
+var parseLayoutIndexesHierarchies = exports.parseLayoutIndexesHierarchies = function parseLayoutIndexesHierarchies(layoutIndexes, layout) {
+  var header = parseSeriesIndexesHierarchies(layoutIndexes.header, layout.header);
+  var sections = R.map(function (_ref) {
+    var _ref2 = (0, _slicedToArray3.default)(_ref, 2),
+        sectionIndexes = _ref2[0],
+        rowsIndexes = _ref2[1];
+
+    return [{ indexes: sectionIndexes, parentsIndexes: [], missingIndexes: [] }, parseSeriesIndexesHierarchies(rowsIndexes, layout.rows)];
+  }, layoutIndexes.sections);
+
+  return { header: header, sections: sections };
+};