@sis-cc/dotstatsuite-components 17.12.6 → 17.13.0

package/test/parseSeriesIndexesHierarchies.test.js

@@ -0,0 +1,104 @@
+import { expect } from 'chai';
+import { parseSeriesIndexesHierarchies } from '../src/rules2/src/table/parseSeriesIndexesHierarchies';
+
+describe('parseSeriesIndexesHierarchies tests', () => {
+	it('simple uniq flat', () => {
+		const dimensions = [
+			{
+				id: 'D0',
+				values: [
+					{ id: 'v0' },
+					{ id: 'v1' },
+					{ id: 'v2' },
+					{ id: 'v3' },
+					{ id: 'v4' },
+				]
+			},
+		];
+
+		const seriesIndexes = [
+			[2],
+			[3],
+			[4]
+		];
+
+		expect(parseSeriesIndexesHierarchies(seriesIndexes, dimensions)).to.deep.equal([
+			{ indexes: [2], parentsIndexes: [[]], missingIndexes: [[]], registeredIndexes: [new Set([2])] },
+			{ indexes: [3], parentsIndexes: [[]], missingIndexes: [[]], registeredIndexes: [new Set([2, 3])] },
+			{ indexes: [4], parentsIndexes: [[]], missingIndexes: [[]], registeredIndexes: [new Set([2, 3, 4])] },
+		])
+	});
+	it('more complex stuff', () => {
+		const dimensions = [
+			{
+				id: 'D0',
+				values: [
+					{ id: 'v0' },
+					{ id: 'v1' },
+					{ id: 'v2' },
+					{ id: 'v3' },
+					{ id: 'v4' },
+				]
+			},
+			{
+				id: 'D1',
+				values: [
+					{ id: 'W', isSelected: true },
+					{ id: 'NA', parents: [0], isSelected: false },
+					{ id: 'A', parents: [0, 1], isSelected: true },
+					{ id: 'USA', parents: [0, 1, 2], isSelected: true },
+					{ id: 'CAN', parents: [0, 1, 2], isSelected: true },
+					{ id: 'MEX', parents: [0, 1, 2], isSelected: true }
+				]
+			}
+		];
+
+		const seriesIndexes = [
+			[0, 3],
+			[0, 4],
+			[1, 5]
+		];
+
+		expect(parseSeriesIndexesHierarchies(seriesIndexes, dimensions)).to.deep.equal([
+			{ indexes: [0, 3], parentsIndexes: [[], []], missingIndexes: [[], [0, 2]], registeredIndexes: [new Set([0]), new Set([0, 2, 3])] },
+			{ indexes: [0, 4], parentsIndexes: [[], [0, 2]], missingIndexes: [[], []], registeredIndexes: [new Set([0]), new Set([0, 2, 3, 4])] },
+			{ indexes: [1, 5], parentsIndexes: [[], []], missingIndexes: [[], [0, 2]], registeredIndexes: [new Set([0, 1]), new Set([0, 2, 5])] },
+		])
+	});
+	it('with combination', () => {
+		const dimensions = [
+			{
+				id: 'COMB',
+				dimensions: [{
+					values: [
+						{ id: 'v0' },
+						{ id: 'v1' },
+						{ id: 'v2' },
+						{ id: 'v3' },
+						{ id: 'v4' },
+					]
+				},
+				{
+					values: [
+						{ id: 'W', isSelected: true },
+						{ id: 'NA', parents: [0], isSelected: false },
+						{ id: 'A', parents: [0, 1], isSelected: true },
+						{ id: 'USA', parents: [0, 1, 2], isSelected: true },
+						{ id: 'CAN', parents: [0, 1, 2], isSelected: true },
+						{ id: 'MEX', parents: [0, 1, 2], isSelected: true }
+					]
+				}]
+			},
+		];
+
+		const seriesIndexes = [
+			[[0, 0]],
+			[[0, 1]],
+		];
+
+		expect(parseSeriesIndexesHierarchies(seriesIndexes, dimensions)).to.deep.equal([
+			{ indexes: [[0, 0]], parentsIndexes: [[[], []]], missingIndexes: [[[], []]], registeredIndexes: [[new Set([0]), new Set([0])]] },
+			{ indexes: [[0, 1]], parentsIndexes: [[[], [0]]], missingIndexes: [[[], []]], registeredIndexes: [[new Set([0]), new Set([0, 1])]] },
+		])
+	});
+});

