@sis-cc/dotstatsuite-components 9.1.3 → 9.2.0

package/test/parseAttributes.test.js

@@ -1,6 +1,6 @@
 import { expect } from 'chai';
 import { parseAttributes } from '../src/rules/src/table/preparators/parseAttributes';
-import { getDisplay } from '../src/rules/src/table/preparators/getDisplay';
+import { getDisplay } from '../src/rules/src/preparators/getDisplay';
 
 const noDisplayIndexes = [0, 5, 10];
 const notDisplayedCodes = { a17: { id: 'a17' }, a18: { values: { a18v2: 'a18v2' } } };

package/test/refineLayoutSize.test.js

@@ -0,0 +1,415 @@
+import { expect } from 'chai';
+import { refineLayoutSize } from '../src/rules/src/table/factories/refineLayoutSize';
+
+const observations1 = {
+  '0:0:0': { orderedDimIndexes: [0, 0, 0] },
+  '0:0:1': { orderedDimIndexes: [0, 0, 1] },
+  '0:0:2': { orderedDimIndexes: [0, 0, 2] },
+  '0:1:0': { orderedDimIndexes: [0, 1, 0] },
+  '0:1:1': { orderedDimIndexes: [0, 1, 1] },
+  '0:1:2': { orderedDimIndexes: [0, 1, 2] },
+  '0:2:0': { orderedDimIndexes: [0, 2, 0] },
+  '0:2:1': { orderedDimIndexes: [0, 2, 1] },
+  '0:2:2': { orderedDimIndexes: [0, 2, 2] },
+  '1:0:0': { orderedDimIndexes: [1, 0, 0] },
+  '1:0:1': { orderedDimIndexes: [1, 0, 1] },
+  '1:0:2': { orderedDimIndexes: [1, 0, 2] },
+  '1:1:0': { orderedDimIndexes: [1, 1, 0] },
+  '1:1:1': { orderedDimIndexes: [1, 1, 1] },
+  '1:1:2': { orderedDimIndexes: [1, 1, 2] },
+  '1:2:0': { orderedDimIndexes: [1, 2, 0] },
+  '1:2:1': { orderedDimIndexes: [1, 2, 1] },
+  '1:2:2': { orderedDimIndexes: [1, 2, 2] },
+  '2:0:0': { orderedDimIndexes: [2, 0, 0] },
+  '2:0:1': { orderedDimIndexes: [2, 0, 1] },
+  '2:0:2': { orderedDimIndexes: [2, 0, 2] },
+  '2:1:0': { orderedDimIndexes: [2, 1, 0] },
+  '2:1:1': { orderedDimIndexes: [2, 1, 1] },
+  '2:1:2': { orderedDimIndexes: [2, 1, 2] },
+  '2:2:0': { orderedDimIndexes: [2, 2, 0] },
+  '2:2:1': { orderedDimIndexes: [2, 2, 1] },
+  '2:2:2': { orderedDimIndexes: [2, 2, 2] },
+};
+
+const partialObservations1 = {
+  '0:0:0': { orderedDimIndexes: [0, 0, 0] },
+  '0:0:1': { orderedDimIndexes: [0, 0, 1] },
+  '0:0:2': { orderedDimIndexes: [0, 0, 2] },
+  '0:1:0': { orderedDimIndexes: [0, 1, 0] },
+  '0:1:1': { orderedDimIndexes: [0, 1, 1] },
+  '0:1:2': { orderedDimIndexes: [0, 1, 2] },
+  '0:2:0': { orderedDimIndexes: [0, 2, 0] },
+  '0:2:1': { orderedDimIndexes: [0, 2, 1] },
+  '0:2:2': { orderedDimIndexes: [0, 2, 2] },
+  '1:2:0': { orderedDimIndexes: [1, 2, 0] },
+  '1:2:1': { orderedDimIndexes: [1, 2, 1] },
+  '1:2:2': { orderedDimIndexes: [1, 2, 2] },
+  '2:0:0': { orderedDimIndexes: [2, 0, 0] },
+  '2:0:1': { orderedDimIndexes: [2, 0, 1] },
+  '2:0:2': { orderedDimIndexes: [2, 0, 2] },
+  '2:1:0': { orderedDimIndexes: [2, 1, 0] },
+  '2:1:1': { orderedDimIndexes: [2, 1, 1] },
+  '2:1:2': { orderedDimIndexes: [2, 1, 2] },
+  '2:2:0': { orderedDimIndexes: [2, 2, 0] },
+  '2:2:1': { orderedDimIndexes: [2, 2, 1] },
+  '2:2:2': { orderedDimIndexes: [2, 2, 2] },
+};
+
+const partialObservations2 = {
+  '0:0:0': { orderedDimIndexes: [0, 0, 0] },
+  '0:1:0': { orderedDimIndexes: [0, 1, 0] },
+  '0:2:0': { orderedDimIndexes: [0, 2, 0] },
+  '1:0:0': { orderedDimIndexes: [1, 0, 0] },
+  '1:1:0': { orderedDimIndexes: [1, 1, 0] },
+  '1:2:0': { orderedDimIndexes: [1, 2, 0] },
+  '2:0:0': { orderedDimIndexes: [2, 0, 0] },
+  '2:0:1': { orderedDimIndexes: [2, 0, 1] },
+  '2:0:2': { orderedDimIndexes: [2, 0, 2] },
+  '2:1:0': { orderedDimIndexes: [2, 1, 0] },
+  '2:1:1': { orderedDimIndexes: [2, 1, 1] },
+  '2:1:2': { orderedDimIndexes: [2, 1, 2] },
+  '2:2:0': { orderedDimIndexes: [2, 2, 0] },
+  '2:2:1': { orderedDimIndexes: [2, 2, 1] },
+  '2:2:2': { orderedDimIndexes: [2, 2, 2] },
+};
+
+/*
+    |  0  |  1  |  2  |
+    |0|1|2|0|1|2|0|1|2|
+  |0|-|-|-|-|-|-|x|x|x|
+  |1|x|x|x|x|x|x|x|x|x|
+  |2|-|-|-|-|-|-|x|x|x|
+*/
+
+const partialObservations3 = {
+  '0:0:2': { orderedDimIndexes: [0, 0, 2] },
+  '0:1:0': { orderedDimIndexes: [0, 1, 0] },
+  '0:1:1': { orderedDimIndexes: [0, 1, 1] },
+  '0:1:2': { orderedDimIndexes: [0, 1, 2] },
+  '0:2:2': { orderedDimIndexes: [0, 2, 2] },
+  '1:0:2': { orderedDimIndexes: [1, 0, 2] },
+  '1:1:0': { orderedDimIndexes: [1, 1, 0] },
+  '1:1:1': { orderedDimIndexes: [1, 1, 1] },
+  '1:1:2': { orderedDimIndexes: [1, 1, 2] },
+  '1:2:2': { orderedDimIndexes: [1, 2, 2] },
+  '2:0:2': { orderedDimIndexes: [2, 0, 2] },
+  '2:1:0': { orderedDimIndexes: [2, 1, 0] },
+  '2:1:1': { orderedDimIndexes: [2, 1, 1] },
+  '2:1:2': { orderedDimIndexes: [2, 1, 2] },
+  '2:2:2': { orderedDimIndexes: [2, 2, 2] },
+};
+
+describe('refineLayoutSize tests', () => {
+  it('no changes under limit', () => {
+    const layout = {
+      header: [{ __index: 0 }],
+      sections: [{ __index: 1 }],
+      rows: [{ __index: 2 }]
+    };
+
+    const layoutIndexes = {
+      header: [[0], [1], [2]],
+      sections: [
+        [[0], [[0], [1], [2]]],
+        [[1], [[0], [1], [2]]],
+        [[2], [[0], [1], [2]]]
+      ]
+    };
+
+    const expected = {
+      truncated: false,
+      header: [[0], [1], [2]],
+      sections: [
+        [[0], [[0], [1], [2]]],
+        [[1], [[0], [1], [2]]],
+        [[2], [[0], [1], [2]]]
+      ]
+    };
+    expect(
+      refineLayoutSize({
+        layout,
+        observations: observations1,
+        limit: 60,
+      })(layoutIndexes)
+    ).to.deep.equal(expected);
+  });
+  it('no headers', () => {
+    const layout = {
+      header: [],
+      sections: [],
+      rows: [{ __index: 0 }, { __index: 1 }, { __index: 2 }]
+    };
+
+    const layoutIndexes = {
+      header: [[]],
+      sections: [
+        [
+          [],
+          [
+            [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]
+          ]
+        ]
+      ]
+    };
+
+    const expected = {
+      truncated: true,
+      header: [[]],
+      sections: [
+        [
+          [],
+          [
+            [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]
+          ]
+        ]
+      ]
+    };
+
+    expect(
+      refineLayoutSize({
+        layout,
+        observations: observations1,
+        limit: 105
+      })(layoutIndexes)
+    ).to.deep.equal(expected);
+  });
+  it('no rows', () => {
+
+    const layout = {
+      header: [{ __index: 0 }, { __index: 1 }, { __index: 2 }],
+      sections: [],
+      rows: [],
+    };
+
+    const layoutIndexes = {
+      header: [
+        [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]
+      ],
+      sections: [[[], [[]]]],
+    };
+
+    const expected = {
+      truncated: true,
+      header: [
+        [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]
+      ],
+      sections: [[[], [[]]]],
+    };
+    expect(
+      refineLayoutSize({
+        layout,
+        observations: observations1,
+        limit: 105
+      })(layoutIndexes)
+    ).to.deep.equal(expected);
+  });
+  it('some empty headers to clean after cut', () => {
+    const layout = {
+      header: [{ __index: 0 }],
+      sections: [{ __index: 1 }],
+      rows: [{ __index: 2 }]
+    };
+
+    const layoutIndexes = {
+      header: [[0], [1], [2]],
+      sections: [
+        [[0], [[0], [1], [2]]],
+        [[1], [[0], [1], [2]]],
+        [[2], [[0], [1], [2]]]
+      ]
+    };
+
+    const expected = {
+      truncated: true,
+      header: [[0],[2]],
+      sections: [
+        [[0], [[0], [1], [2]]],
+        [[1], [[0], [1], [2]]]
+      ]
+    };
+
+    expect(
+      refineLayoutSize({
+        layout,
+        observations: partialObservations1,
+        limit: 45,
+      })(layoutIndexes)
+    ).to.deep.equal(expected);
+  });
+  it('multiple empty rows to clean after cut', () => {
+    const layout = {
+      header: [{ __index: 0 }, { __index: 1 }],
+      sections: [],
+      rows: [{ __index: 2 }],
+    };
+
+    const layoutIndexes = {
+      header: [
+        [0, 0],
+        [0, 1],
+        [0, 2],
+        [1, 0],
+        [1, 1],
+        [1, 2],
+        [2, 0],
+        [2, 1],
+        [2, 2]
+      ],
+      sections: [[[], [[0], [1], [2]]]]
+    };
+
+    const expected = {
+      truncated:true,
+      header: [
+        [0, 0],
+        [0, 1],
+        [0, 2],
+        [1, 0],
+        [1, 1],
+        [1, 2],
+      ],
+      sections: [[[], [[0]]]]
+    };
+
+    expect(
+      refineLayoutSize({
+        layout,
+        observations: partialObservations2,
+        limit: 50,
+      })(layoutIndexes)
+    ).to.deep.equal(expected);
+  });
+  it('multiple empty rows to clean after cut with mixed dimensions order in header', () => {
+    const layout = {
+      header: [{ __index: 2 }, { __index: 0 }],
+      sections: [],
+      rows: [{ __index: 1 }],
+    };
+
+    const layoutIndexes = {
+      header: [
+        [0, 0],
+        [0, 1],
+        [0, 2],
+        [1, 0],
+        [1, 1],
+        [1, 2],
+        [2, 0],
+        [2, 1],
+        [2, 2]
+      ],
+      sections: [[[], [[0], [1], [2]]]]
+    };
+
+    const expected = {
+      truncated: true,
+      header: [
+        [0, 0],
+        [0, 1],
+        [0, 2],
+        [1, 0],
+        [1, 1],
+        [1, 2]
+      ],
+      sections: [[[], [[1]]]]
+    };
+
+    expect(
+      refineLayoutSize({
+        layout,
+        observations: partialObservations3,
+        limit: 50,
+      })(layoutIndexes)
+    ).to.deep.equal(expected);
+  });
+});

