@reltio/components 1.4.699 → 1.4.703

package/components/BasicTableView/BasicTable/HOCs/withFilter.js

@@ -0,0 +1,38 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = __importDefault(require("react"));
+var prop_types_1 = __importDefault(require("prop-types"));
+var ColumnFilter_1 = __importDefault(require("../../ColumnFilter/ColumnFilter"));
+var styles_1 = require("../../ColumnFilter/styles");
+var withFilter = function (_a) {
+    var filter = _a.filter, onFilter = _a.onFilter, filterable = _a.filterable, filterOptions = _a.filterOptions, dataTypeDefinition = _a.dataTypeDefinition;
+    return function (HeadCellRenderer) {
+        var HeadCellRendererWithFilter = function (props) {
+            var columnId = props.headCellData.id;
+            var styles = styles_1.useStyles();
+            var columnFilter = filterable ? (react_1.default.createElement(ColumnFilter_1.default, { columnId: columnId, dataTypeDefinition: dataTypeDefinition, filter: filter, filterOptionsData: filterOptions, onFilter: onFilter })) : (react_1.default.createElement("div", { className: styles.columnFilter }));
+            return react_1.default.createElement(HeadCellRenderer, __assign({}, props, { columnFilter: columnFilter }));
+        };
+        HeadCellRendererWithFilter.propTypes = {
+            headCellData: prop_types_1.default.shape({
+                id: prop_types_1.default.string
+            })
+        };
+        return HeadCellRendererWithFilter;
+    };
+};
+exports.default = withFilter;

package/components/BasicTableView/BasicTable/HOCs/withFilterAtBottom.js

@@ -0,0 +1,43 @@
+"use strict";
+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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = __importDefault(require("react"));
+var prop_types_1 = __importDefault(require("prop-types"));
+var withFilterAtBottom = function (HeadCellRenderer) {
+    var HeadCellRendererWithFilterAtBottom = function (_a) {
+        var columnFilter = _a.columnFilter, otherProps = __rest(_a, ["columnFilter"]);
+        return (react_1.default.createElement("div", { style: { display: 'flex', flexDirection: 'column', height: '100%' } },
+            react_1.default.createElement("div", { style: { display: 'flex', flex: 1 } },
+                react_1.default.createElement(HeadCellRenderer, __assign({}, otherProps))),
+            columnFilter));
+    };
+    HeadCellRendererWithFilterAtBottom.propTypes = {
+        columnFilter: prop_types_1.default.node
+    };
+    return HeadCellRendererWithFilterAtBottom;
+};
+exports.default = withFilterAtBottom;

package/components/BasicTableView/BasicTable/HOCs/withTableContext.js

@@ -0,0 +1,47 @@
+"use strict";
+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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = __importStar(require("react"));
+var TableContext_1 = require("../contexts/TableContext");
+var withTableContext = function (contextSelector) { return function (CellRenderer) {
+    if (contextSelector) {
+        var PureCellRenderer_1 = react_1.memo(CellRenderer);
+        var CellRendererWithContext = function (props) {
+            return (react_1.default.createElement(TableContext_1.TableContext.Consumer, null, function (tableContext) { return react_1.default.createElement(PureCellRenderer_1, __assign({}, props, contextSelector(tableContext, props))); }));
+        };
+        return CellRendererWithContext;
+    }
+    else {
+        return CellRenderer;
+    }
+}; };
+exports.default = withTableContext;

package/components/BasicTableView/BasicTable/cell-value-renderers/BlobRenderer.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var prop_types_1 = __importDefault(require("prop-types"));
+var react_1 = __importDefault(require("react"));
+var styles_1 = require("./styles");
+var stopPropagation = function (event) {
+    event.stopPropagation();
+};
+var BlobRenderer = function (_a) {
+    var value = _a.value;
+    var styles = styles_1.useStyles();
+    return (react_1.default.createElement("div", { className: styles.blobWrapper, onScroll: stopPropagation }, value));
+};
+BlobRenderer.propTypes = {
+    value: prop_types_1.default.node
+};
+exports.default = BlobRenderer;

