@redis-ui/table 2.12.0 → 2.22.0

package/dist/Table/plugins/ExpandableRowPlugin.cjs

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const plugin_utils = require("../utils/plugin.utils.cjs");
+const ClickableRowPlugin = require("./ClickableRowPlugin.cjs");
+const Table_context = require("../Table.context.cjs");
+const index = require("../../node_modules/@tanstack/table-core/build/lib/index.cjs");
+const getTrue = () => true;
+const TableExpandableRowContextKey = "expandableRow";
+const useExpandableRowPlugin = ({
+  defaultExpanded,
+  getRowCanExpand,
+  renderExpandedRow,
+  expandRowOnClick,
+  expandedRowComponent,
+  getSubRows
+}) => {
+  const clickablePluginData = ClickableRowPlugin.useClickableRowPlugin({
+    getCanRowClick: (row) => !!(expandRowOnClick && row.getCanExpand()),
+    onRowClick: (row) => row.toggleExpanded(),
+    shouldClickOnEnter: true
+  });
+  if (!renderExpandedRow && !getSubRows) return void 0;
+  return {
+    tableOptions: {
+      getExpandedRowModel: index.getExpandedRowModel(),
+      getRowCanExpand: getRowCanExpand || (getSubRows ? void 0 : getTrue),
+      getSubRows,
+      initialState: defaultExpanded ? {
+        expanded: defaultExpanded
+      } : void 0
+    },
+    context: {
+      ...plugin_utils.buildPluginContext(TableExpandableRowContextKey, {
+        renderExpandedRow,
+        expandedRowComponent
+      }),
+      ...expandRowOnClick ? clickablePluginData == null ? void 0 : clickablePluginData.context : null
+    }
+  };
+};
+const useExpandableRowContext = () => Table_context.usePluginContext(TableExpandableRowContextKey);
+exports.TableExpandableRowContextKey = TableExpandableRowContextKey;
+exports.useExpandableRowContext = useExpandableRowContext;
+exports.useExpandableRowPlugin = useExpandableRowPlugin;

package/dist/Table/plugins/ExpandableRowPlugin.d.ts

@@ -0,0 +1,28 @@
+import { ComponentType, ReactNode } from 'react';
+import { type Row } from '@tanstack/react-table';
+import { ExpandedState } from '@tanstack/table-core/src/features/RowExpanding';
+import { TablePluginData } from '../utils/plugin.utils';
+import type { TableExpandedRowProps } from '../components/TableExpandedRow';
+export declare const TableExpandableRowContextKey = "expandableRow";
+export type TableExpandableRowContext<T extends object> = {
+    /** Renders content of expanded part */
+    renderExpandedRow?: (row: Row<T>) => ReactNode;
+    /**
+     * Overrides whole expanded part component.<br/>
+     * There are 2 predefined components `Table.ExpandedRow` (default) and `Table.AnimatedExpandedRow`
+     */
+    expandedRowComponent?: ComponentType<TableExpandedRowProps<T>>;
+};
+export interface TableExpandableRowParams<T extends object> extends TableExpandableRowContext<T> {
+    /** Allows expanding row by Click on whole row and by pressing Enter, when row is focused */
+    expandRowOnClick?: boolean;
+    /** Allows individual rows to be expandable */
+    getRowCanExpand?: (row: Row<T>) => boolean;
+    /**
+     * Enables tree-list (hierarchical) data.<br/>
+     * When this prop is set, the `renderExpandedRow` and `expandedRowComponent` parameters are not used. */
+    getSubRows?: (rowData: T, index: number) => T[] | undefined;
+    defaultExpanded?: ExpandedState;
+}
+export declare const useExpandableRowPlugin: <T extends object>({ defaultExpanded, getRowCanExpand, renderExpandedRow, expandRowOnClick, expandedRowComponent, getSubRows }: TableExpandableRowParams<T>) => TablePluginData<T>;
+export declare const useExpandableRowContext: <T extends object>() => TableExpandableRowContext<T> | undefined;