package/test/table-layout-perf.test.js

@@ -0,0 +1,74 @@
+import { expect } from 'chai';
+import { getSortedLayoutIndexes } from '../src/rules/src/table/factories/getSortedLayoutIndexes';
+import { refineLayoutSize } from '../src/rules/src/table/factories/refineLayoutSize';
+import { getLayoutData } from '../src/rules/src/table/factories/getLayoutData';
+import multiHierRowsLayout from './mocks/table-layout-multi-hierarchies--layout.json'
+import multiHierRowsObs from './mocks/table-layout-multi-hierarchies--observations.json'
+import multiHierRowsLayoutIndexes from './mocks/table-layout-multi-hierarchies--layoutIndexes.json'
+import multiHierRowsSizedIndexes from './mocks/table-layout-multi-hierarchies--sizedIndexes.json'
+import multiHierRowsLayoutData from './mocks/table-layout-multi-hierarchies--layoutData.json'
+import truncation1Layout from './mocks/table-layout-truncation1--layout.json'
+import truncation1Obs from './mocks/table-layout-truncation1--observations.json'
+import truncation1LayoutIndexes from './mocks/table-layout-truncation1--layoutIndexes.json'
+import truncation1SizedIndexes from './mocks/table-layout-truncation1--sizedIndexes.json'
+import truncation1LayoutData from './mocks/table-layout-truncation1--layoutData.json'
+import * as R from 'ramda';
+
+describe('table LayoutData performance tests', () => {
+  it('multi hierarchical rows getSortedLayoutIndexes test', function() {
+    this.timeout(2000);
+    expect(
+      getSortedLayoutIndexes(multiHierRowsLayout, multiHierRowsObs)
+    ).to.deep.equal(multiHierRowsLayoutIndexes);
+  });
+  it('multi hierarchical rows refineLayoutSize test', function() {
+    this.timeout(2000);
+    expect(
+      refineLayoutSize({ layout: multiHierRowsLayout, observations: multiHierRowsObs, limit: 3000 })(multiHierRowsLayoutIndexes)
+    ).to.deep.equal(multiHierRowsSizedIndexes);
+  });
+  it('multi hierarchical rows getLayoutData test', function() {
+    this.timeout(2000);
+    expect(
+      getLayoutData(multiHierRowsSizedIndexes, multiHierRowsLayout)
+    ).to.deep.equal(multiHierRowsLayoutData);
+  });
+  it('multi hierarchical rows test', function() {
+    this.timeout(2000);
+    expect(
+      R.pipe(
+        getSortedLayoutIndexes,
+        refineLayoutSize({ layout: multiHierRowsLayout, observations: multiHierRowsObs, limit: 3000 }),
+        indexes => getLayoutData(indexes, multiHierRowsLayout)
+      )(multiHierRowsLayout, multiHierRowsObs)
+    ).to.deep.equal(multiHierRowsLayoutData);
+  });
+  it('truncation1 getSortedLayoutIndexes test', function() {
+    this.timeout(2000);
+    expect(
+      getSortedLayoutIndexes(truncation1Layout, truncation1Obs)
+    ).to.deep.equal(truncation1LayoutIndexes);
+  });
+  it('truncation1 refineLayoutSize test', function() {
+    this.timeout(2000);
+    expect(
+      refineLayoutSize({ layout: truncation1Layout, observations: truncation1Obs, limit: 3000 })(truncation1LayoutIndexes)
+    ).to.deep.equal(truncation1SizedIndexes);
+  });
+  it('truncation1 getLayoutData test', function() {
+    this.timeout(2000);
+    expect(
+      getLayoutData(truncation1SizedIndexes, truncation1Layout)
+    ).to.deep.equal(truncation1LayoutData);
+  });
+  it('truncation1 test', function() {
+    this.timeout(2500);
+    expect(
+      R.pipe(
+        getSortedLayoutIndexes,
+        refineLayoutSize({ layout: truncation1Layout, observations: truncation1Obs, limit: 3000 }),
+        indexes => getLayoutData(indexes, truncation1Layout)
+      )(truncation1Layout, truncation1Obs)
+    ).to.deep.equal(truncation1LayoutData);
+  });
+});