package/components/BasicTableView/BasicTable/cell-value-renderers/DefaultCellValueRenderer.js

@@ -0,0 +1,43 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var BlobRenderer_1 = __importDefault(require("./BlobRenderer"));
+var DataTypeValue_1 = __importDefault(require("../../../DataTypeValue/DataTypeValue"));
+var prop_types_1 = __importDefault(require("prop-types"));
+var react_1 = __importDefault(require("react"));
+var mdm_sdk_1 = require("@reltio/mdm-sdk");
+var styles_1 = require("./styles");
+var ExpandedValueTooltip_1 = __importDefault(require("../../../ExpandedValueTooltip/ExpandedValueTooltip"));
+var DefaultCellValueRenderer = function (props) {
+    var styles = styles_1.useStyles();
+    var value = props.value, dataTypeDefinition = props.columnData.dataTypeDefinition;
+    switch (dataTypeDefinition.type) {
+        case mdm_sdk_1.DataTypes.TYPE_BLOB:
+            return react_1.default.createElement(BlobRenderer_1.default, __assign({}, props));
+        default: {
+            var dataTypeValue = react_1.default.createElement(DataTypeValue_1.default, { value: value, dataTypeDefinition: dataTypeDefinition });
+            return (react_1.default.createElement(ExpandedValueTooltip_1.default, { value: dataTypeValue },
+                react_1.default.createElement("div", { className: styles.defaultWrapper }, dataTypeValue)));
+        }
+    }
+};
+DefaultCellValueRenderer.propTypes = {
+    value: prop_types_1.default.any,
+    columnData: prop_types_1.default.shape({
+        dataTypeDefinition: prop_types_1.default.object
+    })
+};
+exports.default = DefaultCellValueRenderer;

package/components/BasicTableView/BasicTable/cell-value-renderers/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultCellValueRenderer = void 0;
+var DefaultCellValueRenderer_1 = require("./DefaultCellValueRenderer");
+Object.defineProperty(exports, "DefaultCellValueRenderer", { enumerable: true, get: function () { return __importDefault(DefaultCellValueRenderer_1).default; } });

package/components/BasicTableView/BasicTable/cell-value-renderers/styles.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useStyles = exports.BLOB_HEIGHT = void 0;
+var styles_1 = require("@material-ui/core/styles");
+exports.BLOB_HEIGHT = 100;
+exports.useStyles = styles_1.makeStyles({
+    defaultWrapper: {
+        whiteSpace: 'nowrap',
+        overflow: 'hidden',
+        textOverflow: 'ellipsis',
+        padding: '15px 25px 0 25px'
+    },
+    blobWrapper: {
+        position: 'relative',
+        overflowY: 'auto',
+        overflowX: 'hidden',
+        whiteSpace: 'pre',
+        maxHeight: exports.BLOB_HEIGHT + "px",
+        boxSizing: 'border-box',
+        padding: '15px 25px 0 25px'
+    }
+});

package/components/BasicTableView/BasicTable/contexts/RowCollapseContext.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowCollapseContext = void 0;
+var react_1 = __importDefault(require("react"));
+exports.RowCollapseContext = react_1.default.createContext(null);
+exports.RowCollapseContext.displayName = 'RowCollapseContext';

package/components/BasicTableView/BasicTable/contexts/TableContext.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableContext = void 0;
+var react_1 = __importDefault(require("react"));
+exports.TableContext = react_1.default.createContext(null);
+exports.TableContext.displayName = 'TableContext';

package/components/BasicTableView/BasicTable/contexts/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableContext = void 0;
+var TableContext_1 = require("./TableContext");
+Object.defineProperty(exports, "TableContext", { enumerable: true, get: function () { return TableContext_1.TableContext; } });

package/components/BasicTableView/BasicTable/helpers/dataHelpers.js

