@redis-ui/table 2.12.0 → 2.18.0

package/dist/Table/components/PluggableTable/PluggableTable.d.ts

@@ -0,0 +1,10 @@
+import { ChildFree } from '@redislabsdev/redis-ui-components';
+import { ReactNode } from 'react';
+import { OwnTableComposeProps, RestTableComposeProps } from '../Compose/Compose';
+export type OwnPluggableTableProps<T extends object> = OwnTableComposeProps<T> & {
+    caption?: string;
+    emptyStateRender?: (() => ReactNode) | string;
+};
+export type RestPluggableTableProps = ChildFree<RestTableComposeProps>;
+export type PluggableTableProps<T extends object> = OwnPluggableTableProps<T> & RestPluggableTableProps;
+export declare const PluggableTable: <T extends object>({ caption, emptyStateRender, ...restProps }: PluggableTableProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/Table/components/PluggableTable/PluggableTable.js

@@ -0,0 +1,19 @@
+import { j as jsxRuntimeExports } from "../../../node_modules/react/jsx-runtime.js";
+import { compositionComponents } from "./compositionComponents.js";
+const PluggableTable = ({
+  caption,
+  emptyStateRender,
+  ...restProps
+}) => jsxRuntimeExports.jsxs(compositionComponents.Compose, {
+  ...restProps,
+  children: [jsxRuntimeExports.jsxs(compositionComponents.Root, {
+    children: [jsxRuntimeExports.jsx(compositionComponents.SRCaption, {
+      caption
+    }), jsxRuntimeExports.jsx(compositionComponents.Header, {}), jsxRuntimeExports.jsx(compositionComponents.EmptyState, {
+      emptyStateRender
+    }), jsxRuntimeExports.jsx(compositionComponents.Body, {})]
+  }), jsxRuntimeExports.jsx(compositionComponents.Pagination, {}), jsxRuntimeExports.jsx(compositionComponents.SRSortingNotification, {})]
+});
+export {
+  PluggableTable
+};

package/dist/Table/components/PluggableTable/compositionComponents.cjs

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Compose = require("../Compose/Compose.cjs");
+const TableRoot = require("../TableRoot/TableRoot.cjs");
+const HiddenCaption = require("../HiddenCaption/HiddenCaption.cjs");
+const TableHeader = require("../TableHeader/TableHeader.cjs");
+const EmptyState = require("../EmptyState/EmptyState.cjs");
+const TableBody = require("../TableBody/TableBody.cjs");
+const TablePagination = require("../TablePagination/TablePagination.cjs");
+const SRSortingNotification = require("../TableHeaderCell/SRSortingNotification.cjs");
+const compositionComponents = {
+  Compose: Compose.TableCompose,
+  Root: TableRoot.TableRoot,
+  SRCaption: HiddenCaption.HiddenCaption,
+  Header: TableHeader.TableHeader,
+  EmptyState: EmptyState.EmptyState,
+  Body: TableBody.TableBody,
+  Pagination: TablePagination.default,
+  SRSortingNotification: SRSortingNotification.SRSortingNotification
+};
+exports.compositionComponents = compositionComponents;

package/dist/Table/components/PluggableTable/compositionComponents.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="react" />
+import { SRSortingNotification } from '../TableHeaderCell/SRSortingNotification';
+export declare const compositionComponents: {
+    Compose: <T extends object>({ data, columns, pluginsData, tableOptions, components, maxHeight, stripedRows, ...restProps }: import("../Compose/Compose").TableComposeProps<T>) => import("react/jsx-runtime").JSX.Element;
+    Root: import("styled-components").StyledComponent<"table", any, {}, never>;
+    SRCaption: ({ caption }: {
+        caption?: string | undefined;
+    }) => import("react/jsx-runtime").JSX.Element | null;
+    Header: (<T_1 extends object>(props: import("../TableHeader/TableHeader").RestTableHeaderProps) => import("react/jsx-runtime").JSX.Element) & {
+        Compose: import("styled-components").StyledComponent<"thead", any, {}, never>;
+        Row: (<T_2 extends object>(props: import("../TableHeaderRow/TableHeaderRow").OwnTableHeaderRowProps<T_2> & import("../TableHeaderRow/TableHeaderRow").RestTableHeaderRowProps & import("react").RefAttributes<HTMLTableRowElement>) => import("react").ReactElement<any, any> | null) & {
+            Compose: import("styled-components").StyledComponent<"tr", any, {}, never>;
+        };
+        Cell: (<T_3 extends object>(props: import("../TableHeaderCell/TableHeaderCell").OwnTableHeaderCellProps<T_3> & import("../TableHeaderCell/TableHeaderCell").RestTableHeaderCellProps & import("react").RefAttributes<HTMLTableCellElement>) => import("react").ReactElement<any, any> | null) & {
+            Compose: <T_4 extends object>(props: import("../TableHeaderCell/components/Compose/Compose").OwnTableHeaderCellComposeProps<T_4> & import("@redislabsdev/redis-ui-components").ComposeChildrenProps & Omit<import("react").HTMLAttributes<HTMLTableCellElement>, "content" | "children"> & import("react").RefAttributes<HTMLTableCellElement>) => import("react").ReactElement<any, any> | null;
+            SortableHeading: (({ children, ...restProps }: import("@redislabsdev/redis-ui-components").ComposeElementProps<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element) & {
+                Compose: ((props: import("@redislabsdev/redis-ui-components").ComposeElementProps<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element) & {
+                    SortIndicator: () => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+                };
+                SortIndicator: () => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+            };
+            Heading: (props: import("../TableHeaderCell/components/Heading/Heading").RestTableHeaderCellHeadingProps) => import("react/jsx-runtime").JSX.Element;
+        };
+    };
+    EmptyState: ({ emptyStateRender, ...restProps }: import("../EmptyState/EmptyState").EmptyStateProps) => import("react/jsx-runtime").JSX.Element | null;
+    Body: (<T_5 extends object>(props: import("../TableBody/TableBody").RestTableBodyProps) => import("react/jsx-runtime").JSX.Element | null) & {
+        Compose: (props: import("../TableBody/components/Compose/Compose").TableBodyComposeProps) => import("react/jsx-runtime").JSX.Element;
+        Row: (<T_6 extends object>(props: import("../TableBodyRow/TableBodyRow").OwnTableBodyRowProps<T_6> & import("../TableBodyRow/TableBodyRow").RestTableBodyRowProps & import("react").RefAttributes<HTMLTableRowElement>) => import("react").ReactElement<any, any> | null) & {
+            Compose: (props: import("@redislabsdev/redis-ui-components").ComposeChildrenProps & Omit<import("react").HTMLAttributes<HTMLTableRowElement>, "content" | "children"> & import("react").RefAttributes<HTMLTableRowElement>) => import("react").ReactElement<any, any> | null;
+            useHandleClickableRow: <T_7 extends object>({ row, onClick, onKeyDown }: {
+                row: import("@tanstack/table-core").Row<T_7>;
+                onClick?: import("react").MouseEventHandler<HTMLTableRowElement> | undefined;
+                onKeyDown?: import("react").KeyboardEventHandler<HTMLTableRowElement> | undefined;
+            }) => {
+                onClick: import("react").MouseEventHandler<HTMLTableRowElement> | undefined;
+                onKeyDown: ((event: import("react").KeyboardEvent<HTMLTableRowElement>) => void) | undefined;
+            };
+        };
+        ExpandableRow: <T_8 extends object>(props: import("../TableBodyRow/TableBodyRow").OwnTableBodyRowProps<T_8> & import("../TableBodyRow/TableBodyRow").RestTableBodyRowProps & import("react").RefAttributes<HTMLTableRowElement>) => import("react").ReactElement<any, any> | null;
+        Cell: (<T_9 extends object>(props: import("../TableBodyCell/TableBodyCell").OwnTableBodyCellProps<T_9> & import("../TableBodyCell/TableBodyCell").RestTableBodyCellProps & import("react").RefAttributes<HTMLTableCellElement>) => import("react").ReactElement<any, any> | null) & {
+            Compose: import("styled-components").StyledComponent<"td", any, {}, never>;
+        };
+    };
+    Pagination: (() => import("react/jsx-runtime").JSX.Element | null) & {
+        Compose: ({ children }: import("@redislabsdev/redis-ui-components").ComposeChildrenProps) => import("react/jsx-runtime").JSX.Element | null;
+        Bar: import("styled-components").StyledComponent<"nav", any, {
+            'aria-label': string;
+        } & {
+            'aria-label': string;
+        }, "aria-label">;
+        Split: import("styled-components").StyledComponent<"div", any, {}, never>;
+        InfoLabel: import("styled-components").StyledComponent<({ renderer, ...restProps }: import("@redislabsdev/redis-ui-components").PaginationInfoLabelProps) => import("react/jsx-runtime").JSX.Element, any, {}, never>;
+        PageSelect: import("styled-components").StyledComponent<{
+            ({ ...restProps }: import("@redislabsdev/redis-ui-components").PaginationPageSelectProps): import("react/jsx-runtime").JSX.Element;
+            Label: ({ children, ...restProps }: import("@redislabsdev/redis-ui-components").TypographyBodyProps) => import("react/jsx-runtime").JSX.Element;
+        }, any, {}, never>;
+        PageSizeSelect: import("styled-components").StyledComponent<{
+            ({ pageSizes, ...restProps }: import("@redislabsdev/redis-ui-components").PaginationPageSizeSelectProps): import("react/jsx-runtime").JSX.Element | null;
+            Label: ({ children, ...restProps }: import("@redislabsdev/redis-ui-components").TypographyBodyProps) => import("react/jsx-runtime").JSX.Element | null;
+        }, any, {}, never>;
+        NavigationButton: import("styled-components").StyledComponent<({ navType, ...restProps }: import("@redislabsdev/redis-ui-components").PaginationNavigationButtonProps) => import("react/jsx-runtime").JSX.Element, any, {}, never>;
+        PageSizeGroup: import("styled-components").StyledComponent<"div", any, {}, never>;
+        PageNavGroup: import("styled-components").StyledComponent<"div", any, {}, never>;
+        PageSelectGroup: import("styled-components").StyledComponent<"div", any, {}, never>;
+    };
+    SRSortingNotification: typeof SRSortingNotification;
+};

package/dist/Table/components/PluggableTable/compositionComponents.js

@@ -0,0 +1,21 @@
+import { TableCompose } from "../Compose/Compose.js";
+import { TableRoot } from "../TableRoot/TableRoot.js";
+import { HiddenCaption } from "../HiddenCaption/HiddenCaption.js";
+import { TableHeader } from "../TableHeader/TableHeader.js";
+import { EmptyState } from "../EmptyState/EmptyState.js";
+import { TableBody } from "../TableBody/TableBody.js";
+import TablePagination from "../TablePagination/TablePagination.js";
+import { SRSortingNotification } from "../TableHeaderCell/SRSortingNotification.js";
+const compositionComponents = {
+  Compose: TableCompose,
+  Root: TableRoot,
+  SRCaption: HiddenCaption,
+  Header: TableHeader,
+  EmptyState,
+  Body: TableBody,
+  Pagination: TablePagination,
+  SRSortingNotification
+};
+export {
+  compositionComponents
+};

package/dist/Table/components/TableBody/TableBody.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("../../../node_modules/react/jsx-runtime.cjs");
+const Table_context = require("../../Table.context.cjs");
+const TableBodyCell = require("../TableBodyCell/TableBodyCell.cjs");
+const TableBodyRow = require("../TableBodyRow/TableBodyRow.cjs");
+const Compose = require("./components/Compose/Compose.cjs");
+const TableBodyRowExpandable = require("../TableBodyRow/TableBodyRowExpandable.cjs");
+const TableBody = Object.assign((props) => {
+  const {
+    table
+  } = Table_context.useTableContext();
+  const {
+    TableBodyRow: Row
+  } = Table_context.useComposeContext({
+    TableBodyRow: TableBodyRowExpandable.TableBodyRowExpandable
+  });
+  const {
+    rows
+  } = table.getRowModel();
+  return rows.length ? jsxRuntime.jsxRuntimeExports.jsx(TableBody.Compose, {
+    ...props,
+    children: rows.map((row) => jsxRuntime.jsxRuntimeExports.jsx(Row, {
+      row
+    }, row.id))
+  }) : null;
+}, {
+  Compose: Compose.TableBodyCompose,
+  Row: TableBodyRow.TableBodyRow,
+  ExpandableRow: TableBodyRowExpandable.TableBodyRowExpandable,
+  Cell: TableBodyCell.TableBodyCell
+});
+exports.TableBody = TableBody;

package/dist/Table/components/TableBody/TableBody.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+import { ChildFree } from '@redislabsdev/redis-ui-components';
+import { TableBodyComposeProps } from './components/Compose/Compose';
+export type RestTableBodyProps = ChildFree<TableBodyComposeProps>;
+export type TableBodyProps = RestTableBodyProps;
+export declare const TableBody: (<T extends object>(props: TableBodyProps) => import("react/jsx-runtime").JSX.Element | null) & {
+    Compose: (props: TableBodyComposeProps) => import("react/jsx-runtime").JSX.Element;
+    Row: (<T_1 extends object>(props: import("../TableBodyRow/TableBodyRow").OwnTableBodyRowProps<T_1> & import("../TableBodyRow/TableBodyRow").RestTableBodyRowProps & import("react").RefAttributes<HTMLTableRowElement>) => import("react").ReactElement<any, any> | null) & {
+        Compose: (props: import("@redislabsdev/redis-ui-components").ComposeChildrenProps & Omit<import("react").HTMLAttributes<HTMLTableRowElement>, "content" | "children"> & import("react").RefAttributes<HTMLTableRowElement>) => import("react").ReactElement<any, any> | null;
+        useHandleClickableRow: <T_2 extends object>({ row, onClick, onKeyDown }: {
+            row: import("@tanstack/table-core").Row<T_2>;
+            onClick?: import("react").MouseEventHandler<HTMLTableRowElement> | undefined;
+            onKeyDown?: import("react").KeyboardEventHandler<HTMLTableRowElement> | undefined;
+        }) => {
+            onClick: import("react").MouseEventHandler<HTMLTableRowElement> | undefined;
+            onKeyDown: ((event: import("react").KeyboardEvent<HTMLTableRowElement>) => void) | undefined;
+        };
+    };
+    ExpandableRow: <T_3 extends object>(props: import("../TableBodyRow/TableBodyRow").OwnTableBodyRowProps<T_3> & import("../TableBodyRow/TableBodyRow").RestTableBodyRowProps & import("react").RefAttributes<HTMLTableRowElement>) => import("react").ReactElement<any, any> | null;
+    Cell: (<T_4 extends object>(props: import("../TableBodyCell/TableBodyCell").OwnTableBodyCellProps<T_4> & import("../TableBodyCell/TableBodyCell").RestTableBodyCellProps & import("react").RefAttributes<HTMLTableCellElement>) => import("react").ReactElement<any, any> | null) & {
+        Compose: import("styled-components").StyledComponent<"td", any, {}, never>;
+    };
+};

package/dist/Table/components/TableBody/TableBody.js

@@ -0,0 +1,33 @@
+import { j as jsxRuntimeExports } from "../../../node_modules/react/jsx-runtime.js";
+import { useTableContext, useComposeContext } from "../../Table.context.js";
+import { TableBodyCell } from "../TableBodyCell/TableBodyCell.js";
+import { TableBodyRow } from "../TableBodyRow/TableBodyRow.js";
+import { TableBodyCompose } from "./components/Compose/Compose.js";
+import { TableBodyRowExpandable } from "../TableBodyRow/TableBodyRowExpandable.js";
+const TableBody = Object.assign((props) => {
+  const {
+    table
+  } = useTableContext();
+  const {
+    TableBodyRow: Row
+  } = useComposeContext({
+    TableBodyRow: TableBodyRowExpandable
+  });
+  const {
+    rows
+  } = table.getRowModel();
+  return rows.length ? jsxRuntimeExports.jsx(TableBody.Compose, {
+    ...props,
+    children: rows.map((row) => jsxRuntimeExports.jsx(Row, {
+      row
+    }, row.id))
+  }) : null;
+}, {
+  Compose: TableBodyCompose,
+  Row: TableBodyRow,
+  ExpandableRow: TableBodyRowExpandable,
+  Cell: TableBodyCell
+});
+export {
+  TableBody
+};

package/dist/Table/components/TableBody/components/Compose/Compose.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("../../../../../node_modules/react/jsx-runtime.cjs");
+const Table_style = require("../../../../Table.style.cjs");
+const Table_context = require("../../../../Table.context.cjs");
+const TableBodyCompose = (props) => jsxRuntime.jsxRuntimeExports.jsx(Table_style.TableBody, {
+  ...props,
+  maxHeight: Table_context.useTableContext().maxHeight
+});
+exports.TableBodyCompose = TableBodyCompose;

package/dist/Table/components/TableBody/components/Compose/Compose.d.ts

@@ -0,0 +1,3 @@
+import { ComposeElementProps } from '@redislabsdev/redis-ui-components';
+export type TableBodyComposeProps = ComposeElementProps<HTMLTableSectionElement>;
+export declare const TableBodyCompose: (props: TableBodyComposeProps) => import("react/jsx-runtime").JSX.Element;

package/dist/Table/components/TableBody/components/Compose/Compose.js

@@ -0,0 +1,10 @@
+import { j as jsxRuntimeExports } from "../../../../../node_modules/react/jsx-runtime.js";
+import { TableBody } from "../../../../Table.style.js";
+import { useTableContext } from "../../../../Table.context.js";
+const TableBodyCompose = (props) => jsxRuntimeExports.jsx(TableBody, {
+  ...props,
+  maxHeight: useTableContext().maxHeight
+});
+export {
+  TableBodyCompose
+};

package/dist/Table/components/TableBodyCell/TableBodyCell.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("../../../node_modules/react/jsx-runtime.cjs");
+const index = require("../../../node_modules/@tanstack/react-table/build/lib/index.cjs");
+const redisUiComponents = require("@redislabsdev/redis-ui-components");
+const Compose = require("./components/Compose/Compose.cjs");
+const TableBodyCell = Object.assign(redisUiComponents.forwardRefWithGenerics(({
+  cell,
+  style,
+  ...restProps
+}, ref) => jsxRuntime.jsxRuntimeExports.jsx(TableBodyCell.Compose, {
+  ...restProps,
+  ref,
+  style: {
+    width: cell.column.getSize(),
+    ...style
+  },
+  children: index.flexRender(cell.column.columnDef.cell, cell.getContext())
+})), {
+  Compose: Compose.TableBodyCellCompose
+});
+exports.TableBodyCell = TableBodyCell;

package/dist/Table/components/TableBodyCell/TableBodyCell.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { Cell } from '@tanstack/react-table';
+import { ChildFree } from '@redislabsdev/redis-ui-components';
+import { TableBodyCellComposeProps } from './components/Compose/Compose';
+export type OwnTableBodyCellProps<T extends object> = {
+    cell: Cell<T, unknown>;
+};
+export type RestTableBodyCellProps = ChildFree<TableBodyCellComposeProps>;
+export type TableBodyCellProps<T extends object> = OwnTableBodyCellProps<T> & RestTableBodyCellProps;
+export declare const TableBodyCell: (<T extends object>(props: OwnTableBodyCellProps<T> & RestTableBodyCellProps & import("react").RefAttributes<HTMLTableCellElement>) => import("react").ReactElement<any, any> | null) & {
+    Compose: import("styled-components").StyledComponent<"td", any, {}, never>;
+};

package/dist/Table/components/TableBodyCell/TableBodyCell.js

@@ -0,0 +1,22 @@
+import { j as jsxRuntimeExports } from "../../../node_modules/react/jsx-runtime.js";
+import { flexRender } from "../../../node_modules/@tanstack/react-table/build/lib/index.js";
+import { forwardRefWithGenerics } from "@redislabsdev/redis-ui-components";
+import { TableBodyCellCompose } from "./components/Compose/Compose.js";
+const TableBodyCell = Object.assign(forwardRefWithGenerics(({
+  cell,
+  style,
+  ...restProps
+}, ref) => jsxRuntimeExports.jsx(TableBodyCell.Compose, {
+  ...restProps,
+  ref,
+  style: {
+    width: cell.column.getSize(),
+    ...style
+  },
+  children: flexRender(cell.column.columnDef.cell, cell.getContext())
+})), {
+  Compose: TableBodyCellCompose
+});
+export {
+  TableBodyCell
+};

package/dist/Table/components/TableBodyCell/components/Compose/Compose.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Table_style = require("../../../../Table.style.cjs");
+const TableBodyCellCompose = Table_style.TableBodyCell;
+exports.TableBodyCellCompose = TableBodyCellCompose;

package/dist/Table/components/TableBodyCell/components/Compose/Compose.d.ts

@@ -0,0 +1,3 @@
+import { ComposeElementProps } from '@redislabsdev/redis-ui-components';
+export type TableBodyCellComposeProps = ComposeElementProps<HTMLTableCellElement>;
+export declare const TableBodyCellCompose: import("styled-components").StyledComponent<"td", any, {}, never>;

package/dist/Table/components/TableBodyCell/components/Compose/Compose.js

@@ -0,0 +1,5 @@
+import { TableBodyCell } from "../../../../Table.style.js";
+const TableBodyCellCompose = TableBodyCell;
+export {
+  TableBodyCellCompose
+};

package/dist/Table/components/TableBodyRow/TableBodyRow.cjs

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("../../../node_modules/react/jsx-runtime.cjs");
+const redisUiComponents = require("@redislabsdev/redis-ui-components");
+const Table_context = require("../../Table.context.cjs");
+const TableBodyCell = require("../TableBodyCell/TableBodyCell.cjs");
+const Compose = require("./components/Compose/Compose.cjs");
+const ClickableRowPlugin = require("../../plugins/ClickableRowPlugin.cjs");
+const TableBodyRow = Object.assign(redisUiComponents.forwardRefWithGenerics(({
+  row,
+  onClick,
+  onKeyDown,
+  ...restProps
+}, ref) => {
+  const {
+    TableBodyCell: Cell
+  } = Table_context.useComposeContext({
+    TableBodyCell: TableBodyCell.TableBodyCell
+  });
+  const clickableProps = ClickableRowPlugin.useHandleClickableRow({
+    row,
+    onClick,
+    onKeyDown
+  });
+  return jsxRuntime.jsxRuntimeExports.jsx(TableBodyRow.Compose, {
+    tabIndex: 0,
+    ...restProps,
+    ...clickableProps,
+    ref,
+    children: row.getVisibleCells().map((cell) => jsxRuntime.jsxRuntimeExports.jsx(Cell, {
+      cell
+    }, cell.id))
+  });
+}), {
+  Compose: Compose.TableBodyRowCompose,
+  useHandleClickableRow: ClickableRowPlugin.useHandleClickableRow
+});
+exports.TableBodyRow = TableBodyRow;

package/dist/Table/components/TableBodyRow/TableBodyRow.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+import { Row } from '@tanstack/react-table';
+import { ChildFree } from '@redislabsdev/redis-ui-components';
+import { TableBodyRowComposeProps } from './components/Compose/Compose';
+export type OwnTableBodyRowProps<T extends object> = {
+    row: Row<T>;
+};
+export type RestTableBodyRowProps = ChildFree<TableBodyRowComposeProps>;
+export type TableBodyRowProps<T extends object> = OwnTableBodyRowProps<T> & RestTableBodyRowProps;
+export declare const TableBodyRow: (<T extends object>(props: OwnTableBodyRowProps<T> & RestTableBodyRowProps & import("react").RefAttributes<HTMLTableRowElement>) => import("react").ReactElement<any, any> | null) & {
+    Compose: (props: import("@redislabsdev/redis-ui-components").ComposeChildrenProps & Omit<import("react").HTMLAttributes<HTMLTableRowElement>, "content" | "children"> & import("react").RefAttributes<HTMLTableRowElement>) => import("react").ReactElement<any, any> | null;
+    useHandleClickableRow: <T_1 extends object>({ row, onClick, onKeyDown }: {
+        row: Row<T_1>;
+        onClick?: import("react").MouseEventHandler<HTMLTableRowElement> | undefined;
+        onKeyDown?: import("react").KeyboardEventHandler<HTMLTableRowElement> | undefined;
+    }) => {
+        onClick: import("react").MouseEventHandler<HTMLTableRowElement> | undefined;
+        onKeyDown: ((event: import("react").KeyboardEvent<HTMLTableRowElement>) => void) | undefined;
+    };
+};

package/dist/Table/components/TableBodyRow/TableBodyRow.js

@@ -0,0 +1,38 @@
+import { j as jsxRuntimeExports } from "../../../node_modules/react/jsx-runtime.js";
+import { forwardRefWithGenerics } from "@redislabsdev/redis-ui-components";
+import { useComposeContext } from "../../Table.context.js";
+import { TableBodyCell } from "../TableBodyCell/TableBodyCell.js";
+import { TableBodyRowCompose } from "./components/Compose/Compose.js";
+import { useHandleClickableRow } from "../../plugins/ClickableRowPlugin.js";
+const TableBodyRow = Object.assign(forwardRefWithGenerics(({
+  row,
+  onClick,
+  onKeyDown,
+  ...restProps
+}, ref) => {
+  const {
+    TableBodyCell: Cell
+  } = useComposeContext({
+    TableBodyCell
+  });
+  const clickableProps = useHandleClickableRow({
+    row,
+    onClick,
+    onKeyDown
+  });
+  return jsxRuntimeExports.jsx(TableBodyRow.Compose, {
+    tabIndex: 0,
+    ...restProps,
+    ...clickableProps,
+    ref,
+    children: row.getVisibleCells().map((cell) => jsxRuntimeExports.jsx(Cell, {
+      cell
+    }, cell.id))
+  });
+}), {
+  Compose: TableBodyRowCompose,
+  useHandleClickableRow
+});
+export {
+  TableBodyRow
+};

package/dist/Table/components/TableBodyRow/TableBodyRowExpandable.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("../../../node_modules/react/jsx-runtime.cjs");
+const redisUiComponents = require("@redislabsdev/redis-ui-components");
+const ExpandableRowPlugin = require("../../plugins/ExpandableRowPlugin.cjs");
+const TableExpandedRow = require("../TableExpandedRow/TableExpandedRow.cjs");
+require("react");
+require("../TableExpandedRow/TableAnimatedExpandedRow.style.cjs");
+const TableBodyRow = require("./TableBodyRow.cjs");
+const TableBodyRowExpandable = redisUiComponents.forwardRefWithGenerics(({
+  row,
+  ...restProps
+}, ref) => {
+  const {
+    renderExpandedRow,
+    expandedRowComponent: ExpandedRow = TableExpandedRow.TableExpandedRow
+  } = ExpandableRowPlugin.useExpandableRowContext() || {};
+  return jsxRuntime.jsxRuntimeExports.jsxs(jsxRuntime.jsxRuntimeExports.Fragment, {
+    children: [
+      jsxRuntime.jsxRuntimeExports.jsx(TableBodyRow.TableBodyRow, {
+        ...restProps,
+        row,
+        "data-row-type": "regular",
+        ref
+      }),
+      // 2nd row is a custom 1 cell row for expanded part
+      renderExpandedRow && row.getCanExpand() && jsxRuntime.jsxRuntimeExports.jsx(ExpandedRow, {
+        row
+      })
+    ]
+  });
+});
+exports.TableBodyRowExpandable = TableBodyRowExpandable;

package/dist/Table/components/TableBodyRow/TableBodyRowExpandable.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const TableBodyRowExpandable: <T extends object>(props: import("./TableBodyRow").OwnTableBodyRowProps<T> & import("./TableBodyRow").RestTableBodyRowProps & import("react").RefAttributes<HTMLTableRowElement>) => import("react").ReactElement<any, any> | null;

package/dist/Table/components/TableBodyRow/TableBodyRowExpandable.js

@@ -0,0 +1,33 @@
+import { j as jsxRuntimeExports } from "../../../node_modules/react/jsx-runtime.js";
+import { forwardRefWithGenerics } from "@redislabsdev/redis-ui-components";
+import { useExpandableRowContext } from "../../plugins/ExpandableRowPlugin.js";
+import { TableExpandedRow } from "../TableExpandedRow/TableExpandedRow.js";
+import "react";
+import "../TableExpandedRow/TableAnimatedExpandedRow.style.js";
+import { TableBodyRow } from "./TableBodyRow.js";
+const TableBodyRowExpandable = forwardRefWithGenerics(({
+  row,
+  ...restProps
+}, ref) => {
+  const {
+    renderExpandedRow,
+    expandedRowComponent: ExpandedRow = TableExpandedRow
+  } = useExpandableRowContext() || {};
+  return jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, {
+    children: [
+      jsxRuntimeExports.jsx(TableBodyRow, {
+        ...restProps,
+        row,
+        "data-row-type": "regular",
+        ref
+      }),
+      // 2nd row is a custom 1 cell row for expanded part
+      renderExpandedRow && row.getCanExpand() && jsxRuntimeExports.jsx(ExpandedRow, {
+        row
+      })
+    ]
+  });
+});
+export {
+  TableBodyRowExpandable
+};

package/dist/Table/components/TableBodyRow/components/Compose/Compose.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("../../../../../node_modules/react/jsx-runtime.cjs");
+const redisUiComponents = require("@redislabsdev/redis-ui-components");
+const Table_context = require("../../../../Table.context.cjs");
+const Table_style = require("../../../../Table.style.cjs");
+const TableBodyRowCompose = redisUiComponents.forwardRefWithGenerics((props, ref) => {
+  const {
+    stripedRows = false
+  } = Table_context.useTableContext();
+  return jsxRuntime.jsxRuntimeExports.jsx(Table_style.TableBodyRow, {
+    ...props,
+    ref,
+    "$stripedRows": stripedRows
+  });
+});
+exports.TableBodyRowCompose = TableBodyRowCompose;

package/dist/Table/components/TableBodyRow/components/Compose/Compose.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { ComposeElementProps } from '@redislabsdev/redis-ui-components';
+export type TableBodyRowComposeProps = ComposeElementProps<HTMLTableRowElement>;
+export declare const TableBodyRowCompose: (props: import("@redislabsdev/redis-ui-components").ComposeChildrenProps & Omit<import("react").HTMLAttributes<HTMLTableRowElement>, "content" | "children"> & import("react").RefAttributes<HTMLTableRowElement>) => import("react").ReactElement<any, any> | null;

package/dist/Table/components/TableBodyRow/components/Compose/Compose.js

@@ -0,0 +1,17 @@
+import { j as jsxRuntimeExports } from "../../../../../node_modules/react/jsx-runtime.js";
+import { forwardRefWithGenerics } from "@redislabsdev/redis-ui-components";
+import { useTableContext } from "../../../../Table.context.js";
+import { TableBodyRow } from "../../../../Table.style.js";
+const TableBodyRowCompose = forwardRefWithGenerics((props, ref) => {
+  const {
+    stripedRows = false
+  } = useTableContext();
+  return jsxRuntimeExports.jsx(TableBodyRow, {
+    ...props,
+    ref,
+    "$stripedRows": stripedRows
+  });
+});
+export {
+  TableBodyRowCompose
+};

package/dist/Table/components/TableExpandedRow/TableAnimatedExpandedRow.cjs

@@ -5,14 +5,14 @@ const React = require("react");
 const index = require("../../../node_modules/@radix-ui/react-compose-refs/dist/index.cjs");
 const TableAnimatedExpandedRow_style = require("./TableAnimatedExpandedRow.style.cjs");
 const TableAnimatedExpandedRow = ({
-  expanded,
   rowRef,
   ...restProps
 }) => {
   const innerRowRef = React.useRef(null);
   const composedRowRef = index.useComposedRefs(rowRef, innerRowRef);
+  const isExpanded = restProps.row.getIsExpanded();
   React.useEffect(() => {
-    if (expanded) {
+    if (isExpanded) {
       const timer = setTimeout(() => {
         var _a;
         return (_a = innerRowRef.current) == null ? void 0 : _a.scrollIntoView({
@@ -23,10 +23,9 @@ const TableAnimatedExpandedRow = ({
       return () => clearTimeout(timer);
     }
     return void 0;
-  }, [expanded]);
+  }, [isExpanded]);
   return jsxRuntime.jsxRuntimeExports.jsx(TableAnimatedExpandedRow_style.AnimatedExpandedRow, {
     rowRef: composedRowRef,
-    expanded,
     ...restProps,
     keepInDom: true
   });

package/dist/Table/components/TableExpandedRow/TableAnimatedExpandedRow.d.ts

@@ -1,2 +1,2 @@
 import { TableExpandedRowProps } from './TableExpandedRow.types';
-export declare const TableAnimatedExpandedRow: <T extends object>({ expanded, rowRef, ...restProps }: TableExpandedRowProps<T>) => import("react/jsx-runtime").JSX.Element;
+export declare const TableAnimatedExpandedRow: <T extends object>({ rowRef, ...restProps }: TableExpandedRowProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/Table/components/TableExpandedRow/TableAnimatedExpandedRow.js

@@ -3,14 +3,14 @@ import { useRef, useEffect } from "react";
 import { useComposedRefs } from "../../../node_modules/@radix-ui/react-compose-refs/dist/index.js";
 import { AnimatedExpandedRow } from "./TableAnimatedExpandedRow.style.js";
 const TableAnimatedExpandedRow = ({
-  expanded,
   rowRef,
   ...restProps
 }) => {
   const innerRowRef = useRef(null);
   const composedRowRef = useComposedRefs(rowRef, innerRowRef);
+  const isExpanded = restProps.row.getIsExpanded();
   useEffect(() => {
-    if (expanded) {
+    if (isExpanded) {
       const timer = setTimeout(() => {
         var _a;
         return (_a = innerRowRef.current) == null ? void 0 : _a.scrollIntoView({
@@ -21,10 +21,9 @@ const TableAnimatedExpandedRow = ({
       return () => clearTimeout(timer);
     }
     return void 0;
-  }, [expanded]);
+  }, [isExpanded]);
   return jsxRuntimeExports.jsx(AnimatedExpandedRow, {
     rowRef: composedRowRef,
-    expanded,
     ...restProps,
     keepInDom: true
   });