package/test/table-prep-perf.test.js

@@ -0,0 +1,65 @@
+import { expect } from 'chai';
+import { enhanceObservations } from '../src/rules/src/preparators/enhanceObservations';
+import { getUnitsSeries } from '../src/rules/src/table/units/getUnitsSeries';
+import multiHierRowsDim from './mocks/table-prep-multi-hierarchies--dimensions.json';
+import multiHierRowsAttr from './mocks/table-prep-multi-hierarchies--attributes.json';
+import multiHierRowsObs from './mocks/table-prep-multi-hierarchies--observations.json';
+import multiHierEnhancedObs from './mocks/table-prep-multi-hierarchies--enhancedObservations.json';
+
+import truncate1Dim from './mocks/table-prep-truncation1--dimensions.json';
+import truncate1Obs from './mocks/table-prep-truncation1--observations.json';
+import truncate1EnhancedObs from './mocks/table-prep-truncation1--enhancedObservations.json';
+
+import unitsObs from './mocks/table-prep-units--observations.json';
+import unitsSeries from './mocks/table-prep-units--unitsSeries.json';
+
+import numeral from 'numeral';
+
+numeral.register('locale', 'test', { delimiters: { thousands: " ", decimal: "."  } });
+describe('table preparators performance tests', () => {
+  it('multi hierarchical rows enhanceObservations test', function() {
+    numeral.locale('test');
+    this.timeout(3000);
+    const options = {
+      attachmentSeriesIndexes: [],
+      attributesIds: ['OBS_STATUS'],
+      customAttributes: {
+        flags: ['OBS_STATUS', 'CONF_STATUS'],
+        decimals: 'DECIMALS',
+        prefscale: 'PREF_SCALE'
+      },
+      noDisplayIndexes: [4],
+      notDisplayedCodes: {
+        OBS_STATUS: { id: 'OBS_STATUS', values: { A: 'A' } },
+        UNIT_MULT: { id: 'UNIT_MULT', values: { '0': '0' } }
+      },
+      unitsIds: ['UNIT_MEASURE', 'UNIT_MULT', 'BASE_PER']
+    };
+    expect(
+      enhanceObservations(multiHierRowsDim, multiHierRowsObs, multiHierRowsAttr, options)
+    ).to.deep.equal(multiHierEnhancedObs);
+  });
+  it('2500 observations enhanceObservations test', function() {
+    numeral.locale('test');
+    this.timeout(5000);
+    const options = {
+      attachmentSeriesIndexes: [],
+      attributesIds: [],
+      customAttributes: {
+        flags: ['OBS_STATUS', 'CONF_STATUS'],
+        decimals: 'DECIMALS',
+        prefscale: 'PREF_SCALE'
+      },
+      noDisplayIndexes: [],
+      notDisplayedCodes: {},
+      unitsIds: ['UNIT_MEASURE', 'UNIT_MULT', 'BASE_PER']
+    };
+    expect(
+      enhanceObservations(truncate1Dim, truncate1Obs, [], options)
+    ).to.deep.equal(truncate1EnhancedObs);
+  });
+  it('1800 observations getUnitsSeries test', function() {
+    this.timeout(5000);
+    expect(getUnitsSeries(unitsObs)).to.deep.equal(unitsSeries);
+  })
+});

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