@@ -0,0 +1,122 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMaxRowValuesCount = exports.getTableHeadData = exports.getTableRowsData = void 0;
+var DefaultCellValueRenderer_1 = __importDefault(require("../cell-value-renderers/DefaultCellValueRenderer"));
+var withFilter_1 = __importDefault(require("../HOCs/withFilter"));
+var nestedHelpers_1 = require("./nestedHelpers");
+var ramda_1 = require("ramda");
+var mdm_sdk_1 = require("@reltio/mdm-sdk");
+var DefaultHeadCellRenderer_1 = __importDefault(require("react-components/dist/Table/DefaultHeadCellRenderer/DefaultHeadCellRenderer"));
+var withFilterAtBottom_1 = __importDefault(require("../HOCs/withFilterAtBottom"));
+var applyCellRendererToColumnCells = function (columnsData, renderRowCell, rowIndex, rowValue) { return function (cells, columnId) {
+    var columnIndex = columnsData.findIndex(ramda_1.propEq('id', columnId));
+    var columnData = columnsData[columnIndex];
+    var _a = columnsData[columnIndex].rowCellValueRenderer, CellValueRenderer = _a === void 0 ? DefaultCellValueRenderer_1.default : _a;
+    return cells.map(function (cell, cellIndex) { return (__assign(__assign({}, cell), { values: renderRowCell({
+            columnIndex: columnIndex,
+            columnData: columnData,
+            rowIndex: rowIndex,
+            rowValue: rowValue,
+            cellIndex: cellIndex,
+            cell: cell,
+            CellValueRenderer: CellValueRenderer
+        }) })); });
+}; };
+var applyCellRenderer = ramda_1.pipe(applyCellRendererToColumnCells, ramda_1.mapObjIndexed);
+var calcHeightForColumnCells = function (columnsData, getRowCellHeight, rowIndex, rowValue) { return function (cells, columnId) {
+    var columnIndex = columnsData.findIndex(ramda_1.propEq('id', columnId));
+    var columnData = columnsData[columnIndex];
+    return cells.map(function (cell, cellIndex) { return (__assign(__assign({}, cell), { height: getRowCellHeight({ columnIndex: columnIndex, columnData: columnData, rowIndex: rowIndex, rowValue: rowValue, cellIndex: cellIndex, cell: cell }) })); });
+}; };
+var calcHeights = function (columnsData, getRowCellHeight, rowIndex, rowValue) { return function (rowData) {
+    return getRowCellHeight
+        ? ramda_1.mapObjIndexed(calcHeightForColumnCells(columnsData, getRowCellHeight, rowIndex, rowValue), rowData)
+        : rowData;
+}; };
+var addRowSpansToColumnCells = function (rowSpansData) {
+    return ramda_1.map(function (cell) { return (__assign(__assign({}, cell), { rowSpan: rowSpansData[cell.nestedKey || nestedHelpers_1.TOTAL_ROW_SPAN_KEY] })); });
+};
+var getNestedKeysFromRowCells = ramda_1.pipe(ramda_1.chain(ramda_1.pluck('nestedKey')), ramda_1.reject(ramda_1.isNil), ramda_1.uniq);
+var calcRowSpansData = ramda_1.pipe(ramda_1.values, getNestedKeysFromRowCells, nestedHelpers_1.calcRowSpansForNestedKeys);
+var calcRowSpans = function (rowData) {
+    var rowSpansData = calcRowSpansData(rowData);
+    return ramda_1.isEmpty(rowSpansData) ? rowData : ramda_1.map(addRowSpansToColumnCells(rowSpansData), rowData);
+};
+var calcNestedKeys = function (columnNestedPath) {
+    return ramda_1.map(function (cell) { return (__assign(__assign({}, cell), { nestedKey: nestedHelpers_1.getNestedKeyForNestedColumnCell(columnNestedPath, cell) })); });
+};
+var parseNestedColumnValues = function (columnNestedPath, nestedValues) {
+    return ramda_1.pipe(nestedHelpers_1.flattenNestedColumnValues, calcNestedKeys(columnNestedPath))(nestedValues);
+};
+var getCellValues = function (columnNestedPath, columnValues) {
+    return columnNestedPath && !ramda_1.isEmpty(columnValues)
+        ? parseNestedColumnValues(columnNestedPath, columnValues)
+        : [{ values: mdm_sdk_1.wrapInArrayIfNeeded(columnValues) }];
+};
+var buildRowValues = function (rowValue) {
+    return ramda_1.reduce(function (acc, _a) {
+        var id = _a.id, nestedPath = _a.nestedPath;
+        return ramda_1.assoc(id, getCellValues(nestedPath, rowValue[id]), acc);
+    }, {});
+};
+var applyValuesCountConstraint = function (maxValuesCount) {
+    return ramda_1.unless(function () { return maxValuesCount === Infinity; }, ramda_1.map(ramda_1.pipe(ramda_1.reject(function (_a) {
+        var indexPath = _a.indexPath;
+        return indexPath && indexPath.some(function (index) { return index > maxValuesCount - 1; });
+    }), ramda_1.map(ramda_1.evolve({
+        values: ramda_1.slice(0, maxValuesCount)
+    })))));
+};
+var getTableRowsData = function (rowValues, columnsData, renderRowCell, getRowCellHeight, getRowMaxValuesCount) {
+    if (getRowMaxValuesCount === void 0) { getRowMaxValuesCount = ramda_1.always(Infinity); }
+    return rowValues.map(ramda_1.pipe(function (rowValue, rowIndex) {
+        return ramda_1.pipe(buildRowValues(rowValue), applyValuesCountConstraint(getRowMaxValuesCount(rowIndex)), calcRowSpans, calcHeights(columnsData, getRowCellHeight, rowIndex, rowValue), applyCellRenderer(columnsData, renderRowCell, rowIndex, rowValue))(columnsData);
+    }, ramda_1.objOf('data')));
+};
+exports.getTableRowsData = getTableRowsData;
+var getTableHeadData = function (columnsData, filters, onFilter) {
+    return columnsData.map(function (_a) {
+        var id = _a.id, label = _a.label, sortable = _a.sortable, _b = _a.filterable, filterable = _b === void 0 ? true : _b, resizable = _a.resizable, draggable = _a.draggable, _c = _a.autoResize, autoResize = _c === void 0 ? true : _c, initialWidth = _a.initialWidth, minWidth = _a.minWidth, dataTypeDefinition = _a.dataTypeDefinition, filterOptions = _a.filterOptions, _d = _a.headCellRenderer, headCellRenderer = _d === void 0 ? withFilterAtBottom_1.default(DefaultHeadCellRenderer_1.default) : _d;
+        return ({
+            id: id,
+            label: label,
+            sortable: sortable,
+            resizable: resizable,
+            draggable: draggable,
+            initialWidth: initialWidth,
+            minWidth: minWidth,
+            autoResize: autoResize,
+            renderer: ramda_1.unless(function () { return ramda_1.isNil(filters); }, withFilter_1.default({
+                dataTypeDefinition: dataTypeDefinition,
+                filterable: filterable,
+                filter: ramda_1.prop(id, filters),
+                filterOptions: filterOptions,
+                onFilter: onFilter
+            }))(headCellRenderer)
+        });
+    });
+};
+exports.getTableHeadData = getTableHeadData;
+var calcMaxValuesCount = ramda_1.reduce(function (maxCount, cellValues) {
+    var maxSubNestedValuesCount = ramda_1.pipe(ramda_1.chain(ramda_1.propOr([], 'indexPath')), ramda_1.map(ramda_1.add(1)), ramda_1.reduce(ramda_1.max, 0))(cellValues);
+    var maxPlainValuesCount = ramda_1.pipe(ramda_1.pluck('values'), ramda_1.pluck('length'), ramda_1.reduce(ramda_1.max, 0))(cellValues);
+    return Math.max(maxCount, maxSubNestedValuesCount, maxPlainValuesCount);
+}, 0);
+var getMaxRowValuesCount = function (columnsData, rowValue) {
+    return ramda_1.pipe(buildRowValues(rowValue, Infinity), ramda_1.values, calcMaxValuesCount)(columnsData);
+};
+exports.getMaxRowValuesCount = getMaxRowValuesCount;