package/dist/Table/plugins/ExpandableRowPlugin.js

@@ -0,0 +1,44 @@
+import { buildPluginContext } from "../utils/plugin.utils.js";
+import { useClickableRowPlugin } from "./ClickableRowPlugin.js";
+import { usePluginContext } from "../Table.context.js";
+import { getExpandedRowModel } from "../../node_modules/@tanstack/table-core/build/lib/index.js";
+const getTrue = () => true;
+const TableExpandableRowContextKey = "expandableRow";
+const useExpandableRowPlugin = ({
+  defaultExpanded,
+  getRowCanExpand,
+  renderExpandedRow,
+  expandRowOnClick,
+  expandedRowComponent,
+  getSubRows
+}) => {
+  const clickablePluginData = useClickableRowPlugin({
+    getCanRowClick: (row) => !!(expandRowOnClick && row.getCanExpand()),
+    onRowClick: (row) => row.toggleExpanded(),
+    shouldClickOnEnter: true
+  });
+  if (!renderExpandedRow && !getSubRows) return void 0;
+  return {
+    tableOptions: {
+      getExpandedRowModel: getExpandedRowModel(),
+      getRowCanExpand: getRowCanExpand || (getSubRows ? void 0 : getTrue),
+      getSubRows,
+      initialState: defaultExpanded ? {
+        expanded: defaultExpanded
+      } : void 0
+    },
+    context: {
+      ...buildPluginContext(TableExpandableRowContextKey, {
+        renderExpandedRow,
+        expandedRowComponent
+      }),
+      ...expandRowOnClick ? clickablePluginData == null ? void 0 : clickablePluginData.context : null
+    }
+  };
+};
+const useExpandableRowContext = () => usePluginContext(TableExpandableRowContextKey);
+export {
+  TableExpandableRowContextKey,
+  useExpandableRowContext,
+  useExpandableRowPlugin
+};

package/dist/Table/plugins/PaginationPlugin.cjs

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../node_modules/@radix-ui/react-use-controllable-state/dist/index.cjs");
+const plugin_utils = require("../utils/plugin.utils.cjs");
+const Table_context = require("../Table.context.cjs");
+const index$1 = require("../../node_modules/@tanstack/table-core/build/lib/index.cjs");
+const DEFAULT_PAGINATION = {
+  pageIndex: 0,
+  pageSize: 10
+};
+const TablePaginationContextKey = "pagination";
+const usePaginationPlugin = ({
+  pagination,
+  defaultPagination,
+  onPaginationChange,
+  manualPagination,
+  totalRowCount,
+  pageSizes,
+  paginationEnabled = (pagination || defaultPagination || onPaginationChange || pageSizes) !== void 0 || manualPagination !== void 0
+}) => {
+  const [paginationState, setPaginationState] = index.useControllableState({
+    prop: pagination,
+    defaultProp: defaultPagination ?? DEFAULT_PAGINATION,
+    onChange: onPaginationChange
+  });
+  return paginationEnabled ? {
+    tableOptions: {
+      state: {
+        pagination: paginationState
+      },
+      getPaginationRowModel: index$1.getPaginationRowModel(),
+      onPaginationChange: setPaginationState,
+      manualPagination,
+      rowCount: totalRowCount,
+      autoResetPageIndex: false
+    },
+    context: plugin_utils.buildPluginContext(TablePaginationContextKey, {
+      pageSizes
+    })
+  } : void 0;
+};
+const usePaginationContext = () => Table_context.usePluginContext(TablePaginationContextKey);
+exports.TablePaginationContextKey = TablePaginationContextKey;
+exports.usePaginationContext = usePaginationContext;
+exports.usePaginationPlugin = usePaginationPlugin;

package/dist/Table/plugins/PaginationPlugin.d.ts