@@ -1,145 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getSortedLayoutData = undefined;
-
-var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
-
-var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
-
-var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');
-
-var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
-
-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 getSublayoutIndexToPositionPivots = function getSublayoutIndexToPositionPivots(dimensions) {
-  return R.map(function (dimension) {
-    var indexedPositions = R.reduce( // => [(entryIndex) : { ...val, __index }] => { [__index]: entryIndex }
-    function (acc, value) {
-      return (0, _extends4.default)({}, acc, (0, _defineProperty3.default)({}, R.prop('__index', value), R.prop('__indexPosition', value)));
-    }, {}, R.prop('values', dimension));
-
-    return function (splitKey) {
-      return R.pipe(R.nth(R.prop('__index', dimension)), function (index) {
-        return R.prop(index, indexedPositions);
-      })(splitKey);
-    };
-  }, dimensions);
-};
-
-var coordinatesToSublayoutData = function coordinatesToSublayoutData(sublayout, coordinates) {
-  return R.addIndex(R.map)(function (valueIndex, dimensionIndex) {
-    var sublayoutDimension = R.nth(dimensionIndex, sublayout);
-    var value = R.find(R.propEq('__indexPosition', valueIndex), R.prop('values', sublayoutDimension));
-    return {
-      dimension: R.pick(['id', 'name', '__index'], sublayoutDimension),
-      value: value
-    };
-  }, coordinates);
-};
-
-var getSortedLayoutData = exports.getSortedLayoutData = function getSortedLayoutData(layout, observations) {
-  var headersPivots = getSublayoutIndexToPositionPivots(R.prop('header', layout));
-  var rowsPivots = getSublayoutIndexToPositionPivots(R.prop('rows', layout));
-  var sectionsPivots = getSublayoutIndexToPositionPivots(R.prop('sections', layout));
-
-  var rowsSize = R.length(R.prop('rows', layout));
-  var sectionsSize = R.length(R.prop('sections', layout));
-
-  var sortedLayoutPositions = R.pipe(R.keys, R.map(function (key) {
-    var splitKey = R.split(':', key);
-    return R.converge(function () {
-      for (var _len = arguments.length, rest = Array(_len), _key = 0; _key < _len; _key++) {
-        rest[_key] = arguments[_key];
-      }
-
-      return rest;
-    }, [].concat((0, _toConsumableArray3.default)(sectionsPivots), (0, _toConsumableArray3.default)(rowsPivots), (0, _toConsumableArray3.default)(headersPivots)))(splitKey);
-  }), R.map(function (coordinates) {
-    var _R$splitAt = R.splitAt(sectionsSize, coordinates),
-        _R$splitAt2 = (0, _slicedToArray3.default)(_R$splitAt, 2),
-        sections = _R$splitAt2[0],
-        tail = _R$splitAt2[1];
-
-    var _R$splitAt3 = R.splitAt(rowsSize, tail),
-        _R$splitAt4 = (0, _slicedToArray3.default)(_R$splitAt3, 2),
-        rows = _R$splitAt4[0],
-        headers = _R$splitAt4[1];
-
-    return { headers: headers, rows: rows, sections: sections };
-  }))(observations);
-
-  var headerData = R.pipe(R.pluck('headers'), R.uniq, R.map(function (coordinates) {
-    return coordinatesToSublayoutData(R.prop('header', layout), coordinates);
-  }), function (headerData) {
-    if (R.isEmpty(headerData)) {
-      return headerData;
-    }
-    var comparators = R.pipe(R.head, R.length, function (length) {
-      return R.times(R.identity, length);
-    }, R.map(function (index) {
-      return R.ascend(R.pathOr(0, [index, 'value', '__indexPosition']));
-    }))(headerData);
-
-    return R.sortWith(comparators)(headerData);
-  })(sortedLayoutPositions);
-
-  var sectionsData = R.pipe(R.reduce(function (acc, layout) {
-    var sections = layout.sections;
-
-    var index = R.findIndex(R.pathEq([0, 'sections'], sections))(acc);
-    if (index === -1) {
-      return R.append([layout], acc);
-    }
-    return R.over(R.lensIndex(index), R.append(layout))(acc);
-  }, []), R.map(function (entries) {
-    var sectionData = coordinatesToSublayoutData(R.prop('sections', layout), R.prop('sections', R.head(entries)));
-    var rowsData = R.map(function (coordinates) {
-      return coordinatesToSublayoutData(R.prop('rows', layout), coordinates);
-    }, R.uniq(R.pluck('rows', entries)));
-    return [sectionData, rowsData];
-  }), function (sData) {
-    //sort sections
-    if (R.isEmpty(sData) || R.isEmpty(R.head(R.head(sData)))) {
-      return sData;
-    }
-    var comparators = R.pipe(R.head, R.head, R.length, function (length) {
-      return R.times(R.identity, length);
-    }, R.map(function (index) {
-      return R.ascend(R.pathOr(0, [0, index, 'value', '__indexPosition']));
-    }))(sData);
-
-    return R.sortWith(comparators)(sData);
-  }, function (sData) {
-    //sort rows
-    if (R.isEmpty(sData) || R.isEmpty(R.last(R.head(sData)))) {
-      return sData;
-    }
-    var comparators = R.pipe(R.head, R.last, R.head, R.length, function (length) {
-      return R.times(R.identity, length);
-    }, R.map(function (index) {
-      return R.ascend(R.pathOr(0, [index, 'value', '__indexPosition']));
-    }))(sData);
-
-    return R.map(R.over(R.lensIndex(1), R.sortWith(comparators)))(sData);
-  })(sortedLayoutPositions);
-
-  return { headerData: headerData, sectionsData: sectionsData };
-};