package/test/{refineLayoutSize.test.js → refineLayoutSize2.test.js}

@@ -1,6 +1,5 @@
 import { expect } from 'chai';
-//import { refineLayoutSize } from '../src/rules/src/table/factories/refineLayoutSize';
-import { refineLayoutSize } from '../src/rules2/src/';
+import { refineLayoutSize } from '../src/rules2/src/table/refineLayoutSize2';
 
 const observations1 = {
   '0:0:0': { orderedDimIndexes: [0, 0, 0] },
@@ -100,7 +99,7 @@ const partialObservations3 = {
   '2:2:2': { orderedDimIndexes: [2, 2, 2] },
 };
 
-describe('refineLayoutSize tests', () => {
+describe('refineLayoutSize 2 tests', () => {
   it('no changes under limit', () => {
     const layout = {
       header: [{ __index: 0 }],
@@ -109,22 +108,22 @@ describe('refineLayoutSize tests', () => {
     };
 
     const layoutIndexes = {
-      header: [[0], [1], [2]],
+      header: [{ indexes: [0] }, { indexes: [1] }, { indexes: [2] }],
       sections: [
-        [[0], [[0], [1], [2]]],
-        [[1], [[0], [1], [2]]],
-        [[2], [[0], [1], [2]]]
+        [{ indexes: [0] }, [{ indexes: [0] }, { indexes: [1] }, { indexes: [2] }]],
+        [{ indexes: [1] }, [{ indexes: [0] }, { indexes: [1] }, { indexes: [2] }]],
+        [{ indexes: [2] }, [{ indexes: [0] }, { indexes: [1] }, { indexes: [2] }]]
       ]
     };
 
     const expected = {
       truncated: false,
       totalCells: 57,
-      header: [[0], [1], [2]],
+      header: [{ indexes: [0] }, { indexes: [1] }, { indexes: [2] }],
       sections: [
-        [[0], [[0], [1], [2]]],
-        [[1], [[0], [1], [2]]],
-        [[2], [[0], [1], [2]]]
+        [{ indexes: [0] }, [{ indexes: [0] }, { indexes: [1] }, { indexes: [2] }]],
+        [{ indexes: [1] }, [{ indexes: [0] }, { indexes: [1] }, { indexes: [2] }]],
+        [{ indexes: [2] }, [{ indexes: [0] }, { indexes: [1] }, { indexes: [2] }]]
       ]
     };
     expect(
@@ -143,38 +142,38 @@ describe('refineLayoutSize tests', () => {
     };
 
     const layoutIndexes = {
-      header: [[]],
+      header: [{ indexes: [] }],
       sections: [
         [
-          [],
+          { indexes: [] },
           [
-            [0, 0, 0],
-            [0, 0, 1],
-            [0, 0, 2],
-            [0, 1, 0],
-            [0, 1, 1],
-            [0, 1, 2],
-            [0, 2, 0],
-            [0, 2, 1],
-            [0, 2, 2],
-            [1, 0, 0],
-            [1, 0, 1],
-            [1, 0, 2],
-            [1, 1, 0],
-            [1, 1, 1],
-            [1, 1, 2],
-            [1, 2, 0],
-            [1, 2, 1],
-            [1, 2, 2],
-            [2, 0, 0],
-            [2, 0, 1],
-            [2, 0, 2],
-            [2, 1, 0],
-            [2, 1, 1],
-            [2, 1, 2],
-            [2, 2, 0],
-            [2, 2, 1],
-            [2, 2, 2]
+            { indexes: [0, 0, 0] },
+            { indexes: [0, 0, 1] },
+            { indexes: [0, 0, 2] },
+            { indexes: [0, 1, 0] },
+            { indexes: [0, 1, 1] },
+            { indexes: [0, 1, 2] },
+            { indexes: [0, 2, 0] },
+            { indexes: [0, 2, 1] },
+            { indexes: [0, 2, 2] },
+            { indexes: [1, 0, 0] },
+            { indexes: [1, 0, 1] },
+            { indexes: [1, 0, 2] },
+            { indexes: [1, 1, 0] },
+            { indexes: [1, 1, 1] },
+            { indexes: [1, 1, 2] },
+            { indexes: [1, 2, 0] },
+            { indexes: [1, 2, 1] },
+            { indexes: [1, 2, 2] },
+            { indexes: [2, 0, 0] },
+            { indexes: [2, 0, 1] },
+            { indexes: [2, 0, 2] },
+            { indexes: [2, 1, 0] },
+            { indexes: [2, 1, 1] },
+            { indexes: [2, 1, 2] },
+            { indexes: [2, 2, 0] },
+            { indexes: [2, 2, 1] },
+            { indexes: [2, 2, 2] }
           ]
         ]
       ]
@@ -183,31 +182,31 @@ describe('refineLayoutSize tests', () => {
     const expected = {
       totalCells: 140,
       truncated: true,
-      header: [[]],
+      header: [{ indexes: [] }],
       sections: [
         [
-          [],
+          { indexes: [] },
           [
-            [0, 0, 0],
-            [0, 0, 1],
-            [0, 0, 2],
-            [0, 1, 0],
-            [0, 1, 1],
-            [0, 1, 2],
-            [0, 2, 0],
-            [0, 2, 1],
-            [0, 2, 2],
-            [1, 0, 0],
-            [1, 0, 1],
-            [1, 0, 2],
-            [1, 1, 0],
-            [1, 1, 1],
-            [1, 1, 2],
-            [1, 2, 0],
-            [1, 2, 1],
-            [1, 2, 2],
-            [2, 0, 0],
-            [2, 0, 1]
+            { indexes: [0, 0, 0] },
+            { indexes: [0, 0, 1] },
+            { indexes: [0, 0, 2] },
+            { indexes: [0, 1, 0] },
+            { indexes: [0, 1, 1] },
+            { indexes: [0, 1, 2] },
+            { indexes: [0, 2, 0] },
+            { indexes: [0, 2, 1] },
+            { indexes: [0, 2, 2] },
+            { indexes: [1, 0, 0] },
+            { indexes: [1, 0, 1] },
+            { indexes: [1, 0, 2] },
+            { indexes: [1, 1, 0] },
+            { indexes: [1, 1, 1] },
+            { indexes: [1, 1, 2] },
+            { indexes: [1, 2, 0] },
+            { indexes: [1, 2, 1] },
+            { indexes: [1, 2, 2] },
+            { indexes: [2, 0, 0] },
+            { indexes: [2, 0, 1] }
           ]
         ]
       ]
@@ -221,7 +220,7 @@ describe('refineLayoutSize tests', () => {
       })(layoutIndexes)
     ).to.deep.equal(expected);
   });
-  it('no rows', () => {
+  /*it('no rows', () => {
 
     const layout = {
       header: [{ __index: 0 }, { __index: 1 }, { __index: 2 }],
@@ -3121,5 +3120,5 @@ describe('refineLayoutSize tests', () => {
         limit: 800,
       })(indexes)
     ).to.deep.equal(expected);
-  });
+  });*/
 });

package/test/refinedDimensions.test.js

@@ -22,14 +22,14 @@ describe('refine dimensions tests', () => {
 
     expect(refineDimensions(dimensions, dataquery)).to.deep.equal([
       { id: 'd0', values: [], header: true },
-      { id: 'd1', values: [{ id: 'v0' }], header: true },
-      { id: 'd2', values: [{ id: 'v0' }, { id: 'v1', empty: true }, { id: 'v2', empty: true }], header: true },
-      { id: 'd3', values: [{ id: 'v0' }, { id: 'v1' }, { id: 'v2', empty: true }], header: false },
-      { id: 'd4', values: [{ id: 'v0' }, { id: 'v1' }, { id: 'v2' }], header: false },
-      { id: 'd5', values: [{ id: 'v0' }], header: true },
-      { id: 'd6', values: [{ id: 'v0' }, { id: 'v1' }], header: false },
-      { id: 'd7', values: [{ id: 'v0' }], header: true },
-      { id: 'd8', values: [{ id: 'v0' }, { id: 'v1' }], header: false }
+      { id: 'd1', values: [{ id: 'v0', isSelected: true }], header: true },
+      { id: 'd2', values: [{ id: 'v0', isSelected: true }, { id: 'v1', empty: true }, { id: 'v2', empty: true }], header: true },
+      { id: 'd3', values: [{ id: 'v0', isSelected: true }, { id: 'v1', isSelected: true }, { id: 'v2', empty: true }], header: false },
+      { id: 'd4', values: [{ id: 'v0', isSelected: true }, { id: 'v1', isSelected: true }, { id: 'v2', isSelected: true }], header: false },
+      { id: 'd5', values: [{ id: 'v0', isSelected: true }], header: true },
+      { id: 'd6', values: [{ id: 'v0', isSelected: true }, { id: 'v1', isSelected: true }], header: false },
+      { id: 'd7', values: [{ id: 'v0', isSelected: true }], header: true },
+      { id: 'd8', values: [{ id: 'v0', isSelected: true }, { id: 'v1', isSelected: true }], header: false }
     ]);
   })
 });

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

@@ -1,209 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getLayoutData = 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 _getCombinationDimensionsData = require('./getCombinationDimensionsData');
-
-var _parseValueHierarchy = require('./parseValueHierarchy');
-
-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 getSubLayoutData = function getSubLayoutData(series, _definition, _ref) {
-  var metadataCoordinates = _ref.metadataCoordinates,
-      attributesSeries = _ref.attributesSeries,
-      customAttributes = _ref.customAttributes,
-      _ref$topCoordinates = _ref.topCoordinates,
-      topCoordinates = _ref$topCoordinates === undefined ? {} : _ref$topCoordinates;
-
-  var getHasAdvancedAttributes = function getHasAdvancedAttributes(attrValues) {
-    return R.pipe(R.omit(R.concat(customAttributes.flags, customAttributes.notes)), R.isEmpty, R.not)(attrValues);
-  };
-
-  var combinationConceptIds = R.reduce(function (acc, def) {
-    var concepts = R.propOr([], 'concepts', def);
-    if (R.isEmpty(concepts)) {
-      return acc;
-    }
-    return R.concat(acc, concepts);
-  }, [], _definition);
-
-  var definition = R.map( //used for parseValueHierarchy ...
-  function (entry) {
-    if (R.has('dimensions', entry)) {
-      return (0, _extends3.default)({}, entry, {
-        dimensions: R.map(function (dim) {
-          return R.assoc('indexedValues', R.indexBy(R.prop('id'), dim.values || []), dim);
-        }, entry.dimensions)
-      });
-    }
-    return R.assoc('indexedValues', R.indexBy(R.prop('id'), entry.values || []), entry);
-  }, _definition);
-
-  var _R$reduce = R.reduce(function (acc, serie) {
-    var data = [];
-    var next = [];
-    var sameSerie = true;
-    var i = 0;
-    var hasAdvancedAttributes = false;
-    var coordinates = topCoordinates;
-    var ids = [];
-    while (i < serie.length) {
-      var entry = serie[i];
-      if (R.is(Array, entry)) {
-        var combination = definition[i];
-        var previousDimValues = R.nth(i, acc.previous);
-        var combData = (0, _getCombinationDimensionsData.getCombinationDimensionsData)(entry, combination, previousDimValues, sameSerie);
-        data = R.append({
-          dimension: R.pick(['id', 'name'], combination),
-          dimValues: combData.dimValues
-        }, data);
-        next = R.append(combData.dimValues, next);
-        hasAdvancedAttributes = !hasAdvancedAttributes ? combData.hasAdvancedAttributes : true;
-        sameSerie = combData.sameSerie;
-        coordinates = (0, _extends3.default)({}, coordinates, combData.coordinates);
-        ids = R.concat(ids, combData.ids);
-      } else {
-        var dimension = definition[i];
-        var value = R.nth(Math.abs(entry), dimension.values || []);
-        var previousValue = R.nth(i, acc.previous) || {};
-        coordinates = R.assoc(dimension.id, value.id, coordinates);
-        ids = R.append(dimension.id + '=' + value.id, ids);
-        if ((0, _parseValueHierarchy.isSameValueAsPrevious)(value, previousValue) && sameSerie) {
-          next = R.append(previousValue, next);
-          data = R.append({
-            dimension: R.pick(['id', 'name', '__index'], dimension),
-            value: previousValue
-          }, data);
-        } else {
-          hasAdvancedAttributes = !hasAdvancedAttributes ? value.hasAdvancedAttributes : true;
-          var parsedValue = (0, _parseValueHierarchy.parseValueHierarchy)(value, sameSerie ? previousValue || {} : {}, dimension.indexedValues);
-          next = R.append(parsedValue, next);
-          data = R.append({
-            dimension: R.pick(['id', 'name', '__index'], dimension),
-            value: parsedValue
-          }, data);
-          if (!R.isNil(acc.previous)) {
-            sameSerie = false;
-          }
-        }
-      }
-      i++;
-    }
-
-    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)) {
-        return R.append(entry, acc);
-      }
-      var dimValues = entry.dimValues,
-          dimension = entry.dimension;
-
-      var def = R.nth(ind, definition);
-      if (!R.propOr(true, 'display', def)) {
-        return acc;
-      }
-      var fixedDimValues = R.propOr([], 'fixedDimValues', def);
-      var values = R.reduce(function (_acc, id) {
-        if (R.has(id, dimValues)) {
-          var _value = R.prop(id, dimValues);
-          return R.append(_value, _acc);
-        }
-        if (R.has(id, fixedDimValues)) {
-          return R.append(R.prop(id, fixedDimValues), _acc);
-        }
-        if (!R.has(id, attributesValues)) {
-          return _acc;
-        }
-        return R.append(R.path([id, 'value'], attributesValues), _acc);
-      }, [], def.concepts);
-      return R.append({ dimension: dimension, values: values }, acc);
-    }, [], data);
-
-    var layoutAttrValues = R.reject(R.prop('isObs'), R.omit(combinationConceptIds, attributesValues));
-
-    var flags = (0, _getFlagsAndNotes.getFlagsAndNotes)(layoutAttrValues, customAttributes);
-    var hasMetadata = !R.isNil(R.find(coordinatesValidator, metadataCoordinates));
-
-    if (!hasAdvancedAttributes) {
-      hasAdvancedAttributes = getHasAdvancedAttributes(layoutAttrValues);
-    }
-
-    var sideProps = hasMetadata || hasAdvancedAttributes ? { hasMetadata: hasMetadata, hasAdvancedAttributes: hasAdvancedAttributes, coordinates: coordinates } : null;
-
-    return {
-      res: R.append({ data: data, key: R.join(':', ids), flags: flags, sideProps: sideProps, coordinates: coordinates }, acc.res),
-      previous: next
-    };
-  }, { res: [], previous: [] }, series),
-      res = _R$reduce.res;
-
-  return res;
-};
-
-var getLayoutData = function getLayoutData(layoutIndexes, layout, _ref2) {
-  var metadataCoordinates = _ref2.metadataCoordinates,
-      attributesSeries = _ref2.attributesSeries,
-      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, topCoordinates: topCoordinates };
-  var headerData = getSubLayoutData(header, layout.header, opts);
-  var sectionsData = R.pipe(R.transpose, function (_ref3) {
-    var _ref4 = (0, _slicedToArray3.default)(_ref3, 2),
-        sections = _ref4[0],
-        sectionsRows = _ref4[1];
-
-    if (R.isNil(sections)) {
-      return [];
-    }
-    var _sectionsData = getSubLayoutData(sections, layout.sections, opts);
-    var rowsData = R.addIndex(R.map)(function (rows, sectionIndex) {
-      var sectionCoordinates = R.path([sectionIndex, 'coordinates'], _sectionsData);
-      return getSubLayoutData(rows, layout.rows, R.assoc('topCoordinates', sectionCoordinates, opts));
-    }, sectionsRows);
-
-    return R.transpose([_sectionsData, rowsData]);
-  })(sections);
-
-  return (0, _extends3.default)({ headerData: headerData, sectionsData: sectionsData }, rest);
-};
-exports.getLayoutData = getLayoutData;