@@ -0,0 +1,16 @@
+import { PaginationState } from '@tanstack/react-table';
+import { TablePluginData } from '../utils/plugin.utils';
+export declare const TablePaginationContextKey = "pagination";
+export interface TablePaginationContext {
+    pageSizes?: number[];
+    paginationEnabled?: boolean;
+}
+export interface TablePaginationParams extends TablePaginationContext {
+    pagination?: PaginationState;
+    defaultPagination?: PaginationState;
+    onPaginationChange?: (state: PaginationState) => void;
+    manualPagination?: boolean;
+    totalRowCount?: number;
+}
+export declare const usePaginationPlugin: <T extends object>({ pagination, defaultPagination, onPaginationChange, manualPagination, totalRowCount, pageSizes, paginationEnabled }: TablePaginationParams) => TablePluginData<T>;
+export declare const usePaginationContext: () => TablePaginationContext | undefined;

package/dist/Table/plugins/PaginationPlugin.js

@@ -0,0 +1,45 @@
+import { useControllableState } from "../../node_modules/@radix-ui/react-use-controllable-state/dist/index.js";
+import { buildPluginContext } from "../utils/plugin.utils.js";
+import { usePluginContext } from "../Table.context.js";
+import { getPaginationRowModel } from "../../node_modules/@tanstack/table-core/build/lib/index.js";
+const DEFAULT_PAGINATION = {
+  pageIndex: 0,
+  pageSize: 10
+};
+const TablePaginationContextKey = "pagination";
+const usePaginationPlugin = ({
+  pagination,
+  defaultPagination,
+  onPaginationChange,
+  manualPagination,
+  totalRowCount,
+  pageSizes,
+  paginationEnabled = (pagination || defaultPagination || onPaginationChange || pageSizes) !== void 0 || manualPagination !== void 0
+}) => {
+  const [paginationState, setPaginationState] = useControllableState({
+    prop: pagination,
+    defaultProp: defaultPagination ?? DEFAULT_PAGINATION,
+    onChange: onPaginationChange
+  });
+  return paginationEnabled ? {
+    tableOptions: {
+      state: {
+        pagination: paginationState
+      },
+      getPaginationRowModel: getPaginationRowModel(),
+      onPaginationChange: setPaginationState,
+      manualPagination,
+      rowCount: totalRowCount,
+      autoResetPageIndex: false
+    },
+    context: buildPluginContext(TablePaginationContextKey, {
+      pageSizes
+    })
+  } : void 0;
+};
+const usePaginationContext = () => usePluginContext(TablePaginationContextKey);
+export {
+  TablePaginationContextKey,
+  usePaginationContext,
+  usePaginationPlugin
+};

