@reltio/components 1.4.2084 → 1.4.2085

package/cjs/hooks/useCollapsibleTableRows/dataHelpers.test.js

@@ -226,6 +226,47 @@ describe('dataHelpers', function () {
                 }
             ]);
         });
+        it('should calculate correct rowspan if there are two or more columns having same nesting level', function () {
+            var rowValues = [
+                {
+                    'n1.a.b': [[0], [1]],
+                    'n1.x.y': [[2, 3], [4, 5], [6]],
+                    'n1.x.y.z': [[[7], [8]], [[9], [10]], []]
+                }
+            ];
+            var columnsData = [
+                { id: 'n1.a.b', nestedPath: ['a'], label: 'columnA' },
+                { id: 'n1.x.y', nestedPath: ['x'], label: 'columnB' },
+                { id: 'n1.x.y.z', nestedPath: ['x', 'y'], label: 'columnC' }
+            ];
+            var renderRowCell = function (_a) {
+                var cell = _a.cell;
+                return cell.values;
+            };
+            expect((0, dataHelpers_1.getTableRowsData)(rowValues, columnsData, renderRowCell)).toEqual([
+                {
+                    data: {
+                        'n1.a.b': [
+                            { values: [0], indexPath: [0], nestedKey: 'a.0', rowSpan: 2 },
+                            { values: [1], indexPath: [1], nestedKey: 'a.1', rowSpan: 3 }
+                        ],
+                        'n1.x.y': [
+                            { values: [2, 3], indexPath: [0], nestedKey: 'x.0', rowSpan: 2 },
+                            { values: [4, 5], indexPath: [1], nestedKey: 'x.1', rowSpan: 2 },
+                            { values: [6], indexPath: [2], nestedKey: 'x.2', rowSpan: 1 }
+                        ],
+                        'n1.x.y.z': [
+                            { values: [7], indexPath: [0, 0], nestedKey: 'x.0.y.0', rowSpan: 1 },
+                            { values: [8], indexPath: [0, 1], nestedKey: 'x.0.y.1', rowSpan: 1 },
+                            { values: [9], indexPath: [1, 0], nestedKey: 'x.1.y.0', rowSpan: 1 },
+                            { values: [10], indexPath: [1, 1], nestedKey: 'x.1.y.1', rowSpan: 1 },
+                            { values: [], indexPath: [2], nestedKey: 'x.2', rowSpan: 1 }
+                        ]
+                    },
+                    id: 0
+                }
+            ]);
+        });
         it('should apply max values count constraint if getRowMaxValuesCount is provided', function () {
             var rowValues = [
                 {

package/cjs/hooks/useCollapsibleTableRows/nestedHelpers.js

@@ -30,6 +30,25 @@ exports.getSiblingSubRowsKeyBySubRowKey = getSiblingSubRowsKeyBySubRowKey;
 var getParentRowKeyBySiblingsSubRowsKey = (0, ramda_1.pipe)((0, ramda_1.split)(NESTED_KEY_DELIMITER), (0, ramda_1.dropLast)(1), (0, ramda_1.join)(NESTED_KEY_DELIMITER), (0, ramda_1.unless)(ramda_1.length, (0, ramda_1.always)(TOTAL_ROW_SPAN_KEY)));
 exports.getParentRowKeyBySiblingsSubRowsKey = getParentRowKeyBySiblingsSubRowsKey;
 var getParentRowKeyBySubRowKey = (0, ramda_1.pipe)(getSiblingSubRowsKeyBySubRowKey, getParentRowKeyBySiblingsSubRowsKey);
+var getSameNestingDepthNestedKeys = function (rowSpanData, keyToBeMatched) {
+    var parentKeyToBeMatched = getSiblingSubRowsKeyBySubRowKey(keyToBeMatched);
+    return Object.keys(rowSpanData).filter(function (currentKey) {
+        var currentParentKey = getParentRowKeyBySubRowKey(currentKey);
+        return (currentParentKey === parentKeyToBeMatched ||
+            (currentParentKey === TOTAL_ROW_SPAN_KEY && parentKeyToBeMatched === ''));
+    });
+};
+var getRequiredRowSpan = function (rowSpanData, sameLevelNestedKeys, subRowKey, cellsWithExtraSpanAvailable) {
+    var subcellIndex = subRowKey.split(NESTED_KEY_DELIMITER).pop();
+    var minSpan = sameLevelNestedKeys
+        .filter(function (key) { return key.split(NESTED_KEY_DELIMITER).pop() === subcellIndex; })
+        .reduce(function (minSpan, key) {
+        return cellsWithExtraSpanAvailable.includes(getSiblingSubRowsKeyBySubRowKey(key))
+            ? minSpan
+            : Math.min(minSpan, rowSpanData[key]);
+    }, Infinity);
+    return minSpan === Infinity ? rowSpanData[subRowKey] : Math.max(rowSpanData[subRowKey], minSpan);
+};
 var countParentSpanByAllSubRows = function (rowSpanData, siblingSubRowsKey) {
     return (0, ramda_1.pipe)((0, ramda_1.pickBy)(function (_val, key) { return getSiblingSubRowsKeyBySubRowKey(key) === siblingSubRowsKey; }), ramda_1.values, ramda_1.sum)(rowSpanData);
 };
@@ -49,23 +68,52 @@ var addNestedKey = function (rowSpanData, nestedKey) {
     var _a;
     return calcParentRowSpan(__assign(__assign({}, rowSpanData), (_a = {}, _a[nestedKey] = 1, _a)), nestedKey);
 };
-var validateParentRowSpan = function (rowSpanData, _a) {
+var validateRowSpans = function (rowSpanData) { return function (groups) {
+    var cellsWithExtraSpanAvailable = [];
+    for (var _i = 0, groups_1 = groups; _i < groups_1.length; _i++) {
+        var group = groups_1[_i];
+        var siblingSubRowsKey = group[0];
+        var parentKey = getParentRowKeyBySiblingsSubRowsKey(siblingSubRowsKey);
+        var currentParentSpan = (0, ramda_1.propOr)(0, parentKey, rowSpanData);
+        var actualParentSpan = countParentSpanByAllSubRows(rowSpanData, siblingSubRowsKey);
+        if (currentParentSpan > actualParentSpan) {
+            cellsWithExtraSpanAvailable.push(siblingSubRowsKey);
+        }
+    }
+    return groups.reduce(function (rowSpanData, group) { return validateParentRowSpan(rowSpanData, group, cellsWithExtraSpanAvailable); }, rowSpanData);
+}; };
+var validateParentRowSpan = function (rowSpanData, _a, cellsWithExtraSpanAvailable) {
     var siblingSubRowsKey = _a[0], subRowsKeys = _a[1];
     var parentKey = getParentRowKeyBySiblingsSubRowsKey(siblingSubRowsKey);
     var currentParentSpan = (0, ramda_1.propOr)(0, parentKey, rowSpanData);
     var actualParentSpan = countParentSpanByAllSubRows(rowSpanData, siblingSubRowsKey);
     var spanDiff = currentParentSpan - actualParentSpan;
     if (spanDiff > 0) {
+        var sameDepthNestedKeys_1 = getSameNestingDepthNestedKeys(rowSpanData, siblingSubRowsKey);
+        var sumOfRequiredRowSpans_1 = 0;
+        var correctedRowSpanData = subRowsKeys.reduce(function (acc, subRowKey) {
+            var requiredRowSpan = getRequiredRowSpan(rowSpanData, sameDepthNestedKeys_1, subRowKey, cellsWithExtraSpanAvailable);
+            acc[subRowKey] = requiredRowSpan;
+            sumOfRequiredRowSpans_1 += requiredRowSpan;
+            return acc;
+        }, {});
+        var newRowSpanData = __assign({}, rowSpanData);
+        if (currentParentSpan >= sumOfRequiredRowSpans_1) {
+            spanDiff = currentParentSpan - sumOfRequiredRowSpans_1;
+            newRowSpanData = __assign(__assign({}, rowSpanData), correctedRowSpanData);
+            if (spanDiff === 0)
+                return newRowSpanData;
+        }
         var lowestSubRowKey = "".concat(siblingSubRowsKey).concat(NESTED_KEY_DELIMITER).concat(subRowsKeys.length - 1);
-        var lowestSubRowSpan = rowSpanData[lowestSubRowKey];
-        return (0, ramda_1.assoc)(lowestSubRowKey, lowestSubRowSpan + spanDiff, rowSpanData);
+        var lowestSubRowSpan = newRowSpanData[lowestSubRowKey];
+        return (0, ramda_1.assoc)(lowestSubRowKey, lowestSubRowSpan + spanDiff, newRowSpanData);
     }
     else {
         return rowSpanData;
     }
 };
 var validateRowSpanData = function (rowSpanData) {
-    return (0, ramda_1.pipe)((0, ramda_1.omit)([TOTAL_ROW_SPAN_KEY]), ramda_1.keys, (0, ramda_1.sortBy)(ramda_1.identity), (0, ramda_1.groupBy)(getSiblingSubRowsKeyBySubRowKey), ramda_1.toPairs, (0, ramda_1.reduce)(validateParentRowSpan, rowSpanData))(rowSpanData);
+    return (0, ramda_1.pipe)((0, ramda_1.omit)([TOTAL_ROW_SPAN_KEY]), ramda_1.keys, (0, ramda_1.sortBy)(ramda_1.identity), (0, ramda_1.groupBy)(getSiblingSubRowsKeyBySubRowKey), ramda_1.toPairs, validateRowSpans(rowSpanData))(rowSpanData);
 };
 exports.validateRowSpanData = validateRowSpanData;
 var calcRowSpansForNestedKeys = (0, ramda_1.pipe)((0, ramda_1.sortBy)(ramda_1.identity), (0, ramda_1.reduce)(addNestedKey, {}), validateRowSpanData);

package/hooks/useCollapsibleTableRows/dataHelpers.test.js

@@ -221,6 +221,47 @@ describe('dataHelpers', function () {
                 }
             ]);
         });
+        it('should calculate correct rowspan if there are two or more columns having same nesting level', function () {
+            var rowValues = [
+                {
+                    'n1.a.b': [[0], [1]],
+                    'n1.x.y': [[2, 3], [4, 5], [6]],
+                    'n1.x.y.z': [[[7], [8]], [[9], [10]], []]
+                }
+            ];
+            var columnsData = [
+                { id: 'n1.a.b', nestedPath: ['a'], label: 'columnA' },
+                { id: 'n1.x.y', nestedPath: ['x'], label: 'columnB' },
+                { id: 'n1.x.y.z', nestedPath: ['x', 'y'], label: 'columnC' }
+            ];
+            var renderRowCell = function (_a) {
+                var cell = _a.cell;
+                return cell.values;
+            };
+            expect(getTableRowsData(rowValues, columnsData, renderRowCell)).toEqual([
+                {
+                    data: {
+                        'n1.a.b': [
+                            { values: [0], indexPath: [0], nestedKey: 'a.0', rowSpan: 2 },
+                            { values: [1], indexPath: [1], nestedKey: 'a.1', rowSpan: 3 }
+                        ],
+                        'n1.x.y': [
+                            { values: [2, 3], indexPath: [0], nestedKey: 'x.0', rowSpan: 2 },
+                            { values: [4, 5], indexPath: [1], nestedKey: 'x.1', rowSpan: 2 },
+                            { values: [6], indexPath: [2], nestedKey: 'x.2', rowSpan: 1 }
+                        ],
+                        'n1.x.y.z': [
+                            { values: [7], indexPath: [0, 0], nestedKey: 'x.0.y.0', rowSpan: 1 },
+                            { values: [8], indexPath: [0, 1], nestedKey: 'x.0.y.1', rowSpan: 1 },
+                            { values: [9], indexPath: [1, 0], nestedKey: 'x.1.y.0', rowSpan: 1 },
+                            { values: [10], indexPath: [1, 1], nestedKey: 'x.1.y.1', rowSpan: 1 },
+                            { values: [], indexPath: [2], nestedKey: 'x.2', rowSpan: 1 }
+                        ]
+                    },
+                    id: 0
+                }
+            ]);
+        });
         it('should apply max values count constraint if getRowMaxValuesCount is provided', function () {
             var rowValues = [
                 {

package/hooks/useCollapsibleTableRows/nestedHelpers.js

@@ -24,6 +24,25 @@ var NESTED_KEY_DELIMITER = '.';
 var getSiblingSubRowsKeyBySubRowKey = pipe(split(NESTED_KEY_DELIMITER), dropLast(1), join(NESTED_KEY_DELIMITER));
 var getParentRowKeyBySiblingsSubRowsKey = pipe(split(NESTED_KEY_DELIMITER), dropLast(1), join(NESTED_KEY_DELIMITER), unless(length, always(TOTAL_ROW_SPAN_KEY)));
 var getParentRowKeyBySubRowKey = pipe(getSiblingSubRowsKeyBySubRowKey, getParentRowKeyBySiblingsSubRowsKey);
+var getSameNestingDepthNestedKeys = function (rowSpanData, keyToBeMatched) {
+    var parentKeyToBeMatched = getSiblingSubRowsKeyBySubRowKey(keyToBeMatched);
+    return Object.keys(rowSpanData).filter(function (currentKey) {
+        var currentParentKey = getParentRowKeyBySubRowKey(currentKey);
+        return (currentParentKey === parentKeyToBeMatched ||
+            (currentParentKey === TOTAL_ROW_SPAN_KEY && parentKeyToBeMatched === ''));
+    });
+};
+var getRequiredRowSpan = function (rowSpanData, sameLevelNestedKeys, subRowKey, cellsWithExtraSpanAvailable) {
+    var subcellIndex = subRowKey.split(NESTED_KEY_DELIMITER).pop();
+    var minSpan = sameLevelNestedKeys
+        .filter(function (key) { return key.split(NESTED_KEY_DELIMITER).pop() === subcellIndex; })
+        .reduce(function (minSpan, key) {
+        return cellsWithExtraSpanAvailable.includes(getSiblingSubRowsKeyBySubRowKey(key))
+            ? minSpan
+            : Math.min(minSpan, rowSpanData[key]);
+    }, Infinity);
+    return minSpan === Infinity ? rowSpanData[subRowKey] : Math.max(rowSpanData[subRowKey], minSpan);
+};
 var countParentSpanByAllSubRows = function (rowSpanData, siblingSubRowsKey) {
     return pipe(pickBy(function (_val, key) { return getSiblingSubRowsKeyBySubRowKey(key) === siblingSubRowsKey; }), values, sum)(rowSpanData);
 };
@@ -43,23 +62,52 @@ var addNestedKey = function (rowSpanData, nestedKey) {
     var _a;
     return calcParentRowSpan(__assign(__assign({}, rowSpanData), (_a = {}, _a[nestedKey] = 1, _a)), nestedKey);
 };
-var validateParentRowSpan = function (rowSpanData, _a) {
+var validateRowSpans = function (rowSpanData) { return function (groups) {
+    var cellsWithExtraSpanAvailable = [];
+    for (var _i = 0, groups_1 = groups; _i < groups_1.length; _i++) {
+        var group = groups_1[_i];
+        var siblingSubRowsKey = group[0];
+        var parentKey = getParentRowKeyBySiblingsSubRowsKey(siblingSubRowsKey);
+        var currentParentSpan = propOr(0, parentKey, rowSpanData);
+        var actualParentSpan = countParentSpanByAllSubRows(rowSpanData, siblingSubRowsKey);
+        if (currentParentSpan > actualParentSpan) {
+            cellsWithExtraSpanAvailable.push(siblingSubRowsKey);
+        }
+    }
+    return groups.reduce(function (rowSpanData, group) { return validateParentRowSpan(rowSpanData, group, cellsWithExtraSpanAvailable); }, rowSpanData);
+}; };
+var validateParentRowSpan = function (rowSpanData, _a, cellsWithExtraSpanAvailable) {
     var siblingSubRowsKey = _a[0], subRowsKeys = _a[1];
     var parentKey = getParentRowKeyBySiblingsSubRowsKey(siblingSubRowsKey);
     var currentParentSpan = propOr(0, parentKey, rowSpanData);
     var actualParentSpan = countParentSpanByAllSubRows(rowSpanData, siblingSubRowsKey);
     var spanDiff = currentParentSpan - actualParentSpan;
     if (spanDiff > 0) {
+        var sameDepthNestedKeys_1 = getSameNestingDepthNestedKeys(rowSpanData, siblingSubRowsKey);
+        var sumOfRequiredRowSpans_1 = 0;
+        var correctedRowSpanData = subRowsKeys.reduce(function (acc, subRowKey) {
+            var requiredRowSpan = getRequiredRowSpan(rowSpanData, sameDepthNestedKeys_1, subRowKey, cellsWithExtraSpanAvailable);
+            acc[subRowKey] = requiredRowSpan;
+            sumOfRequiredRowSpans_1 += requiredRowSpan;
+            return acc;
+        }, {});
+        var newRowSpanData = __assign({}, rowSpanData);
+        if (currentParentSpan >= sumOfRequiredRowSpans_1) {
+            spanDiff = currentParentSpan - sumOfRequiredRowSpans_1;
+            newRowSpanData = __assign(__assign({}, rowSpanData), correctedRowSpanData);
+            if (spanDiff === 0)
+                return newRowSpanData;
+        }
         var lowestSubRowKey = "".concat(siblingSubRowsKey).concat(NESTED_KEY_DELIMITER).concat(subRowsKeys.length - 1);
-        var lowestSubRowSpan = rowSpanData[lowestSubRowKey];
-        return assoc(lowestSubRowKey, lowestSubRowSpan + spanDiff, rowSpanData);
+        var lowestSubRowSpan = newRowSpanData[lowestSubRowKey];
+        return assoc(lowestSubRowKey, lowestSubRowSpan + spanDiff, newRowSpanData);
     }
     else {
         return rowSpanData;
     }
 };
 var validateRowSpanData = function (rowSpanData) {
-    return pipe(omit([TOTAL_ROW_SPAN_KEY]), keys, sortBy(identity), groupBy(getSiblingSubRowsKeyBySubRowKey), toPairs, reduce(validateParentRowSpan, rowSpanData))(rowSpanData);
+    return pipe(omit([TOTAL_ROW_SPAN_KEY]), keys, sortBy(identity), groupBy(getSiblingSubRowsKeyBySubRowKey), toPairs, validateRowSpans(rowSpanData))(rowSpanData);
 };
 var calcRowSpansForNestedKeys = pipe(sortBy(identity), reduce(addNestedKey, {}), validateRowSpanData);
 var chainWithIndex = addIndex(chain);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reltio/components",
-  "version": "1.4.2084",
+  "version": "1.4.2085",
   "license": "SEE LICENSE IN LICENSE FILE",
   "main": "./cjs/index.js",
   "module": "./index.js",