@reltio/components 1.4.2080 → 1.4.2082

package/helpers/tableCompactCollapseHelpers.d.ts

@@ -0,0 +1,4 @@
+import { RowValue } from '../types/basicTable';
+declare const applyCompactValuesCountConstraint: (maxValuesCount: number) => (rowValue: RowValue) => RowValue;
+declare const getHasHiddenAttributes: any;
+export { applyCompactValuesCountConstraint, getHasHiddenAttributes };

package/helpers/tableCompactCollapseHelpers.js

@@ -0,0 +1,183 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { adjust, assoc, difference, identity, __, gt, length, pathOr, chain, pipe, values } from 'ramda';
+var INDEX_PATH_SEPARATOR = ',';
+var indexPathToStringKey = function (indexPath) { return indexPath === null || indexPath === void 0 ? void 0 : indexPath.join(INDEX_PATH_SEPARATOR); };
+var stringKeyToIndexPath = function (stringKey) { return stringKey.split(INDEX_PATH_SEPARATOR).map(Number); };
+var isIndexPathSmaller = function (maxIndexPath, indexPath) {
+    if (!indexPath || !maxIndexPath) {
+        return true;
+    }
+    var minLength = Math.min(maxIndexPath.length, indexPath.length);
+    for (var i = 0; i < minLength; i++) {
+        if (indexPath[i] < maxIndexPath[i]) {
+            return true;
+        }
+        else if (indexPath[i] > maxIndexPath[i]) {
+            return false;
+        }
+    }
+    return indexPath.length < maxIndexPath.length;
+};
+var isIndexPathOnSameLevel = function (maxIndexPath, indexPath) {
+    if (!indexPath || !maxIndexPath) {
+        return false;
+    }
+    var maxIndexPathLength = maxIndexPath.length;
+    var isEqual = maxIndexPath.length === indexPath.length && maxIndexPath.every(function (value, index) { return value === indexPath[index]; });
+    var isLeftEqual = maxIndexPath.every(function (value, index) { return value === indexPath[index]; });
+    var isRightEqual = indexPath.slice(maxIndexPathLength).every(function (value) { return value === 0; });
+    return isEqual || (isLeftEqual && isRightEqual);
+};
+var getBaseIndexStartsAt = function (rowValue) {
+    for (var _i = 0, _a = Object.entries(rowValue); _i < _a.length; _i++) {
+        var _b = _a[_i], columnId = _b[0], subcells = _b[1];
+        if (columnId.startsWith('attributes.')) {
+            var columnAttributes = columnId.split('.').slice(1);
+            if (Array.isArray(subcells)) {
+                for (var _c = 0, subcells_1 = subcells; _c < subcells_1.length; _c++) {
+                    var subcell = subcells_1[_c];
+                    if (subcell.nestedKey) {
+                        var cellAttributes = subcell.nestedKey.split('.').filter(function (part) { return !isFinite(part); });
+                        var diff = difference(cellAttributes, columnAttributes);
+                        return diff.length;
+                    }
+                }
+            }
+        }
+    }
+    return 0;
+};
+var getMaxIndexPath = function (maxValuesCount, sortedSubcellValueGroups, baseIndexStartsAt) {
+    var maxCount = 0;
+    var baseCount = 0;
+    var previousLevel = 0;
+    var previousBaseIndex = 0;
+    var maxIndexPathValuesCount = Infinity;
+    var maxIndexPath = null;
+    for (var _i = 0, sortedSubcellValueGroups_1 = sortedSubcellValueGroups; _i < sortedSubcellValueGroups_1.length; _i++) {
+        var _a = sortedSubcellValueGroups_1[_i], indexPathKey = _a[0], visibleValuesCount = _a[1];
+        var currentIndexPath = stringKeyToIndexPath(indexPathKey);
+        var currentLevel = currentIndexPath.length;
+        var currentBaseIndex = currentIndexPath[baseIndexStartsAt] || 0;
+        var remainingCount = maxValuesCount - baseCount - maxCount;
+        if (currentBaseIndex !== previousBaseIndex) {
+            baseCount += maxCount;
+            previousBaseIndex = currentBaseIndex;
+            maxCount = 0;
+        }
+        if (currentLevel > previousLevel) {
+            maxCount = Math.max(maxCount, Math.min(visibleValuesCount, maxValuesCount - baseCount));
+        }
+        else {
+            maxCount += Math.min(visibleValuesCount, remainingCount);
+        }
+        if (maxCount + baseCount === maxValuesCount) {
+            maxIndexPath = currentIndexPath;
+            maxIndexPathValuesCount = currentLevel > previousLevel ? maxValuesCount - baseCount : remainingCount;
+            break;
+        }
+        previousLevel = currentLevel;
+    }
+    return { maxIndexPath: maxIndexPath, maxIndexPathValuesCount: maxIndexPathValuesCount };
+};
+var sortIndexPaths = function (indexPathA, indexPathB) {
+    var _a, _b;
+    var numbersA = stringKeyToIndexPath(indexPathA);
+    var numbersB = stringKeyToIndexPath(indexPathB);
+    for (var i = 0; i < Math.max(numbersA.length, numbersB.length); i++) {
+        var valA = (_a = numbersA[i]) !== null && _a !== void 0 ? _a : -1;
+        var valB = (_b = numbersB[i]) !== null && _b !== void 0 ? _b : -1;
+        if (valA !== valB)
+            return valA - valB;
+    }
+    return 0;
+};
+var getSubcellValuesGroup = function (rowValue) {
+    var subcellValueGroups = {};
+    Object.values(rowValue).forEach(function (subcells) {
+        return Array.isArray(subcells) &&
+            subcells.forEach(function (subcell, i) {
+                var indexPathKey = indexPathToStringKey(subcell.indexPath) || i;
+                subcellValueGroups[indexPathKey] = Math.max(subcellValueGroups[indexPathKey] || 0, subcell.values.length);
+            });
+    });
+    return Object.entries(subcellValueGroups).sort(function (_a, _b) {
+        var indexPathKeyA = _a[0];
+        var indexPathKeyB = _b[0];
+        return sortIndexPaths(indexPathKeyA, indexPathKeyB);
+    });
+};
+var processSubcell = function (subcell, maxIndexPath, maxIndexPathValuesCount) {
+    var values = subcell.values, indexPath = subcell.indexPath, rest = __rest(subcell, ["values", "indexPath"]);
+    var isPathSmaller = isIndexPathSmaller(maxIndexPath, indexPath);
+    var isPathOnSameLevel = isIndexPathOnSameLevel(maxIndexPath, indexPath);
+    var allowedCount = 0;
+    if (isPathSmaller) {
+        allowedCount = values.length;
+    }
+    else if (isPathOnSameLevel) {
+        allowedCount = maxIndexPathValuesCount;
+    }
+    var visibleValues = values.slice(0, allowedCount);
+    var hiddenSubcellValues = values.slice(allowedCount);
+    var processedSubcell = __assign(__assign(__assign({}, rest), (indexPath ? { indexPath: indexPath } : {})), { values: visibleValues });
+    var shouldIncludeSubcell = isPathSmaller || isPathOnSameLevel;
+    return {
+        processedSubcell: shouldIncludeSubcell ? processedSubcell : null,
+        hiddenSubcellValues: hiddenSubcellValues
+    };
+};
+var processAllSubcells = function (subcells, maxIndexPath, maxIndexPathValuesCount, columnHiddenValues) {
+    var processedSubcells = subcells.map(function (subcell) {
+        var _a = processSubcell(subcell, maxIndexPath, maxIndexPathValuesCount), processedSubcell = _a.processedSubcell, hiddenSubcellValues = _a.hiddenSubcellValues;
+        if (hiddenSubcellValues.length) {
+            columnHiddenValues.push.apply(columnHiddenValues, hiddenSubcellValues);
+        }
+        return processedSubcell;
+    });
+    return processedSubcells.filter(identity);
+};
+var applyCompactValuesCountConstraintForEntity = function (maxValuesCount, rowValue) {
+    var sortedSubcellValueGroups = getSubcellValuesGroup(rowValue);
+    var baseIndexStartsAt = getBaseIndexStartsAt(rowValue);
+    var _a = getMaxIndexPath(maxValuesCount, sortedSubcellValueGroups, baseIndexStartsAt), maxIndexPath = _a.maxIndexPath, maxIndexPathValuesCount = _a.maxIndexPathValuesCount;
+    var rowValueWithConstraints = Object.entries(rowValue).reduce(function (acc, _a) {
+        var columnId = _a[0], subcells = _a[1];
+        var columnHiddenValues = [];
+        var processedSubcells = Array.isArray(subcells)
+            ? processAllSubcells(subcells, maxIndexPath, maxIndexPathValuesCount, columnHiddenValues)
+            : subcells;
+        acc[columnId] = adjust(0, assoc('hiddenValues', columnHiddenValues), processedSubcells);
+        return acc;
+    }, {});
+    return rowValueWithConstraints;
+};
+var applyCompactValuesCountConstraint = function (maxValuesCount) { return function (rowValue) {
+    if (maxValuesCount === Infinity) {
+        return rowValue;
+    }
+    return applyCompactValuesCountConstraintForEntity(maxValuesCount, rowValue);
+}; };
+var getHasHiddenAttributes = pipe(values, chain(identity), chain(pathOr([], ['hiddenValues'])), length, gt(__, 0));
+export { applyCompactValuesCountConstraint, getHasHiddenAttributes };