package/dist/Table/plugins/RowNavigationPlugin.cjs

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+const redisUiComponents = require("@redislabsdev/redis-ui-components");
+const index = require("../../node_modules/@radix-ui/react-compose-refs/dist/index.cjs");
+const plugin_utils = require("../utils/plugin.utils.cjs");
+const Table_context = require("../Table.context.cjs");
+const TableRowNavigationContextKey = "RowNavigation";
+const useRowNavigationPlugin = ({
+  enableRowNavigation = true
+}) => {
+  const [activeRowId, setActiveRowId] = React.useState();
+  const rowRefs = React.useRef(/* @__PURE__ */ new Map());
+  const unregisterRow = React.useCallback((rowId) => {
+    rowRefs.current.delete(rowId);
+  }, []);
+  const registerRow = React.useCallback((rowId, rowEl) => {
+    if (rowEl) rowRefs.current.set(rowId, rowEl);
+    else unregisterRow(rowId);
+  }, [unregisterRow]);
+  const goToRowId = (rowId, noScroll) => {
+    var _a;
+    return rowId && ((_a = rowRefs.current.get(rowId)) == null ? void 0 : _a.focus({
+      preventScroll: noScroll
+    }));
+  };
+  const getGoToRow = (getTargetRow) => (table) => {
+    const {
+      rows
+    } = table.getRowModel();
+    if (!rows.length) return false;
+    const targetRow = getTargetRow(rows);
+    if (!targetRow) return false;
+    setActiveRowId(targetRow.id);
+    goToRowId(targetRow.id);
+    return true;
+  };
+  const findActiveIndex = (rows) => rows.findIndex((row) => row.id === activeRowId);
+  const goToNextRow = getGoToRow((rows) => activeRowId && rows[findActiveIndex(rows) + 1] || rows.at(0));
+  const goToPrevRow = getGoToRow((rows) => activeRowId && rows[findActiveIndex(rows) - 1] || rows.at(-1));
+  const goToFirstRow = getGoToRow((rows) => rows.at(0));
+  const goToLastRow = getGoToRow((rows) => rows.at(-1));
+  return enableRowNavigation ? {
+    tableOptions: {},
+    context: plugin_utils.buildPluginContext(TableRowNavigationContextKey, {
+      registerRow,
+      unregisterRow,
+      activeRowId,
+      setActiveRowId,
+      goToNextRow,
+      goToPrevRow,
+      goToFirstRow,
+      goToLastRow,
+      goToRowId
+    })
+  } : void 0;
+};
+const useRowNavigationContext = () => Table_context.usePluginContext(TableRowNavigationContextKey);
+const useHandleRowNavigationOnRow = ({
+  row,
+  onFocus,
+  ref
+}) => {
+  const {
+    registerRow,
+    setActiveRowId,
+    activeRowId
+  } = useRowNavigationContext() || {};
+  const innerRowRef = registerRow && ((rowEl) => registerRow(row.id, rowEl));
+  const composedRowRef = index.useComposedRefs(ref, innerRowRef);
+  const handleFocus = redisUiComponents.combineHandlers(setActiveRowId && (() => setActiveRowId(row.id)), onFocus);
+  return {
+    ref: composedRowRef,
+    onFocus: handleFocus,
+    ...setActiveRowId && {
+      tabIndex: activeRowId === row.id ? 0 : -1
+    }
+  };
+};
+const useHandleRowNavigationOnTable = ({
+  onKeyDown,
+  onFocus
+}) => {
+  const {
+    table
+  } = Table_context.useTableContext();
+  const nav = useRowNavigationContext();
+  if (!nav) {
+    return {
+      ...onKeyDown && {
+        onKeyDown
+      },
+      ...onFocus && {
+        onFocus
+      }
+    };
+  }
+  const {
+    goToNextRow,
+    goToPrevRow,
+    goToFirstRow,
+    goToLastRow,
+    goToRowId,
+    activeRowId
+  } = nav;
+  const handleKeyDown = redisUiComponents.combineHandlers((e) => {
+    if (e.key === "ArrowDown") {
+      e.preventDefault();
+      goToNextRow(table);
+    }
+    if (e.key === "ArrowUp") {
+      e.preventDefault();
+      goToPrevRow(table);
+    }
+    if (e.key === "Home") {
+      e.preventDefault();
+      goToFirstRow(table);
+    }
+    if (e.key === "End") {
+      e.preventDefault();
+      goToLastRow(table);
+    }
+  }, onKeyDown);
+  const handleFocus = redisUiComponents.combineHandlers((e) => {
+    if (e.target === e.currentTarget) {
+      goToRowId(activeRowId, !e.target.matches(":focus-visible"));
+    }
+  }, onFocus);
+  return {
+    onKeyDown: handleKeyDown,
+    onFocus: handleFocus,
+    tabIndex: 0
+  };
+};
+exports.TableRowNavigationContextKey = TableRowNavigationContextKey;
+exports.useHandleRowNavigationOnRow = useHandleRowNavigationOnRow;
+exports.useHandleRowNavigationOnTable = useHandleRowNavigationOnTable;
+exports.useRowNavigationContext = useRowNavigationContext;
+exports.useRowNavigationPlugin = useRowNavigationPlugin;

package/dist/Table/plugins/RowNavigationPlugin.d.ts

