@dynatrace/strato-components 3.5.2 → 3.7.0

package/esm/tables/DataTable/features/RowSelection/RowSelection.js

@@ -1,56 +1,29 @@
-import { jsx } from "react/jsx-runtime";
-import { useCallback } from "react";
-import { RowSelectionCell, RowSelectionHeader } from "./RowSelectionCells.js";
-import { useControllableState } from "../../../../core/hooks/useControllableState.js";
-import { useDataTableConfigElement } from "../../../hooks/useDataTableConfig.js";
 import {
-  DATA_TABLE_BUILTIN_COLUMN_MIN_WIDTH,
-  DATA_TABLE_ROW_SELECTION_COLUMN_ID
-} from "../../constants.js";
-import { assignRowMethods } from "../../hooks/useTable/utils.js";
+  assignPrototypeAPIs,
+  assignTableAPIs
+} from "@tanstack/react-table";
+import {
+  row_getCanSelectSubRows,
+  row_getIsSelected,
+  table_getFilteredSelectedRowModel,
+  table_setRowSelection
+} from "@tanstack/react-table/static-functions";
+import { DATA_TABLE_ROW_SELECTION_COLUMN_ID } from "../../constants.js";
 function isRowSelectionColumnDef(column) {
-  return column.id === ROW_SELECTION_COLUMN.id;
+  return column.id === DATA_TABLE_ROW_SELECTION_COLUMN_ID;
 }
