@nova-design-system/nova-react 3.28.0 → 3.30.0

package/dist/components/NvDatatable/NvDatatable.js

@@ -1,14 +1,15 @@
 import React, { useMemo, useState, useEffect, useRef, useCallback, } from 'react';
-import { flexRender, getCoreRowModel, getPaginationRowModel, getSortedRowModel, getFilteredRowModel, useReactTable, } from '@tanstack/react-table';
-import { NvTable, NvTableheader, NvPaginationtable, NvFieldcheckbox, } from '../../generated/components';
+import { flexRender, getCoreRowModel, getPaginationRowModel, getSortedRowModel, getFilteredRowModel, getExpandedRowModel, useReactTable, } from '@tanstack/react-table';
+import { NvTable, NvTableheader, NvPaginationtable, NvFieldcheckbox, NvIconbutton, } from '../../generated/components';
 import { defineCustomElement as defineNvPaginationtable } from '@nova-design-system/nova-webcomponents/dist/components/nv-paginationtable.js';
 if (typeof window !== 'undefined' &&
     !customElements.get('nv-paginationtable')) {
     defineNvPaginationtable();
 }
 import { applyRowSelection, applySelectAllSelection, shouldIgnoreSelectAllEvent, } from './selectionState';
-function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filtering, selection, renderPagination, renderFiltering, stickyHeader, ...htmlProps }) {
-    const SELECTION_EVENT_SUPPRESSION_MS = 16;
+import { shouldShowExpandedContent } from './expandState';
+import { resolvePaginationRowCount } from './paginationState';
+function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filtering, selection, renderPagination, renderFiltering, onRowClick, expandable, stickyHeader, ...htmlProps }) {
     const areSetsEqual = useCallback((a, b) => {
         if (a.size !== b.size) {
             return false;
@@ -25,16 +26,29 @@ function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filt
         pageIndex: 0,
         pageSize: pagination?.initialPageSize || 10,
     });
-    const [sortingState, setSortingState] = useState(sorting?.sortState || []);
+    const [sortingState, setSortingState] = useState(sorting?.sortState ?? sorting?.initialSortState ?? []);
     const [globalFilterState, setGlobalFilterState] = useState(filtering?.filterState);
     const [selectedRowIdsState, setSelectedRowIdsState] = useState(() => new Set(selection?.selectedRowIds ?? []));
     const selectedRowIdsRef = useRef(new Set(selection?.selectedRowIds ?? []));
     const selectionMode = selection?.mode ?? 'none';
     const selectionEnabled = selectionMode !== 'none';
     const selectAllEnabled = selection?.enableSelectAll ?? true;
+    const rowClickEnabled = typeof onRowClick === 'function';
+    const hasExpandable = !!expandable;
+    const isCollapsible = expandable?.collapsible ?? false;
+    const [expandedState, setExpandedState] = useState(expandable?.expandedState ?? {});
+    useEffect(() => {
+        if (expandable?.expandedState !== undefined) {
+            setExpandedState(expandable.expandedState);
+        }
+    }, [expandable?.expandedState]);
     const getSelectionRowId = useCallback((row) => selection?.getRowId?.(row) ?? '', [selection]);
     const lastRowRef = useRef(null);
-    const suppressRowSelectionEventsRef = useRef(false);
+    const selectAllIntentRef = useRef(false);
+    const rowSelectionIntentRef = useRef(null);
+    const selectAllIntentResetTimerRef = useRef(null);
+    const rowSelectionIntentResetTimerRef = useRef(null);
+    const INTENT_RESET_DELAY_MS = 16;
     const debouncedSetFilter = useRef(null);
     const setGlobalFilterDebounced = useCallback((value) => {
         const debounceMs = filtering?.debounceMs ?? 300;
@@ -53,6 +67,12 @@ function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filt
             if (debouncedSetFilter.current) {
                 clearTimeout(debouncedSetFilter.current);
             }
+            if (selectAllIntentResetTimerRef.current) {
+                clearTimeout(selectAllIntentResetTimerRef.current);
+            }
+            if (rowSelectionIntentResetTimerRef.current) {
+                clearTimeout(rowSelectionIntentResetTimerRef.current);
+            }
         };
     }, []);
     useEffect(() => {
@@ -130,29 +150,66 @@ function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filt
             }
             return columnDef;
         });
