@tanstack/table-core 8.9.11 → 8.10.1

package/build/lib/types.d.ts

@@ -1,7 +1,7 @@
 import { CoreOptions, CoreTableState, CoreInstance } from './core/table';
 import { VisibilityInstance, VisibilityTableState, VisibilityColumn as ColumnVisibilityColumn, VisibilityOptions, VisibilityColumnDef, VisibilityRow } from './features/Visibility';
 import { ColumnOrderInstance, ColumnOrderOptions, ColumnOrderTableState } from './features/Ordering';
-import { ColumnPinningColumn, ColumnPinningColumnDef, ColumnPinningInstance, ColumnPinningOptions, ColumnPinningRow, ColumnPinningTableState } from './features/Pinning';
+import { ColumnPinningColumn, ColumnPinningColumnDef, ColumnPinningInstance, ColumnPinningOptions, ColumnPinningRow, ColumnPinningTableState, RowPinningInstance, RowPinningOptions, RowPinningRow, RowPinningTableState } from './features/Pinning';
 import { CoreHeader, CoreHeaderGroup, HeaderContext, HeadersInstance } from './core/headers';
 import { FiltersColumn, FiltersColumnDef, FiltersInstance, FiltersOptions, FiltersRow, FiltersTableState } from './features/Filters';
 import { SortingColumn, SortingColumnDef, SortingInstance, SortingOptions, SortingTableState } from './features/Sorting';
@@ -30,20 +30,20 @@ export type Updater<T> = T | ((old: T) => T);
 export type OnChangeFn<T> = (updaterOrValue: Updater<T>) => void;
 export type RowData = unknown | object | any[];
 export type AnyRender = (Comp: any, props: any) => any;
