@reltio/components 1.4.876 → 1.4.877

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

@@ -1,4 +1,3 @@
-"use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -10,22 +9,17 @@ var __assign = (this && this.__assign) || function () {
     };
     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"));
+import DefaultCellValueRenderer from '../cell-value-renderers/DefaultCellValueRenderer';
+import withFilter from '../HOCs/withFilter';
+import { calcRowSpansForNestedKeys, flattenNestedColumnValues, getNestedKeyForNestedColumnCell, TOTAL_ROW_SPAN_KEY } from './nestedHelpers';
+import { add, always, assoc, chain, evolve, isEmpty, isNil, map, mapObjIndexed, max, objOf, pipe, pluck, prop, propEq, propOr, reduce, reject, slice, uniq, unless, values } from 'ramda';
+import { wrapInArrayIfNeeded } from '@reltio/mdm-sdk';
+import DefaultHeadCellRenderer from 'react-components/dist/Table/DefaultHeadCellRenderer/DefaultHeadCellRenderer';
+import withFilterAtBottom from '../HOCs/withFilterAtBottom';
 var applyCellRendererToColumnCells = function (columnsData, renderRowCell, rowIndex, rowValue) { return function (cells, columnId) {
-    var columnIndex = columnsData.findIndex(ramda_1.propEq('id', columnId));
+    var columnIndex = columnsData.findIndex(propEq('id', columnId));
     var columnData = columnsData[columnIndex];
-    var _a = columnsData[columnIndex].rowCellValueRenderer, CellValueRenderer = _a === void 0 ? DefaultCellValueRenderer_1.default : _a;
+    var _a = columnsData[columnIndex].rowCellValueRenderer, CellValueRenderer = _a === void 0 ? DefaultCellValueRenderer : _a;
     return cells.map(function (cell, cellIndex) { return (__assign(__assign({}, cell), { values: renderRowCell({
             columnIndex: columnIndex,
             columnData: columnData,
@@ -36,61 +30,60 @@ var applyCellRendererToColumnCells = function (columnsData, renderRowCell, rowIn
             CellValueRenderer: CellValueRenderer
         }) })); });
 }; };
-var applyCellRenderer = ramda_1.pipe(applyCellRendererToColumnCells, ramda_1.mapObjIndexed);
+var applyCellRenderer = pipe(applyCellRendererToColumnCells, mapObjIndexed);
 var calcHeightForColumnCells = function (columnsData, getRowCellHeight, rowIndex, rowValue) { return function (cells, columnId) {
-    var columnIndex = columnsData.findIndex(ramda_1.propEq('id', columnId));
+    var columnIndex = columnsData.findIndex(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)
+        ? 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] })); });
+    return map(function (cell) { return (__assign(__assign({}, cell), { rowSpan: rowSpansData[cell.nestedKey || 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 getNestedKeysFromRowCells = pipe(chain(pluck('nestedKey')), reject(isNil), uniq);
+var calcRowSpansData = pipe(values, getNestedKeysFromRowCells, calcRowSpansForNestedKeys);
 var calcRowSpans = function (rowData) {
     var rowSpansData = calcRowSpansData(rowData);
-    return ramda_1.isEmpty(rowSpansData) ? rowData : ramda_1.map(addRowSpansToColumnCells(rowSpansData), rowData);
+    return isEmpty(rowSpansData) ? rowData : map(addRowSpansToColumnCells(rowSpansData), rowData);
 };
 var calcNestedKeys = function (columnNestedPath) {
-    return ramda_1.map(function (cell) { return (__assign(__assign({}, cell), { nestedKey: nestedHelpers_1.getNestedKeyForNestedColumnCell(columnNestedPath, cell) })); });
+    return map(function (cell) { return (__assign(__assign({}, cell), { nestedKey: getNestedKeyForNestedColumnCell(columnNestedPath, cell) })); });
 };
 var parseNestedColumnValues = function (columnNestedPath, nestedValues) {
-    return ramda_1.pipe(nestedHelpers_1.flattenNestedColumnValues, calcNestedKeys(columnNestedPath))(nestedValues);
+    return pipe(flattenNestedColumnValues, calcNestedKeys(columnNestedPath))(nestedValues);
 };
 var getCellValues = function (columnNestedPath, columnValues) {
-    return columnNestedPath && !ramda_1.isEmpty(columnValues)
+    return columnNestedPath && !isEmpty(columnValues)
         ? parseNestedColumnValues(columnNestedPath, columnValues)
-        : [{ values: mdm_sdk_1.wrapInArrayIfNeeded(columnValues) }];
+        : [{ values: wrapInArrayIfNeeded(columnValues) }];
 };
 var buildRowValues = function (rowValue) {
-    return ramda_1.reduce(function (acc, _a) {
+    return reduce(function (acc, _a) {
         var id = _a.id, nestedPath = _a.nestedPath;
-        return ramda_1.assoc(id, getCellValues(nestedPath, rowValue[id]), acc);
+        return 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) {
+    return unless(function () { return maxValuesCount === Infinity; }, map(pipe(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)
+    }), map(evolve({
+        values: 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')));
+    if (getRowMaxValuesCount === void 0) { getRowMaxValuesCount = always(Infinity); }
+    return rowValues.map(pipe(function (rowValue, rowIndex) {
+        return pipe(buildRowValues(rowValue), applyValuesCountConstraint(getRowMaxValuesCount(rowIndex)), calcRowSpans, calcHeights(columnsData, getRowCellHeight, rowIndex, rowValue), applyCellRenderer(columnsData, renderRowCell, rowIndex, rowValue))(columnsData);
+    }, 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;
+        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(DefaultHeadCellRenderer) : _d;
         return ({
             id: id,
             label: label,
@@ -100,23 +93,22 @@ var getTableHeadData = function (columnsData, filters, onFilter) {
             initialWidth: initialWidth,
             minWidth: minWidth,
             autoResize: autoResize,
-            renderer: ramda_1.unless(function () { return ramda_1.isNil(filters); }, withFilter_1.default({
+            renderer: unless(function () { return isNil(filters); }, withFilter({
                 dataTypeDefinition: dataTypeDefinition,
                 filterable: filterable,
-                filter: ramda_1.prop(id, filters),
+                filter: 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);
+var calcMaxValuesCount = reduce(function (maxCount, cellValues) {
+    var maxSubNestedValuesCount = pipe(chain(propOr([], 'indexPath')), map(add(1)), reduce(max, 0))(cellValues);
+    var maxPlainValuesCount = pipe(pluck('values'), pluck('length'), reduce(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);
+    return pipe(buildRowValues(rowValue, Infinity), values, calcMaxValuesCount)(columnsData);
 };
-exports.getMaxRowValuesCount = getMaxRowValuesCount;
+export { getTableRowsData, getTableHeadData, getMaxRowValuesCount };

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

@@ -1,6 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var mdm_sdk_1 = require("@reltio/mdm-sdk");
+import { DataTypes } from '@reltio/mdm-sdk';
 var BLOB_HEIGHT = 100;
 var IMAGE_HEIGHT = 64;
 var PADDING = 15;
@@ -9,12 +7,12 @@ var defaultGetRowCellHeight = function (_a) {
     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:
+        case DataTypes.TYPE_BLOB:
             return BLOB_HEIGHT * valuesCount;
-        case mdm_sdk_1.DataTypes.TYPE_IMAGE:
+        case DataTypes.TYPE_IMAGE:
             return (PADDING + IMAGE_HEIGHT) * valuesCount + PADDING;
         default:
             return 33 * Math.max(valuesCount, 1) + PADDING;
     }
 };
-exports.default = defaultGetRowCellHeight;
+export default defaultGetRowCellHeight;

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

@@ -1,4 +1,3 @@
-"use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -21,13 +20,9 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     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"));
+import React from '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)); });
+    return cell.values.map(function (value, index) { return React.createElement(CellValueRenderer, __assign({ key: index, value: value }, otherProps)); });
 };
-exports.default = defaultRenderRowCell;
+export default defaultRenderRowCell;

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

@@ -1,4 +1,3 @@
-"use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -15,26 +14,21 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from) {
         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");
+import { __, addIndex, always, assoc, chain, curry, dropLast, groupBy, join, keys, length, omit, pickBy, pipe, propOr, reduce, split, sum, toPairs, unless, unnest, values, zip } from '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 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 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);
+    return pipe(pickBy(function (_val, key) { return getSiblingSubRowsKeyBySubRowKey(key) === siblingSubRowsKey; }), values, sum)(rowSpanData);
 };
 var calcParentRowSpan = function (rowSpanData, subRowKey) {
     var parentKey = getParentRowKeyBySubRowKey(subRowKey);
-    var currentParentSpan = ramda_1.propOr(0, parentKey, rowSpanData);
+    var currentParentSpan = propOr(0, parentKey, rowSpanData);
     var actualParentSpan = countParentSpanByAllSubRows(rowSpanData, getSiblingSubRowsKeyBySubRowKey(subRowKey));
     if (actualParentSpan > currentParentSpan) {
-        var nextRowSpanData = ramda_1.assoc(parentKey, actualParentSpan, rowSpanData);
+        var nextRowSpanData = assoc(parentKey, actualParentSpan, rowSpanData);
         return parentKey === TOTAL_ROW_SPAN_KEY ? nextRowSpanData : calcParentRowSpan(nextRowSpanData, parentKey);
     }
     else {
@@ -48,24 +42,23 @@ var addNestedKey = function (rowSpanData, 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 currentParentSpan = 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);
+        return 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);
+    return pipe(omit([TOTAL_ROW_SPAN_KEY]), keys, groupBy(getSiblingSubRowsKeyBySubRowKey), toPairs, 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 calcRowSpansForNestedKeys = pipe(reduce(addNestedKey, {}), validateRowSpanData);
+var chainWithIndex = addIndex(chain);
 var flattenNestedColumnValues = function (values, indexPath) {
     if (indexPath === void 0) { indexPath = []; }
     var head = values[0];
@@ -73,8 +66,7 @@ var flattenNestedColumnValues = function (values, indexPath) {
         ? 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);
+var getNestedKeyForNestedColumnCell = curry(function (columnNestedPath, cell) {
+    return pipe(zip(__, cell.indexPath), unnest, join(NESTED_KEY_DELIMITER))(columnNestedPath);
 });
-exports.getNestedKeyForNestedColumnCell = getNestedKeyForNestedColumnCell;
+export { calcRowSpansForNestedKeys, TOTAL_ROW_SPAN_KEY, flattenNestedColumnValues, getSiblingSubRowsKeyBySubRowKey, getParentRowKeyBySiblingsSubRowsKey, getNestedKeyForNestedColumnCell };

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

@@ -1,10 +1,2 @@
-"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; } });
+export { default as useDynamicRowCellHeight } from './useDynamicRowCellHeight';
+export { default as useBasicTableCellRenderer } from './useBasicTableCellRenderer';

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

@@ -1,4 +1,3 @@
-"use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -10,25 +9,6 @@ var __assign = (this && this.__assign) || function () {
     };
     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)
@@ -40,44 +20,40 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     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");
+import React, { useMemo } from 'react';
+import PropTypes from 'prop-types';
+import { calculateRowHeight, getCellContentFromRowsData } from 'react-components/dist/Table/tableUtils';
+import defaultRenderRowCell from '../helpers/defaultRenderRowCell';
+import defaultGetRowCellHeight from '../helpers/defaultGetRowCellHeight';
+import { pathOr, propEq } from 'ramda';
+import useCollapsibleTableRows from './useCollapsibleTableRows';
+import { RowCollapseContext } from '../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({
+    var rowsData = _a.rowsData, columnsData = _a.columnsData, _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 _f = useCollapsibleTableRows({
         rowsData: rowsData,
         columnsData: columnsData,
         renderRowCell: renderRowCell,
         getRowCellHeight: getRowCellHeight,
         maxRowValuesCount: maxRowValuesCount
     }), tableRowsData = _f.tableRowsData, collapseContextValue = _f.collapseContextValue;
-    return react_1.useMemo(function () {
+    return useMemo(function () {
         var rowHeightCache = tableRowsData.reduce(function (cache, rowData, rowIndex) {
             var data = rowData.data;
-            cache[rowIndex] = tableUtils_1.calculateRowHeight(data, defaultRowHeight);
+            cache[rowIndex] = 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);
+            return pathOr(0, heightPath, rowHeightCache);
         };
-        var getRowHeight = function (rowIndex) { return ramda_1.pathOr(0, [rowIndex, 'height'], rowHeightCache); };
+        var getRowHeight = function (rowIndex) { return 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)),
+            return (React.createElement(RowCollapseContext.Provider, { value: collapseContextValue },
+                React.createElement("div", __assign({}, otherProps, { style: { height: getRowHeight(rowIndex) } }), tableRowsData.length > 0 &&
+                    getCellContentFromRowsData({
+                        columnIndex: columnsData.findIndex(propEq('id', columnId)),
                         headData: columnsData,
                         rowsData: tableRowsData,
                         rowIndex: rowIndex,
@@ -85,10 +61,10 @@ var useBasicTableCellRenderer = function (_a) {
                     }))));
         };
         CellRenderer.propTypes = {
-            columnId: prop_types_1.default.string,
-            rowIndex: prop_types_1.default.number
+            columnId: PropTypes.string,
+            rowIndex: PropTypes.number
         };
         return { getRowHeight: getRowHeight, CellRenderer: CellRenderer };
     }, [tableRowsData, defaultRowHeight, collapseContextValue, columnsData]);
 };
-exports.default = useBasicTableCellRenderer;
+export default useBasicTableCellRenderer;

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

@@ -1,37 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var react_1 = require("react");
-var ramda_1 = require("ramda");
-var dataHelpers_1 = require("../helpers/dataHelpers");
-var hooks_1 = require("../../../../hooks");
+import { useCallback, useMemo, useState } from 'react';
+import { equals, filter, remove } from 'ramda';
+import { getTableRowsData, getMaxRowValuesCount } from '../helpers/dataHelpers';
+import { useDidUpdateEffect, usePrevious } from '../../../../hooks';
 var useCollapsibleTableRows = function (_a) {
     var rowsData = _a.rowsData, columnsData = _a.columnsData, renderRowCell = _a.renderRowCell, getRowCellHeight = _a.getRowCellHeight, maxRowValuesCount = _a.maxRowValuesCount;
-    var _b = react_1.useState([]), expandedIndexes = _b[0], setExpandedIndexes = _b[1];
-    var getRowMaxValuesCount = react_1.useCallback(function (rowIndex) {
+    var _b = useState([]), expandedIndexes = _b[0], setExpandedIndexes = _b[1];
+    var getRowMaxValuesCount = useCallback(function (rowIndex) {
         return expandedIndexes.includes(rowIndex) ? Infinity : maxRowValuesCount;
     }, [expandedIndexes, maxRowValuesCount]);
-    var tableRowsData = react_1.useMemo(function () { return dataHelpers_1.getTableRowsData(rowsData, columnsData, renderRowCell, getRowCellHeight, getRowMaxValuesCount); }, [rowsData, columnsData, renderRowCell, getRowCellHeight, getRowMaxValuesCount]);
-    var toggleRowCollapse = react_1.useCallback(function (rowIndex) {
+    var tableRowsData = useMemo(function () { return getTableRowsData(rowsData, columnsData, renderRowCell, getRowCellHeight, getRowMaxValuesCount); }, [rowsData, columnsData, renderRowCell, getRowCellHeight, getRowMaxValuesCount]);
+    var toggleRowCollapse = useCallback(function (rowIndex) {
         setExpandedIndexes(function (expandedIndexes) {
-            var index = expandedIndexes.findIndex(ramda_1.equals(rowIndex));
-            return index === -1 ? expandedIndexes.concat(rowIndex) : ramda_1.remove(index, 1, expandedIndexes);
+            var index = expandedIndexes.findIndex(equals(rowIndex));
+            return index === -1 ? expandedIndexes.concat(rowIndex) : remove(index, 1, expandedIndexes);
         });
     }, []);
-    var getIsRowCollapsible = react_1.useCallback(function (rowValue) {
-        return dataHelpers_1.getMaxRowValuesCount(columnsData, rowValue) > maxRowValuesCount;
+    var getIsRowCollapsible = useCallback(function (rowValue) {
+        return getMaxRowValuesCount(columnsData, rowValue) > maxRowValuesCount;
     }, [maxRowValuesCount, columnsData]);
-    var getIsRowCollapsed = react_1.useCallback(function (rowIndex) {
+    var getIsRowCollapsed = useCallback(function (rowIndex) {
         return !expandedIndexes.includes(rowIndex);
     }, [expandedIndexes]);
-    var collapseContextValue = react_1.useMemo(function () { return ({
+    var collapseContextValue = useMemo(function () { return ({
         toggleRowCollapse: toggleRowCollapse,
         getIsRowCollapsible: getIsRowCollapsible,
         getIsRowCollapsed: getIsRowCollapsed
     }); }, [toggleRowCollapse, getIsRowCollapsible, getIsRowCollapsed]);
-    var prevRowsData = hooks_1.usePrevious(rowsData);
-    hooks_1.useDidUpdateEffect(function () {
+    var prevRowsData = usePrevious(rowsData);
+    useDidUpdateEffect(function () {
         if (expandedIndexes.length > 0) {
-            setExpandedIndexes(ramda_1.filter(function (index) {
+            setExpandedIndexes(filter(function (index) {
                 var rowValue = rowsData[index] || {};
                 var prevRowValue = prevRowsData[index] || {};
                 return rowValue.rawValue === prevRowValue.rawValue && getIsRowCollapsible(rowValue);
@@ -40,4 +38,4 @@ var useCollapsibleTableRows = function (_a) {
     }, [rowsData]);
     return { tableRowsData: tableRowsData, collapseContextValue: collapseContextValue };
 };
-exports.default = useCollapsibleTableRows;
+export default useCollapsibleTableRows;

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

@@ -1,4 +1,3 @@
-"use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -10,28 +9,27 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-var react_1 = require("react");
-var ramda_1 = require("ramda");
-var mdm_sdk_1 = require("@reltio/mdm-sdk");
+import { useCallback, useRef, useState } from 'react';
+import { __, curry, identity, pipe, prop, useWith } from 'ramda';
+import { debounce } from '@reltio/mdm-sdk';
 var getRowCellKey = function (_a) {
     var rowIndex = _a.rowIndex, id = _a.columnData.id, cellIndex = _a.cellIndex;
     return id + "[" + rowIndex + "][" + cellIndex + "]";
 };
 var useDynamicRowCellHeight = function () {
-    var _a = react_1.useState({}), rowCellHeightsMap = _a[0], setRowCellHeightsMap = _a[1];
-    var rowCellHeightsMapCache = react_1.useRef({});
+    var _a = useState({}), rowCellHeightsMap = _a[0], setRowCellHeightsMap = _a[1];
+    var rowCellHeightsMapCache = useRef({});
     var batchHeightUpdate = function (key, value) {
         rowCellHeightsMapCache.current[key] = value;
     };
-    var flushHeightUpdates = react_1.useCallback(mdm_sdk_1.debounce(function () {
+    var flushHeightUpdates = useCallback(debounce(function () {
         setRowCellHeightsMap(__assign({}, rowCellHeightsMapCache.current));
     }), []);
-    var clearHeightsCache = react_1.useCallback(function () {
+    var clearHeightsCache = useCallback(function () {
         rowCellHeightsMapCache.current = {};
     }, []);
-    var getDynamicRowCellHeight = react_1.useCallback(ramda_1.pipe(getRowCellKey, ramda_1.prop(ramda_1.__, rowCellHeightsMap)), [rowCellHeightsMap]);
-    var changeRowCellHeight = react_1.useCallback(ramda_1.curry(ramda_1.useWith(ramda_1.pipe(batchHeightUpdate, flushHeightUpdates), [getRowCellKey, ramda_1.identity])), []);
+    var getDynamicRowCellHeight = useCallback(pipe(getRowCellKey, prop(__, rowCellHeightsMap)), [rowCellHeightsMap]);
+    var changeRowCellHeight = useCallback(curry(useWith(pipe(batchHeightUpdate, flushHeightUpdates), [getRowCellKey, identity])), []);
     return { getDynamicRowCellHeight: getDynamicRowCellHeight, changeRowCellHeight: changeRowCellHeight, clearHeightsCache: clearHeightsCache };
 };
-exports.default = useDynamicRowCellHeight;
+export default useDynamicRowCellHeight;

package/components/BasicTableView/BasicTableHeader/ColumnsSettings/ColumnListItem.js

@@ -1,30 +1,25 @@
-"use strict";
-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 AttributeListItem_1 = __importDefault(require("../../../AttributeListItem/AttributeListItem"));
-var Highlighter_1 = __importDefault(require("../../../Highlighter/Highlighter"));
-var classnames_1 = __importDefault(require("classnames"));
-var styles_1 = require("./styles");
+import React from 'react';
+import PropTypes from 'prop-types';
+import AttributeListItem from '../../../AttributeListItem/AttributeListItem';
+import Highlighter from '../../../Highlighter/Highlighter';
+import classnames from 'classnames';
+import { useStyles } from './styles';
 var ColumnListItem = function (_a) {
     var _b;
     var item = _a.item, onClick = _a.onClick, checked = _a.checked, level = _a.level, style = _a.style, isFocused = _a.isFocused, isGroupItem = _a.isGroupItem;
-    var styles = styles_1.useStyles();
-    return (react_1.default.createElement(AttributeListItem_1.default, { key: item.id, onClick: onClick, checked: checked, level: level, data: item, label: react_1.default.createElement(Highlighter_1.default, { text: item.label, highlight: item.filterText }), labelInText: item.label, style: style, isFocused: isFocused, hideIcon: isGroupItem, className: classnames_1.default((_b = {}, _b[styles.groupItem] = isGroupItem, _b)) }));
+    var styles = useStyles();
+    return (React.createElement(AttributeListItem, { key: item.id, onClick: onClick, checked: checked, level: level, data: item, label: React.createElement(Highlighter, { text: item.label, highlight: item.filterText }), labelInText: item.label, style: style, isFocused: isFocused, hideIcon: isGroupItem, className: classnames((_b = {}, _b[styles.groupItem] = isGroupItem, _b)) }));
 };
 ColumnListItem.propTypes = {
-    item: prop_types_1.default.shape({
-        label: prop_types_1.default.string,
-        filterText: prop_types_1.default.string
+    item: PropTypes.shape({
+        label: PropTypes.string,
+        filterText: PropTypes.string
     }),
-    level: prop_types_1.default.number,
-    onClick: prop_types_1.default.func,
-    checked: prop_types_1.default.bool,
-    style: prop_types_1.default.object,
-    isGroupItem: prop_types_1.default.bool,
-    isFocused: prop_types_1.default.bool
+    level: PropTypes.number,
+    onClick: PropTypes.func,
+    checked: PropTypes.bool,
+    style: PropTypes.object,
+    isGroupItem: PropTypes.bool,
+    isFocused: PropTypes.bool
 };
-exports.default = ColumnListItem;
+export default ColumnListItem;