package/helpers/tableCompactCollapseHelpers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/helpers/tableCompactCollapseHelpers.test.js

@@ -0,0 +1,25 @@
+import { getRowValueData, getRowValueWithConstraintsDataForMVC1, getRowValueWithConstraintsDataForMVC2, getRowValueWithConstraintsDataForMVC3, getRowValueWithConstraintsDataForMVC6 } from './data/tableCompactCollapseHelper.data';
+import { applyCompactValuesCountConstraint } from './tableCompactCollapseHelpers';
+var rowValue = getRowValueData();
+describe('applyCompactValuesCountConstraint tests', function () {
+    it('should not update row value if maxValuesCount is Infinity', function () {
+        var maxValuesCount = Infinity;
+        expect(applyCompactValuesCountConstraint(maxValuesCount)(rowValue)).toEqual(rowValue);
+    });
+    it('should correctly apply constraints for maxValuesCount 1', function () {
+        var maxValuesCount = 1;
+        expect(applyCompactValuesCountConstraint(maxValuesCount)(rowValue)).toEqual(getRowValueWithConstraintsDataForMVC1());
+    });
+    it('should correctly apply constraints for maxValuesCount 2', function () {
+        var maxValuesCount = 2;
+        expect(applyCompactValuesCountConstraint(maxValuesCount)(rowValue)).toEqual(getRowValueWithConstraintsDataForMVC2());
+    });
+    it('should correctly apply constraints for maxValuesCount 3', function () {
+        var maxValuesCount = 3;
+        expect(applyCompactValuesCountConstraint(maxValuesCount)(rowValue)).toEqual(getRowValueWithConstraintsDataForMVC3());
+    });
+    it('should correctly apply constraints for maxValuesCount 6', function () {
+        var maxValuesCount = 6;
+        expect(applyCompactValuesCountConstraint(maxValuesCount)(rowValue)).toEqual(getRowValueWithConstraintsDataForMVC6());
+    });
+});