package/components/BasicTableView/BasicTable/helpers/defaultGetRowCellHeight.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var mdm_sdk_1 = require("@reltio/mdm-sdk");
+var BLOB_HEIGHT = 100;
+var IMAGE_HEIGHT = 64;
+var PADDING = 15;
+var defaultGetRowCellHeight = function (_a) {
+    var _b;
+    var columnData = _a.columnData, cell = _a.cell;
+    var valuesCount = cell.values.length;
+    switch ((_b = columnData === null || columnData === void 0 ? void 0 : columnData.dataTypeDefinition) === null || _b === void 0 ? void 0 : _b.type) {
+        case mdm_sdk_1.DataTypes.TYPE_BLOB:
+            return BLOB_HEIGHT * valuesCount;
+        case mdm_sdk_1.DataTypes.TYPE_IMAGE:
+            return (PADDING + IMAGE_HEIGHT) * valuesCount + PADDING;
+        default:
+            return 33 * Math.max(valuesCount, 1) + PADDING;
+    }
+};
+exports.default = defaultGetRowCellHeight;

package/components/BasicTableView/BasicTable/helpers/defaultRenderRowCell.js

@@ -0,0 +1,33 @@
+"use strict";
+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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = __importDefault(require("react"));
+var defaultRenderRowCell = function (_a) {
+    var cell = _a.cell, CellValueRenderer = _a.CellValueRenderer, otherProps = __rest(_a, ["cell", "CellValueRenderer"]);
+    return cell.values.map(function (value, index) { return react_1.default.createElement(CellValueRenderer, __assign({ key: index, value: value }, otherProps)); });
+};
+exports.default = defaultRenderRowCell;

