@sis-cc/dotstatsuite-components 17.12.6 → 17.14.0

package/test/{hierarchiseDimensionWithAdvancedHierarchy.test.js → hierarchiseDimensionWithAdvancedHierarchy2.test.js}

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { hierarchiseDimensionWithAdvancedHierarchy } from '../src/rules2/src/hierarchiseDimensionWithAdvancedHierarchy';
+import { hierarchiseDimensionWithAdvancedHierarchy } from '../src/rules2/src/hierarchiseDimensionWithAdvancedHierarchy2';
 
 describe('hierarchiseDimensionWithAdvancedHierarchy tests', () => {
   it('basic test', () => {
@@ -26,16 +26,16 @@ describe('hierarchiseDimensionWithAdvancedHierarchy tests', () => {
     const hierarchised = {
       id: 'test',
       values: [
-        { id: 'OECD', parent: undefined, parents: [] },
-        { id: 'GER', parent: 'OECD', parents: ['OECD'] },
-        { id: 'FRA', parent: 'OECD', parents: ['OECD'] },
-        { id: 'USA', parent: 'OECD', parents: ['OECD'] },
-        { id: 'A', parent: undefined, parents: [] },
-        { id: 'USA', parent: 'A', parents: ['A'] },
-        { id: 'MEX', parent: 'A', parents: ['A'] },
-        { id: 'EA', parent: undefined, parents: [] },
-        { id: 'FRA', parent: 'EA', parents: ['EA'] },
-        { id: 'GER', parent: 'EA', parents: ['EA'] },
+        { id: 'OECD', parent: undefined, parents: [], __indexPosition: 0 },
+        { id: 'GER', parent: 'OECD', parents: [0], __indexPosition: 1 },
+        { id: 'FRA', parent: 'OECD', parents: [0], __indexPosition: 2 },
+        { id: 'USA', parent: 'OECD', parents: [0], __indexPosition: 3 },
+        { id: 'A', parent: undefined, parents: [], __indexPosition: 4 },
+        { id: 'USA', parent: 'A', parents: [4], __indexPosition: 5 },
+        { id: 'MEX', parent: 'A', parents: [4], __indexPosition: 6 },
+        { id: 'EA', parent: undefined, parents: [], __indexPosition: 7 },
+        { id: 'FRA', parent: 'EA', parents: [7], __indexPosition: 8 },
+        { id: 'GER', parent: 'EA', parents: [7], __indexPosition: 9 },
       ]
     }
 
@@ -70,15 +70,15 @@ describe('hierarchiseDimensionWithAdvancedHierarchy tests', () => {
     const hierarchised = {
       id: 'test',
       values: [
-        { id: 'AFK', parent: undefined, parents: [], __indexPosition: 3 },
-        { id: 'USA', parent: undefined, parents: [], __indexPosition: 2 },
-        { id: 'CAN', parent: undefined, parents: [], __indexPosition: 1 },
-        { id: 'W', parent: undefined, parents: [], __indexPosition: 8 },
-        { id: 'EA', parent: 'W', parents: ['W'], __indexPosition: 6 },
-        { id: 'FRA', parent: 'EA', parents: ['W', 'EA'], __indexPosition: 5 },
-        { id: 'IDF', parent: 'FRA', parents: ['W', 'EA', 'FRA'], __indexPosition: 0 },
-        { id: 'GER', parent: 'EA', parents: ['W', 'EA'], __indexPosition: 4 },
-        { id: 'A', parent: 'W', parents: ['W'], __indexPosition: 7 },
+        { id: 'AFK', parent: undefined, parents: [], __indexPosition: 0 },
+        { id: 'USA', parent: undefined, parents: [], __indexPosition: 1 },
+        { id: 'CAN', parent: undefined, parents: [], __indexPosition: 2 },
+        { id: 'W', parent: undefined, parents: [], __indexPosition: 3 },
+        { id: 'EA', parent: 'W', parents: [3], __indexPosition: 4 },
+        { id: 'FRA', parent: 'EA', parents: [3, 4], __indexPosition: 5 },
+        { id: 'IDF', parent: 'FRA', parents: [3, 4, 5], __indexPosition: 6 },
+        { id: 'GER', parent: 'EA', parents: [3, 4], __indexPosition: 7 },
+        { id: 'A', parent: 'W', parents: [3], __indexPosition: 8 },
       ]
     };
 
@@ -114,18 +114,18 @@ describe('hierarchiseDimensionWithAdvancedHierarchy tests', () => {
     const expected = {
       id: 'test',
       values: [
-        { id: 'OECD', parents: [], parent: undefined },
-        { id: 'USA', parents: ['OECD'], parent: 'OECD' },
-        { id: 'NY', parents: ['OECD', 'USA'], parent: 'USA' },
-        { id: 'SF', parents: ['OECD', 'USA'], parent: 'USA' },
-        { id: 'LA', parents: ['OECD', 'USA'], parent: 'USA' },
-        { id: 'FRA', parents: ['OECD'], parent: 'OECD' },
-        { id: 'IDF', parents: ['OECD', 'FRA'], parent: 'FRA' },
-        { id: 'UE', parents: [], parent: undefined },
-        { id: 'FRA', parents: ['UE'], parent: 'UE' },
-        { id: 'IDF', parents: ['UE', 'FRA'], parent: 'FRA' },
-        { id: 'GER', parents: ['UE'], parent: 'UE' },
-        { id: 'BER', parents: ['UE', 'GER'], parent: 'GER' },
+        { id: 'OECD', parents: [], parent: undefined, __indexPosition: 0 },
+        { id: 'USA', parents: [0], parent: 'OECD', __indexPosition: 1 },
+        { id: 'NY', parents: [0, 1], parent: 'USA', __indexPosition: 2 },
+        { id: 'SF', parents: [0, 1], parent: 'USA', __indexPosition: 3 },
+        { id: 'LA', parents: [0, 1], parent: 'USA', __indexPosition: 4 },
+        { id: 'FRA', parents: [0], parent: 'OECD', __indexPosition: 5 },
+        { id: 'IDF', parents: [0, 5], parent: 'FRA', __indexPosition: 6 },
+        { id: 'UE', parents: [], parent: undefined, __indexPosition: 7 },
+        { id: 'FRA', parents: [7], parent: 'UE', __indexPosition: 8 },
+        { id: 'IDF', parents: [7, 8], parent: 'FRA', __indexPosition: 9 },
+        { id: 'GER', parents: [7], parent: 'UE', __indexPosition: 10 },
+        { id: 'BER', parents: [7, 10], parent: 'GER', __indexPosition: 11 },
       ]
     };
 
@@ -149,46 +149,11 @@ describe('hierarchiseDimensionWithAdvancedHierarchy tests', () => {
     const expected = {
       id: 'REF_AREA',
       values: [
-        { id: 'FRA', parents: [], parent: undefined },
-        { id: 'USA', parents: [], parent: undefined }
+        { id: 'FRA', parents: [], parent: undefined, __indexPosition: 0 },
+        { id: 'USA', parents: [], parent: undefined, __indexPosition: 1 }
       ]
     };
 
     expect(hierarchiseDimensionWithAdvancedHierarchy(dimension, hierarchy)).to.deep.equal(expected);
   });
-  it('non duplicates case 2', () => {
-    const hierarchy = {
-      '#ROOT': ['ONU', 'OECD'],
-      'ONU': ['USA', 'FRA'],
-      'OECD': ['FRA', 'USA'],
-      'ONU.USA': ['NY', 'LA'],
-      'ONU.FRA': ['PA', 'LY']
-    };
-
-    const dimension = {
-      id: 'REF_AREA',
-      values: [
-        { id: 'OECD' },
-        { id: 'FRA' },
-        { id: 'PA' },
-        { id: 'LY' },
-        { id: 'USA' },
-        { id: 'NY' },
-        { id: 'LA' },
-      ]
-    };
-
-    const expected = {
-      id: 'REF_AREA',
-      values: [
-        { id: 'OECD', parents: [], parent: undefined },
-        { id: 'FRA', parents: ['OECD'], parent: 'OECD' },
-        { id: 'PA', parents: ['OECD.FRA'], parent: 'FRA' },
-        { id: 'LY', parents: ['OECD.FRA'], parent: 'FRA' },
-        { id: 'USA', parents: ['OECD'], parent: 'OECD' },
-        { id: 'NY', parents: ['OECD.USA'], parent: 'USA' },
-        { id: 'LA', parents: ['OECD.USA'], parent: 'USA' },
-      ]
-    };
-  });
 });

package/test/{hierarchiseDimensionWithNativeHierarchy.test.js → hierarchiseDimensionWithNativeHierarchy2.test.js}

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { hierarchiseDimensionWithNativeHierarchy } from '../src/rules2/src/hierarchiseDimensionWithNativeHierarchy';
+import { hierarchiseDimensionWithNativeHierarchy } from '../src/rules2/src/hierarchiseDimensionWithNativeHierarchy2';
 
 describe('hierarchiseDimensionWithNativeHierarchy tests', () => {
   it('basic test', () => {
@@ -19,11 +19,11 @@ describe('hierarchiseDimensionWithNativeHierarchy tests', () => {
       id: 'test',
       values: [
         { id: 'CHI', parent: undefined, parents: [], __indexPosition: 0 },
-        { id: 'W', parent: undefined, parents: [], __indexPosition: 5 },
-        { id: 'A', parent: 'W', parents: ['W'], __indexPosition: 20 },
-        { id: 'EA', parent: 'W', parents: ['W'], __indexPosition: 30 },
-        { id: 'GER', parent: 'EA', parents: ['W', 'EA'], __indexPosition: 100 },
-        { id: 'FRA', parent: 'EA', parents: ['W', 'EA'], __indexPosition: 101 }
+        { id: 'W', parent: undefined, parents: [], __indexPosition: 1 },
+        { id: 'A', parent: 'W', parents: [1], __indexPosition: 2 },
+        { id: 'EA', parent: 'W', parents: [1], __indexPosition: 3 },
+        { id: 'GER', parent: 'EA', parents: [1, 3], __indexPosition: 4 },
+        { id: 'FRA', parent: 'EA', parents: [1, 3], __indexPosition: 5 }
       ]
     };
 
@@ -45,10 +45,10 @@ describe('hierarchiseDimensionWithNativeHierarchy tests', () => {
       id: 'test',
       values: [
         { id: 'CHI', parent: undefined, parents: [], __indexPosition: 0 },
-        { id: 'A', parent: undefined, parents: [], __indexPosition: 20 },
-        { id: 'EA', parent: undefined, parents: [], __indexPosition: 30 },
-        { id: 'GER', parent: 'EA', parents: ['EA'], __indexPosition: 100 },
-        { id: 'FRA', parent: 'EA', parents: ['EA'], __indexPosition: 101 }
+        { id: 'A', parent: undefined, parents: [], __indexPosition: 1 },
+        { id: 'EA', parent: undefined, parents: [], __indexPosition: 2 },
+        { id: 'GER', parent: 'EA', parents: [2], __indexPosition: 3 },
+        { id: 'FRA', parent: 'EA', parents: [2], __indexPosition: 4 }
       ]
     };
 
@@ -70,10 +70,10 @@ describe('hierarchiseDimensionWithNativeHierarchy tests', () => {
       id: 'test',
       values: [
         { id: 'CHI', parent: undefined, parents: [], __indexPosition: 0 },
-        { id: 'A', parent: undefined, parents: [], __indexPosition: 20 },
-        { id: 'EA', parent: undefined, parents: [], __indexPosition: 30 },
-        { id: 'GER', parent: 'EA', parents: ['EA'], __indexPosition: 100 },
-        { id: '', parent: undefined, parents: [], __indexPosition: 101 }
+        { id: 'A', parent: undefined, parents: [], __indexPosition: 1 },
+        { id: 'EA', parent: undefined, parents: [], __indexPosition: 2 },
+        { id: 'GER', parent: 'EA', parents: [2], __indexPosition: 3 },
+        { id: '', parent: undefined, parents: [], __indexPosition: 4 }
       ]
     };
 

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/getSidebarData.js

@@ -1,92 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getSidebarData = undefined;
-
-var _extends2 = require('babel-runtime/helpers/extends');
-
-var _extends3 = _interopRequireDefault(_extends2);
-
-var _ramda = require('ramda');
-
-var R = _interopRequireWildcard(_ramda);
-
-var _src = require('../../rules/src');
-
-var _constants = require('./constants');
-
-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 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 _R$addIndex = R.addIndex(R.reduce)(function (acc, valIndex, dimIndex) {
-      if (R.isEmpty(valIndex)) {
-        return (0, _extends3.default)({}, acc, { split: R.append('', acc.split) });
-      }
-      var dim = R.nth(dimIndex, dimensions);
-      var values = R.propOr([], 'values', dim || {});
-      var value = R.nth(Number(valIndex), values);
-      if (!value || !R.propOr(true, 'display', dim) || !R.propOr(true, 'display', value) || R.includes(R.prop('id', value), _constants.REJECTED_VALUE_IDS)) {
-        return (0, _extends3.default)({}, acc, { split: R.append('', acc.split) });
-      }
-      var dimLabel = (0, _src.dimensionValueDisplay)(options.display)(dim);
-      var valLabel = (0, _src.dimensionValueDisplay)(options.display)(value);
-      return {
-        labels: R.append(dimLabel + ': ' + valLabel, acc.labels),
-        split: R.append(valIndex, acc.split)
-      };
-    }, { split: [], labels: [] }, splitCoord),
-        split = _R$addIndex.split,
-        labels = _R$addIndex.labels;
-
-    var label = R.isEmpty(labels) ? (0, _src.dimensionValueDisplay)(options.display)(dataflow) : R.join(' - ', labels);
-
-    return {
-      id: R.join(':', split),
-      splitCoord: split,
-      label: label,
-      children: R.filter(R.identity, children)
-    };
-  }), function (series) {
-    // after removed non displayed dim vals, some series might be duplicated
-    var grouped = R.groupBy(R.prop('id'), series);
-    return R.pipe(R.map(function (entries) {
-      if (R.length(entries) === 1) {
-        return R.head(entries);
-      }
-      var head = R.head(entries);
-      var children = R.pipe(R.pluck('children'), R.unnest)(entries);
-      return R.assoc('children', children, head);
-    }), R.values)(grouped);
-  }, R.sort(sortByCoordinates))(coordinates);
-};