lightning-base-components 1.21.3-alpha → 1.21.4-alpha

package/src/lightning/datatable/rows.js

@@ -1,43 +1,23 @@
 import { assert } from 'lightning/utilsPrivate';
-import { classSet, isObjectLike, styleToString } from './utils';
-import { isTreeType, getAttributesNames } from './types';
+import { classSet, isObjectLike } from './utils';
+import { getAttributesNames } from './types';
 import {
-    isSelectedRow,
-    isDisabledRow,
-    getRowSelectionInputType,
+    getCurrentSelectionLength,
+    SELECTABLE_HEADER_TYPE,
 } from './rowSelectionShared';
-import { getTreeStateIndicatorFieldNames, getStateTreeColumn } from './tree';
 import {
-    getColumns,
     getTypeAttributesValues,
     getSubTypeAttributesValues,
     getCellAttributesValues,
-    isCustomerColumn,
     generateColKeyValue,
 } from './columns';
-import { isRowNumberColumn, getRowNumberErrorColumnDef } from './rowNumber';
-import { getRowError } from './errors';
-import { getDirtyValueFromCell } from './inlineEditShared';
+import { getRowNumberError } from './rowNumber';
 
-export function getData(state) {
-    return state.data;
-}
-
-export function setData(state, data) {
-    if (Array.isArray(data)) {
-        state.data = data;
-    } else {
-        state.data = [];
-    }
-}
-
-export function getRows(state) {
-    return state.rows;
-}
-
-export function getKeyField(state) {
-    return state.keyField;
-}
+const CELL_EDIT_CLASS = 'slds-cell-edit';
+const HAS_ERROR_CLASS = 'slds-has-error';
+const IS_EDITED_CLASS = 'slds-is-edited';
+const ROLE_BASED_CELL_CLASS = 'cell';
+const TREE__ITEM_CLASS = 'slds-tree__item';
 
 export function setKeyField(state, value) {
     if (typeof value === 'string') {
@@ -51,51 +31,6 @@ export function setKeyField(state, value) {
     }
 }
 
-export function hasValidKeyField(state) {
-    const keyField = getKeyField(state);
-    return typeof keyField === 'string';
-}
-
-/**
- * Resolves the CSS classes for a row based on the row.isSelected state
- *
- * @param {object} row - a row object in state.rows collection
- * @returns {string} the classSet string
- */
-export function resolveRowClassNames(row) {
-    return `slds-hint-parent${row.isSelected ? ' slds-is-selected' : ''}`;
-}
-
-/**
- *
- * @param {object} state - data table state
- * @param {string} rowKeyValue - computed id for the row
- * @param {string} colKeyValue - computed id for the column
- * @returns {object} The user row that its related to the action.
- */
-export function getUserRowByCellKeys(state, rowKeyValue, colKeyValue) {
-    const rowIndex = state.indexes[rowKeyValue][colKeyValue][0];
-    return getData(state)[rowIndex];
-}
-
-/**
- * It creates a row key generator based on the keyField passed in by the consumer.
- * If the keyField passed in through the generator does not point to a value in the row object,
- * it falls back to a generated key using indexes. Ex. row-0/row-1
- *
- * @param {String} keyField  - keyField provided by the consumer
- * @returns {Function} - function with the unique row key generator
- */
-export function uniqueRowKeyGenerator(keyField) {
-    let index = 0;
-    return function (row) {
-        if (row[keyField]) {
-            return row[keyField];
-        }
-        return `row-${index++}`;
-    };
-}
-
 /**
  * It compute the state.rows collection based on the current normalized (data, columns)
  * and generate cells indexes map(state.indexes)
@@ -105,60 +40,83 @@ export function uniqueRowKeyGenerator(keyField) {
  * attaching the 'cell' class, calling this from connectedCallback of datatable would
  * eliminate the need for updateCellClassForRoleBasedMode.
  *
- * @param {object} state - the current datatable state
+ * @param {Object} state - The datatable state
+ * @param {Object} types - The type handling factory
  */
-export function updateRowsAndCellIndexes() {
-    const { state, privateTypes: types } = this;
-    const { keyField, renderModeRoleBased, virtualize, rowHeight } = state;
-    const data = getData(state);
-    const columns = getColumns(state);
-    const computeUniqueRowKey = uniqueRowKeyGenerator(keyField);
+export function updateRowsAndCellIndexes(state, types) {
+    const {
+        columns,
+        data,
+        keyField,
+        maxRowSelection,
+        renderModeRoleBased,
+        virtualize,
+        rowHeight,
+    } = state;
     const { length: rowCount } = data;
+    const { dirtyValues } = state.inlineEdit;
     const { length: colCount } = columns;
+    const currentSelectionLength =
+        maxRowSelection === 1 ? 1 : getCurrentSelectionLength(state);
+    const inputType = maxRowSelection === 1 ? 'radio' : 'checkbox';
 
     let scopeCol;
+    let treeColTypeAttrs;
     for (let colIndex = 0; colIndex < colCount; colIndex += 1) {
         const col = columns[colIndex];
-        if (col.isScopeCol && types.isValidType(col.type)) {
+        const { type: columnType } = col;
+        if (!scopeCol && col.isScopeCol && types.isValidType(columnType)) {
             scopeCol = col;
-            break;
+        }
+        if (columnType === 'tree' && treeColTypeAttrs === undefined) {
+            treeColTypeAttrs = getTypeAttributesValues(col);
         }
     }
 
     // initializing indexes
     state.indexes = {};
 
+    const { rows: errorsRows } = state.errors;
     const rows = Array(rowCount);
+    // Tracked state changes.
     state.rows = rows;
 
     for (let rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
         const rowData = data[rowIndex];
-        const key = computeUniqueRowKey(rowData);
-        const rowErrors = getRowError(state, key);
-
-        state.indexes[key] = { rowIndex };
-
-        const isRowSelected = isSelectedRow(state, key);
+        const rowDataKeyField = rowData[keyField];
+        const rowKeyValue = rowDataKeyField
+            ? `${rowDataKeyField}`
+            : `row-${rowIndex}`;
+        const dirtyRowData = dirtyValues[rowKeyValue];
+        const rowErrors = errorsRows && errorsRows[rowKeyValue];
+        const cellErrors = rowErrors && rowErrors.cells;
+        const errorFieldNames = rowErrors && rowErrors.fieldNames;
+
+        state.indexes[rowKeyValue] = { rowIndex };
+
+        const isRowSelected = !!state.selectedRowsKeys[rowKeyValue];
         const rowNumber = rowIndex + 1;
         const cells = Array(colCount);
 
         const row = {
-            key,
+            key: rowKeyValue,
             cells,
             rowIndex,
             rowNumber, // for UTAM since methods are base-1
             ariaRowIndex: rowIndex + 2, // aria attrs are base-1 and also count header as a row
-            inputType: getRowSelectionInputType(state),
+            inputType,
             isSelected: isRowSelected,
             ariaSelected: isRowSelected ? 'true' : false,
-            isDisabled: isDisabledRow(state, key),
-            classnames: resolveRowClassNames(rowData),
+            isDisabled:
+                !isRowSelected &&
+                maxRowSelection !== 1 &&
+                currentSelectionLength === maxRowSelection,
+            classnames: `slds-hint-parent${
+                isRowSelected ? ' slds-is-selected' : ''
+            }`,
             tabIndex: -1,
             style: virtualize
-                ? styleToString({
-                      position: 'absolute',
-                      top: `${rowIndex * rowHeight}px`,
-                  })
+                ? `position:absolute;top:${rowIndex * rowHeight}px;`
                 : '',
             level: undefined,
             posInSet: undefined,
@@ -168,7 +126,25 @@ export function updateRowsAndCellIndexes() {
         };
 
         // Add tree specific row properties.
-        Object.assign(row, getRowStateForTree(rowData, state));
+        if (treeColTypeAttrs) {
+            const hasChildren = !!resolveAttributeValue(
+                treeColTypeAttrs.hasChildren,
+                rowData
+            );
+            row.hasChildren = hasChildren;
+            row.isExpanded = hasChildren
+                ? `${!!resolveAttributeValue(
+                      treeColTypeAttrs.isExpanded,
+                      rowData
+                  )}`
+                : undefined;
+            row.level =
+                resolveAttributeValue(treeColTypeAttrs.level, rowData) || 1;
+            row.posInSet =
+                resolveAttributeValue(treeColTypeAttrs.posInSet, rowData) || 1;
+            row.setSize =
+                resolveAttributeValue(treeColTypeAttrs.setSize, rowData) || 1;
+        }
 
         rows[rowIndex] = row;
 
@@ -176,6 +152,7 @@ export function updateRowsAndCellIndexes() {
         for (let colIndex = 0; colIndex < colCount; colIndex += 1) {
             const col = columns[colIndex];
             const {
+                columnKey,
                 fieldName,
                 isScopeCol,
                 label: dataLabel,
@@ -186,57 +163,111 @@ export function updateRowsAndCellIndexes() {
             const columnSubType = typeAttributes
                 ? typeAttributes.subType
                 : undefined;
-            const dirtyValue = getDirtyValueFromCell(
-                state,
-                row.key,
-                colKeyValue
-            );
-            const hasError = hasCellErrors(rowErrors, fieldName, col.columnKey);
+            const dirtyValue = dirtyRowData && dirtyRowData[colKeyValue];
+            const hasError = columnKey
+                ? !!(cellErrors && cellErrors[columnKey])
+                : !!(errorFieldNames && errorFieldNames.includes(fieldName));
+            const hasTreeData = columnType === 'tree';
             // value based on the fieldName
             const value =
                 dirtyValue === undefined ? rowData[fieldName] : dirtyValue;
+            const displayReadOnlyIcon = !!col.displayReadOnlyIcon;
+            const editable = isCellEditable(rowData, col);
             const isValidType = types.isValidType(columnType);
-            const isCheckbox = columnType === 'SELECTABLE_CHECKBOX';
+            const isCheckbox = columnType === SELECTABLE_HEADER_TYPE;
             const isDataType = isValidType && !isScopeCol;
             const isDataTypeScope = isValidType && isScopeCol;
 
             // cell object creation
             const cell = {
-                columnType,
+                ariaReadOnly: !editable,
+                class: '',
+                colKeyValue, // unique column key value
                 columnSubType,
+                columnType,
                 dataLabel,
-                value,
+                describedBy: dirtyValue ? 'unsaved-cell-notification' : null,
+                displayReadOnlyIcon,
                 displayValue: rowData.displayValue || '',
-                rowKeyValue: row.key, // unique row key value
-                colKeyValue, // unique column key value
-                tabIndex: -1,
-                isCheckbox,
-                class: computeCellClassNames(
-                    rowData,
-                    col,
-                    hasError,
-                    dirtyValue,
-                    renderModeRoleBased
-                ),
+                editable,
                 hasError,
+                isCheckbox,
                 isDataType,
                 isDataTypeScope,
+                rowKeyValue: row.key, // unique row key value
+                style: computeCellStyles(types, col, renderModeRoleBased),
+                tabIndex: -1,
+                value,
                 wrapText: state.wrapText[colKeyValue], // wrapText state
                 wrapTextMaxLines: state.wrapText[colKeyValue]
                     ? state.wrapTextMaxLines
                     : undefined,
-                style: computeCellStyles(types, col, renderModeRoleBased),
             };
 
-            if (isCustomerColumn(col)) {
-                assignCustomerColumnAttributes(cell, row, rowData, col, types);
-            } else if (isRowNumberColumn(col)) {
-                assignRowNumberColumnAttributes(
-                    cell,
-                    rowData,
-                    types,
+            cell.class = computeCellClassNames(
+                cell,
+                hasTreeData,
+                dirtyValue,
+                renderModeRoleBased
+            );
+
+            if (!col.internal) {
+                // Assign cell type or cell subType attributes.
+                let attributeNames;
+                let attributeValues;
+                if (columnSubType) {
+                    attributeNames = getAttributesNames(columnSubType);
+                    attributeValues = getSubTypeAttributesValues(col);
+                } else {
+                    attributeNames = types.getType(columnType).typeAttributes;
+                    attributeValues = getTypeAttributesValues(col);
+                }
+                const attributeNamesLength = attributeNames
+                    ? attributeNames.length
+                    : 0;
+                for (let i = 0; i < attributeNamesLength; i += 1) {
+                    const attrName = attributeNames[i];
+                    const attrValue = attributeValues[attrName];
+                    cell[`typeAttribute${i}`] = resolveAttributeValue(
+                        attrValue,
+                        rowData
+                    );
+                }
+
+                // Extract the `cellAttributes` and their values that are specified in the
+                // column definition.
+                // If a cell attribute points to a fieldName in a row, that value is resolved here.
+                // This object that contains the resolved mapping is then set in the `cell`
+                // object in each row.
+                const cellAttributes = getCellAttributesValues(col);
+                const keys = Object.keys(cellAttributes);
+                for (let i = 0, { length } = keys; i < length; i += 1) {
+                    const attrName = keys[i];
+                    const attrValue = cellAttributes[attrName];
+                    cell[attrName] = resolveAttributeValue(attrValue, rowData);
+                }
+
+                // If this is tree grid, this maps and sets into the cell object
+                // the tree specific attributes:
+                // 1) row.hasChildren to typeAttribute21 and
+                // 2) row.isExpanded to and typeAttribute22
+                if (hasTreeData) {
+                    // Attaches if the row containing this cell hasChildren or
+                    // not and isExpanded or not attributes to typeAttribute21
+                    // and typeAttribute22 respectively typeAttribute0-typeAttribute20
+                    // are reserved for types supported by tree
+                    cell.typeAttribute21 = row.hasChildren;
+                    cell.typeAttribute22 = row.isExpanded === 'true';
+                }
+            }
+            // Populate row number attributes.
+            else if (columnType === 'rowNumber') {
+                const scopeColValue = rowData[scopeCol.fieldName];
+                // computes and sets the resolved typeAttribute for the row
+                // number column error state
+                cell.typeAttribute0 = getRowNumberError(
                     rowErrors,
-                    scopeCol
+                    scopeColValue
                 );
             }
 
@@ -249,176 +280,6 @@ export function updateRowsAndCellIndexes() {
     }
 }
 
-/**
- * Checks whether there are errors for the specified column
- * When a columnKey exists for a column, we will look for its errors inside the
- * cells property of rowErrors. Only when it doesn't exist will we look for a
- * reference to the column's fieldName.
- *
- * This maintains backwards compatibility with those continuing to use fieldName
- * as column identifiers.
- */
-function hasCellErrors(rowErrors, fieldName, columnKey) {
-    const cellErrors = rowErrors.cells;
-    const errorFieldNames = rowErrors.fieldNames;
-    return columnKey
-        ? !!(cellErrors && cellErrors[columnKey])
-        : !!(errorFieldNames && errorFieldNames.includes(fieldName));
-}
-
-/**
- * Computes and sets the following resolved values in the cell object:
- * 1. `typeAttributes` specified in the column definition
- * 2. `cellAttributes` specified in the column definition
- * 3. Editability of the cell and subsequently the ariaReadOnly property
- * 4. Visibility of read only icon
- *
- * Computes and sets the following tree specific attributes
- * into typeAttributes21/22 in the cell object:
- * 1. row.hasChildren
- * 2. row.isExpanded
- *
- * @param {Object} cell - cell metadata
- * @param {Object} row - row metadata
- * @param {Object} rowData - data to be rendered in the cells of that row
- * @param {Object} colData - column definition
- * @param {Object} types - instance of DatatableTypes from `./types.js`
- */
-function assignCustomerColumnAttributes(cell, row, rowData, colData, types) {
-    Object.assign(
-        cell,
-        computeCellTypeAttributes(rowData, colData, types),
-        computeCellAttributes(rowData, colData),
-        computeCellEditable(rowData, colData),
-        computeCellDisplayReadOnlyIcon(colData)
-    );
-    if (!cell.editable) {
-        cell.ariaReadOnly = true;
-    }
-
-    // If this is tree grid, this maps and sets into the cell object the tree specific attributes:
-    // 1) row.hasChildren to typeAttribute21 and
-    // 2) row.isExpanded to and typeAttribute22
-    if (isTreeType(colData.type)) {
-        Object.assign(cell, computeCellStateTypeAttributes(row));
-    }
-}
-
-/**
- * Computes and sets the resolved typeAttribute for the row number column error state
- *
- * @param {Object} cell - cell metadata
- * @param {Object} rowData - data to be rendered in the cells of that row
- * @param {Object} types - instance of DatatableTypes from `./types.js`
- * @param {Object} rowErrors - contains the errors present in that row
- * @param {Object} scopeCol - column with scope=row
- */
-function assignRowNumberColumnAttributes(
-    cell,
-    rowData,
-    types,
-    rowErrors,
-    scopeCol
-) {
-    const scopeColValue = rowData[scopeCol.fieldName];
-    const errorColumnDef = getRowNumberErrorColumnDef(rowErrors, scopeColValue);
-    Object.assign(
-        cell,
-        computeCellTypeAttributes(rowData, errorColumnDef, types)
-    );
-}
-
-/**
- * This function extracts the `cellAttributes` and their values that are specified
- * in the column definition.
- * If a cell attribute points to a fieldName in a row, that value is resolved here.
- *
- * This object that contains the resolved mapping is then set in the `cell` object
- * in each row.
- *
- * @param {Object} rowData - current row data. Required for cases cellAttributes refers to a fieldName in a row
- * @param {Object} col - column definition
- * @returns {Object} - contains the resolved mapping of cellAttributes and their values
- */
-export function computeCellAttributes(rowData, col) {
-    const cellAttrs = {};
-    const cellAttributes = getCellAttributesValues(col);
-    const keys = Object.keys(cellAttributes);
-    for (let i = 0, { length } = keys; i < length; i += 1) {
-        const attrName = keys[i];
-        const attrValue = cellAttributes[attrName];
-        cellAttrs[attrName] = resolveAttributeValue(attrValue, rowData);
-    }
-    return cellAttrs;
-}
-
-/**
- * This function retrieves the allowlisted type attributes for a particular type and
- * maps the value set in the column definition to `typeAttribute{index}`.
- *
- * The types and their corresponding allowlisted attributes can be seen in types.js
- *
- * Ex. For the type 'url', there are 3 type attributes allowlisted: label, target, tooltip
- * If you pass typeAttributes: {label: 'My Label', target: '_blank', myattr: false}
- * in the column definition, this function would map ->
- * typeAttribute0: 'My Label', typeAttribute1: '_blank' and typeAttribute2: undefined
- * `myattr` is not allowlisted so it is discarded
- *
- * This mapping is later set into the `cell` object for each row and
- * will be passed in to primitive-cell-factory as
- * type-attribute-0={cell.typeAttribute0}
- * type-attribute-1={cell.typeAttribute1}
- * ...
- *
- * @param {Object} rowData - current row data. Required for cases typeAttributes refers to a fieldName in a row
- * @param {Object} col - column definition
- * @param {Object} types - instance of DatatableTypes from `./types.js`
- * @returns {Object} - object containing all the typeAttributes{index} and their mapped values
- */
-export function computeCellTypeAttributes(rowData, column, types) {
-    const { typeAttributes } = column;
-    if (typeAttributes && typeAttributes.subType) {
-        return computeCellSubTypeAttributes(rowData, column);
-    }
-    const attributeNames = types.getType(column.type).typeAttributes;
-    const attributeValues = getTypeAttributesValues(column);
-
-    const cellAttrs = {};
-    const attributeNamesLength = attributeNames ? attributeNames.length : 0;
-    for (let i = 0; i < attributeNamesLength; i += 1) {
-        const attrName = attributeNames[i];
-        const attrValue = attributeValues[attrName];
-        cellAttrs[`typeAttribute${i}`] = resolveAttributeValue(
-            attrValue,
-            rowData
-        );
-    }
-    return cellAttrs;
-}
-
-function computeCellSubTypeAttributes(rowData, column) {
-    const attributeNames = getAttributesNames(column.typeAttributes.subType);
-    const attributeValues = getSubTypeAttributesValues(column);
-
-    const cellAttrs = {};
-    const attributeNamesLength = attributeNames ? attributeNames.length : 0;
-    for (let i = 0; i < attributeNamesLength; i += 1) {
-        const attrName = attributeNames[i];
-        const attrValue = attributeValues[attrName];
-        cellAttrs[`typeAttribute${i}`] = resolveAttributeValue(
-            attrValue,
-            rowData
-        );
-    }
-    return cellAttrs;
-}
-
-function computeCellEditable(row, column) {
-    return {
-        editable: isCellEditable(row, column),
-    };
-}
-
 /**
  * Returns true in the following three cases:
  *
@@ -435,12 +296,6 @@ export function isCellEditable(rowData, col) {
     return !!resolveAttributeValue(col.editable, rowData);
 }
 
-function computeCellDisplayReadOnlyIcon(col) {
-    return {
-        displayReadOnlyIcon: !!col.displayReadOnlyIcon,
-    };
-}
-
 /**
  * Computes styles to be set on the cell
  * 1. Remove padding from the cell if the cell is of a custom type
@@ -468,7 +323,7 @@ function computeCellStyles(types, col, renderModeRoleBased) {
 
     // Width needs to be managed when rendering as divs
     if (renderModeRoleBased) {
-        const { columnWidth } = col.columnWidth;
+        const { columnWidth } = col;
         if (columnWidth > 0) {
             cellStyle += `width:${columnWidth}px;`;
         }
@@ -478,9 +333,8 @@ function computeCellStyles(types, col, renderModeRoleBased) {
 }
 
 function computeCellClassNames(
-    row,
-    column,
-    hasError,
+    cell,
+    hasTreeData,
     dirtyValue,
     renderModeRoleBased
 ) {
@@ -488,60 +342,24 @@ function computeCellClassNames(
     // where the read only icon is to be displayed. This is an issue with their design that will need to
     // be addressed on their end, so once they do that we can modify this code accordingly.
     let cellClass = '';
-    if (column.displayReadOnlyIcon || isCellEditable(row, column)) {
-        cellClass += 'slds-cell-edit';
+    if (cell.displayReadOnlyIcon || cell.editable) {
+        cellClass += CELL_EDIT_CLASS;
     }
-    if (isTreeType(column.type)) {
-        cellClass += (cellClass.length ? ' ' : '') + 'slds-tree__item';
+    if (hasTreeData) {
+        cellClass += (cellClass.length ? ' ' : '') + TREE__ITEM_CLASS;
     }
-    if (hasError) {
-        cellClass += (cellClass.length ? ' ' : '') + 'slds-has-error';
+    if (cell.hasError) {
+        cellClass += (cellClass.length ? ' ' : '') + HAS_ERROR_CLASS;
     }
     if (dirtyValue !== undefined) {
-        cellClass += (cellClass.length ? ' ' : '') + 'slds-is-edited';
+        cellClass += (cellClass.length ? ' ' : '') + IS_EDITED_CLASS;
     }
     if (renderModeRoleBased) {
-        cellClass += (cellClass.length ? ' ' : '') + 'cell';
+        cellClass += (cellClass.length ? ' ' : '') + ROLE_BASED_CELL_CLASS;
     }
     return cellClass;
 }
 
-/**
- * Attaches if the row containing this cell hasChildren or not and isExpanded or not
- * attributes to typeAttribute21 and typeAttribute22 respectively
- * typeAttribute0-typeAttribute20 are reserved for  types supported by tree
- * @param {object}row - current row which is stored in state.rows
- * @returns {{typeAttribute21, typeAttribute22: boolean}} typeAttributes
- * describing state of the row associated
- */
-function computeCellStateTypeAttributes(row) {
-    return {
-        typeAttribute21: row.hasChildren,
-        typeAttribute22: row.isExpanded === 'true',
-    };
-}
-
-export function getRowIndexByKey(state, key) {
-    if (!state.indexes[key]) {
-        return undefined;
-    }
-
-    return state.indexes[key].rowIndex;
-}
-
-export function getRowByKey(state, key) {
-    const rows = getRows(state);
-    return rows[getRowIndexByKey(state, key)];
-}
-
-export function rowKeyExists(state, key) {
-    return !!state.indexes[key];
-}
-
-export function getRowsTotal(state) {
-    return getRows(state).length;
-}
-
 function resolveAttributeValue(attrValue, rowData) {
     if (isObjectLike(attrValue)) {
         const { fieldName } = attrValue;
@@ -553,71 +371,6 @@ function resolveAttributeValue(attrValue, rowData) {
     return attrValue;
 }
 
-function getRowStateForTree(row, state) {
-    const _row = {};
-    const column = getStateTreeColumn(state);
-    if (column) {
-        _row.hasChildren = getRowHasChildren(column, row);
-        _row.isExpanded = isRowExpanded(column, row);
-        _row.level = getRowLevel(column, row);
-        _row.posInSet = getRowPosInSet(column, row);
-        _row.setSize = getRowSetSize(column, row);
-    }
-    return _row;
-}
-
-export function getRowLevel(column, rowData) {
-    const treeColTypeAttrs = getTypeAttributesValues(column);
-    return (
-        resolveAttributeValue(
-            treeColTypeAttrs[getTreeStateIndicatorFieldNames().level],
-            rowData
-        ) || 1
-    );
-}
-
-function getRowPosInSet(column, row) {
-    const treeColTypeAttrs = getTypeAttributesValues(column);
-    return (
-        resolveAttributeValue(
-            treeColTypeAttrs[getTreeStateIndicatorFieldNames().position],
-            row
-        ) || 1
-    );
-}
-
-function getRowSetSize(column, row) {
-    const treeColTypeAttrs = getTypeAttributesValues(column);
-    return (
-        resolveAttributeValue(
-            treeColTypeAttrs[getTreeStateIndicatorFieldNames().setsize],
-            row
-        ) || 1
-    );
-}
-
-export function isRowExpanded(column, rowData) {
-    const treeColTypeAttrs = getTypeAttributesValues(column);
-    const hasChildren = resolveAttributeValue(
-        treeColTypeAttrs[getTreeStateIndicatorFieldNames().children],
-        rowData
-    );
-    return hasChildren
-        ? `${!!resolveAttributeValue(
-              treeColTypeAttrs[getTreeStateIndicatorFieldNames().expanded],
-              rowData
-          )}`
-        : undefined;
-}
-
-function getRowHasChildren(column, rowData) {
-    const treeColTypeAttrs = getTypeAttributesValues(column);
-    return !!resolveAttributeValue(
-        treeColTypeAttrs[getTreeStateIndicatorFieldNames().children],
-        rowData
-    );
-}
-
 /**
  * For the role-based table, we need to manage the width of each cell separately.
  * Re-compute the cell styles so that the width of the cell is set
@@ -626,7 +379,7 @@ function getRowHasChildren(column, rowData) {
  * @param {Object} state - Datatable's state object
  */
 export function recomputeCellStyles(types, state) {
-    const columns = getColumns(state);
+    const { columns } = state;
     state.rows.forEach((row) => {
         row.cells.forEach((cell, colIndex) => {
             const colData = columns[colIndex];