@sis-cc/dotstatsuite-components 9.1.0 → 9.2.0

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

@@ -3,200 +3,141 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getLayoutData = exports.truncateHeader = exports.truncateSectionRows = exports.refineHeaderData = exports.refineSectionsData = undefined;
-
-var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
-
-var _defineProperty3 = _interopRequireDefault(_defineProperty2);
+exports.getLayoutData = undefined;
 
 var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
 
 var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
 
-var _extends3 = require('babel-runtime/helpers/extends');
+var _extends2 = require('babel-runtime/helpers/extends');
 
-var _extends4 = _interopRequireDefault(_extends3);
+var _extends3 = _interopRequireDefault(_extends2);
 
 var _ramda = require('ramda');
 
 var R = _interopRequireWildcard(_ramda);
 
-var _getSortedLayoutData = require('./getSortedLayoutData');
-
-var _getCuratedCells = require('./getCuratedCells');
-
 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 layoutDataToKey = R.pipe(R.addIndex(R.map)(function (entry, index) {
-  return (0, _extends4.default)({}, entry, { f: R.path([index, 'value', '__index']) });
-}), R.map(R.prop('f')), function (getters) {
-  return R.converge(function () {
-    for (var _len = arguments.length, results = Array(_len), _key = 0; _key < _len; _key++) {
-      results[_key] = arguments[_key];
-    }
-
-    return R.join(':', results);
-  }, getters);
-});
-
-var refineSectionsData = exports.refineSectionsData = function refineSectionsData(sectionsData, extractedKeys, curatedData, dataToKey) {
-  return R.pipe(R.map(function (section) {
-    var sectionKey = dataToKey.sections(R.head(section));
-    return R.over(R.lensIndex(1), R.filter(function (rowData) {
-      var rowKey = dataToKey.rows(rowData);
-      return R.pipe(R.path([sectionKey, rowKey]), R.omit(extractedKeys), R.isEmpty, R.not)(curatedData);
-    }))(section);
-  }), R.filter(R.pipe(R.nth(1), R.isEmpty, R.not)))(sectionsData);
-};
-
-var refineHeaderData = exports.refineHeaderData = function refineHeaderData(headerData, extractedKeys, curatedData, dataToKey) {
-  return R.filter( // extracted : { [sectionKey]: [...rowKeys] }
-  function (header) {
-    var headerKey = dataToKey.header(header);
-    return R.pipe(R.prop(headerKey), function (sections) {
-      return R.pickBy(function (rows, section) {
-        return R.pipe(R.omit(R.propOr([], section, extractedKeys)), R.isEmpty, R.not)(rows);
-      }, sections);
-    }, R.isEmpty, R.not)(curatedData);
-  })(headerData);
-};
-
-var truncateSectionRows = exports.truncateSectionRows = function truncateSectionRows(n, sectionsData, dataToKey) {
-  var _R$pipe = R.pipe(R.last, // last section
-  R.nth(1), // rows
-  R.splitAt(R.negate(n)) // truncate from the end
-  )(sectionsData),
-      _R$pipe2 = (0, _slicedToArray3.default)(_R$pipe, 2),
-      rest = _R$pipe2[0],
-      extracted = _R$pipe2[1];
-
-  var truncatedData = R.isEmpty(rest) ? R.dropLast(1, sectionsData) // remove section if no more rows
-  : R.adjust(-1, R.adjust(1, R.always(rest)), sectionsData);
-
-  var sectionKey = dataToKey.sections(R.pipe(R.last, R.head)(sectionsData));
-  var rowKeys = R.map(dataToKey.rows, extracted);
-
-  var extractedLength = R.length(extracted);
-  if (extractedLength < n) {
-    var _truncateSectionRows = truncateSectionRows(n - extractedLength, truncatedData, dataToKey),
-        truncated = _truncateSectionRows.truncated,
-        extractedKeys = _truncateSectionRows.extractedKeys;
-
-    return { truncated: truncated, extractedKeys: (0, _extends4.default)({}, extractedKeys, (0, _defineProperty3.default)({}, sectionKey, rowKeys)) };
-  }
-
-  return { truncated: truncatedData, extractedKeys: (0, _defineProperty3.default)({}, sectionKey, rowKeys) };
-};
-
-var truncateHeader = exports.truncateHeader = function truncateHeader(n, headerData, dataToKey) {
-  var _R$splitAt = R.splitAt(R.negate(n))(headerData),
-      _R$splitAt2 = (0, _slicedToArray3.default)(_R$splitAt, 2),
-      truncated = _R$splitAt2[0],
-      extracted = _R$splitAt2[1];
-
-  return { truncated: truncated, extractedKeys: R.map(dataToKey.header, extracted) };
-};
-
-var refineLength = function refineLength(length) {
-  return length === 0 ? 1 : length;
-};
-
-var truncateLayout = function truncateLayout(isVertical) {
-  return R.ifElse(R.always(isVertical), truncateSectionRows, truncateHeader);
+var indexesToLayoutData = function indexesToLayoutData(dimensions, indexes) {
+  return R.addIndex(R.map)(function (valueIndex, dimensionIndex) {
+    var dimension = R.nth(dimensionIndex, dimensions);
+    return {
+      dimension: R.pick(['id', 'name', '__index'], dimension),
+      value: R.nth(Number(valueIndex), R.propOr([], 'values', dimension))
+    };
+  }, indexes);
 };
 
-var refineLayout = function refineLayout(isVertical) {
-  return R.ifElse(R.always(isVertical), refineHeaderData, refineSectionsData);
-};
+var getRowData = function getRowData(indexes, dimension) {
+  return R.pipe(R.propOr([], 'values'), R.props(indexes), R.reduce(function (_ref, _value) {
+    var data = _ref.data,
+        missingParents = _ref.missingParents;
+
+    var raw = {
+      dimension: R.pick(['id', 'name', '__index'], dimension),
+      value: _value
+    };
+    if (R.isNil(_value.parents) || R.isEmpty(_value.parents)) {
+      return { data: R.append([raw], data), missingParents: {} };
+    }
+    var previous = R.head(R.last(data) || []);
 
-var getShape = function getShape(isVertical) {
-  return isVertical ? ['header', 'sections', 'rows'] : ['sections', 'rows', 'header'];
-};
+    if (R.last(_value.parents) === R.path(['value', 'id'], previous)) {
+      //previous is parent
+      var _value2 = R.set(R.lensPath(['value', 'parents']), R.append(R.path(['value', 'id'], previous), R.pathOr([], ['value', 'parents'], previous)))(raw);
+      return { data: R.append([_value2], data), missingParents: {} };
+    }
 
-var getRefinedLayout = function getRefinedLayout(isVertical, truncated, refined) {
-  return R.ifElse(R.always(isVertical), R.pipe(R.assoc('sectionsData', truncated), R.assoc('headerData', refined)), R.pipe(R.assoc('headerData', truncated), R.assoc('sectionsData', refined)))({});
-};
+    var previousParent = R.pipe(R.pathOr([], ['value', 'parents']), R.last)(previous);
+    if (R.last(_value.parents) === previousParent) {
+      //previous is bro
+      var _value3 = R.set(R.lensPath(['value']), (0, _extends3.default)({}, _value, {
+        name: R.isEmpty(missingParents) ? _value.name : missingParents.name + ' > ' + _value.name,
+        parents: R.pathOr([], ['value', 'parents'], previous)
+      }))(raw);
+      return { data: R.append([_value3], data), missingParents: missingParents };
+    }
 
-var segregateLayout = function segregateLayout(isVertical) {
-  return R.ifElse(R.always(isVertical), R.props(['sectionsData', 'headerData']), R.props(['headerData', 'sectionsData']));
+    var missingIds = R.takeLastWhile(function (id) {
+      return id !== R.path(['value', 'id'], previous);
+    }, _value.parents);
+    var _missingParents = R.reduce(function (acc, value) {
+      if (value.id !== R.head(acc.missingIds)) {
+        return acc;
+      }
+      var _missingIds = R.tail(acc.missingIds);
+      if (R.isEmpty(acc.name)) {
+        return { name: value.name, missingIds: _missingIds };
+      }
+      return {
+        name: acc.name + ' > ' + value.name,
+        missingIds: _missingIds
+      };
+    }, { name: '', missingIds: missingIds }, dimension.values);
+
+    var value = R.set(R.lensProp('value'), (0, _extends3.default)({}, _value, {
+      name: _missingParents.name + ' > ' + _value.name,
+      parents: R.length(missingIds) === R.length(_value.parents) ? [] : R.append(R.path(['value', 'id'], previous), R.pathOr([], ['value', 'parents'], previous))
+    }))(raw);
+
+    return { data: R.append([value], data), missingParents: _missingParents };
+  }, { data: [], missingParents: {} }), R.prop('data'))(dimension);
 };
 
-var getLayoutData = exports.getLayoutData = function getLayoutData(_ref) {
-  var layout = _ref.layout,
-      observations = _ref.observations,
-      limit = _ref.limit;
+var getRowsData = function getRowsData(rowsIndexes, dimensions) {
+  var dimension = R.head(dimensions);
 
-  var layoutData = (0, _getSortedLayoutData.getSortedLayoutData)(layout, observations);
-  var headerData = layoutData.headerData,
-      sectionsData = layoutData.sectionsData;
-
-  if (R.isNil(limit) || limit === 0 || R.all(R.isEmpty, [headerData, sectionsData])) {
-    return R.assoc('truncated', false, layoutData);
+  if (R.length(dimensions) === 1) {
+    return getRowData(R.unnest(rowsIndexes), R.head(dimensions));
   }
 
-  //number of dimensions in header
-  var headerDimCount = R.pipe(R.head, // first column
-  R.when(R.isNil, R.always([])), R.length // number of dims
-  )(headerData);
-
-  //number of columns for values
-  var headerValuesCount = R.pipe(R.length, R.when(R.equals(0), R.always(1)))(headerData);
-
-  //total of cells in header
-  var headerCellsCount = headerDimCount * (headerValuesCount + 1);
-
-  // number of dimensions in a row
-  var rowDimCount = R.pipe(R.head, // firstSection
-  R.last, // rows,
-  R.head, // first row
-  R.length)(sectionsData);
-
-  // number of cells in a row
-  var rowCellsCount = rowDimCount + headerValuesCount + 1;
-
-  // number of rows
-  var rowsCount = R.pipe(R.map(R.last), R.unnest, R.length, R.add(1))(sectionsData);
-
-  // total of cells in all rows
-  var rowsCellsCount = rowCellsCount * rowsCount;
-
-  // number of sections cells
-  var sectionsCellsCount = R.ifElse(R.pipe(R.head, R.head, R.length, R.equals(0)), R.always(0), R.length)(sectionsData);
-
-  var total = rowsCellsCount + sectionsCellsCount + headerCellsCount;
-
-  var excess = total - limit;
-  if (excess <= 0) {
-    return R.assoc('truncated', false, layoutData);
-  }
+  var groupedIndexes = R.reduce(function (acc, indexes) {
+    var headIndex = R.head(indexes);
+    var last = R.last(acc.heads);
+    if (last === headIndex) {
+      return (0, _extends3.default)({}, acc, {
+        tails: R.over(R.lensIndex(-1), R.append(R.tail(indexes)))(acc.tails)
+      });
+    }
+    return {
+      heads: R.append(headIndex, acc.heads),
+      tails: R.append([R.tail(indexes)], acc.tails)
+    };
+  }, { heads: [], tails: [] }, rowsIndexes);
 
-  // total of cells in one column
-  var columnCellsCount = headerDimCount + rowsCount;
+  var headsDatas = getRowData(groupedIndexes.heads, R.head(dimensions));
 
-  var isVertical = columnCellsCount > rowCellsCount;
+  var res = R.addIndex(R.map)(function (tail, i) {
+    var tailData = getRowsData(tail, R.tail(dimensions));
+    return R.map(R.prepend(R.head(headsDatas[i])), tailData);
+  }, groupedIndexes.tails);
 
-  var _segregateLayout = segregateLayout(isVertical)(layoutData),
-      _segregateLayout2 = (0, _slicedToArray3.default)(_segregateLayout, 2),
-      toTruncate = _segregateLayout2[0],
-      toRefine = _segregateLayout2[1];
+  return R.unnest(res);
+};
 
-  var cutLength = R.pipe(R.ifElse(R.identity, R.always(rowCellsCount), R.always(columnCellsCount)), R.divide(excess), Math.ceil)(isVertical);
+var getLayoutData = exports.getLayoutData = function getLayoutData(layoutIndexes, layout) {
+  var header = layoutIndexes.header,
+      sections = layoutIndexes.sections,
+      truncated = layoutIndexes.truncated;
 
-  var dataToKey = R.mapObjIndexed(layoutDataToKey, layout);
+  var headerData = R.map(function (i) {
+    return indexesToLayoutData(layout.header, i);
+  }, header);
 
-  var _truncateLayout = truncateLayout(isVertical)(cutLength, toTruncate, dataToKey),
-      truncated = _truncateLayout.truncated,
-      extractedKeys = _truncateLayout.extractedKeys;
+  var sectionsData = R.map(function (_ref2) {
+    var _ref3 = (0, _slicedToArray3.default)(_ref2, 2),
+        sectionIndexes = _ref3[0],
+        rows = _ref3[1];
 
-  var curatedData = R.pipe(getShape, function (shape) {
-    return (0, _getCuratedCells.getCuratedCells)({ layout: layout, observations: observations, shape: shape });
-  })(isVertical);
+    var sectionData = indexesToLayoutData(layout.sections, sectionIndexes);
 
-  var refined = refineLayout(isVertical)(toRefine, extractedKeys, curatedData, dataToKey);
+    var rowsData = getRowsData(rows, layout.rows);
 
-  var result = getRefinedLayout(isVertical, truncated, refined);
+    return [sectionData, rowsData];
+  }, sections);
 
-  return R.assoc('truncated', true, result);
+  return { headerData: headerData, sectionsData: sectionsData, truncated: truncated };
 };

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

@@ -0,0 +1,118 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSortedLayoutIndexes = undefined;
+
+var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
+
+var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
+
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/*
+
+const layout = {
+  header: [
+    { ...dim, values: [] } // values already sorted regarding order annotation
+  ],
+  rows: [],
+  sections: []
+};
+
+const observations = {
+  [obsKey]: {
+    ...obs,
+    orderedDimIndexes: [sortedValIndex]
+  }
+}
+
+*/
+
+var getLayoutPivots = function getLayoutPivots(layout) {
+  return R.mapObjIndexed(function (dimensions) {
+    return R.props(R.pluck('__index', dimensions));
+  })(layout);
+};
+
+var comparator = function comparator(size) {
+  return function (a, b) {
+    var i = 0;
+    while (a[i] === b[i] && i < size) {
+      i++;
+    }
+    return a[i] - b[i];
+  };
+};
+
+// simple call to ramda uniq method is very slow regarding performance 
+var uniqIndexes = function uniqIndexes(indexes) {
+  return R.pipe(R.reduce(function (acc, i) {
+    var key = R.join(':', i);
+    if (R.has(key, acc.keys)) {
+      return acc;
+    }
+    return {
+      indexes: R.append(i, acc.indexes),
+      keys: R.assoc(key, key, acc.keys)
+    };
+  }, { indexes: [], keys: {} }), R.prop('indexes'))(indexes);
+};
+
+var getSortedLayoutIndexes = exports.getSortedLayoutIndexes = function getSortedLayoutIndexes(layout, observations) {
+  var dimIndexes = R.pipe(R.values, R.pluck('orderedDimIndexes'))(observations);
+
+  var headerLength = R.length(layout.header);
+
+  var sectionLength = R.length(layout.sections);
+  var rowLength = R.length(layout.rows);
+
+  var layoutPivots = getLayoutPivots(layout);
+
+  var _R$pipe = R.pipe(R.reduce(function (acc, indexes) {
+    var headerIndexes = layoutPivots.header(indexes);
+    var sectionsIndexes = layoutPivots.sections(indexes);
+    var rowsIndexes = layoutPivots.rows(indexes);
+
+    return {
+      header: R.append(headerIndexes, acc.header),
+      sections: R.append(R.concat(sectionsIndexes, rowsIndexes), acc.sections)
+    };
+  }, { header: [], sections: [] }), R.mapObjIndexed(uniqIndexes), R.evolve({
+    header: R.sort(comparator(headerLength)),
+    sections: R.sort(comparator(sectionLength + rowLength))
+  }), function (indexes) {
+    return (0, _extends3.default)({}, indexes, {
+      sections: R.reduce(function (acc, i) {
+        var _R$splitAt = R.splitAt(sectionLength, i),
+            _R$splitAt2 = (0, _slicedToArray3.default)(_R$splitAt, 2),
+            sectionIndexes = _R$splitAt2[0],
+            rowIndexes = _R$splitAt2[1];
+
+        var previousSecIndexes = R.pipe(R.nth(-1), function (i) {
+          return R.isNil(i) ? null : R.head(i);
+        })(acc);
+        if (R.equals(sectionIndexes, previousSecIndexes)) {
+          return R.over(R.lensIndex(-1), R.over(R.lensIndex(1), R.append(rowIndexes)))(acc);
+        }
+
+        return R.append([sectionIndexes, [rowIndexes]], acc);
+      }, [], indexes.sections)
+    });
+  })(dimIndexes),
+      header = _R$pipe.header,
+      sections = _R$pipe.sections;
+
+  return { header: header, sections: sections };
+};

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

@@ -21,18 +21,20 @@ var _getConfirmedSeriesAttributesIds = require('./getConfirmedSeriesAttributesId
 
 var _getCuratedCells = require('./getCuratedCells');
 
-var _getLayoutData = require('./getLayoutData');
-
 var _getLayoutWithFlags = require('./getLayoutWithFlags');
 
-var _refineLayoutHierarchy = require('./refineLayoutHierarchy');
-
 var _getUnitsinLayout = require('../units/getUnitsinLayout');
 
 var _appendUnitsInLayoutData = require('../units/appendUnitsInLayoutData');
 
 var _cleanUnitsInLayoutData = require('../units/cleanUnitsInLayoutData');
 
+var _getSortedLayoutIndexes = require('./getSortedLayoutIndexes');
+
+var _refineLayoutSize = require('./refineLayoutSize');
+
+var _getLayoutData = require('./getLayoutData');
+
 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 }; }
@@ -74,21 +76,21 @@ var getTableProps = exports.getTableProps = function getTableProps(_ref) {
   }), function (dim) {
     return R.over( // sort values
     R.lensProp('values'), R.sortWith([R.ascend(R.prop('__indexPosition')), R.ascend(R.prop('order'))]))(dim);
-  }, R.when( // refine hierarchy on last row
-  R.pipe(R.prop('id'), R.equals(R.last(R.propOr([], 'rows', layoutIds)))), _dotstatsuiteSdmxjs.withFlatHierarchy)), R.pathOr({}, ['dimensions', 'many'], data));
+  }, R.when( // refine hierarchy on rows
+  R.pipe(R.prop('id'), R.flip(R.includes)(R.propOr([], 'rows', layoutIds))), _dotstatsuiteSdmxjs.withFlatHierarchy)), R.pathOr({}, ['dimensions', 'many'], data));
 
   var seriesAttributesValues = R.propOr({}, 'seriesAttributesValues', data);
   var layout = R.pipe(R.mergeRight({ header: [], sections: [], rows: [] }), R.mapObjIndexed(R.flip(R.props)(dimensions)))(layoutIds);
 
   var partialUnitSerieIndexes = R.pipe(R.pathOr(0, ['dimensions', 'length']), R.times(R.always('x')))(data);
 
-  var layoutData = R.pipe(_getLayoutData.getLayoutData, R.over(R.lensProp('sectionsData'), function (sectionsData) {
-    return (0, _refineLayoutHierarchy.refineLayoutHierarchy)(sectionsData, R.last(R.prop('rows', layout)));
-  }), (0, _appendUnitsInLayoutData.appendUnitsInLayoutData)({
+  var layoutData = R.pipe(_getSortedLayoutIndexes.getSortedLayoutIndexes, (0, _refineLayoutSize.refineLayoutSize)({ layout: layout, observations: data.observations, limit: R.when(R.isNil, R.always(0))(limit) }), function (indexes) {
+    return (0, _getLayoutData.getLayoutData)(indexes, layout);
+  }, (0, _appendUnitsInLayoutData.appendUnitsInLayoutData)({
     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: layout, observations: cells, limit: R.when(R.isNil, R.always(0))(limit) });
+  }), (0, _getLayoutWithFlags.getLayoutDataWithFlags)(seriesAttributesValues, display, customAttributes), (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