@@ -0,0 +1,44 @@
+import { FocusEventHandler, KeyboardEventHandler, Ref } from 'react';
+import { Row, Table } from '@tanstack/react-table';
+import { TablePluginData } from '../utils/plugin.utils';
+export declare const TableRowNavigationContextKey = "RowNavigation";
+export type TableRowNavigationContext = {
+    registerRow: (rowId: string, rowEl: HTMLTableRowElement | null) => void;
+    unregisterRow: (rowId: string) => void;
+    activeRowId: string | undefined;
+    setActiveRowId: (rowId: string) => void;
+    goToNextRow: (table: Table<object>) => void;
+    goToPrevRow: (table: Table<object>) => void;
+    goToFirstRow: (table: Table<object>) => void;
+    goToLastRow: (table: Table<object>) => void;
+    goToRowId: (rowId: string | undefined, noScroll?: boolean) => void;
+};
+export type TableRowNavigationParams = {
+    enableRowNavigation?: boolean;
+};
+export declare const useRowNavigationPlugin: <T extends object>({ enableRowNavigation }: TableRowNavigationParams) => TablePluginData<T>;
+export declare const useRowNavigationContext: () => TableRowNavigationContext | undefined;
+type UseHandleRowNavigationOnRowParams<T extends object> = {
+    row: Row<T>;
+    onFocus?: FocusEventHandler<HTMLTableRowElement>;
+    ref?: Ref<HTMLTableRowElement>;
+};
+export declare const useHandleRowNavigationOnRow: <T extends object>({ row, onFocus, ref }: UseHandleRowNavigationOnRowParams<T>) => {
+    tabIndex?: number | undefined;
+    ref: (node: HTMLTableRowElement) => void;
+    onFocus: FocusEventHandler<HTMLTableRowElement> | undefined;
+};
+type UseHandleRowNavigationOnTableParams = {
+    onKeyDown?: KeyboardEventHandler<HTMLTableElement>;
+    onFocus?: FocusEventHandler<HTMLTableElement>;
+};
+export declare const useHandleRowNavigationOnTable: ({ onKeyDown, onFocus }: UseHandleRowNavigationOnTableParams) => {
+    onFocus?: FocusEventHandler<HTMLTableElement> | undefined;
+    onKeyDown?: KeyboardEventHandler<HTMLTableElement> | undefined;
+    tabIndex?: undefined;
+} | {
+    onKeyDown: KeyboardEventHandler<HTMLTableElement> | undefined;
+    onFocus: FocusEventHandler<HTMLTableElement> | undefined;
+    tabIndex: number;
+};
+export {};

package/dist/Table/plugins/RowNavigationPlugin.js