-        if (!selectionEnabled) {
-            return dataColumns;
-        }
-        const selectionColumn = {
-            id: '__selection__',
-            header: '',
-            size: selection?.checkboxColumnWidth ?? 48,
-            enableResizing: false,
-            enableSorting: false,
-            cell: () => null,
-        };
-        return [selectionColumn, ...dataColumns];
-    }, [columns, sorting, selectionEnabled, selection?.checkboxColumnWidth]);
+        const prefixColumns = [];
+        const isCombinedColumn = selectionEnabled && isCollapsible;
+        if (isCombinedColumn) {
+            prefixColumns.push({
+                id: '__selection_expand__',
+                header: '',
+                size: (selection?.checkboxColumnWidth ?? 48) +
+                    (expandable?.toggleColumnWidth ?? 48),
+                enableResizing: false,
+                enableSorting: false,
+                cell: () => null,
+            });
+        }
+        else {
+            if (selectionEnabled) {
+                prefixColumns.push({
+                    id: '__selection__',
+                    header: '',
+                    size: selection?.checkboxColumnWidth ?? 48,
+                    enableResizing: false,
+                    enableSorting: false,
+                    cell: () => null,
+                });
+            }
+            if (isCollapsible) {
+                prefixColumns.push({
+                    id: '__expand__',
+                    header: '',
+                    size: expandable?.toggleColumnWidth ?? 48,
+                    enableResizing: false,
+                    enableSorting: false,
+                    cell: () => null,
+                });
+            }
+        }
+        return [...prefixColumns, ...dataColumns];
+    }, [
+        columns,
+        sorting,
+        selectionEnabled,
+        selection?.checkboxColumnWidth,
+        isCollapsible,
+        expandable?.toggleColumnWidth,
+    ]);
     const tableConfig = useMemo(() => {
+        const tableState = {};
+        if (sorting) {
+            tableState.sorting = sorting.sortState || sortingState;
+        }
+        if (filtering) {
+            tableState.globalFilter = globalFilterState;
+        }
+        if (isCollapsible) {
+            tableState.expanded = expandable?.expandedState ?? expandedState;
+        }
         const baseConfig = {
             data: rows,
             columns: tableColumns,
             getCoreRowModel: getCoreRowModel(),
             ...(sorting && {
-                state: {
-                    sorting: sorting.sortState || sortingState,
-                    ...(filtering && { globalFilter: globalFilterState }),
-                },
                 onSortingChange: mode === 'server'
                     ? (updater) => {
                         const newSort = typeof updater === 'function'
@@ -172,10 +229,6 @@ function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filt
                 getSortedRowModel: mode === 'client' ? getSortedRowModel() : undefined,
             }),
             ...(filtering && {
-                state: {
-                    ...(sorting && { sorting: sorting.sortState || sortingState }),
-                    globalFilter: globalFilterState,
-                },
                 onGlobalFilterChange: (updater) => {
                     const newFilter = typeof updater === 'function'
                         ? updater(globalFilterState)
@@ -188,6 +241,20 @@ function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filt
                 globalFilterFn: filtering.globalFilterFn,
                 getFilteredRowModel: mode === 'client' ? getFilteredRowModel() : undefined,
             }),
+            ...(isCollapsible && {
+                getExpandedRowModel: getExpandedRowModel(),
+                getRowCanExpand: expandable?.getRowCanExpand
+                    ? (row) => expandable.getRowCanExpand(row.original)
+                    : () => true,
+                onExpandedChange: (updater) => {
+                    const newExpanded = typeof updater === 'function'
+                        ? updater(expandedState)
+                        : updater;
+                    setExpandedState(newExpanded);
+                    expandable?.onExpandedChange?.(newExpanded);
+                },
+            }),
+            ...(Object.keys(tableState).length > 0 && { state: tableState }),
         };
         if (!pagination) {
             return baseConfig;
@@ -233,12 +300,21 @@ function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filt
         sortingState,
         filtering,
         globalFilterState,
+        isCollapsible,
+        expandable,
+        expandedState,
         mode,
     ]);
     const table = useReactTable(tableConfig);
     const tableRows = table.getRowModel().rows;
+    const getCurrentVisibleRowIds = useCallback(() => {
+        return table
+            .getRowModel()
+            .rows.map((row) => getSelectionRowId(row.original))
+            .filter((id) => !!id);
+    }, [table, getSelectionRowId]);
     const setSelectionState = useCallback((nextSelectedIds) => {
-        const current = new Set(selection?.selectedRowIds ?? selectedRowIdsRef.current);
+        const current = new Set(selectedRowIdsRef.current);
         const nextRaw = typeof nextSelectedIds === 'function'
             ? nextSelectedIds(new Set(current))
             : nextSelectedIds;
@@ -246,27 +322,14 @@ function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filt
         if (areSetsEqual(current, next)) {
             return;
         }
+        const hasExplicitSelectionIntent = selectAllIntentRef.current || rowSelectionIntentRef.current !== null;
+        if (!hasExplicitSelectionIntent && next.size < current.size) {
+            return;
+        }
         selectedRowIdsRef.current = next;
         setSelectedRowIdsState(next);
         selection?.onSelectionChange?.(new Set(next));
-    }, [selection, selection?.selectedRowIds, areSetsEqual]);
-    const resolveCheckedChange = useCallback((event) => {
-        if (event && typeof event === 'object') {
-            const eventLike = event;
-            const target = eventLike.target;
-            const currentTarget = eventLike.currentTarget;
-            if (typeof eventLike.detail === 'boolean') {
-                return eventLike.detail;
-            }
-            if (typeof target?.checked === 'boolean') {
-                return target.checked;
-            }
-            if (typeof currentTarget?.checked === 'boolean') {
-                return currentTarget.checked;
-            }
-        }
-        return undefined;
-    }, []);
+    }, [selection, areSetsEqual]);
     const isRowSelected = useCallback((row) => {
         if (!selectionEnabled) {
             return false;
@@ -277,22 +340,18 @@ function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filt
     const visibleRowIds = useMemo(() => tableRows
         .map((row) => getSelectionRowId(row.original))
         .filter((id) => !!id), [tableRows, getSelectionRowId]);
-    const visibleRowIdsSet = useMemo(() => new Set(visibleRowIds), [visibleRowIds]);
     const setRowSelection = useCallback((row, isChecked) => {
         if (!selectionEnabled) {
             return;
         }
-        if (suppressRowSelectionEventsRef.current) {
-            return;
-        }
         const rowId = getSelectionRowId(row);
         if (!rowId) {
             return;
         }
-        if (!visibleRowIdsSet.has(rowId)) {
+        const currentVisibleRowIdsSet = new Set(getCurrentVisibleRowIds());
+        if (!currentVisibleRowIdsSet.has(rowId)) {
             return;
         }
-        suppressRowSelectionEventsRef.current = true;
         setSelectionState((current) => {
             return applyRowSelection({
                 currentSelectedIds: current,
@@ -301,15 +360,12 @@ function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filt
                 selectionMode,
             });
         });
-        setTimeout(() => {
-            suppressRowSelectionEventsRef.current = false;
-        }, SELECTION_EVENT_SUPPRESSION_MS);
     }, [
         selectionEnabled,
         getSelectionRowId,
-        visibleRowIdsSet,
         selectionMode,
         setSelectionState,
+        getCurrentVisibleRowIds,
     ]);
     const selectAllState = useMemo(() => {
         if (!selectionEnabled ||
@@ -333,34 +389,37 @@ function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filt
         visibleRowIds,
         selectedRowIdsState,
     ]);
+    const selectAllStateRef = useRef(selectAllState);
+    selectAllStateRef.current = selectAllState;
     const handleSelectAllChanged = useCallback((isChecked) => {
         if (!selectionEnabled ||
             selectionMode !== 'multiple' ||
-            !selectAllEnabled ||
-            !visibleRowIds.length) {
+            !selectAllEnabled) {
+            return;
+        }
+        const currentVisibleRowIds = getCurrentVisibleRowIds();
+        if (!currentVisibleRowIds.length) {
             return;
         }
-        if (shouldIgnoreSelectAllEvent({ isChecked, selectAllState })) {
+        if (shouldIgnoreSelectAllEvent({
+            isChecked,
+            selectAllState: selectAllStateRef.current,
+        })) {
             return;
         }
-        suppressRowSelectionEventsRef.current = true;
         setSelectionState((current) => {
             return applySelectAllSelection({
                 currentSelectedIds: current,
-                visibleRowIds,
+                visibleRowIds: currentVisibleRowIds,
                 isChecked,
             });
         });
-        setTimeout(() => {
-            suppressRowSelectionEventsRef.current = false;
-        }, SELECTION_EVENT_SUPPRESSION_MS);
     }, [
         selectionEnabled,
         selectionMode,
         selectAllEnabled,
-        visibleRowIds,
-        selectAllState,
         setSelectionState,
+        getCurrentVisibleRowIds,
     ]);
     useEffect(() => {
         if (!selectionEnabled || selection?.deselectOnFilter === false) {
@@ -437,9 +496,14 @@ function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filt
             return null;
         }
         const pageCount = table.getPageCount();
-        const rowCount = mode === 'server' && !pagination.infinite
-            ? pagination.totalRowCount || rows.length
-            : rows.length;
+        const rowCount = resolvePaginationRowCount({
+            mode,
+            isInfinite: !!pagination.infinite,
+            hasFiltering: !!filtering,
+            totalRowCount: pagination.totalRowCount,
+            rowsLength: rows.length,
+            filteredRowsLength: table.getFilteredRowModel().rows.length,
+        });
         const api = {
             pageIndex: tablePaginationState.pageIndex,
             pageSize: tablePaginationState.pageSize,
@@ -474,7 +538,11 @@ function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filt
         if (pagination?.labels?.pageSizeOption)
             labelProps.labelPageSizeOption = pagination.labels.pageSizeOption;
         return (React.createElement("div", { "data-testid": "default-pagination-wrapper", style: { marginTop: '16px' } },
-            React.createElement(NvPaginationtable, { pageIndex: api.pageIndex, pageSize: api.pageSize, pageCount: api.pageCount, rowCount: api.rowCount, ...labelProps, onPageIndexChanged: (e) => api.setPageIndex(e.detail), onPageSizeChanged: (e) => api.setPageSize(e.detail) })));
+            React.createElement(NvPaginationtable, { pageIndex: api.pageIndex, pageSize: api.pageSize, pageCount: api.pageCount, rowCount: api.rowCount, ...labelProps, onPageIndexChanged: (e) => {
+                    api.setPageIndex(e.detail);
+                }, onPageSizeChanged: (e) => {
+                    api.setPageSize(e.detail);
+                } })));
     };
     const filteringAPI = useMemo(() => {
         if (!filtering) {
@@ -495,29 +563,122 @@ function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filt
             filteredRows: filteredRowModel.rows.length,
         };
     }, [filtering, globalFilterState, table, setGlobalFilterDebounced]);
+    const markSelectAllIntentFromKey = (event) => {
+        if (event.key === ' ' || event.key === 'Enter') {
+            if (selectAllIntentResetTimerRef.current) {
+                clearTimeout(selectAllIntentResetTimerRef.current);
+            }
+            selectAllIntentRef.current = true;
+        }
+    };
+    const scheduleSelectAllIntentReset = () => {
+        if (selectAllIntentResetTimerRef.current) {
+            clearTimeout(selectAllIntentResetTimerRef.current);
+        }
+        selectAllIntentResetTimerRef.current = setTimeout(() => {
+            selectAllIntentRef.current = false;
+            selectAllIntentResetTimerRef.current = null;
+        }, INTENT_RESET_DELAY_MS);
+    };
+    const markRowSelectionIntentFromKey = (event, rowId) => {
+        if (event.key === ' ' || event.key === 'Enter') {
+            if (rowSelectionIntentResetTimerRef.current) {
+                clearTimeout(rowSelectionIntentResetTimerRef.current);
+            }
+            rowSelectionIntentRef.current = rowId;
+        }
+    };
+    const scheduleRowSelectionIntentReset = (rowId) => {
+        if (rowSelectionIntentResetTimerRef.current) {
+            clearTimeout(rowSelectionIntentResetTimerRef.current);
+        }
+        rowSelectionIntentResetTimerRef.current = setTimeout(() => {
+            if (rowSelectionIntentRef.current === rowId) {
+                rowSelectionIntentRef.current = null;
+            }
+            rowSelectionIntentResetTimerRef.current = null;
+        }, INTENT_RESET_DELAY_MS);
+    };
+    const renderRowSelectionCheckbox = useCallback((row, rowIndex) => {
+        const rowId = getSelectionRowId(row);
+        return (React.createElement(NvFieldcheckbox, { "data-testid": `datatable-row-${rowIndex}-checkbox`, checked: isRowSelected(row), label: `Select row ${rowIndex + 1}`, hideLabel: true, onPointerDownCapture: () => {
+                if (rowSelectionIntentResetTimerRef.current) {
+                    clearTimeout(rowSelectionIntentResetTimerRef.current);
+                }
+                rowSelectionIntentRef.current = rowId;
+            }, onKeyDownCapture: (event) => {
+                markRowSelectionIntentFromKey(event, rowId);
+            }, onBlurCapture: () => {
+                scheduleRowSelectionIntentReset(rowId);
+            }, onCheckedChanged: (event) => {
+                if (!rowId || rowSelectionIntentRef.current !== rowId) {
+                    return;
+                }
+                try {
+                    setRowSelection(row, event.detail);
+                }
+                finally {
+                    rowSelectionIntentRef.current = null;
+                }
+            } }));
+    }, [getSelectionRowId, isRowSelected, setRowSelection]);
+    const renderExpandToggle = useCallback((row, rowIndex) => {
+        const isExpanded = row.getIsExpanded();
+        const canExpand = row.getCanExpand();
+        const expandedContentId = `datatable-expanded-content-${rowIndex}`;
+        if (!canExpand) {
+            return null;
+        }
+        return (React.createElement(NvIconbutton, { "data-testid": `datatable-row-${rowIndex}-expand-toggle`, "aria-expanded": isExpanded ? 'true' : 'false', "aria-controls": expandedContentId, "aria-label": isExpanded
+                ? `Collapse row ${rowIndex + 1}`
+                : `Expand row ${rowIndex + 1}`, onClick: (e) => {
+                e.stopPropagation();
+                row.toggleExpanded();
+            }, name: isExpanded ? 'chevron-down' : 'chevron-right', size: "sm", emphasis: "lower" }));
+    }, []);
     return (React.createElement(React.Fragment, null,
         filteringAPI && renderFiltering && renderFiltering(filteringAPI),
         React.createElement(NvTable, { ...htmlProps },
-            React.createElement("table", null,
+            React.createElement("table", { "data-row-click-enabled": rowClickEnabled ? 'true' : 'false' },
                 React.createElement("thead", { "data-sticky-top": stickyHeader ? 'true' : undefined }, table.getHeaderGroups().map((headerGroup) => (React.createElement("tr", { key: headerGroup.id }, headerGroup.headers.map((header) => {
                     const isSelectionHeader = header.id === '__selection__';
+                    const isExpandHeader = header.id === '__expand__';
+                    const isCombinedHeader = header.id === '__selection_expand__';
+                    const isSpecialHeader = isSelectionHeader || isExpandHeader || isCombinedHeader;
                     const canSort = header.column.getCanSort();
                     const sortDirection = header.column.getIsSorted();
+                    const renderSelectAllCheckbox = selectionMode === 'multiple' && selectAllEnabled ? (React.createElement("div", { className: "flex items-center justify-center" },
+                        React.createElement(NvFieldcheckbox, { "data-testid": "datatable-select-all-checkbox", checked: selectAllState === 'checked', indeterminate: selectAllState === 'indeterminate', label: "Select all rows", hideLabel: true, onPointerDownCapture: () => {
+                                if (selectAllIntentResetTimerRef.current) {
+                                    clearTimeout(selectAllIntentResetTimerRef.current);
+                                }
+                                selectAllIntentRef.current = true;
+                            }, onKeyDownCapture: markSelectAllIntentFromKey, onBlurCapture: () => {
+                                scheduleSelectAllIntentReset();
+                            }, onCheckedChanged: (event) => {
+                                if (!selectAllIntentRef.current) {
+                                    return;
+                                }
+                                try {
+                                    handleSelectAllChanged(event.detail);
+                                }
+                                finally {
+                                    selectAllIntentRef.current = false;
+                                }
+                            } }))) : null;
                     return (React.createElement("th", { key: header.id, "data-testid": isSelectionHeader
                             ? 'datatable-header-selection'
-                            : `datatable-header-${header.id}`, style: {
+                            : isExpandHeader
+                                ? 'datatable-header-expand'
+                                : isCombinedHeader
+                                    ? 'datatable-header-selection-expand'
+                                    : `datatable-header-${header.id}`, style: {
                             width: header.column.columnDef.size + 'px',
-                        }, "data-no-resize": isSelectionHeader
+                        }, "data-no-resize": isSpecialHeader
                             ? true
                             : header.column.columnDef.enableResizing
                                 ? null
-                                : true }, isSelectionHeader ? (selectionMode === 'multiple' && selectAllEnabled ? (React.createElement("div", { className: "flex items-center justify-center" },
-                        React.createElement(NvFieldcheckbox, { "data-testid": "datatable-select-all-checkbox", checked: selectAllState === 'checked', indeterminate: selectAllState === 'indeterminate', label: "Select all rows", hideLabel: true, onCheckedChanged: (event) => {
-                                const checked = resolveCheckedChange(event);
-                                if (typeof checked === 'boolean') {
-                                    handleSelectAllChanged(checked);
-                                }
-                            } }))) : null) : (React.createElement(NvTableheader, { sortable: canSort ? true : undefined, sortDirection: sortDirection || (canSort ? 'none' : undefined), onSortDirectionChanged: canSort
+                                : true }, isSelectionHeader ? (renderSelectAllCheckbox) : isCombinedHeader ? (renderSelectAllCheckbox) : isExpandHeader ? null : (React.createElement(NvTableheader, { sortable: canSort ? true : undefined, sortDirection: sortDirection || (canSort ? 'none' : undefined), onSortDirectionChanged: canSort
                             ? header.column.getToggleSortingHandler()
                             : undefined }, header.isPlaceholder
                         ? null
@@ -525,14 +686,59 @@ function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filt
                 }))))),
                 React.createElement("tbody", null, tableRows.map((row, index) => {
                     const isLastRow = isInfiniteScroll && index === tableRows.length - 1;
-                    return (React.createElement("tr", { key: row.id, "data-testid": `datatable-row-${index}`, ref: isLastRow ? lastRowRef : undefined }, row.getVisibleCells().map((cell) => (React.createElement("td", { key: cell.id, "data-testid": cell.column.id === '__selection__'
-                            ? 'datatable-cell-selection'
-                            : `datatable-cell-${cell.column.id}` }, cell.column.id === '__selection__' ? (React.createElement(NvFieldcheckbox, { "data-testid": `datatable-row-${index}-checkbox`, checked: isRowSelected(row.original), label: `Select row ${index + 1}`, hideLabel: true, onCheckedChanged: (event) => {
-                            const checked = resolveCheckedChange(event);
-                            if (typeof checked === 'boolean') {
-                                setRowSelection(row.original, checked);
-                            }
-                        } })) : (flexRender(cell.column.columnDef.cell, cell.getContext())))))));
+                    const stableRowKey = getSelectionRowId(row.original) || row.id;
+                    const expandedContent = hasExpandable
+                        ? expandable.renderExpandedContent({
+                            row: row.original,
+                            rowIndex: index,
+                        })
+                        : null;
+                    const hasContent = expandedContent != null;
+                    const showExpanded = shouldShowExpandedContent({
+                        hasContent,
+                        isCollapsible,
+                        isExpanded: isCollapsible ? row.getIsExpanded() : false,
+                    });
+                    const expandedContentId = `datatable-expanded-content-${index}`;
+                    const totalColumnCount = row.getVisibleCells().length;
+                    return (React.createElement(React.Fragment, { key: stableRowKey },
+                        React.createElement("tr", { "data-testid": `datatable-row-${index}`, "data-selected": isRowSelected(row.original) ? '' : undefined, ref: isLastRow ? lastRowRef : undefined, className: rowClickEnabled ? 'nv-datatable-row-clickable' : undefined, tabIndex: rowClickEnabled ? 0 : undefined, onClick: rowClickEnabled
+                                ? () => onRowClick?.({
+                                    row: row.original,
+                                    rowIndex: index,
+                                })
+                                : undefined, onKeyDown: rowClickEnabled
+                                ? (event) => {
+                                    if (event.currentTarget !== event.target) {
+                                        return;
+                                    }
+                                    if (event.key === 'Enter' || event.key === ' ') {
+                                        event.preventDefault();
+                                        onRowClick?.({
+                                            row: row.original,
+                                            rowIndex: index,
+                                        });
+                                    }
+                                }
+                                : undefined }, row.getVisibleCells().map((cell) => {
+                            const isCombinedCell = cell.column.id === '__selection_expand__';
+                            const isSelectionCell = cell.column.id === '__selection__';
+                            const isExpandCell = cell.column.id === '__expand__';
+                            return (React.createElement("td", { key: cell.id, "data-testid": isSelectionCell
+                                    ? 'datatable-cell-selection'
+                                    : isExpandCell
+                                        ? 'datatable-cell-expand'
+                                        : isCombinedCell
+                                            ? 'datatable-cell-selection-expand'
+                                            : `datatable-cell-${cell.column.id}`, onClick: isSelectionCell || isExpandCell || isCombinedCell
+                                    ? (event) => event.stopPropagation()
+                                    : undefined }, isSelectionCell ? (renderRowSelectionCheckbox(row.original, index)) : isExpandCell ? (renderExpandToggle(row, index)) : isCombinedCell ? (React.createElement("div", { className: "flex items-center justify-center gap-1" },
+                                renderRowSelectionCheckbox(row.original, index),
+                                renderExpandToggle(row, index))) : (flexRender(cell.column.columnDef.cell, cell.getContext()))));
+                        })),
+                        showExpanded && (React.createElement("tr", { className: "nv-datatable-expanded-row", "data-testid": `datatable-expanded-row-${index}`, id: expandedContentId, role: "region", "aria-label": `Expanded content for row ${index + 1}` },
+                            React.createElement("td", { colSpan: totalColumnCount },
+                                React.createElement("div", { className: "nv-datatable-expanded-content" }, expandedContent))))));
                 })))),
         paginationAPI &&
             (renderPagination

package/dist/components/NvDatatable/expandState.js

@@ -0,0 +1,8 @@
+export function shouldShowExpandedContent(params) {
+    const { hasContent, isCollapsible, isExpanded } = params;
+    if (!hasContent)
+        return false;
+    if (!isCollapsible)
+        return true;
+    return isExpanded;
+}

package/dist/components/NvDatatable/expandState.test.js

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest';
+import { shouldShowExpandedContent } from './expandState';
+describe('expandState', () => {
+    describe('shouldShowExpandedContent', () => {
+        it('returns false when there is no content', () => {
+            expect(shouldShowExpandedContent({
+                hasContent: false,
+                isCollapsible: false,
+                isExpanded: false,
+            })).toBe(false);
+        });
+        it('returns false when there is no content even if expanded', () => {
+            expect(shouldShowExpandedContent({
+                hasContent: false,
+                isCollapsible: true,
+                isExpanded: true,
+            })).toBe(false);
+        });
+        it('returns true when has content and not collapsible', () => {
+            expect(shouldShowExpandedContent({
+                hasContent: true,
+                isCollapsible: false,
+                isExpanded: false,
+            })).toBe(true);
+        });
+        it('returns false when collapsible and not expanded', () => {
+            expect(shouldShowExpandedContent({
+                hasContent: true,
+                isCollapsible: true,
+                isExpanded: false,
+            })).toBe(false);
+        });
+        it('returns true when collapsible and expanded', () => {
+            expect(shouldShowExpandedContent({
+                hasContent: true,
+                isCollapsible: true,
+                isExpanded: true,
+            })).toBe(true);
+        });
+    });
+});

package/dist/components/NvDatatable/paginationState.js

@@ -0,0 +1,9 @@
+export function resolvePaginationRowCount(opts) {
+    if (opts.mode === 'server' && !opts.isInfinite) {
+        return opts.totalRowCount || opts.rowsLength;
+    }
+    if (opts.mode === 'client' && opts.hasFiltering) {
+        return opts.filteredRowsLength;
+    }
+    return opts.rowsLength;
+}