package/components/BasicTableView/BasicTable/helpers/nestedHelpers.js

@@ -0,0 +1,80 @@
+"use strict";
+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 __spreadArray = (this && this.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNestedKeyForNestedColumnCell = exports.getParentRowKeyBySiblingsSubRowsKey = exports.getSiblingSubRowsKeyBySubRowKey = exports.flattenNestedColumnValues = exports.TOTAL_ROW_SPAN_KEY = exports.calcRowSpansForNestedKeys = void 0;
+var ramda_1 = require("ramda");
+var TOTAL_ROW_SPAN_KEY = 'total';
+exports.TOTAL_ROW_SPAN_KEY = TOTAL_ROW_SPAN_KEY;
+var NESTED_KEY_DELIMITER = '.';
+var getSiblingSubRowsKeyBySubRowKey = ramda_1.pipe(ramda_1.split(NESTED_KEY_DELIMITER), ramda_1.dropLast(1), ramda_1.join(NESTED_KEY_DELIMITER));
+exports.getSiblingSubRowsKeyBySubRowKey = getSiblingSubRowsKeyBySubRowKey;
+var getParentRowKeyBySiblingsSubRowsKey = ramda_1.pipe(ramda_1.split(NESTED_KEY_DELIMITER), ramda_1.dropLast(1), ramda_1.join(NESTED_KEY_DELIMITER), ramda_1.unless(ramda_1.length, ramda_1.always(TOTAL_ROW_SPAN_KEY)));
+exports.getParentRowKeyBySiblingsSubRowsKey = getParentRowKeyBySiblingsSubRowsKey;
+var getParentRowKeyBySubRowKey = ramda_1.pipe(getSiblingSubRowsKeyBySubRowKey, getParentRowKeyBySiblingsSubRowsKey);
+var countParentSpanByAllSubRows = function (rowSpanData, siblingSubRowsKey) {
+    return ramda_1.pipe(ramda_1.pickBy(function (_val, key) { return getSiblingSubRowsKeyBySubRowKey(key) === siblingSubRowsKey; }), ramda_1.values, ramda_1.sum)(rowSpanData);
+};
+var calcParentRowSpan = function (rowSpanData, subRowKey) {
+    var parentKey = getParentRowKeyBySubRowKey(subRowKey);
+    var currentParentSpan = ramda_1.propOr(0, parentKey, rowSpanData);
+    var actualParentSpan = countParentSpanByAllSubRows(rowSpanData, getSiblingSubRowsKeyBySubRowKey(subRowKey));
+    if (actualParentSpan > currentParentSpan) {
+        var nextRowSpanData = ramda_1.assoc(parentKey, actualParentSpan, rowSpanData);
+        return parentKey === TOTAL_ROW_SPAN_KEY ? nextRowSpanData : calcParentRowSpan(nextRowSpanData, parentKey);
+    }
+    else {
+        return rowSpanData;
+    }
+};
+var addNestedKey = function (rowSpanData, nestedKey) {
+    var _a;
+    return calcParentRowSpan(__assign(__assign({}, rowSpanData), (_a = {}, _a[nestedKey] = 1, _a)), nestedKey);
+};
+var validateParentRowSpan = function (rowSpanData, _a) {
+    var siblingSubRowsKey = _a[0], subRowsKeys = _a[1];
+    var parentKey = getParentRowKeyBySiblingsSubRowsKey(siblingSubRowsKey);
+    var currentParentSpan = ramda_1.propOr(0, parentKey, rowSpanData);
+    var actualParentSpan = countParentSpanByAllSubRows(rowSpanData, siblingSubRowsKey);
+    var spanDiff = currentParentSpan - actualParentSpan;
+    if (spanDiff > 0) {
+        var lowestSubRowKey = "" + siblingSubRowsKey + NESTED_KEY_DELIMITER + (subRowsKeys.length - 1);
+        var lowestSubRowSpan = rowSpanData[lowestSubRowKey];
+        return ramda_1.assoc(lowestSubRowKey, lowestSubRowSpan + spanDiff, rowSpanData);
+    }
+    else {
+        return rowSpanData;
+    }
+};
+var validateRowSpanData = function (rowSpanData) {
+    return ramda_1.pipe(ramda_1.omit([TOTAL_ROW_SPAN_KEY]), ramda_1.keys, ramda_1.groupBy(getSiblingSubRowsKeyBySubRowKey), ramda_1.toPairs, ramda_1.reduce(validateParentRowSpan, rowSpanData))(rowSpanData);
+};
+var calcRowSpansForNestedKeys = ramda_1.pipe(ramda_1.reduce(addNestedKey, {}), validateRowSpanData);
+exports.calcRowSpansForNestedKeys = calcRowSpansForNestedKeys;
+var chainWithIndex = ramda_1.addIndex(ramda_1.chain);
+var flattenNestedColumnValues = function (values, indexPath) {
+    if (indexPath === void 0) { indexPath = []; }
+    var head = values[0];
+    return Array.isArray(head)
+        ? chainWithIndex(function (value, index) { return flattenNestedColumnValues(value, __spreadArray(__spreadArray([], indexPath), [index])); }, values)
+        : { indexPath: indexPath, values: values };
+};
+exports.flattenNestedColumnValues = flattenNestedColumnValues;
+var getNestedKeyForNestedColumnCell = ramda_1.curry(function (columnNestedPath, cell) {
+    return ramda_1.pipe(ramda_1.zip(ramda_1.__, cell.indexPath), ramda_1.unnest, ramda_1.join(NESTED_KEY_DELIMITER))(columnNestedPath);
+});
+exports.getNestedKeyForNestedColumnCell = getNestedKeyForNestedColumnCell;

package/components/BasicTableView/BasicTable/hooks/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useBasicTableCellRenderer = exports.useDynamicRowCellHeight = void 0;
+var useDynamicRowCellHeight_1 = require("./useDynamicRowCellHeight");
+Object.defineProperty(exports, "useDynamicRowCellHeight", { enumerable: true, get: function () { return __importDefault(useDynamicRowCellHeight_1).default; } });
+var useBasicTableCellRenderer_1 = require("./useBasicTableCellRenderer");
+Object.defineProperty(exports, "useBasicTableCellRenderer", { enumerable: true, get: function () { return __importDefault(useBasicTableCellRenderer_1).default; } });

package/components/BasicTableView/BasicTable/hooks/useBasicTableCellRenderer.js

@@ -0,0 +1,94 @@
+"use strict";
+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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = __importStar(require("react"));
+var prop_types_1 = __importDefault(require("prop-types"));
+var tableUtils_1 = require("react-components/dist/Table/tableUtils");
+var defaultRenderRowCell_1 = __importDefault(require("../helpers/defaultRenderRowCell"));
+var defaultGetRowCellHeight_1 = __importDefault(require("../helpers/defaultGetRowCellHeight"));
+var ramda_1 = require("ramda");
+var useCollapsibleTableRows_1 = __importDefault(require("./useCollapsibleTableRows"));
+var RowCollapseContext_1 = require("../contexts/RowCollapseContext");
+var useBasicTableCellRenderer = function (_a) {
+    var rowsData = _a.rowsData, columnsData = _a.columnsData, _b = _a.renderRowCell, renderRowCell = _b === void 0 ? defaultRenderRowCell_1.default : _b, _c = _a.getRowCellHeight, getRowCellHeight = _c === void 0 ? defaultGetRowCellHeight_1.default : _c, _d = _a.defaultRowHeight, defaultRowHeight = _d === void 0 ? 48 : _d, _e = _a.maxRowValuesCount, maxRowValuesCount = _e === void 0 ? Infinity : _e;
+    var _f = useCollapsibleTableRows_1.default({
+        rowsData: rowsData,
+        columnsData: columnsData,
+        renderRowCell: renderRowCell,
+        getRowCellHeight: getRowCellHeight,
+        maxRowValuesCount: maxRowValuesCount
+    }), tableRowsData = _f.tableRowsData, collapseContextValue = _f.collapseContextValue;
+    return react_1.useMemo(function () {
+        var rowHeightCache = tableRowsData.reduce(function (cache, rowData, rowIndex) {
+            var data = rowData.data;
+            cache[rowIndex] = tableUtils_1.calculateRowHeight(data, defaultRowHeight);
+            return cache;
+        }, {});
+        var getHeightForSubRow = function (rowIndex, columnIndex, subRowIndex) {
+            var heightPath = [rowIndex, 'subRowHeight', columnIndex, subRowIndex, 'height'];
+            return ramda_1.pathOr(0, heightPath, rowHeightCache);
+        };
+        var getRowHeight = function (rowIndex) { return ramda_1.pathOr(0, [rowIndex, 'height'], rowHeightCache); };
+        var CellRenderer = function (_a) {
+            var columnId = _a.columnId, rowIndex = _a.rowIndex, otherProps = __rest(_a, ["columnId", "rowIndex"]);
+            return (react_1.default.createElement(RowCollapseContext_1.RowCollapseContext.Provider, { value: collapseContextValue },
+                react_1.default.createElement("div", __assign({}, otherProps, { style: { height: getRowHeight(rowIndex) } }), tableRowsData.length > 0 &&
+                    tableUtils_1.getCellContentFromRowsData({
+                        columnIndex: columnsData.findIndex(ramda_1.propEq('id', columnId)),
+                        headData: columnsData,
+                        rowsData: tableRowsData,
+                        rowIndex: rowIndex,
+                        getHeightForSubRow: getHeightForSubRow
+                    }))));
+        };
+        CellRenderer.propTypes = {
+            columnId: prop_types_1.default.string,
+            rowIndex: prop_types_1.default.number
+        };
+        return { getRowHeight: getRowHeight, CellRenderer: CellRenderer };
+    }, [tableRowsData, defaultRowHeight, collapseContextValue, columnsData]);
+};
+exports.default = useBasicTableCellRenderer;