@@ -0,0 +1,139 @@
+import { useState, useRef, useCallback } from "react";
+import { combineHandlers } from "@redislabsdev/redis-ui-components";
+import { useComposedRefs } from "../../node_modules/@radix-ui/react-compose-refs/dist/index.js";
+import { buildPluginContext } from "../utils/plugin.utils.js";
+import { usePluginContext, useTableContext } from "../Table.context.js";
+const TableRowNavigationContextKey = "RowNavigation";
+const useRowNavigationPlugin = ({
+  enableRowNavigation = true
+}) => {
+  const [activeRowId, setActiveRowId] = useState();
+  const rowRefs = useRef(/* @__PURE__ */ new Map());
+  const unregisterRow = useCallback((rowId) => {
+    rowRefs.current.delete(rowId);
+  }, []);
+  const registerRow = useCallback((rowId, rowEl) => {
+    if (rowEl) rowRefs.current.set(rowId, rowEl);
+    else unregisterRow(rowId);
+  }, [unregisterRow]);
+  const goToRowId = (rowId, noScroll) => {
+    var _a;
+    return rowId && ((_a = rowRefs.current.get(rowId)) == null ? void 0 : _a.focus({
+      preventScroll: noScroll
+    }));
+  };
+  const getGoToRow = (getTargetRow) => (table) => {
+    const {
+      rows
+    } = table.getRowModel();
+    if (!rows.length) return false;
+    const targetRow = getTargetRow(rows);
+    if (!targetRow) return false;
+    setActiveRowId(targetRow.id);
+    goToRowId(targetRow.id);
+    return true;
+  };
+  const findActiveIndex = (rows) => rows.findIndex((row) => row.id === activeRowId);
+  const goToNextRow = getGoToRow((rows) => activeRowId && rows[findActiveIndex(rows) + 1] || rows.at(0));
+  const goToPrevRow = getGoToRow((rows) => activeRowId && rows[findActiveIndex(rows) - 1] || rows.at(-1));
+  const goToFirstRow = getGoToRow((rows) => rows.at(0));
+  const goToLastRow = getGoToRow((rows) => rows.at(-1));
+  return enableRowNavigation ? {
+    tableOptions: {},
+    context: buildPluginContext(TableRowNavigationContextKey, {
+      registerRow,
+      unregisterRow,
+      activeRowId,
+      setActiveRowId,
+      goToNextRow,
+      goToPrevRow,
+      goToFirstRow,
+      goToLastRow,
+      goToRowId
+    })
+  } : void 0;
+};
+const useRowNavigationContext = () => usePluginContext(TableRowNavigationContextKey);
+const useHandleRowNavigationOnRow = ({
+  row,
+  onFocus,
+  ref
+}) => {
+  const {
+    registerRow,
+    setActiveRowId,
+    activeRowId
+  } = useRowNavigationContext() || {};
+  const innerRowRef = registerRow && ((rowEl) => registerRow(row.id, rowEl));
+  const composedRowRef = useComposedRefs(ref, innerRowRef);
+  const handleFocus = combineHandlers(setActiveRowId && (() => setActiveRowId(row.id)), onFocus);
+  return {
+    ref: composedRowRef,
+    onFocus: handleFocus,
+    ...setActiveRowId && {
+      tabIndex: activeRowId === row.id ? 0 : -1
+    }
+  };
+};
+const useHandleRowNavigationOnTable = ({
+  onKeyDown,
+  onFocus
+}) => {
+  const {
+    table
+  } = useTableContext();
+  const nav = useRowNavigationContext();
+  if (!nav) {
+    return {
+      ...onKeyDown && {
+        onKeyDown
+      },
+      ...onFocus && {
+        onFocus
+      }
+    };
+  }
+  const {
+    goToNextRow,
+    goToPrevRow,
+    goToFirstRow,
+    goToLastRow,
+    goToRowId,
+    activeRowId
+  } = nav;
+  const handleKeyDown = combineHandlers((e) => {
+    if (e.key === "ArrowDown") {
+      e.preventDefault();
+      goToNextRow(table);
+    }
+    if (e.key === "ArrowUp") {
+      e.preventDefault();
+      goToPrevRow(table);
+    }
+    if (e.key === "Home") {
+      e.preventDefault();
+      goToFirstRow(table);
+    }
+    if (e.key === "End") {
+      e.preventDefault();
+      goToLastRow(table);
+    }
+  }, onKeyDown);
+  const handleFocus = combineHandlers((e) => {
+    if (e.target === e.currentTarget) {
+      goToRowId(activeRowId, !e.target.matches(":focus-visible"));
+    }
+  }, onFocus);
+  return {
+    onKeyDown: handleKeyDown,
+    onFocus: handleFocus,
+    tabIndex: 0
+  };
+};
+export {
+  TableRowNavigationContextKey,
+  useHandleRowNavigationOnRow,
+  useHandleRowNavigationOnTable,
+  useRowNavigationContext,
+  useRowNavigationPlugin
+};

package/dist/Table/plugins/RowSelectionPlugin.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../node_modules/@radix-ui/react-use-controllable-state/dist/index.cjs");
+const DEFAULT_ROW_SELECTION = {};
+const useRowSelectionPlugin = ({
+  rowSelection,
+  defaultRowSelection,
+  onRowSelectionChange,
+  rowSelectionMode,
+  getRowCanSelect
+}) => {
+  const [rowSelectionState = DEFAULT_ROW_SELECTION, setRowSelectionState] = index.useControllableState({
+    prop: rowSelection,
+    defaultProp: defaultRowSelection,
+    onChange: onRowSelectionChange
+  });
+  return rowSelectionMode && {
+    tableOptions: {
+      state: {
+        rowSelection: rowSelectionState
+      },
+      enableRowSelection: getRowCanSelect ?? true,
+      enableMultiRowSelection: rowSelectionMode === "multiple",
+      onRowSelectionChange: setRowSelectionState
+    }
+  };
+};
+exports.useRowSelectionPlugin = useRowSelectionPlugin;