package/hooks/useBasicTableCellRenderer/useBasicTableCellRenderer.d.ts

@@ -7,13 +7,14 @@ type Props = {
     getRowCellHeight?: GetRowCellHeight;
     defaultRowHeight?: number;
     maxRowValuesCount?: number;
+    applyMaxValuesCountConstraint?: (maxValuesCount: number) => (rowValue: RowValue) => RowValue;
 };
-export declare const useBasicTableCellRenderer: ({ rowsData, columnsData, getIdFromRowValue, renderRowCell, getRowCellHeight, defaultRowHeight, maxRowValuesCount }: Props) => {
+export declare const useBasicTableCellRenderer: ({ rowsData, columnsData, getIdFromRowValue, renderRowCell, getRowCellHeight, defaultRowHeight, maxRowValuesCount, applyMaxValuesCountConstraint }: Props) => {
     getRowHeight: (rowId: RowId) => number;
     collapseContextValue: {
         maxRowValuesCount: number;
         toggleRowCollapse: (rowIndex: number) => void;
-        getIsRowCollapsible: (rowValue: Record<string, unknown>) => boolean;
+        getIsRowCollapsible: (rowValue: Record<string, unknown>) => any;
         getIsRowCollapsed: (rowIndex: number) => boolean;
     };
     getHeightForSubRow: (rowId: RowId, columnIndex: number, subRowIndex: number) => any;

package/hooks/useBasicTableCellRenderer/useBasicTableCellRenderer.js

@@ -4,14 +4,15 @@ import { calculateRowHeight } from 'react-components/dist/Table/tableUtils';
 import { defaultRenderRowCell, defaultGetRowCellHeight } from '../../helpers/basicTable';
 import { useCollapsibleTableRows } from '../useCollapsibleTableRows';
 export var useBasicTableCellRenderer = function (_a) {
-    var rowsData = _a.rowsData, columnsData = _a.columnsData, getIdFromRowValue = _a.getIdFromRowValue, _b = _a.renderRowCell, renderRowCell = _b === void 0 ? defaultRenderRowCell : _b, _c = _a.getRowCellHeight, getRowCellHeight = _c === void 0 ? defaultGetRowCellHeight : _c, _d = _a.defaultRowHeight, defaultRowHeight = _d === void 0 ? 48 : _d, _e = _a.maxRowValuesCount, maxRowValuesCount = _e === void 0 ? Infinity : _e;
+    var rowsData = _a.rowsData, columnsData = _a.columnsData, getIdFromRowValue = _a.getIdFromRowValue, _b = _a.renderRowCell, renderRowCell = _b === void 0 ? defaultRenderRowCell : _b, _c = _a.getRowCellHeight, getRowCellHeight = _c === void 0 ? defaultGetRowCellHeight : _c, _d = _a.defaultRowHeight, defaultRowHeight = _d === void 0 ? 48 : _d, _e = _a.maxRowValuesCount, maxRowValuesCount = _e === void 0 ? Infinity : _e, applyMaxValuesCountConstraint = _a.applyMaxValuesCountConstraint;
     var _f = useCollapsibleTableRows({
         rowsData: rowsData,
         columnsData: columnsData,
         renderRowCell: renderRowCell,
         getRowCellHeight: getRowCellHeight,
         maxRowValuesCount: maxRowValuesCount,
-        getIdFromRowValue: getIdFromRowValue
+        getIdFromRowValue: getIdFromRowValue,
+        applyMaxValuesCountConstraint: applyMaxValuesCountConstraint
     }), tableRowsData = _f.tableRowsData, collapseContextValue = _f.collapseContextValue;
     return useMemo(function () {
         var rowHeightCache = tableRowsData.reduce(function (cache, rowData) {

package/hooks/useCollapsibleTableRows/dataHelpers.d.ts

@@ -1,2 +1,3 @@
-export function getTableRowsData(rowValues: any, columnsData: any, renderRowCell: any, getRowCellHeight: any, getRowMaxValuesCount?: any, getIdFromRowValue?: (_: any, rowIndex: any) => any): any;
+export function getTableRowsData(rowValues: any, columnsData: any, renderRowCell: any, getRowCellHeight: any, getRowMaxValuesCount: any, getIdFromRowValue: (_: any, rowIndex: any) => any, applyMaxValuesCountConstraint: any): any;
 export function getMaxRowValuesCount(columnsData: any, rowValue: any): any;
+export function getIsRowCollapsibleFromMaxValuesCount(columnsData: any, rowValue: any, maxValuesCount: any, applyMaxValuesCountConstraint: any): any;

package/hooks/useCollapsibleTableRows/dataHelpers.js

@@ -9,7 +9,7 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-import { add, adjust, always, assoc, chain, evolve, isEmpty, isNil, map, mapObjIndexed, max, pipe, pluck, propEq, propOr, reduce, reject, slice, uniq, unless, values } from 'ramda';
+import { __, add, adjust, always, assoc, chain, evolve, gt, identity, isEmpty, isNil, length, map, mapObjIndexed, max, pathOr, pipe, pluck, propEq, propOr, reduce, reject, slice, uniq, unless, values } from 'ramda';
 import { wrapInArrayIfNeeded } from '@reltio/mdm-sdk';
 import { DefaultCellValueRenderer } from '../../DefaultCellValueRenderer';
 import { calcRowSpansForNestedKeys, flattenNestedColumnValues, getNestedKeyForNestedColumnCell, TOTAL_ROW_SPAN_KEY } from './nestedHelpers';
@@ -70,7 +70,7 @@ var areNestedValuesExceedingLimit = function (maxValuesCount) {
         return indexPath && indexPath.some(function (index) { return index > maxValuesCount - 1; });
     };
 };
-var getAllRowHiddenValues = function (rowValues, maxValuesCount) {
+var getHiddenValues = function (rowValues, maxValuesCount) {
     if (maxValuesCount === void 0) { maxValuesCount = Infinity; }
     return rowValues.reduce(function (hiddenValues, _a) {
         var _b = _a.values, values = _b === void 0 ? [] : _b, indexPath = _a.indexPath;
@@ -83,21 +83,22 @@ var getAllRowHiddenValues = function (rowValues, maxValuesCount) {
 var adjustFirstWithHiddenValues = function (maxValuesCount) {
     if (maxValuesCount === void 0) { maxValuesCount = Infinity; }
     return function (rowValues) {
-        var hiddenValues = getAllRowHiddenValues(rowValues, maxValuesCount);
-        return adjust(0, assoc('allRowHiddenValues', hiddenValues), rowValues);
+        var hiddenValues = getHiddenValues(rowValues, maxValuesCount);
+        return adjust(0, assoc('hiddenValues', hiddenValues), rowValues);
     };
 };
-var applyValuesCountConstraint = function (maxValuesCount) {
+var applyDefaultValuesCountConstraint = function (maxValuesCount) {
     return unless(function () { return maxValuesCount === Infinity; }, map(pipe(adjustFirstWithHiddenValues(maxValuesCount), reject(areNestedValuesExceedingLimit(maxValuesCount)), map(evolve({
         values: slice(0, maxValuesCount)
     })))));
 };
 var defaultGetIdFromRowValue = function (_, rowIndex) { return rowIndex; };
-var getTableRowsData = function (rowValues, columnsData, renderRowCell, getRowCellHeight, getRowMaxValuesCount, getIdFromRowValue) {
+var getTableRowsData = function (rowValues, columnsData, renderRowCell, getRowCellHeight, getRowMaxValuesCount, getIdFromRowValue, applyMaxValuesCountConstraint) {
     if (getRowMaxValuesCount === void 0) { getRowMaxValuesCount = always(Infinity); }
     if (getIdFromRowValue === void 0) { getIdFromRowValue = defaultGetIdFromRowValue; }
+    applyMaxValuesCountConstraint = applyMaxValuesCountConstraint || applyDefaultValuesCountConstraint;
     return rowValues.map(function (rowValue, rowIndex) {
-        return pipe(buildRowValues(rowValue), applyValuesCountConstraint(getRowMaxValuesCount(rowIndex)), calcRowSpans, calcHeights(columnsData, getRowCellHeight, rowIndex, rowValue), applyCellRenderer(columnsData, renderRowCell, rowIndex, rowValue), function (val) { return ({ data: val, id: getIdFromRowValue(rowValue, rowIndex) }); })(columnsData);
+        return pipe(buildRowValues(rowValue), applyMaxValuesCountConstraint(getRowMaxValuesCount(rowIndex)), calcRowSpans, calcHeights(columnsData, getRowCellHeight, rowIndex, rowValue), applyCellRenderer(columnsData, renderRowCell, rowIndex, rowValue), function (val) { return ({ data: val, id: getIdFromRowValue(rowValue, rowIndex) }); })(columnsData);
     });
 };
 var calcMaxValuesCount = reduce(function (maxCount, cellValues) {
@@ -108,4 +109,11 @@ var calcMaxValuesCount = reduce(function (maxCount, cellValues) {
 var getMaxRowValuesCount = function (columnsData, rowValue) {
     return pipe(buildRowValues(rowValue), values, calcMaxValuesCount)(columnsData);
 };
-export { getTableRowsData, getMaxRowValuesCount };
+var getHasHiddenAttributes = pipe(values, chain(identity), chain(pathOr([], ['hiddenValues'])), length, gt(__, 0));
+var getIsRowCollapsibleFromMaxValuesCount = function (columnsData, rowValue, maxValuesCount, applyMaxValuesCountConstraint) {
+    if (applyMaxValuesCountConstraint) {
+        return pipe(buildRowValues(rowValue), applyMaxValuesCountConstraint(maxValuesCount), getHasHiddenAttributes)(columnsData);
+    }
+    return getMaxRowValuesCount(columnsData, rowValue) > maxValuesCount;
+};
+export { getTableRowsData, getMaxRowValuesCount, getIsRowCollapsibleFromMaxValuesCount };

package/hooks/useCollapsibleTableRows/dataHelpers.test.js

@@ -246,7 +246,7 @@ describe('dataHelpers', function () {
                     data: {
                         'n1.a': [
                             {
-                                allRowHiddenValues: [2, 3],
+                                hiddenValues: [2, 3],
                                 values: [1],
                                 indexPath: [0],
                                 nestedKey: 'n1.0',
@@ -254,17 +254,17 @@ describe('dataHelpers', function () {
                             }
                         ],
                         'n1.n2.b': [
-                            { values: [], allRowHiddenValues: [4, 5, 6], indexPath: [0], nestedKey: 'n1.0', rowSpan: 1 }
+                            { values: [], hiddenValues: [4, 5, 6], indexPath: [0], nestedKey: 'n1.0', rowSpan: 1 }
                         ],
-                        c: [{ allRowHiddenValues: [8, 9, 10], values: [7], rowSpan: 1 }],
-                        'n1.d': [{ values: [], allRowHiddenValues: [], rowSpan: 1 }]
+                        c: [{ hiddenValues: [8, 9, 10], values: [7], rowSpan: 1 }],
+                        'n1.d': [{ values: [], hiddenValues: [], rowSpan: 1 }]
                     },
                     id: 0
                 }
             ]);
             expect(getRowMaxValuesCount).toHaveBeenCalledWith(0);
         });
-        it('should apply allRowHiddenValues correctly if maxValuesCount more than 1', function () {
+        it('should apply hiddenValues correctly if maxValuesCount more than 1', function () {
             var rowValues = [
                 {
                     'n1.n2.a': [[[1, 2]], [[3, 4, 5]]]
@@ -282,7 +282,7 @@ describe('dataHelpers', function () {
                         'n1.n2.a': [
                             {
                                 values: [1, 2],
-                                allRowHiddenValues: [5],
+                                hiddenValues: [5],
                                 indexPath: [0, 0],
                                 nestedKey: 'n1.0.n2.0',
                                 rowSpan: 1

package/hooks/useCollapsibleTableRows/useCollapsibleTableRows.d.ts

@@ -6,13 +6,14 @@ type Props = {
     getRowCellHeight: GetRowCellHeight;
     maxRowValuesCount: number;
     getIdFromRowValue?: (rowValue: RowValue, rowIndex: number) => RowId;
+    applyMaxValuesCountConstraint?: (maxValuesCount: number) => (rowValue: RowValue) => RowValue;
 };
-export declare const useCollapsibleTableRows: ({ rowsData, columnsData, renderRowCell, getRowCellHeight, maxRowValuesCount, getIdFromRowValue }: Props) => {
+export declare const useCollapsibleTableRows: ({ rowsData, columnsData, renderRowCell, getRowCellHeight, maxRowValuesCount, getIdFromRowValue, applyMaxValuesCountConstraint }: Props) => {
     tableRowsData: TableRowsData;
     collapseContextValue: {
         maxRowValuesCount: number;
         toggleRowCollapse: (rowIndex: number) => void;
-        getIsRowCollapsible: (rowValue: Record<string, unknown>) => boolean;
+        getIsRowCollapsible: (rowValue: Record<string, unknown>) => any;
         getIsRowCollapsed: (rowIndex: number) => boolean;
     };
 };

package/hooks/useCollapsibleTableRows/useCollapsibleTableRows.js

@@ -1,17 +1,25 @@
 import { useCallback, useMemo, useState } from 'react';
 import { equals, filter, remove } from 'ramda';
-import { getTableRowsData, getMaxRowValuesCount } from './dataHelpers';
+import { getTableRowsData, getIsRowCollapsibleFromMaxValuesCount } from './dataHelpers';
 import { useDidUpdateEffect } from '../useDidUpdateEffect';
 import { usePrevious } from '../../hooks/usePrevious';
 export var useCollapsibleTableRows = function (_a) {
-    var rowsData = _a.rowsData, columnsData = _a.columnsData, renderRowCell = _a.renderRowCell, getRowCellHeight = _a.getRowCellHeight, maxRowValuesCount = _a.maxRowValuesCount, getIdFromRowValue = _a.getIdFromRowValue;
+    var rowsData = _a.rowsData, columnsData = _a.columnsData, renderRowCell = _a.renderRowCell, getRowCellHeight = _a.getRowCellHeight, maxRowValuesCount = _a.maxRowValuesCount, getIdFromRowValue = _a.getIdFromRowValue, applyMaxValuesCountConstraint = _a.applyMaxValuesCountConstraint;
     var _b = useState([]), expandedIndexes = _b[0], setExpandedIndexes = _b[1];
     var getRowMaxValuesCount = useCallback(function (rowIndex) {
         return expandedIndexes.includes(rowIndex) ? Infinity : maxRowValuesCount;
     }, [expandedIndexes, maxRowValuesCount]);
     var tableRowsData = useMemo(function () {
-        return getTableRowsData(rowsData, columnsData, renderRowCell, getRowCellHeight, getRowMaxValuesCount, getIdFromRowValue);
-    }, [rowsData, columnsData, renderRowCell, getRowCellHeight, getRowMaxValuesCount, getIdFromRowValue]);
+        return getTableRowsData(rowsData, columnsData, renderRowCell, getRowCellHeight, getRowMaxValuesCount, getIdFromRowValue, applyMaxValuesCountConstraint);
+    }, [
+        rowsData,
+        columnsData,
+        renderRowCell,
+        getRowCellHeight,
+        getRowMaxValuesCount,
+        getIdFromRowValue,
+        applyMaxValuesCountConstraint
+    ]);
     var toggleRowCollapse = useCallback(function (rowIndex) {
         setExpandedIndexes(function (expandedIndexes) {
             var index = expandedIndexes.findIndex(equals(rowIndex));
@@ -19,8 +27,8 @@ export var useCollapsibleTableRows = function (_a) {
         });
     }, []);
     var getIsRowCollapsible = useCallback(function (rowValue) {
-        return getMaxRowValuesCount(columnsData, rowValue) > maxRowValuesCount;
-    }, [maxRowValuesCount, columnsData]);
+        return getIsRowCollapsibleFromMaxValuesCount(columnsData, rowValue, maxRowValuesCount, applyMaxValuesCountConstraint);
+    }, [maxRowValuesCount, columnsData, applyMaxValuesCountConstraint]);
     var getIsRowCollapsed = useCallback(function (rowIndex) {
         return !expandedIndexes.includes(rowIndex);
     }, [expandedIndexes]);

package/hooks/useCollapsibleTableRows/useCollapsibleTableRows.test.js

@@ -44,11 +44,11 @@ describe('useCollapsibleTableRows tests', function () {
     };
     beforeAll(function () {
         jest.spyOn(dataHelpers, 'getTableRowsData');
-        jest.spyOn(dataHelpers, 'getMaxRowValuesCount');
+        jest.spyOn(dataHelpers, 'getIsRowCollapsibleFromMaxValuesCount');
     });
     beforeEach(function () {
         dataHelpers.getTableRowsData.mockClear();
-        dataHelpers.getMaxRowValuesCount.mockClear();
+        dataHelpers.getIsRowCollapsibleFromMaxValuesCount.mockClear();
     });
     it('should return collapsed table rows data by default', function () {
         var result = getCollapsibleTableRows().result;
@@ -73,9 +73,8 @@ describe('useCollapsibleTableRows tests', function () {
     });
     it('should return correct getIsRowCollapsible function for context', function () {
         var _a = getCollapsibleTableRows(), result = _a.result, rerender = _a.rerender;
-        dataHelpers.getMaxRowValuesCount.mockReturnValueOnce(3);
         expect(result.current.collapseContextValue.getIsRowCollapsible(rowsData[0])).toBe(true);
-        expect(dataHelpers.getMaxRowValuesCount).toHaveBeenCalledWith(columnsData, rowsData[0]);
+        expect(dataHelpers.getIsRowCollapsibleFromMaxValuesCount).toHaveBeenCalledWith(columnsData, rowsData[0], 1, undefined);
         rerender(__assign(__assign({}, initialProps), { maxRowValuesCount: 4 }));
         expect(result.current.collapseContextValue.getIsRowCollapsible(rowsData[0])).toBe(false);
     });

package/index.d.ts

@@ -277,6 +277,7 @@ export { showDefaultErrorMessage, showErrorMessage } from './helpers/errors';
 export { getChecked, getValue, isControlOrCommandPressed } from './helpers/events';
 export { mergeClasses } from './helpers/classes';
 export { getAttributeSelectorItems } from './helpers/attributesSelector';
+export { applyCompactValuesCountConstraint } from './helpers/tableCompactCollapseHelpers';
 export type { AttributeFiltersComponentProps } from './AttributesFiltersBuilder';
 export type { ChartData } from './types/charts';
 export type { AddInlineAttributeEvent, DeleteInlineAttributeEvent, EditInlineAttributeEvent, IgnoreInlineAttributeEvent, PinInlineAttributeEvent } from './types/inlineAttributes';

package/index.js

@@ -282,6 +282,7 @@ export { showDefaultErrorMessage, showErrorMessage } from './helpers/errors';
 export { getChecked, getValue, isControlOrCommandPressed } from './helpers/events';
 export { mergeClasses } from './helpers/classes';
 export { getAttributeSelectorItems } from './helpers/attributesSelector';
+export { applyCompactValuesCountConstraint } from './helpers/tableCompactCollapseHelpers';
 export * from './types/preferences';
 export * from './types';
 // constants

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reltio/components",
-  "version": "1.4.2080",
+  "version": "1.4.2082",
   "license": "SEE LICENSE IN LICENSE FILE",
   "main": "./cjs/index.js",
   "module": "./index.js",
@@ -11,7 +11,7 @@
     "@fluentui/react-context-selector": "^9.1.26",
     "@googlemaps/markerclusterer": "^2.5.3",
     "@react-sigma/core": "3.4.0",
-    "@reltio/mdm-sdk": "^1.4.1923",
+    "@reltio/mdm-sdk": "^1.4.1925",
     "@vis.gl/react-google-maps": "^1.3.0",
     "d3-cloud": "^1.2.5",
     "d3-geo": "^2.0.1",