@sis-cc/dotstatsuite-components 17.15.0 → 17.16.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
|
@@ -17,6 +17,10 @@ var _extends3 = require('babel-runtime/helpers/extends');
|
|
|
17
17
|
|
|
18
18
|
var _extends4 = _interopRequireDefault(_extends3);
|
|
19
19
|
|
|
20
|
+
var _set = require('babel-runtime/core-js/set');
|
|
21
|
+
|
|
22
|
+
var _set2 = _interopRequireDefault(_set);
|
|
23
|
+
|
|
20
24
|
var _ramda = require('ramda');
|
|
21
25
|
|
|
22
26
|
var R = _interopRequireWildcard(_ramda);
|
|
@@ -27,8 +31,11 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
|
|
|
27
31
|
|
|
28
32
|
var toKey = function toKey(indexes) {
|
|
29
33
|
return R.reduce(function (acc, _ind) {
|
|
30
|
-
var ind = R.is(Array, _ind) ? toKey(_ind) : Math.abs(_ind);
|
|
31
|
-
|
|
34
|
+
var ind = R.is(Array, _ind) ? toKey(_ind) : String(Math.abs(_ind));
|
|
35
|
+
if (R.isEmpty(ind)) {
|
|
36
|
+
return acc;
|
|
37
|
+
}
|
|
38
|
+
return R.isEmpty(acc) ? ind : acc + ':' + ind;
|
|
32
39
|
}, '', indexes);
|
|
33
40
|
};
|
|
34
41
|
|
|
@@ -60,26 +67,70 @@ var getCuratedCells = exports.getCuratedCells = function getCuratedCells(_ref) {
|
|
|
60
67
|
return indexWithPivots(pivots, observations);
|
|
61
68
|
};
|
|
62
69
|
|
|
70
|
+
var filterSeries = function filterSeries(series, getHasStillData) {
|
|
71
|
+
var removedMissingIndexes = [];
|
|
72
|
+
return R.reduce(function (acc, serie) {
|
|
73
|
+
var hasStillData = getHasStillData(serie);
|
|
74
|
+
var serieParentsSets = R.map(function (p) {
|
|
75
|
+
return new _set2.default(p);
|
|
76
|
+
}, R.propOr([], 'parentsIndexes', serie));
|
|
77
|
+
if (!hasStillData) {
|
|
78
|
+
removedMissingIndexes = R.addIndex(R.map)(function (mIs, ind) {
|
|
79
|
+
var filtered = R.filter(function (i) {
|
|
80
|
+
return serieParentsSets[ind].has(i);
|
|
81
|
+
}, R.nth(ind, removedMissingIndexes) || []);
|
|
82
|
+
return R.concat(filtered, mIs);
|
|
83
|
+
}, serie.missingIndexes || []);
|
|
84
|
+
return acc;
|
|
85
|
+
}
|
|
86
|
+
var _serie = R.pipe(R.over(R.lensProp('missingIndexes'), function () {
|
|
87
|
+
var missingIndexes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
|
|
88
|
+
return R.addIndex(R.map)(function (mIs, ind) {
|
|
89
|
+
var removed = R.nth(ind, removedMissingIndexes) || [];
|
|
90
|
+
if (R.isEmpty(removed)) {
|
|
91
|
+
return mIs;
|
|
92
|
+
}
|
|
93
|
+
var filteredRemoved = R.filter(function (i) {
|
|
94
|
+
return serieParentsSets[ind].has(i);
|
|
95
|
+
}, removed);
|
|
96
|
+
return R.concat(filteredRemoved, mIs || []);
|
|
97
|
+
}, missingIndexes);
|
|
98
|
+
}), R.over(R.lensProp('parentsIndexes'), function () {
|
|
99
|
+
var parentsIndexes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
|
|
100
|
+
return R.addIndex(R.map)(function (p, ind) {
|
|
101
|
+
return R.reject(function (i) {
|
|
102
|
+
return R.includes(i, R.nth(ind, removedMissingIndexes) || []);
|
|
103
|
+
}, p || []);
|
|
104
|
+
}, parentsIndexes);
|
|
105
|
+
}))(serie);
|
|
106
|
+
removedMissingIndexes = [];
|
|
107
|
+
return R.append(_serie, acc);
|
|
108
|
+
}, [], series);
|
|
109
|
+
};
|
|
110
|
+
|
|
63
111
|
var refineSections = exports.refineSections = function refineSections(sections, extractedKeys, curatedObs) {
|
|
64
112
|
return R.pipe(R.map(function (section) {
|
|
65
113
|
var sectionKey = toKey(R.propOr([], 'indexes', R.head(section)));
|
|
66
|
-
|
|
114
|
+
var getHasRowStillData = function getHasRowStillData(row) {
|
|
67
115
|
var rowKey = toKey(R.prop('indexes', row));
|
|
68
116
|
return R.pipe(R.path([sectionKey, rowKey]), R.omit(extractedKeys), R.isEmpty, R.not)(curatedObs);
|
|
69
|
-
}
|
|
117
|
+
};
|
|
118
|
+
return R.over(R.lensIndex(1), function (rows) {
|
|
119
|
+
return filterSeries(rows, getHasRowStillData);
|
|
120
|
+
})(section);
|
|
70
121
|
}), R.filter(R.pipe(R.nth(1), R.isEmpty, R.not)))(sections);
|
|
71
122
|
};
|
|
72
123
|
|
|
73
|
-
var refineHeader = exports.refineHeader = function refineHeader(
|
|
74
|
-
|
|
75
|
-
function (header) {
|
|
124
|
+
var refineHeader = exports.refineHeader = function refineHeader(headers, extractedKeys, curatedObs) {
|
|
125
|
+
var getHasHeaderStillData = function getHasHeaderStillData(header) {
|
|
76
126
|
var headerKey = toKey(R.prop('indexes', header));
|
|
77
127
|
return R.pipe(R.prop(headerKey), function (sections) {
|
|
78
128
|
return R.pickBy(function (rows, section) {
|
|
79
129
|
return R.pipe(R.omit(R.propOr([], section, extractedKeys)), R.isEmpty, R.not)(rows);
|
|
80
130
|
}, sections);
|
|
81
131
|
}, R.isEmpty, R.not)(curatedObs);
|
|
82
|
-
}
|
|
132
|
+
};
|
|
133
|
+
return filterSeries(headers, getHasHeaderStillData);
|
|
83
134
|
};
|
|
84
135
|
|
|
85
136
|
var getSerieLinesCount = function getSerieLinesCount(serie) {
|
package/package.json
CHANGED
|
@@ -2,8 +2,11 @@ import * as R from 'ramda';
|
|
|
2
2
|
|
|
3
3
|
const toKey = indexes => R.reduce(
|
|
4
4
|
(acc, _ind) => {
|
|
5
|
-
const ind = R.is(Array, _ind) ? toKey(_ind) : Math.abs(_ind);
|
|
6
|
-
|
|
5
|
+
const ind = R.is(Array, _ind) ? toKey(_ind) : String(Math.abs(_ind));
|
|
6
|
+
if (R.isEmpty(ind)) {
|
|
7
|
+
return acc;
|
|
8
|
+
}
|
|
9
|
+
return R.isEmpty(acc) ? ind : `${acc}:${ind}`
|
|
7
10
|
},
|
|
8
11
|
'',
|
|
9
12
|
indexes
|
|
@@ -47,23 +50,58 @@ export const getCuratedCells = ({ layout, observations, shape }) => {
|
|
|
47
50
|
return indexWithPivots(pivots, observations);
|
|
48
51
|
};
|
|
49
52
|
|
|
53
|
+
const filterSeries = (series, getHasStillData) => {
|
|
54
|
+
let removedMissingIndexes = [];
|
|
55
|
+
return R.reduce((acc, serie) => {
|
|
56
|
+
const hasStillData = getHasStillData(serie);
|
|
57
|
+
const serieParentsSets = R.map(p => new Set(p), R.propOr([], 'parentsIndexes', serie));
|
|
58
|
+
if (!hasStillData) {
|
|
59
|
+
removedMissingIndexes = R.addIndex(R.map)((mIs, ind) => {
|
|
60
|
+
const filtered = R.filter(i => serieParentsSets[ind].has(i), R.nth(ind, removedMissingIndexes) || []);
|
|
61
|
+
return R.concat(filtered, mIs);
|
|
62
|
+
}, serie.missingIndexes || []);
|
|
63
|
+
return acc;
|
|
64
|
+
}
|
|
65
|
+
const _serie = R.pipe(
|
|
66
|
+
R.over(
|
|
67
|
+
R.lensProp('missingIndexes'),
|
|
68
|
+
(missingIndexes = []) => R.addIndex(R.map)((mIs, ind) => {
|
|
69
|
+
const removed = R.nth(ind, removedMissingIndexes) || [];
|
|
70
|
+
if (R.isEmpty(removed)) {
|
|
71
|
+
return mIs;
|
|
72
|
+
}
|
|
73
|
+
const filteredRemoved = R.filter(i => serieParentsSets[ind].has(i), removed);
|
|
74
|
+
return R.concat(filteredRemoved, mIs || []);
|
|
75
|
+
}, missingIndexes)
|
|
76
|
+
),
|
|
77
|
+
R.over(
|
|
78
|
+
R.lensProp('parentsIndexes'),
|
|
79
|
+
(parentsIndexes = []) => R.addIndex(R.map)((p, ind) => {
|
|
80
|
+
return R.reject(i => R.includes(i, R.nth(ind, removedMissingIndexes) || []), p || []);
|
|
81
|
+
}, parentsIndexes)
|
|
82
|
+
)
|
|
83
|
+
)(serie);
|
|
84
|
+
removedMissingIndexes = [];
|
|
85
|
+
return R.append(_serie, acc);
|
|
86
|
+
}, [], series);
|
|
87
|
+
};
|
|
88
|
+
|
|
50
89
|
export const refineSections = (sections, extractedKeys, curatedObs) => R.pipe(
|
|
51
90
|
R.map(
|
|
52
91
|
(section) => {
|
|
53
92
|
const sectionKey = toKey(R.propOr([], 'indexes', R.head(section)));
|
|
93
|
+
const getHasRowStillData = (row) => {
|
|
94
|
+
const rowKey = toKey(R.prop('indexes', row));
|
|
95
|
+
return R.pipe(
|
|
96
|
+
R.path([sectionKey, rowKey]),
|
|
97
|
+
R.omit(extractedKeys),
|
|
98
|
+
R.isEmpty,
|
|
99
|
+
R.not
|
|
100
|
+
)(curatedObs);
|
|
101
|
+
};
|
|
54
102
|
return R.over(
|
|
55
103
|
R.lensIndex(1),
|
|
56
|
-
|
|
57
|
-
row => {
|
|
58
|
-
const rowKey = toKey(R.prop('indexes', row));
|
|
59
|
-
return R.pipe(
|
|
60
|
-
R.path([sectionKey, rowKey]),
|
|
61
|
-
R.omit(extractedKeys),
|
|
62
|
-
R.isEmpty,
|
|
63
|
-
R.not
|
|
64
|
-
)(curatedObs);
|
|
65
|
-
}
|
|
66
|
-
)
|
|
104
|
+
rows => filterSeries(rows, getHasRowStillData)
|
|
67
105
|
)(section);
|
|
68
106
|
}
|
|
69
107
|
),
|
|
@@ -72,8 +110,8 @@ export const refineSections = (sections, extractedKeys, curatedObs) => R.pipe(
|
|
|
72
110
|
)
|
|
73
111
|
)(sections);
|
|
74
112
|
|
|
75
|
-
export const refineHeader = (
|
|
76
|
-
(header) => {
|
|
113
|
+
export const refineHeader = (headers, extractedKeys, curatedObs) => {
|
|
114
|
+
const getHasHeaderStillData = (header) => {
|
|
77
115
|
const headerKey = toKey(R.prop('indexes', header));
|
|
78
116
|
return R.pipe(
|
|
79
117
|
R.prop(headerKey),
|
|
@@ -90,8 +128,9 @@ export const refineHeader = (header, extractedKeys, curatedObs) => R.filter( //
|
|
|
90
128
|
R.isEmpty,
|
|
91
129
|
R.not
|
|
92
130
|
)(curatedObs);
|
|
93
|
-
}
|
|
94
|
-
|
|
131
|
+
};
|
|
132
|
+
return filterSeries(headers, getHasHeaderStillData);
|
|
133
|
+
};
|
|
95
134
|
|
|
96
135
|
const getSerieLinesCount = serie => {
|
|
97
136
|
const missingParents = R.propOr([], 'missingParents', serie);
|
|
@@ -245,7 +284,7 @@ export const refineLayoutSize = ({ layout, observations, limit }) => layoutIndex
|
|
|
245
284
|
// total of cells in one column
|
|
246
285
|
const columnCellsCount = headerDimCount + rowsCount;
|
|
247
286
|
|
|
248
|
-
const isVertical = columnCellsCount > rowCellsCount
|
|
287
|
+
const isVertical = columnCellsCount > rowCellsCount;
|
|
249
288
|
|
|
250
289
|
const [toTruncate, toRefine] = segregateLayout(isVertical)(layoutIndexes);
|
|
251
290
|
|
|
@@ -182,7 +182,7 @@ describe('refineLayoutSize 2 tests', () => {
|
|
|
182
182
|
const expected = {
|
|
183
183
|
totalCells: 140,
|
|
184
184
|
truncated: true,
|
|
185
|
-
header: [{ indexes: [] }],
|
|
185
|
+
header: [{ indexes: [], missingIndexes: [], parentsIndexes: [] }],
|
|
186
186
|
sections: [
|
|
187
187
|
[
|
|
188
188
|
{ indexes: [] },
|
|
@@ -220,6 +220,122 @@ describe('refineLayoutSize 2 tests', () => {
|
|
|
220
220
|
})(layoutIndexes)
|
|
221
221
|
).to.deep.equal(expected);
|
|
222
222
|
});
|
|
223
|
+
it('truncated missing indexes', () => {
|
|
224
|
+
const layout = {
|
|
225
|
+
header: [{ __index: 0 }, { __index: 1 }],
|
|
226
|
+
rows: [{ __index: 2 }],
|
|
227
|
+
sections: [],
|
|
228
|
+
};
|
|
229
|
+
//102 cells
|
|
230
|
+
const layoutIndexes = {
|
|
231
|
+
header: [
|
|
232
|
+
{ indexes: [1, 1], parentsIndexes: [[], []], missingIndexes: [[0], [0]] },
|
|
233
|
+
{ indexes: [1, 2], parentsIndexes: [[0], [0]], missingIndexes: [[], []] },
|
|
234
|
+
{ indexes: [1, 3], parentsIndexes: [[0], [0]], missingIndexes: [[], []] },
|
|
235
|
+
{ indexes: [2, 1], parentsIndexes: [[0], [0]], missingIndexes: [[], []] },
|
|
236
|
+
{ indexes: [2, 2], parentsIndexes: [[0], [0]], missingIndexes: [[], []] },
|
|
237
|
+
{ indexes: [2, 3], parentsIndexes: [[0], [0]], missingIndexes: [[], []] },
|
|
238
|
+
],
|
|
239
|
+
sections: [
|
|
240
|
+
[
|
|
241
|
+
{ indexes: [] },
|
|
242
|
+
[
|
|
243
|
+
{ indexes: [0], parentsIndexes: [[]], missingIndexes: [[]] },
|
|
244
|
+
{ indexes: [1], parentsIndexes: [[]], missingIndexes: [[]] },
|
|
245
|
+
{ indexes: [2], parentsIndexes: [[]], missingIndexes: [[]] },
|
|
246
|
+
{ indexes: [3], parentsIndexes: [[]], missingIndexes: [[]] },
|
|
247
|
+
{ indexes: [4], parentsIndexes: [[]], missingIndexes: [[]] },
|
|
248
|
+
{ indexes: [5], parentsIndexes: [[]], missingIndexes: [[]] },
|
|
249
|
+
{ indexes: [6], parentsIndexes: [[]], missingIndexes: [[]] },
|
|
250
|
+
{ indexes: [7], parentsIndexes: [[]], missingIndexes: [[]] },
|
|
251
|
+
{ indexes: [8], parentsIndexes: [[]], missingIndexes: [[]] },
|
|
252
|
+
{ indexes: [9], parentsIndexes: [[]], missingIndexes: [[]] },
|
|
253
|
+
]
|
|
254
|
+
]
|
|
255
|
+
]
|
|
256
|
+
};
|
|
257
|
+
|
|
258
|
+
const observations = {
|
|
259
|
+
'1:1:8': { orderedDimIndexes: [1, 1, 8] },
|
|
260
|
+
'1:1:9': { orderedDimIndexes: [1, 1, 9] },
|
|
261
|
+
'1:2:8': { orderedDimIndexes: [1, 2, 8] },
|
|
262
|
+
'1:2:9': { orderedDimIndexes: [1, 2, 9] },
|
|
263
|
+
'1:3:0': { orderedDimIndexes: [1, 3, 0] },
|
|
264
|
+
'1:3:1': { orderedDimIndexes: [1, 3, 1] },
|
|
265
|
+
'1:3:2': { orderedDimIndexes: [1, 3, 2] },
|
|
266
|
+
'1:3:3': { orderedDimIndexes: [1, 3, 3] },
|
|
267
|
+
'1:3:4': { orderedDimIndexes: [1, 3, 4] },
|
|
268
|
+
'1:3:5': { orderedDimIndexes: [1, 3, 5] },
|
|
269
|
+
'1:3:6': { orderedDimIndexes: [1, 3, 6] },
|
|
270
|
+
'1:3:7': { orderedDimIndexes: [1, 3, 7] },
|
|
271
|
+
'1:3:8': { orderedDimIndexes: [1, 3, 8] },
|
|
272
|
+
'1:3:9': { orderedDimIndexes: [1, 3, 9] },
|
|
273
|
+
'2:1:0': { orderedDimIndexes: [2, 1, 0] },
|
|
274
|
+
'2:1:1': { orderedDimIndexes: [2, 1, 1] },
|
|
275
|
+
'2:1:2': { orderedDimIndexes: [2, 1, 2] },
|
|
276
|
+
'2:1:3': { orderedDimIndexes: [2, 1, 3] },
|
|
277
|
+
'2:1:4': { orderedDimIndexes: [2, 1, 4] },
|
|
278
|
+
'2:1:5': { orderedDimIndexes: [2, 1, 5] },
|
|
279
|
+
'2:1:6': { orderedDimIndexes: [2, 1, 6] },
|
|
280
|
+
'2:1:7': { orderedDimIndexes: [2, 1, 7] },
|
|
281
|
+
'2:1:8': { orderedDimIndexes: [2, 1, 8] },
|
|
282
|
+
'2:1:9': { orderedDimIndexes: [2, 1, 9] },
|
|
283
|
+
'2:2:0': { orderedDimIndexes: [2, 2, 0] },
|
|
284
|
+
'2:2:1': { orderedDimIndexes: [2, 2, 1] },
|
|
285
|
+
'2:2:2': { orderedDimIndexes: [2, 2, 2] },
|
|
286
|
+
'2:2:3': { orderedDimIndexes: [2, 2, 3] },
|
|
287
|
+
'2:2:4': { orderedDimIndexes: [2, 2, 4] },
|
|
288
|
+
'2:2:5': { orderedDimIndexes: [2, 2, 5] },
|
|
289
|
+
'2:2:6': { orderedDimIndexes: [2, 2, 6] },
|
|
290
|
+
'2:2:7': { orderedDimIndexes: [2, 2, 7] },
|
|
291
|
+
'2:2:8': { orderedDimIndexes: [2, 2, 8] },
|
|
292
|
+
'2:2:9': { orderedDimIndexes: [2, 2, 9] },
|
|
293
|
+
'2:3:0': { orderedDimIndexes: [2, 3, 0] },
|
|
294
|
+
'2:3:1': { orderedDimIndexes: [2, 3, 1] },
|
|
295
|
+
'2:3:2': { orderedDimIndexes: [2, 3, 2] },
|
|
296
|
+
'2:3:3': { orderedDimIndexes: [2, 3, 3] },
|
|
297
|
+
'2:3:4': { orderedDimIndexes: [2, 3, 4] },
|
|
298
|
+
'2:3:5': { orderedDimIndexes: [2, 3, 5] },
|
|
299
|
+
'2:3:6': { orderedDimIndexes: [2, 3, 6] },
|
|
300
|
+
'2:3:7': { orderedDimIndexes: [2, 3, 7] },
|
|
301
|
+
'2:3:8': { orderedDimIndexes: [2, 3, 8] },
|
|
302
|
+
'2:3:9': { orderedDimIndexes: [2, 3, 9] },
|
|
303
|
+
};
|
|
304
|
+
|
|
305
|
+
const expected = {
|
|
306
|
+
header: [
|
|
307
|
+
{ indexes: [1, 3], parentsIndexes: [[], []], missingIndexes: [[0], [0]] },
|
|
308
|
+
{ indexes: [2, 1], parentsIndexes: [[0], [0]], missingIndexes: [[], []] },
|
|
309
|
+
{ indexes: [2, 2], parentsIndexes: [[0], [0]], missingIndexes: [[], []] },
|
|
310
|
+
{ indexes: [2, 3], parentsIndexes: [[0], [0]], missingIndexes: [[], []] },
|
|
311
|
+
],
|
|
312
|
+
sections: [
|
|
313
|
+
[
|
|
314
|
+
{ indexes: [] },
|
|
315
|
+
[
|
|
316
|
+
{ indexes: [0], parentsIndexes: [[]], missingIndexes: [[]] },
|
|
317
|
+
{ indexes: [1], parentsIndexes: [[]], missingIndexes: [[]] },
|
|
318
|
+
{ indexes: [2], parentsIndexes: [[]], missingIndexes: [[]] },
|
|
319
|
+
{ indexes: [3], parentsIndexes: [[]], missingIndexes: [[]] },
|
|
320
|
+
{ indexes: [4], parentsIndexes: [[]], missingIndexes: [[]] },
|
|
321
|
+
{ indexes: [5], parentsIndexes: [[]], missingIndexes: [[]] },
|
|
322
|
+
{ indexes: [6], parentsIndexes: [[]], missingIndexes: [[]] },
|
|
323
|
+
{ indexes: [7], parentsIndexes: [[]], missingIndexes: [[]] },
|
|
324
|
+
]
|
|
325
|
+
]
|
|
326
|
+
],
|
|
327
|
+
truncated: true,
|
|
328
|
+
totalCells: 102
|
|
329
|
+
};
|
|
330
|
+
|
|
331
|
+
expect(
|
|
332
|
+
refineLayoutSize({
|
|
333
|
+
layout,
|
|
334
|
+
observations,
|
|
335
|
+
limit: 90
|
|
336
|
+
})(layoutIndexes)
|
|
337
|
+
).to.deep.equal(expected);
|
|
338
|
+
});
|
|
223
339
|
/*it('no rows', () => {
|
|
224
340
|
|
|
225
341
|
const layout = {
|