-const ROW_SELECTION_COLUMN = {
-  id: DATA_TABLE_ROW_SELECTION_COLUMN_ID,
-  alignment: "left",
-  accessorFn: () => "",
-  header: ({ table }) => /* @__PURE__ */ jsx(RowSelectionHeader, { table }),
-  width: "content",
-  minWidth: DATA_TABLE_BUILTIN_COLUMN_MIN_WIDTH,
-  enableSorting: false,
-  enableResizing: false,
-  enableUserActions: false,
-  enableHiding: false,
-  meta: {
-    builtin: true,
-    hasCustomCellRenderer: true,
-    hasCustomHeaderRenderer: true,
-    builtinPlacement: "prefix",
-    cellDeps: (cell) => {
-      return [
-        cell.row.getIsSelected(),
-        cell.row.getIsAllSubRowsSelected(),
-        cell.row.getIsSomeSelected(),
-        cell.row.getCanSelect(),
-        cell.row.getShouldDisableRowSelection()
-      ];
-    }
-  },
-  cell: ({ row }) => /* @__PURE__ */ jsx(RowSelectionCell, { row })
-};
-const mutateRowIsSelected = (selectedRowIds, id, value, includeChildren, table) => {
+function mutateRowIsSelected(selectedRowIds, id, value, includeChildren, table) {
   const row = table.getRow(id, true);
-  if (!row.getShouldDisableRowSelection()) {
+  if (!row_getShouldDisableRowSelection(row)) {
     if (value) {
-      if (row.getCanSelect() && !table.getIsRowSelectionLimitReached(selectedRowIds)) {
+      if (row_getCanSelect(row) && !table_getIsRowSelectionLimitReached(table, selectedRowIds)) {
         selectedRowIds[id] = true;
       }
     } else {
       delete selectedRowIds[id];
     }
   }
-  if (includeChildren && row.subRows?.length && row.getCanSelectSubRows() && !table.getIsRowSelectionLimitReached(selectedRowIds)) {
+  if (includeChildren && row.subRows?.length && row_getCanSelectSubRows(row) && !table_getIsRowSelectionLimitReached(table, selectedRowIds)) {
     row.subRows.forEach(
       (row2) => mutateRowIsSelected(
         selectedRowIds,
@@ -61,328 +34,374 @@ const mutateRowIsSelected = (selectedRowIds, id, value, includeChildren, table)
       )
     );
   }
-};
-const DataTableRowSelection = {
-  createTable(table) {
-    let _batchSelectionRowId = void 0;
-    let _previousSelectionRange = void 0;
-    table.resetBatchSelection = (event) => {
-      if (!(_batchSelectionRowId || _previousSelectionRange)) {
-        return;
-      }
-      const checkboxElement = event.target.closest(
-        "[data-row-selection-checkbox]"
+}
+function table_resetBatchSelection(table) {
+  table._batchSelectionRowId ??= void 0;
+  table._previousSelectionRange ??= void 0;
+  return (event) => {
+    if (!(table._batchSelectionRowId || table._previousSelectionRange)) {
+      return;
+    }
+    const checkboxElement = event.target.closest(
+      "[data-row-selection-checkbox]"
+    );
+    if (checkboxElement === null) {
+      table._batchSelectionRowId = void 0;
+      table._previousSelectionRange = void 0;
+      return;
+    }
+    if (table.getRowVirtualizationContainer()?.contains(checkboxElement) === false) {
+      table._batchSelectionRowId = void 0;
+      table._previousSelectionRange = void 0;
+    }
+  };
+}
+function table_getToggleAllLimitedRowsSelectedHandler(table) {
+  return (event) => {
+    table_toggleAllLimitedRowsSelected(
+      table,
+      event.target.checked
+    );
+  };
+}
+function table_getToggleAllLimitedPageRowsSelectedHandler(table) {
+  return (event) => {
+    table_toggleAllLimitedPageRowsSelected(
+      table,
+      event.target.checked
+    );
+  };
+}
+function table_getSelectionCount(table) {
+  return table_getFilteredSelectedRowModel(table).flatRows.length;
+}
+function table_toggleAllPageRowsSelected(table, value) {
+  table_setRowSelection(table, (old) => {
+    const resolvedValue = value ?? !table_getIsAllPageRowsSelected(table);
+    const rowSelection = { ...old };
+    table.getRowModel().flatRows.forEach((row) => {
+      mutateRowIsSelected(
+        rowSelection,
+        row.id,
+        resolvedValue,
+        false,
+        // we don't need to include children as they are already included in `flatRows`
+        table
       );
-      if (checkboxElement === null) {
-        _batchSelectionRowId = void 0;
-        _previousSelectionRange = void 0;
-        return;
-      }
-      if (table.getRowVirtualizationContainer()?.contains(checkboxElement) === false) {
-        _batchSelectionRowId = void 0;
-        _previousSelectionRange = void 0;
-      }
-    };
-    table.getToggleAllLimitedRowsSelectedHandler = () => {
-      return (e) => {
-        table.toggleAllLimitedRowsSelected(
-          e.target.checked
-        );
-      };
-    };
-    table.getToggleAllLimitedPageRowsSelectedHandler = () => {
-      return (e) => {
-        table.toggleAllLimitedPageRowsSelected(
-          e.target.checked
-        );
-      };
-    };
-    table.getSelectionCount = () => table.getFilteredSelectedRowModel().flatRows.length;
-    table.toggleAllPageRowsSelected = (value) => {
-      table.setRowSelection((old) => {
-        const resolvedValue = value ?? !table.getIsAllPageRowsSelected();
-        const rowSelection = { ...old };
-        table.getRowModel().flatRows.forEach((row) => {
-          mutateRowIsSelected(
-            rowSelection,
-            row.id,
-            resolvedValue,
-            false,
-            // we don't need to include children as they are already included in `flatRows`
-            table
-          );
-        });
-        return rowSelection;
-      });
-    };
-    table.toggleAllRowsSelected = (value) => {
-      table.setRowSelection((old) => {
-        const resolvedValue = value ?? !table.getIsAllRowsSelected();
-        const rowSelection = { ...old };
-        table.getPrePaginationRowModel().flatRows.forEach((row) => {
-          mutateRowIsSelected(
-            rowSelection,
-            row.id,
-            resolvedValue,
-            false,
-            // we don't need to include children as they are already included in `flatRows`
-            table
-          );
-        });
-        return rowSelection;
-      });
-    };
-    table.toggleAllLimitedPageRowsSelected = (value) => {
-      const resolvedValue = value ?? !table.getIsAllPageRowsSelected();
-      if (resolvedValue === false) {
-        table.toggleAllPageRowsSelected(false);
-        return;
-      }
-      table.setRowSelection((old) => {
-        const rowSelection = { ...old };
-        const limit = table.options.rowSelectionLimit ?? 0;
-        const currentSelectionLength = table.getSelectionCount();
-        if (currentSelectionLength < limit) {
-          const rows = table.getRowModel().rows;
-          let currentSelectionCount = currentSelectionLength;
-          for (const row of rows) {
-            if (!row.getCanSelect() || row.getIsSelected()) {
-              continue;
-            }
-            rowSelection[row.id] = true;
-            currentSelectionCount += 1;
-            if (currentSelectionCount >= limit) {
-              break;
-            }
-          }
+    });
+    return rowSelection;
+  });
+}
+function table_toggleAllRowsSelected(table, value) {
+  table_setRowSelection(table, (old) => {
+    const resolvedValue = value ?? !table_getIsAllRowsSelected(table);
+    const rowSelection = { ...old };
+    table.getPrePaginatedRowModel().flatRows.forEach((row) => {
+      mutateRowIsSelected(
+        rowSelection,
+        row.id,
+        resolvedValue,
+        false,
+        // we don't need to include children as they are already included in `flatRows`
+        table
+      );
+    });
+    return rowSelection;
+  });
+}
+function table_toggleAllLimitedPageRowsSelected(table, value) {
+  const resolvedValue = value ?? !table_getIsAllPageRowsSelected(table);
+  if (resolvedValue === false) {
+    table_toggleAllPageRowsSelected(table, false);
+    return;
+  }
+  table_setRowSelection(table, (old) => {
+    const rowSelection = { ...old };
+    const limit = table.options.rowSelectionLimit ?? 0;
+    const currentSelectionLength = table_getSelectionCount(table);
+    if (currentSelectionLength < limit) {
+      const rows = table.getRowModel().rows;
+      let currentSelectionCount = currentSelectionLength;
+      for (const row of rows) {
+        if (!row_getCanSelect(row) || row_getIsSelected(row)) {
+          continue;
         }
-        return rowSelection;
-      });
-    };
-    table.toggleAllLimitedRowsSelected = (value) => {
-      const resolvedValue = value ?? !table.getIsAllPageRowsSelected();
-      if (resolvedValue === false) {
-        table.toggleAllRowsSelected(false);
-        return;
-      }
-      table.setRowSelection((old) => {
-        const rowSelection = { ...old };
-        const limit = table.options.rowSelectionLimit ?? 0;
-        const currentSelectionLength = table.getSelectionCount();
-        if (currentSelectionLength < limit) {
-          const rows = table.getPrePaginationRowModel().flatRows;
-          let currentSelectionCount = currentSelectionLength;
-          for (const row of rows) {
-            if (!row.getCanSelect() || row.getIsSelected()) {
-              continue;
-            }
-            rowSelection[row.id] = true;
-            currentSelectionCount += 1;
-            if (currentSelectionCount >= limit) {
-              break;
-            }
-          }
+        rowSelection[row.id] = true;
+        currentSelectionCount += 1;
+        if (currentSelectionCount >= limit) {
+          break;
         }
-        return rowSelection;
-      });
-    };
-    table.getIsRowSelectionLimitReached = (rowSelectionState) => {
-      const rowSelection = rowSelectionState || table.getState().rowSelection;
-      const rowSelectionLimit = table.options.rowSelectionLimit;
-      const selectionCount = Object.keys(rowSelection).length;
-      return rowSelectionLimit !== void 0 && rowSelectionLimit !== 0 && selectionCount >= rowSelectionLimit;
-    };
-    table.getIsAllPageRowsSelected = () => {
-      if (table.getIsRowSelectionLimitReached()) {
-        return true;
       }
-      return table.getPaginationRowModel().flatRows.filter((row) => row.subRows.length === 0).every((row) => row.getIsSelected() || !row.getCanSelect());
-    };
-    table.getIsAllRowsSelected = () => {
-      if (table.getIsRowSelectionLimitReached()) {
-        return true;
-      }
-      return table.getPrePaginationRowModel().flatRows.filter((row) => row.subRows.length === 0).every((row) => row.getIsSelected() || !row.getCanSelect());
-    };
-    table.getIsSomePageRowsSelected = () => {
-      return table.getPaginationRowModel().flatRows.filter((row) => row.subRows.length === 0).some((row) => row.getIsSelected());
-    };
-    table.getIsSomeRowsSelected = () => {
-      return table.getPrePaginationRowModel().flatRows.filter((row) => row.subRows.length === 0).some((row) => row.getIsSelected());
-    };
-    table.getIsAllPageRowsSelectionDisabled = () => {
-      return table.getPaginationRowModel().flatRows.every((row) => row.getShouldDisableRowSelection());
-    };
-    table.getIsAllRowsSelectionDisabled = () => {
-      return table.getPrePaginationRowModel().flatRows.every((row) => row.getShouldDisableRowSelection());
-    };
-    assignRowMethods(table, {
-      getShouldDisableRowSelection() {
-        const { enableRowSelection } = table.options;
-        const isRowSelectionEnabled = typeof enableRowSelection === "function" ? enableRowSelection(this) : enableRowSelection ?? true;
-        const hasSelectionLimit = table.options.rowSelectionLimit !== void 0;
-        if (hasSelectionLimit && this.getIsSelected()) {
-          return false;
-        }
-        return !isRowSelectionEnabled || table.getIsRowSelectionLimitReached();
-      },
-      getCanSelect() {
-        const isParentRow = !!this.subRows?.length;
-        if (isParentRow) {
-          return false;
-        }
-        const { enableRowSelection } = table.options;
-        return typeof enableRowSelection === "function" ? enableRowSelection(this) : enableRowSelection ?? true;
-      },
-      toggleSelected(value) {
-        if (this.getShouldDisableRowSelection()) {
-          return;
-        }
-        const isSelected = this.getIsSelected();
-        table.setRowSelection((old) => {
-          value = value ?? !isSelected;
-          const selectedRowIds = { ...old };
-          if (this.getCanSelect() && isSelected === value) {
-            return old;
-          }
-          mutateRowIsSelected(selectedRowIds, this.id, value, true, table);
-          return selectedRowIds;
-        });
-      },
-      // Override TanStack's implementation to include selected, but disabled rows
-      getIsSomeSelected() {
-        const subRows = this.subRows;
-        if (!subRows.length) {
-          return this.getIsSelected();
-        }
-        return subRows.some(
-          (subRow) => subRow.getIsSelected() || subRow.getIsSomeSelected()
-        );
-      },
-      // Override TanStack's implementation to include selected, but disabled rows
-      getIsAllSubRowsSelected() {
-        const subRows = this.subRows;
-        if (!subRows.length) {
-          return this.getIsSelected();
-        }
-        for (const subRow of subRows) {
-          if (!subRow.getIsAllSubRowsSelected()) {
-            return false;
-          }
+    }
+    return rowSelection;
+  });
+}
+function table_toggleAllLimitedRowsSelected(table, value) {
+  const resolvedValue = value ?? !table_getIsAllPageRowsSelected(table);
+  if (resolvedValue === false) {
+    table_toggleAllRowsSelected(table, false);
+    return;
+  }
+  table_setRowSelection(table, (old) => {
+    const rowSelection = { ...old };
+    const limit = table.options.rowSelectionLimit ?? 0;
+    const currentSelectionLength = table_getSelectionCount(table);
+    if (currentSelectionLength < limit) {
+      const rows = table.getPrePaginatedRowModel().flatRows;
+      let currentSelectionCount = currentSelectionLength;
+      for (const row of rows) {
+        if (!row_getCanSelect(row) || row_getIsSelected(row)) {
+          continue;
         }
-        return true;
-      },
-      /**
-       * Handles row selection/deselection with support for batch selection using Shift+click. If Shift is not pressed,
-       * or no previous selection exists, the row is simply selected/deselected and becomes the reference for a possible batch selection.
-       * If a batch selection reference exists, and the user selects a row while holding Shift, all rows in between are selected/deselected.
-       * If the user then selects another row with the Shift pressed, the previous batch selection is removed, and only the new one is selected.
-       * The batch selection reference is reset, once the user clicks anywhere in the table outside the checkboxes.
-       */
-      batchSelect(value, shiftKey) {
-        const selectSingleRow = () => {
-          this.toggleSelected(value);
-          _batchSelectionRowId = this.id;
-          _previousSelectionRange = void 0;
-        };
-        if (_batchSelectionRowId === void 0 || !shiftKey) {
-          selectSingleRow();
-          return;
+        rowSelection[row.id] = true;
+        currentSelectionCount += 1;
+        if (currentSelectionCount >= limit) {
+          break;
         }
-        const flatRows = table.getRowOrderRowModel().flatRows;
-        const firstSelectedIndex = flatRows.findIndex(
-          (flatRow) => _batchSelectionRowId && flatRow.id === _batchSelectionRowId
-        );
-        const currentSelectedIndex = flatRows.findIndex(
-          (flatRow) => flatRow.id === this.id
-        );
-        if (firstSelectedIndex === -1) {
-          selectSingleRow();
-          return;
-        }
-        const startIndex = Math.min(firstSelectedIndex, currentSelectedIndex);
-        const endIndex = Math.max(firstSelectedIndex, currentSelectedIndex);
-        const shouldUpdateChildren = (idx) => endIndex === idx;
-        table.setRowSelection((old) => {
-          const rowSelection = { ...old };
-          const firstSelectedCheckedValue = flatRows[firstSelectedIndex].getIsSelected();
-          if (_previousSelectionRange) {
-            const start = _previousSelectionRange.start;
-            const end = Math.min(
-              _previousSelectionRange.end,
-              flatRows.length - 1
-            );
-            for (let i = start; i <= end; i++) {
-              mutateRowIsSelected(
-                rowSelection,
-                flatRows[i].id,
-                false,
-                true,
-                table
-              );
-            }
-          }
-          for (let i = startIndex; i <= endIndex; i++) {
-            mutateRowIsSelected(
-              rowSelection,
-              flatRows[i].id,
-              firstSelectedCheckedValue,
-              shouldUpdateChildren(i),
-              table
-            );
-          }
-          _previousSelectionRange = firstSelectedCheckedValue ? { start: startIndex, end: endIndex } : void 0;
-          return rowSelection;
-        });
       }
-    });
+    }
+    return rowSelection;
+  });
+}
+function table_getIsRowSelectionLimitReached(table, rowSelectionState) {
+  const rowSelection = rowSelectionState || table.atoms.rowSelection?.get();
+  const rowSelectionLimit = table.options.rowSelectionLimit;
+  const selectionCount = Object.keys(rowSelection ?? {}).length;
+  return rowSelectionLimit !== void 0 && rowSelectionLimit !== 0 && selectionCount >= rowSelectionLimit;
+}
+function table_getIsAllPageRowsSelected(table) {
+  if (table_getIsRowSelectionLimitReached(table)) {
+    return true;
   }
-};
-function useRowSelection(props, options) {
-  const configSelectableRows = useDataTableConfigElement("selectableRows");
-  const selectableRows = props.selectableRows ?? configSelectableRows;
-  const enableRowSelectionCallback = useCallback(
-    (row) => {
-      if (selectableRows !== void 0 && typeof selectableRows !== "boolean" && selectableRows.disableRowSelection) {
-        return !selectableRows.disableRowSelection(row.original);
-      }
-      return true;
-    },
-    [selectableRows]
+  return table.getPaginatedRowModel().flatRows.filter((row) => row.subRows.length === 0).every((row) => row_getIsSelected(row) || !row_getCanSelect(row));
+}
+function table_getIsAllRowsSelected(table) {
+  if (table_getIsRowSelectionLimitReached(table)) {
+    return true;
+  }
+  return table.getPrePaginatedRowModel().flatRows.filter((row) => row.subRows.length === 0).every((row) => row_getIsSelected(row) || !row_getCanSelect(row));
+}
+function table_getIsSomePageRowsSelected(table) {
+  return table.getPaginatedRowModel().flatRows.filter((row) => row.subRows.length === 0).some((row) => row_getIsSelected(row));
+}
+function table_getIsSomeRowsSelected(table) {
+  return table.getPrePaginatedRowModel().flatRows.filter((row) => row.subRows.length === 0).some((row) => row_getIsSelected(row));
+}
+function table_getIsAllPageRowsSelectionDisabled(table) {
+  return table.getPaginatedRowModel().flatRows.every((row) => row.getShouldDisableRowSelection());
+}
+function table_getIsAllRowsSelectionDisabled(table) {
+  return table.getPrePaginatedRowModel().flatRows.every((row) => row.getShouldDisableRowSelection());
+}
+function row_getShouldDisableRowSelection(row) {
+  const { enableRowSelection } = row.table.options;
+  const isRowSelectionEnabled = typeof enableRowSelection === "function" ? enableRowSelection(row) : enableRowSelection ?? true;
+  const hasSelectionLimit = row.table.options.rowSelectionLimit !== void 0;
+  if (hasSelectionLimit && row_getIsSelected(row)) {
+    return false;
+  }
+  return !isRowSelectionEnabled || table_getIsRowSelectionLimitReached(row.table);
+}
+function row_getCanSelect(row) {
+  const isParentRow = !!row.subRows?.length;
+  if (isParentRow) {
+    return false;
+  }
+  const { enableRowSelection } = row.table.options;
+  return typeof enableRowSelection === "function" ? enableRowSelection(row) : enableRowSelection ?? true;
+}
+function row_toggleSelected(row, value) {
+  if (row_getShouldDisableRowSelection(row)) {
+    return;
+  }
+  const isSelected = row_getIsSelected(row);
+  table_setRowSelection(row.table, (old) => {
+    value = value ?? !isSelected;
+    const selectedRowIds = { ...old };
+    if (row_getCanSelect(row) && isSelected === value) {
+      return old;
+    }
+    mutateRowIsSelected(selectedRowIds, row.id, value, true, row.table);
+    return selectedRowIds;
+  });
+}
+function row_getIsSomeSelected(row) {
+  const subRows = row.subRows;
+  if (!subRows.length) {
+    return row_getIsSelected(row);
+  }
+  return subRows.some(
+    (subRow) => row_getIsSelected(subRow) || row_getIsSomeSelected(subRow)
   );
-  if (selectableRows !== void 0) {
-    options.enableRowSelection = true;
-    let rowSelectionMode = "page";
-    if (selectableRows === true || selectableRows === false) {
-      options.enableRowSelection = selectableRows;
-    } else {
-      const { selectAllBehavior, limit } = selectableRows;
-      options.enableRowSelection = enableRowSelectionCallback;
-      if (selectAllBehavior) {
-        rowSelectionMode = selectAllBehavior;
-      }
-      options.rowSelectionLimit = limit !== void 0 && limit >= 0 ? limit : void 0;
+}
+function row_getIsAllSubRowsSelected(row) {
+  const subRows = row.subRows;
+  if (!subRows.length) {
+    return row_getIsSelected(row);
+  }
+  for (const subRow of subRows) {
+    if (!row_getIsAllSubRowsSelected(subRow)) {
+      return false;
     }
-    options.enableMultiRowSelection = true;
-    options.rowSelectionSelectAllMode = rowSelectionMode;
-  } else {
-    options.enableRowSelection = false;
   }
-  const [selectedRows, setSelectedRows] = useControllableState({
-    value: props.selectedRows,
-    defaultValue: props.defaultSelectedRows,
-    onChange: props.onRowSelectionChange
+  return true;
+}
+function row_batchSelect(row, value, shiftKey) {
+  const selectSingleRow = () => {
+    row_toggleSelected(row, value);
+    row.table._batchSelectionRowId = row.id;
+    row.table._previousSelectionRange = void 0;
+  };
+  if (row.table._batchSelectionRowId === void 0 || !shiftKey) {
+    selectSingleRow();
+    return;
+  }
+  const flatRows = row.table.getRowOrderRowModel().flatRows;
+  const firstSelectedIndex = flatRows.findIndex(
+    (flatRow) => row.table._batchSelectionRowId && flatRow.id === row.table._batchSelectionRowId
+  );
+  const currentSelectedIndex = flatRows.findIndex(
+    (flatRow) => flatRow.id === row.id
+  );
+  if (firstSelectedIndex === -1) {
+    selectSingleRow();
+    return;
+  }
+  const startIndex = Math.min(firstSelectedIndex, currentSelectedIndex);
+  const endIndex = Math.max(firstSelectedIndex, currentSelectedIndex);
+  const shouldUpdateChildren = (idx) => endIndex === idx;
+  table_setRowSelection(row.table, (old) => {
+    const rowSelection = { ...old };
+    const firstSelectedCheckedValue = row_getIsSelected(
+      flatRows[firstSelectedIndex]
+    );
+    if (row.table._previousSelectionRange) {
+      const start = row.table._previousSelectionRange.start;
+      const end = Math.min(
+        row.table._previousSelectionRange.end,
+        flatRows.length - 1
+      );
+      for (let i = start; i <= end; i++) {
+        mutateRowIsSelected(
+          rowSelection,
+          flatRows[i].id,
+          false,
+          true,
+          row.table
+        );
+      }
+    }
+    for (let i = startIndex; i <= endIndex; i++) {
+      mutateRowIsSelected(
+        rowSelection,
+        flatRows[i].id,
+        firstSelectedCheckedValue,
+        shouldUpdateChildren(i),
+        row.table
+      );
+    }
+    row.table._previousSelectionRange = firstSelectedCheckedValue ? { start: startIndex, end: endIndex } : void 0;
+    return rowSelection;
   });
-  options.state = {
-    ...options.state,
-    rowSelection: selectedRows ?? {}
+}
+function constructRowSelectionFeature() {
+  return {
+    assignRowPrototype: (prototype, table) => {
+      assignPrototypeAPIs("rowSelectionFeature", prototype, table, {
+        row_getShouldDisableRowSelection: {
+          fn: (row) => row_getShouldDisableRowSelection(row)
+        },
+        row_getCanSelect: {
+          fn: (row) => row_getCanSelect(row)
+        },
+        row_toggleSelected: {
+          fn: (row, value) => row_toggleSelected(row, value)
+        },
+        row_getIsSomeSelected: {
+          fn: (row) => row_getIsSomeSelected(row)
+        },
+        row_getIsAllSubRowsSelected: {
+          fn: (row) => row_getIsAllSubRowsSelected(row)
+        },
+        row_batchSelect: {
+          fn: (row, value, shiftKey) => row_batchSelect(row, value, shiftKey)
+        }
+      });
+    },
+    constructTableAPIs: (table) => {
+      assignTableAPIs("rowSelectionFeature", table, {
+        table_resetBatchSelection: {
+          fn: () => table_resetBatchSelection(table)
+        },
+        table_getToggleAllLimitedRowsSelectedHandler: {
+          fn: () => table_getToggleAllLimitedRowsSelectedHandler(table)
+        },
+        table_getToggleAllLimitedPageRowsSelectedHandler: {
+          fn: () => table_getToggleAllLimitedPageRowsSelectedHandler(table)
+        },
+        table_getSelectionCount: { fn: () => table_getSelectionCount(table) },
+        table_toggleAllPageRowsSelected: {
+          fn: (value) => table_toggleAllPageRowsSelected(table, value)
+        },
+        table_toggleAllRowsSelected: {
+          fn: (value) => table_toggleAllRowsSelected(table, value)
+        },
+        table_toggleAllLimitedPageRowsSelected: {
+          fn: (value) => table_toggleAllLimitedPageRowsSelected(table, value)
+        },
+        table_toggleAllLimitedRowsSelected: {
+          fn: (value) => table_toggleAllLimitedRowsSelected(table, value)
+        },
+        table_getIsRowSelectionLimitReached: {
+          fn: () => table_getIsRowSelectionLimitReached(table)
+        },
+        table_getIsAllPageRowsSelected: {
+          fn: () => table_getIsAllPageRowsSelected(table)
+        },
+        table_getIsAllRowsSelected: {
+          fn: () => table_getIsAllRowsSelected(table)
+        },
+        table_getIsSomePageRowsSelected: {
+          fn: () => table_getIsSomePageRowsSelected(table)
+        },
+        table_getIsSomeRowsSelected: {
+          fn: () => table_getIsSomeRowsSelected(table)
+        },
+        table_getIsAllPageRowsSelectionDisabled: {
+          fn: () => table_getIsAllPageRowsSelectionDisabled(table)
+        },
+        table_getIsAllRowsSelectionDisabled: {
+          fn: () => table_getIsAllRowsSelectionDisabled(table)
+        }
+      });
+    }
   };
-  options.onRowSelectionChange = setSelectedRows;
 }
+const DataTableRowSelectionFeature = constructRowSelectionFeature();
 export {
-  DataTableRowSelection,
-  ROW_SELECTION_COLUMN,
+  DataTableRowSelectionFeature,
+  constructRowSelectionFeature,
   isRowSelectionColumnDef,
-  useRowSelection
+  row_batchSelect,
+  row_getCanSelect,
+  row_getIsAllSubRowsSelected,
+  row_getIsSomeSelected,
+  row_getShouldDisableRowSelection,
+  row_toggleSelected,
+  table_getIsAllPageRowsSelected,
+  table_getIsAllPageRowsSelectionDisabled,
+  table_getIsAllRowsSelected,
+  table_getIsAllRowsSelectionDisabled,
+  table_getIsRowSelectionLimitReached,
+  table_getIsSomePageRowsSelected,
+  table_getIsSomeRowsSelected,
+  table_getSelectionCount,
+  table_getToggleAllLimitedPageRowsSelectedHandler,
+  table_getToggleAllLimitedRowsSelectedHandler,
+  table_resetBatchSelection,
+  table_toggleAllLimitedPageRowsSelected,
+  table_toggleAllLimitedRowsSelected,
+  table_toggleAllPageRowsSelected,
+  table_toggleAllRowsSelected
 };
 //# sourceMappingURL=RowSelection.js.map