package/dist/Table/plugins/RowSelectionPlugin.d.ts

@@ -0,0 +1,12 @@
+import type { Row, RowSelectionState } from '@tanstack/react-table';
+import { TablePluginData } from '../utils/plugin.utils';
+export interface TableRowSelectionParams<T extends object> {
+    rowSelection?: RowSelectionState;
+    defaultRowSelection?: RowSelectionState;
+    onRowSelectionChange?: (state: RowSelectionState) => void;
+    /** Enables row selection sets selection mode */
+    rowSelectionMode?: 'single' | 'multiple';
+    /** Allows individual rows to be selectable */
+    getRowCanSelect?: (row: Row<T>) => boolean;
+}
+export declare const useRowSelectionPlugin: <T extends object>({ rowSelection, defaultRowSelection, onRowSelectionChange, rowSelectionMode, getRowCanSelect }: TableRowSelectionParams<T>) => TablePluginData<T>;

package/dist/Table/plugins/RowSelectionPlugin.js

@@ -0,0 +1,28 @@
+import { useControllableState } from "../../node_modules/@radix-ui/react-use-controllable-state/dist/index.js";
+const DEFAULT_ROW_SELECTION = {};
+const useRowSelectionPlugin = ({
+  rowSelection,
+  defaultRowSelection,
+  onRowSelectionChange,
+  rowSelectionMode,
+  getRowCanSelect
+}) => {
+  const [rowSelectionState = DEFAULT_ROW_SELECTION, setRowSelectionState] = useControllableState({
+    prop: rowSelection,
+    defaultProp: defaultRowSelection,
+    onChange: onRowSelectionChange
+  });
+  return rowSelectionMode && {
+    tableOptions: {
+      state: {
+        rowSelection: rowSelectionState
+      },
+      enableRowSelection: getRowCanSelect ?? true,
+      enableMultiRowSelection: rowSelectionMode === "multiple",
+      onRowSelectionChange: setRowSelectionState
+    }
+  };
+};
+export {
+  useRowSelectionPlugin
+};

package/dist/Table/plugins/SortingPlugin.cjs

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../node_modules/@radix-ui/react-use-controllable-state/dist/index.cjs");
+const React = require("react");
+const plugin_utils = require("../utils/plugin.utils.cjs");
+const Table_context = require("../Table.context.cjs");
+const index$1 = require("../../node_modules/@tanstack/table-core/build/lib/index.cjs");
+const TableSortingContextKey = "sorting";
+const useSortingPlugin = ({
+  defaultSorting,
+  onSortingChange,
+  sorting,
+  manualSorting = false,
+  enableSorting = true
+  // added plugin is enabled by default
+} = {}) => {
+  const [sortedByUser, setSortedByUser] = React.useState(false);
+  const [sortingState, setSortingState] = index.useControllableState({
+    prop: sorting,
+    defaultProp: defaultSorting,
+    onChange: onSortingChange
+  });
+  return enableSorting ? {
+    tableOptions: {
+      enableSorting: true,
+      getSortedRowModel: index$1.getSortedRowModel(),
+      state: {
+        sorting: sortingState
+      },
+      manualSorting,
+      onSortingChange: (value) => {
+        setSortingState(value);
+        setSortedByUser(true);
+      }
+    },
+    context: plugin_utils.buildPluginContext(TableSortingContextKey, {
+      sortedByUser
+    })
+  } : void 0;
+};
+const useSortingContext = () => Table_context.usePluginContext(TableSortingContextKey);
+exports.TableSortingContextKey = TableSortingContextKey;
+exports.useSortingContext = useSortingContext;
+exports.useSortingPlugin = useSortingPlugin;