-export interface Table<TData extends RowData> extends CoreInstance<TData>, HeadersInstance<TData>, VisibilityInstance<TData>, ColumnOrderInstance<TData>, ColumnPinningInstance<TData>, FiltersInstance<TData>, SortingInstance<TData>, GroupingInstance<TData>, ColumnSizingInstance, ExpandedInstance<TData>, PaginationInstance<TData>, RowSelectionInstance<TData> {
+export interface Table<TData extends RowData> extends CoreInstance<TData>, HeadersInstance<TData>, VisibilityInstance<TData>, ColumnOrderInstance<TData>, ColumnPinningInstance<TData>, RowPinningInstance<TData>, FiltersInstance<TData>, SortingInstance<TData>, GroupingInstance<TData>, ColumnSizingInstance, ExpandedInstance<TData>, PaginationInstance<TData>, RowSelectionInstance<TData> {
 }
-interface FeatureOptions<TData extends RowData> extends VisibilityOptions, ColumnOrderOptions, ColumnPinningOptions, FiltersOptions<TData>, SortingOptions<TData>, GroupingOptions, ExpandedOptions<TData>, ColumnSizingOptions, PaginationOptions, RowSelectionOptions<TData> {
+interface FeatureOptions<TData extends RowData> extends VisibilityOptions, ColumnOrderOptions, ColumnPinningOptions, RowPinningOptions<TData>, FiltersOptions<TData>, SortingOptions<TData>, GroupingOptions, ExpandedOptions<TData>, ColumnSizingOptions, PaginationOptions, RowSelectionOptions<TData> {
 }
 export type TableOptionsResolved<TData extends RowData> = CoreOptions<TData> & FeatureOptions<TData>;
 export interface TableOptions<TData extends RowData> extends PartialKeys<TableOptionsResolved<TData>, 'state' | 'onStateChange' | 'renderFallbackValue'> {
 }
-export interface TableState extends CoreTableState, VisibilityTableState, ColumnOrderTableState, ColumnPinningTableState, FiltersTableState, SortingTableState, ExpandedTableState, GroupingTableState, ColumnSizingTableState, PaginationTableState, RowSelectionTableState {
+export interface TableState extends CoreTableState, VisibilityTableState, ColumnOrderTableState, ColumnPinningTableState, RowPinningTableState, FiltersTableState, SortingTableState, ExpandedTableState, GroupingTableState, ColumnSizingTableState, PaginationTableState, RowSelectionTableState {
 }
-interface CompleteInitialTableState extends CoreTableState, VisibilityTableState, ColumnOrderTableState, ColumnPinningTableState, FiltersTableState, SortingTableState, ExpandedTableState, GroupingTableState, ColumnSizingTableState, PaginationInitialTableState, RowSelectionTableState {
+interface CompleteInitialTableState extends CoreTableState, VisibilityTableState, ColumnOrderTableState, ColumnPinningTableState, RowPinningTableState, FiltersTableState, SortingTableState, ExpandedTableState, GroupingTableState, ColumnSizingTableState, PaginationInitialTableState, RowSelectionTableState {
 }
 export interface InitialTableState extends Partial<CompleteInitialTableState> {
 }
-export interface Row<TData extends RowData> extends CoreRow<TData>, VisibilityRow<TData>, ColumnPinningRow<TData>, FiltersRow<TData>, GroupingRow, RowSelectionRow, ExpandedRow {
+export interface Row<TData extends RowData> extends CoreRow<TData>, VisibilityRow<TData>, ColumnPinningRow<TData>, RowPinningRow, FiltersRow<TData>, GroupingRow, RowSelectionRow, ExpandedRow {
 }
 export interface RowModel<TData extends RowData> {
     rows: Row<TData>[];

package/build/umd/index.development.js

@@ -910,6 +910,15 @@
         var _table$options$getRow, _table$options$enable, _row$subRows;
         return (_table$options$getRow = table.options.getRowCanExpand == null ? void 0 : table.options.getRowCanExpand(row)) != null ? _table$options$getRow : ((_table$options$enable = table.options.enableExpanding) != null ? _table$options$enable : true) && !!((_row$subRows = row.subRows) != null && _row$subRows.length);
       };
+      row.getIsAllParentsExpanded = () => {
+        let isFullyExpanded = true;
+        let currentRow = row;
+        while (isFullyExpanded && currentRow.parentId) {
+          currentRow = table.getRow(currentRow.parentId, true);
+          isFullyExpanded = currentRow.getIsExpanded();
+        }
+        return isFullyExpanded;
+      };
       row.getToggleExpandedHandler = () => {
         const canExpand = row.getCanExpand();
         return () => {
@@ -1633,20 +1642,26 @@
 
   //
 
-  const getDefaultPinningState = () => ({
+  const getDefaultColumnPinningState = () => ({
     left: [],
     right: []
   });
+  const getDefaultRowPinningState = () => ({
+    top: [],
+    bottom: []
+  });
   const Pinning = {
     getInitialState: state => {
       return {
-        columnPinning: getDefaultPinningState(),
+        columnPinning: getDefaultColumnPinningState(),
+        rowPinning: getDefaultRowPinningState(),
         ...state
       };
     },
     getDefaultOptions: table => {
       return {
-        onColumnPinningChange: makeStateUpdater('columnPinning', table)
+        onColumnPinningChange: makeStateUpdater('columnPinning', table),
+        onRowPinningChange: makeStateUpdater('rowPinning', table)
       };
     },
     createColumn: (column, table) => {
@@ -1677,8 +1692,8 @@
       column.getCanPin = () => {
         const leafColumns = column.getLeafColumns();
         return leafColumns.some(d => {
-          var _d$columnDef$enablePi, _table$options$enable;
-          return ((_d$columnDef$enablePi = d.columnDef.enablePinning) != null ? _d$columnDef$enablePi : true) && ((_table$options$enable = table.options.enablePinning) != null ? _table$options$enable : true);
+          var _d$columnDef$enablePi, _ref, _table$options$enable;
+          return ((_d$columnDef$enablePi = d.columnDef.enablePinning) != null ? _d$columnDef$enablePi : true) && ((_ref = (_table$options$enable = table.options.enableColumnPinning) != null ? _table$options$enable : table.options.enablePinning) != null ? _ref : true);
         });
       };
       column.getIsPinned = () => {
@@ -1698,11 +1713,80 @@
       };
     },
     createRow: (row, table) => {
+      row.pin = (position, includeLeafRows, includeParentRows) => {
+        const leafRowIds = includeLeafRows ? row.getLeafRows().map(_ref2 => {
+          let {
+            id
+          } = _ref2;
+          return id;
+        }) : [];
+        const parentRowIds = includeParentRows ? row.getParentRows().map(_ref3 => {
+          let {
+            id
+          } = _ref3;
+          return id;
+        }) : [];
+        const rowIds = new Set([...parentRowIds, row.id, ...leafRowIds]);
+        table.setRowPinning(old => {
+          var _old$top3, _old$bottom3;
+          if (position === 'bottom') {
+            var _old$top, _old$bottom;
+            return {
+              top: ((_old$top = old == null ? void 0 : old.top) != null ? _old$top : []).filter(d => !(rowIds != null && rowIds.has(d))),
+              bottom: [...((_old$bottom = old == null ? void 0 : old.bottom) != null ? _old$bottom : []).filter(d => !(rowIds != null && rowIds.has(d))), ...Array.from(rowIds)]
+            };
+          }
+          if (position === 'top') {
+            var _old$top2, _old$bottom2;
+            return {
+              top: [...((_old$top2 = old == null ? void 0 : old.top) != null ? _old$top2 : []).filter(d => !(rowIds != null && rowIds.has(d))), ...Array.from(rowIds)],
+              bottom: ((_old$bottom2 = old == null ? void 0 : old.bottom) != null ? _old$bottom2 : []).filter(d => !(rowIds != null && rowIds.has(d)))
+            };
+          }
+          return {
+            top: ((_old$top3 = old == null ? void 0 : old.top) != null ? _old$top3 : []).filter(d => !(rowIds != null && rowIds.has(d))),
+            bottom: ((_old$bottom3 = old == null ? void 0 : old.bottom) != null ? _old$bottom3 : []).filter(d => !(rowIds != null && rowIds.has(d)))
+          };
+        });
+      };
+      row.getCanPin = () => {
+        var _ref4;
+        const {
+          enableRowPinning,
+          enablePinning
+        } = table.options;
+        if (typeof enableRowPinning === 'function') {
+          return enableRowPinning(row);
+        }
+        return (_ref4 = enableRowPinning != null ? enableRowPinning : enablePinning) != null ? _ref4 : true;
+      };
+      row.getIsPinned = () => {
+        const rowIds = [row.id];
+        const {
+          top,
+          bottom
+        } = table.getState().rowPinning;
+        const isTop = rowIds.some(d => top == null ? void 0 : top.includes(d));
+        const isBottom = rowIds.some(d => bottom == null ? void 0 : bottom.includes(d));
+        return isTop ? 'top' : isBottom ? 'bottom' : false;
+      };
+      row.getPinnedIndex = () => {
+        var _table$_getPinnedRows, _visiblePinnedRowIds$;
+        const position = row.getIsPinned();
+        if (!position) return -1;
+        const visiblePinnedRowIds = (_table$_getPinnedRows = table._getPinnedRows(position)) == null ? void 0 : _table$_getPinnedRows.map(_ref5 => {
+          let {
+            id
+          } = _ref5;
+          return id;
+        });
+        return (_visiblePinnedRowIds$ = visiblePinnedRowIds == null ? void 0 : visiblePinnedRowIds.indexOf(row.id)) != null ? _visiblePinnedRowIds$ : -1;
+      };
       row.getCenterVisibleCells = memo(() => [row._getAllVisibleCells(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allCells, left, right) => {
         const leftAndRight = [...(left != null ? left : []), ...(right != null ? right : [])];
         return allCells.filter(d => !leftAndRight.includes(d.column.id));
       }, {
-        key: "development" === 'production' ,
+        key: 'row.getCenterVisibleCells',
         debug: () => {
           var _table$options$debugA;
           return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugRows;
@@ -1715,7 +1799,7 @@
         }));
         return cells;
       }, {
-        key: "development" === 'production' ,
+        key: 'row.getLeftVisibleCells',
         debug: () => {
           var _table$options$debugA2;
           return (_table$options$debugA2 = table.options.debugAll) != null ? _table$options$debugA2 : table.options.debugRows;
@@ -1728,7 +1812,7 @@
         }));
         return cells;
       }, {
-        key: "development" === 'production' ,
+        key: 'row.getRightVisibleCells',
         debug: () => {
           var _table$options$debugA3;
           return (_table$options$debugA3 = table.options.debugAll) != null ? _table$options$debugA3 : table.options.debugRows;
@@ -1739,7 +1823,7 @@
       table.setColumnPinning = updater => table.options.onColumnPinningChange == null ? void 0 : table.options.onColumnPinningChange(updater);
       table.resetColumnPinning = defaultState => {
         var _table$initialState$c, _table$initialState;
-        return table.setColumnPinning(defaultState ? getDefaultPinningState() : (_table$initialState$c = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.columnPinning) != null ? _table$initialState$c : getDefaultPinningState());
+        return table.setColumnPinning(defaultState ? getDefaultColumnPinningState() : (_table$initialState$c = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.columnPinning) != null ? _table$initialState$c : getDefaultColumnPinningState());
       };
       table.getIsSomeColumnsPinned = position => {
         var _pinningState$positio;
@@ -1778,6 +1862,54 @@
           return (_table$options$debugA6 = table.options.debugAll) != null ? _table$options$debugA6 : table.options.debugColumns;
         }
       });
+      table.setRowPinning = updater => table.options.onRowPinningChange == null ? void 0 : table.options.onRowPinningChange(updater);
+      table.resetRowPinning = defaultState => {
+        var _table$initialState$r, _table$initialState2;
+        return table.setRowPinning(defaultState ? getDefaultRowPinningState() : (_table$initialState$r = (_table$initialState2 = table.initialState) == null ? void 0 : _table$initialState2.rowPinning) != null ? _table$initialState$r : getDefaultRowPinningState());
+      };
+      table.getIsSomeRowsPinned = position => {
+        var _pinningState$positio2;
+        const pinningState = table.getState().rowPinning;
+        if (!position) {
+          var _pinningState$top, _pinningState$bottom;
+          return Boolean(((_pinningState$top = pinningState.top) == null ? void 0 : _pinningState$top.length) || ((_pinningState$bottom = pinningState.bottom) == null ? void 0 : _pinningState$bottom.length));
+        }
+        return Boolean((_pinningState$positio2 = pinningState[position]) == null ? void 0 : _pinningState$positio2.length);
+      };
+      table._getPinnedRows = position => memo(() => [table.getRowModel().rows, table.getState().rowPinning[position]], (visibleRows, pinnedRowIds) => {
+        var _table$options$keepPi;
+        const rows = ((_table$options$keepPi = table.options.keepPinnedRows) != null ? _table$options$keepPi : true) ?
+        //get all rows that are pinned even if they would not be otherwise visible
+        //account for expanded parent rows, but not pagination or filtering
+        (pinnedRowIds != null ? pinnedRowIds : []).map(rowId => {
+          const row = table.getRow(rowId, true);
+          return row.getIsAllParentsExpanded() ? row : null;
+        }) :
+        //else get only visible rows that are pinned
+        (pinnedRowIds != null ? pinnedRowIds : []).map(rowId => visibleRows.find(row => row.id === rowId));
+        return rows.filter(Boolean).map(d => ({
+          ...d,
+          position
+        }));
+      }, {
+        key: `row.get${position === 'top' ? 'Top' : 'Bottom'}Rows`,
+        debug: () => {
+          var _table$options$debugA7;
+          return (_table$options$debugA7 = table.options.debugAll) != null ? _table$options$debugA7 : table.options.debugRows;
+        }
+      })();
+      table.getTopRows = () => table._getPinnedRows('top');
+      table.getBottomRows = () => table._getPinnedRows('bottom');
+      table.getCenterRows = memo(() => [table.getRowModel().rows, table.getState().rowPinning.top, table.getState().rowPinning.bottom], (allRows, top, bottom) => {
+        const topAndBottom = new Set([...(top != null ? top : []), ...(bottom != null ? bottom : [])]);
+        return allRows.filter(d => !topAndBottom.has(d.id));
+      }, {
+        key: 'row.getCenterRows',
+        debug: () => {
+          var _table$options$debugA8;
+          return (_table$options$debugA8 = table.options.debugAll) != null ? _table$options$debugA8 : table.options.debugRows;
+        }
+      });
     }
   };
 
@@ -2669,8 +2801,8 @@
       getRowModel: () => {
         return table.getPaginationRowModel();
       },
-      getRow: id => {
-        const row = table.getRowModel().rowsById[id];
+      getRow: (id, searchAll) => {
+        const row = (searchAll ? table.getCoreRowModel() : table.getRowModel()).rowsById[id];
         if (!row) {
           {
             throw new Error(`getRow expected an ID, but got ${id}`);