Comp AI CRM is an open source, CRM designed for AI agents. Agentic-first CRM.
TypeScript
"use client";
import { Button } from "@crm/ui/components/button";
import { Checkbox } from "@crm/ui/components/checkbox";
import {
Command,
CommandEmpty,
CommandGroup,
CommandInput,
CommandItem,
CommandList,
} from "@crm/ui/components/command";
import {
DropdownMenu,
DropdownMenuCheckboxItem,
DropdownMenuContent,
DropdownMenuGroup,
DropdownMenuItem,
DropdownMenuLabel,
DropdownMenuRadioGroup,
DropdownMenuRadioItem,
DropdownMenuSeparator,
DropdownMenuSub,
DropdownMenuSubContent,
DropdownMenuSubTrigger,
DropdownMenuTrigger,
} from "@crm/ui/components/dropdown-menu";
import { useOverflowTooltip } from "@crm/ui/components/overflow-tooltip";
import { SkeletonLine } from "@crm/ui/components/skeleton-lines";
import {
Table,
TableBody,
TableCell,
TableHead,
TableHeader,
TableRow,
} from "@crm/ui/components/table";
import { TablePagination } from "@crm/ui/components/table-pagination";
import { useMountEffect } from "@crm/ui/hooks/use-mount-effect";
import type { TableSelection } from "@crm/ui/hooks/use-table-selection";
import { ROW_ACCENT } from "@crm/ui/lib/row-accent";
import type { TableQueryState } from "@crm/ui/lib/table-query";
import { cn } from "@crm/ui/lib/utils";
import {
ArrowDownIcon,
ArrowUpDownIcon,
ArrowUpIcon,
ChevronDownIcon,
ChevronRightIcon,
Columns3Icon,
LayoutListIcon,
ListFilterIcon,
} from "lucide-react";
import { parseAsArrayOf, parseAsString, useQueryState } from "nuqs";
import {
Fragment,
type ReactNode,
useDeferredValue,
useId,
useState,
} from "react";
export type ColumnWidth =
| "px"
| "12"
| "14"
| "24"
| "28"
| "32"
| "36"
| "40"
| "42"
| "44"
| "56"
| "64";
export type TableSize = "sm" | "md" | "lg" | "xl" | "2xl";
export type DataTableColumn<TRow> = {
id: string;
header: ReactNode;
cell: (row: TRow) => ReactNode;
label?: string;
sortable?: boolean;
width?: ColumnWidth | { sm: ColumnWidth };
align?: "left" | "right" | "center";
hideable?: boolean;
defaultHidden?: boolean;
hideBelow?: TableSize;
lines?: 1 | 2;
};
export type DataTableFacet = {
id: string;
label: string;
options: { value: string; label: string }[];
searchable?: boolean;
search?: string;
onSearchChange?: (search: string) => void;
stale?: boolean;
empty?: ReactNode;
};
export type DataTableTabs = {
id: string;
label?: string;
allLabel?: string;
options: { value: string; label: string }[];
};
export type DataTableExpandable<TRow, TSub> = {
isExpandable: (row: TRow) => boolean;
getSubRows: (row: TRow) => TSub[];
getSubRowId: (sub: TSub, row: TRow) => string;
renderSubCell: (sub: TSub, columnId: string, row: TRow) => ReactNode;
onSubRowClick?: (sub: TSub, row: TRow) => void;
};
export type DataTableSelection<TRow> = {
state: TableSelection;
actions: ReactNode;
rowLabel?: (row: TRow) => string;
};
export type DataTableProps<TRow, TSub> = {
query: TableQueryState;
columns: DataTableColumn<TRow>[];
getRowId: (row: TRow) => string;
rows: TRow[];
total: number;
facetCounts?: Record<string, Record<string, number>>;
loading?: boolean;
facets?: DataTableFacet[];
tabs?: DataTableTabs;
onRowClick?: (row: TRow, orderedRows: readonly TRow[]) => void;
onRowHover?: (row: TRow) => void;
expandable?: DataTableExpandable<TRow, TSub>;
selection?: DataTableSelection<TRow>;
actions?: ReactNode;
leadingActions?: ReactNode;
search?: ReactNode;
meta?: ReactNode;
empty?: ReactNode;
label?: string;
className?: string;
};
type ColumnLayout = Pick<
DataTableColumn<unknown>,
"width" | "align" | "hideBelow" | "lines"
>;
function columnLayout({ width, align, hideBelow }: ColumnLayout) {
return {
"data-align": align,
"data-hide-below": hideBelow,
"data-width": typeof width === "string" ? width : undefined,
"data-width-sm": typeof width === "object" ? width.sm : undefined,
};
}
const COLUMN_LAYOUT_CLASS = cn(
"data-[align=center]:text-center data-[align=right]:text-right data-[align=right]:tabular-nums",
"data-[hide-below=sm]:hidden @xl/table:data-[hide-below=sm]:table-cell",
"data-[hide-below=md]:hidden @3xl/table:data-[hide-below=md]:table-cell",
"data-[hide-below=lg]:hidden @4xl/table:data-[hide-below=lg]:table-cell",
"data-[hide-below=xl]:hidden @5xl/table:data-[hide-below=xl]:table-cell",
"data-[hide-below=2xl]:hidden @6xl/table:data-[hide-below=2xl]:table-cell",
"data-[width=px]:w-px data-[width=12]:w-12 data-[width=14]:w-14 data-[width=24]:w-24 data-[width=28]:w-28 data-[width=32]:w-32",
"data-[width=36]:w-36 data-[width=40]:w-40 data-[width=42]:w-42 data-[width=44]:w-44 data-[width=56]:w-56 data-[width=64]:w-64",
"@xl/table:data-[width-sm=px]:w-px @xl/table:data-[width-sm=12]:w-12 @xl/table:data-[width-sm=14]:w-14 @xl/table:data-[width-sm=24]:w-24 @xl/table:data-[width-sm=28]:w-28 @xl/table:data-[width-sm=32]:w-32",
"@xl/table:data-[width-sm=36]:w-36 @xl/table:data-[width-sm=40]:w-40 @xl/table:data-[width-sm=42]:w-42 @xl/table:data-[width-sm=44]:w-44 @xl/table:data-[width-sm=56]:w-56 @xl/table:data-[width-sm=64]:w-64",
);
const COLUMN_HEAD_CLASS = cn(
"h-10 overflow-hidden px-3 font-medium text-13 text-muted-foreground",
COLUMN_LAYOUT_CLASS,
);
const COLUMN_CELL_CLASS = cn("overflow-hidden px-3", COLUMN_LAYOUT_CLASS);
const TABLE_CLASS =
"table-fixed [&_td:first-child]:pl-4 [&_th:first-child]:pl-4 [&_td:last-child]:pr-4 [&_th:last-child]:pr-4";
const TABLE_CONTAINER_CLASS =
"min-h-0 overflow-auto rounded-md bg-card shadow-border";
const TABLE_HEADER_CLASS =
"sticky top-0 z-10 bg-card [&_th]:bg-card [&_tr]:border-0 [&_tr]:shadow-divider";
function TableFrame({
label,
overlay,
children,
}: {
label?: string;
overlay: ReactNode;
children: ReactNode;
}) {
return (
<section
aria-label={label}
data-slot="table-frame"
onKeyUp={(event) => {
if (event.key === "Tab") delete event.currentTarget.dataset.pointer;
}}
onPointerDown={(event) => {
event.currentTarget.dataset.pointer = "";
}}
className={cn(
"relative w-full outline-hidden focus-visible:not-data-pointer:outline-2 focus-visible:not-data-pointer:outline-solid focus-visible:not-data-pointer:outline-offset-0 focus-visible:not-data-pointer:outline-ring [&>[data-slot=table-container]]:overflow-visible",
TABLE_CONTAINER_CLASS,
overlay && "min-h-80",
)}
tabIndex={0}
>
{children}
{overlay}
</section>
);
}
const TABLE_EMPTY_OVERLAY_CLASS =
"absolute inset-0 flex items-center justify-center px-4 py-8 text-center";
const LOADING_ROW_COUNT = 5;
const NARROW_TABLE_COLUMNS = 3;
function LoadingRows({
columns,
selectable,
expandable,
}: {
columns: (ColumnLayout & { id: string })[];
selectable: boolean;
expandable: boolean;
}) {
const detailColumn = Math.max(
0,
columns.findIndex((column) => !column.width),
);
return Array.from({ length: LOADING_ROW_COUNT }, (_, index) => (
<TableRow
className="hover:bg-transparent"
data-slot="table-loading-row"
key={index}
>
{selectable ? (
<TableCell
className={cn("w-10 px-3 py-3", COLUMN_LAYOUT_CLASS)}
data-hide-below="sm"
/>
) : null}
{expandable ? <TableCell className="w-10 px-3 py-3" /> : null}
{columns.map((column, position) => (
<TableCell
key={column.id}
{...columnLayout(column)}
className={cn(COLUMN_CELL_CLASS, "py-3")}
>
<div
className="flex min-h-5 flex-col justify-center gap-2 data-[align=right]:items-end"
data-align={column.align}
>
<SkeletonLine width={column.width === "px" ? "24" : "two-thirds"} />
{(column.lines ?? (position === detailColumn ? 2 : 1)) === 2 ? (
<SkeletonLine size="sm" width="40" />
) : null}
</div>
</TableCell>
))}
</TableRow>
));
}
function columnLabel<TRow>(column: DataTableColumn<TRow>): string {
if (column.label) return column.label;
return typeof column.header === "string" ? column.header : column.id;
}
function SortIndicator({
active,
dir,
}: {
active: boolean;
dir: "asc" | "desc";
}) {
return (
<span className="text-muted-foreground">
{active ? (
dir === "asc" ? (
<ArrowUpIcon size={12} />
) : (
<ArrowDownIcon size={12} />
)
) : (
<ArrowUpDownIcon
size={12}
className="opacity-0 transition-opacity group-hover/button:opacity-40 group-focus-visible/button:opacity-40"
/>
)}
</span>
);
}
function toggle(selected: string[], value: string, checked: boolean): string[] {
return checked ? [...selected, value] : selected.filter((v) => v !== value);
}
function FacetCount({
counts,
value,
}: {
counts?: Record<string, number>;
value: string;
}) {
if (counts === undefined) return null;
return (
<span className="ml-2 shrink-0 text-13 text-muted-foreground tabular-nums">
{counts[value] ?? 0}
</span>
);
}
function FacetSubmenu({
facet,
selected,
counts,
onChange,
}: {
facet: DataTableFacet;
selected: string[];
counts?: Record<string, number>;
onChange: (values: string[]) => void;
}) {
return (
<DropdownMenuSub>
<DropdownMenuSubTrigger>
<span className="flex-1">{facet.label}</span>
{selected.length > 0 && (
<span className="tabular-nums opacity-60">({selected.length})</span>
)}
</DropdownMenuSubTrigger>
<DropdownMenuSubContent
className={cn(
"max-h-72 min-w-52 overflow-hidden",
facet.searchable && "p-0",
)}
sideOffset={4}
>
{facet.searchable ? (
<Command
shouldFilter={facet.onSearchChange === undefined}
className="max-h-72"
>
<CommandInput
placeholder={`Search ${facet.label.toLowerCase()}…`}
value={facet.search}
onValueChange={facet.onSearchChange}
onKeyDown={(event) => event.stopPropagation()}
/>
<CommandList>
<CommandEmpty>{facet.empty ?? "Nothing matches."}</CommandEmpty>
<CommandGroup>
{facet.options.map((option) => {
const checked = selected.includes(option.value);
return (
<CommandItem
key={option.value}
value={option.label}
disabled={facet.stale}
data-checked={checked}
onSelect={() =>
onChange(toggle(selected, option.value, !checked))
}
>
<Checkbox
checked={checked}
className="pointer-events-none"
/>
<span className="flex-1 truncate">{option.label}</span>
<FacetCount counts={counts} value={option.value} />
</CommandItem>
);
})}
</CommandGroup>
</CommandList>
</Command>
) : (
<div className="max-h-72 overflow-x-hidden overflow-y-auto">
{selected.length > 0 && (
<>
<DropdownMenuGroup>
<DropdownMenuItem onSelect={() => onChange([])}>
Clear
</DropdownMenuItem>
</DropdownMenuGroup>
<DropdownMenuSeparator />
</>
)}
<DropdownMenuGroup>
{facet.options.map((option) => {
const checked = selected.includes(option.value);
return (
<DropdownMenuCheckboxItem
key={option.value}
checked={checked}
onSelect={(event) => event.preventDefault()}
onCheckedChange={(next) =>
onChange(toggle(selected, option.value, next))
}
>
<span className="flex-1 truncate">{option.label}</span>
<FacetCount counts={counts} value={option.value} />
</DropdownMenuCheckboxItem>
);
})}
</DropdownMenuGroup>
</div>
)}
</DropdownMenuSubContent>
</DropdownMenuSub>
);
}
function ReturnToPage({
page,
setPage,
}: {
page: number;
setPage: (page: number) => Promise<void>;
}) {
useMountEffect(() => {
void setPage(page);
});
return null;
}
function SelectionBar<TRow>({
selection,
selecting,
}: {
selection: DataTableSelection<TRow>;
selecting: boolean;
}) {
return (
<div
aria-hidden={!selecting}
className={cn(
"col-start-1 row-start-1 flex h-9 items-center gap-2 self-start",
!selecting && "invisible",
)}
inert={!selecting}
>
<span className="truncate text-13 text-muted-foreground">
<span className="font-medium text-foreground tabular-nums">
{selection.state.count}
</span>{" "}
selected
</span>
<div className="ml-auto flex items-center gap-2">
{selection.actions}
<Button
variant="ghost"
size="sm"
onClick={() => selection.state.clear()}
>
Clear
</Button>
</div>
</div>
);
}
function CellControl({ children }: { children: ReactNode }) {
return (
<span className="inline-flex h-5 items-center">
{""}
{children}
</span>
);
}
export function DataTable<TRow, TSub = unknown>({
query,
columns,
getRowId,
rows,
total,
facetCounts,
loading = false,
facets,
tabs,
onRowClick,
onRowHover,
expandable,
selection,
actions,
leadingActions,
search,
meta,
empty,
label,
className,
}: DataTableProps<TRow, TSub>) {
const [expandedIds, setExpandedIds] = useQueryState(
"expand",
parseAsArrayOf(parseAsString).withDefault([]),
);
const expanded = new Set(expandedIds);
const defaultHiddenIds = columns
.filter((column) => column.defaultHidden)
.map((column) => column.id);
const [hidden, setHidden] = useQueryState(
"hide",
parseAsArrayOf(parseAsString).withDefault(defaultHiddenIds),
);
const [filtersOpen, setFiltersOpen] = useState(false);
const filtersId = useId();
const hideable = columns.filter((column) => column.hideable !== false);
const visibleColumns = columns.filter(
(column) => !hidden.includes(column.id),
);
const sortableColumns = columns.filter((column) => column.sortable);
const tabCounts = tabs ? facetCounts?.[tabs.id] : undefined;
const activeTabOption =
query.tab === "all"
? undefined
: tabs?.options.find((option) => option.value === query.tab);
const activeTabLabel = activeTabOption
? activeTabOption.label
: (tabs?.allLabel ?? "All");
const deferredRows = useDeferredValue(rows);
const anyExpandable =
expandable != null &&
deferredRows.some((row) => expandable.isExpandable(row));
const selecting = selection != null && selection.state.count > 0;
const pageSize = query.pageSize;
const totalPages = Math.max(1, Math.ceil(total / pageSize));
const pageIsPastEnd = !loading && query.page > totalPages;
const availableFacets = (facets ?? []).filter(
(facet) =>
facet.options.length > 0 ||
facet.searchable ||
(query.filters[facet.id]?.length ?? 0) > 0,
);
const hasFilterControls =
tabs != null ||
(facets?.length ?? 0) > 0 ||
sortableColumns.length > 0 ||
anyExpandable ||
hideable.length > 0 ||
actions != null ||
leadingActions != null;
const activeFacetFilterCount = availableFacets.filter(
(facet) => (query.filters[facet.id]?.length ?? 0) > 0,
).length;
const activeFilterCount =
(tabs && query.tab !== "all" ? 1 : 0) + activeFacetFilterCount;
const overflow = useOverflowTooltip();
const showEmpty = deferredRows.length === 0 && !loading;
const showHeadings = deferredRows.length > 0 || loading;
const wide =
visibleColumns.filter((column) => column.hideBelow === undefined).length >
NARROW_TABLE_COLUMNS;
return (
<div
className={cn(
"@container/table flex min-h-0 flex-1 flex-col gap-3",
className,
)}
>
{pageIsPastEnd ? (
<ReturnToPage
key={totalPages}
page={totalPages}
setPage={query.setPage}
/>
) : null}
<div className="grid">
{selection ? (
<SelectionBar selecting={selecting} selection={selection} />
) : null}
<div
aria-hidden={selecting || undefined}
className={cn(
"col-start-1 row-start-1 flex flex-col gap-2 lg:flex-row lg:flex-wrap lg:items-center lg:justify-between",
selecting && "invisible",
)}
inert={selecting}
>
{search}
{hasFilterControls && (
<Button
type="button"
variant="outline"
className="w-full justify-between sm:hidden"
aria-expanded={filtersOpen}
aria-controls={filtersId}
onClick={() => setFiltersOpen((open) => !open)}
>
<span className="flex items-center gap-2">
<ListFilterIcon />
Table options
{activeFilterCount > 0 && (
<span className="tabular-nums opacity-60">
({activeFilterCount})
</span>
)}
</span>
<ChevronDownIcon
className={cn(
"shrink-0 opacity-60 transition-transform",
filtersOpen && "rotate-180",
)}
/>
</Button>
)}
<div
id={filtersId}
className={cn(
"flex-col gap-2 lg:contents",
filtersOpen ? "flex" : "hidden sm:flex",
)}
>
{leadingActions}
<div className="grid grid-cols-1 gap-2 sm:flex sm:flex-wrap sm:items-center lg:ml-auto">
{tabs && (
<DropdownMenu>
<DropdownMenuTrigger asChild>
<Button
type="button"
variant="outline"
className="justify-start sm:justify-center"
>
<LayoutListIcon data-icon="inline-start" />
{tabs.label ?? "View"}
<span className="truncate opacity-60">
{activeTabLabel}
</span>
</Button>
</DropdownMenuTrigger>
<DropdownMenuContent align="start" className="min-w-52">
<DropdownMenuRadioGroup
value={query.tab}
onValueChange={(value) => query.setTab(value)}
>
<DropdownMenuRadioItem value="all">
<span className="flex-1">{tabs.allLabel ?? "All"}</span>
</DropdownMenuRadioItem>
{tabs.options.map((option) => {
return (
<DropdownMenuRadioItem
key={option.value}
value={option.value}
disabled={
tabCounts?.[option.value] === 0 &&
query.tab !== option.value
}
>
<span className="flex-1">{option.label}</span>
</DropdownMenuRadioItem>
);
})}
</DropdownMenuRadioGroup>
</DropdownMenuContent>
</DropdownMenu>
)}
{(facets?.length ?? 0) > 0 && (
<DropdownMenu>
<DropdownMenuTrigger asChild>
<Button
variant="outline"
disabled={availableFacets.length === 0}
className="justify-start sm:justify-center"
>
<ListFilterIcon data-icon="inline-start" />
Filters
{activeFacetFilterCount > 0 && (
<span className="tabular-nums opacity-60">
({activeFacetFilterCount})
</span>
)}
</Button>
</DropdownMenuTrigger>
<DropdownMenuContent align="start" className="min-w-48">
{availableFacets.map((facet) => (
<FacetSubmenu
key={facet.id}
counts={facetCounts?.[facet.id]}
facet={facet}
selected={query.filters[facet.id] ?? []}
onChange={(values) => query.setFilter(facet.id, values)}
/>
))}
</DropdownMenuContent>
</DropdownMenu>
)}
{(sortableColumns.length > 0 || anyExpandable) && (
<DropdownMenu>
<DropdownMenuTrigger asChild>
<Button
variant="outline"
className="justify-start sm:justify-center"
>
<ArrowUpDownIcon data-icon="inline-start" />
Sort
</Button>
</DropdownMenuTrigger>
<DropdownMenuContent align="end" className="min-w-48">
<DropdownMenuRadioGroup
value={query.sort}
onValueChange={query.setSort}
>
<DropdownMenuLabel>Sort by</DropdownMenuLabel>
{anyExpandable && (
<DropdownMenuRadioItem value="detail">
Detail
</DropdownMenuRadioItem>
)}
{sortableColumns.map((column) => (
<DropdownMenuRadioItem
key={column.id}
value={column.id}
>
{columnLabel(column)}
</DropdownMenuRadioItem>
))}
</DropdownMenuRadioGroup>
<DropdownMenuSeparator />
<DropdownMenuRadioGroup
value={query.dir}
onValueChange={(value) =>
query.setDir(value === "desc" ? "desc" : "asc")
}
>
<DropdownMenuRadioItem value="asc">
Ascending
</DropdownMenuRadioItem>
<DropdownMenuRadioItem value="desc">
Descending
</DropdownMenuRadioItem>
</DropdownMenuRadioGroup>
</DropdownMenuContent>
</DropdownMenu>
)}
{hideable.length > 0 && (
<DropdownMenu>
<DropdownMenuTrigger asChild>
<Button
variant="outline"
className="justify-start sm:justify-center"
>
<Columns3Icon data-icon="inline-start" />
Columns
<span className="tabular-nums opacity-60">
(
{
visibleColumns.filter(
(column) => column.hideable !== false,
).length
}
)
</span>
</Button>
</DropdownMenuTrigger>
<DropdownMenuContent align="end" className="min-w-48">
<DropdownMenuGroup>
<DropdownMenuLabel>Toggle columns</DropdownMenuLabel>
{hideable.map((column) => (
<DropdownMenuCheckboxItem
key={column.id}
checked={!hidden.includes(column.id)}
onSelect={(event) => event.preventDefault()}
onCheckedChange={(checked) =>
setHidden((prev) => {
const set = new Set(prev);
if (checked) set.delete(column.id);
else set.add(column.id);
return [...set];
})
}
>
{columnLabel(column)}
</DropdownMenuCheckboxItem>
))}
</DropdownMenuGroup>
</DropdownMenuContent>
</DropdownMenu>
)}
{actions}
</div>
</div>
</div>
</div>
<TableFrame
label={label}
overlay={
showEmpty ? (
<div className={TABLE_EMPTY_OVERLAY_CLASS}>
{typeof empty === "string" || empty == null ? (
<p className="text-muted-foreground">
{empty ?? "No results found."}
</p>
) : (
empty
)}
</div>
) : null
}
>
<Table
{...overflow.handlers}
aria-busy={loading || undefined}
className={cn(TABLE_CLASS, wide && "min-w-lg")}
>
{showHeadings ? (
<TableHeader className={TABLE_HEADER_CLASS}>
<TableRow>
{selection && (
<TableHead
className={cn("h-10 w-10 px-3", COLUMN_LAYOUT_CLASS)}
data-hide-below="sm"
>
{deferredRows.length > 0 && (
<CellControl>
<Checkbox
checked={
selection.state.allSelected
? true
: selection.state.someSelected
? "indeterminate"
: false
}
onCheckedChange={(checked) =>
selection.state.toggleAll(checked === true)
}
aria-label="Select every row on this page"
/>
</CellControl>
)}
</TableHead>
)}
{anyExpandable && (
<TableHead className="h-10 w-10 px-3">
<span className="sr-only">Detail</span>
</TableHead>
)}
{visibleColumns.map((column) => {
const isActive = query.sort === column.id;
return (
<TableHead
key={column.id}
{...columnLayout(column)}
className={COLUMN_HEAD_CLASS}
aria-sort={
isActive
? query.dir === "asc"
? "ascending"
: "descending"
: undefined
}
>
{column.sortable ? (
<Button
variant="ghost"
size="xs"
onClick={() => query.toggleSort(column.id)}
className={cn(
"-ml-2 font-medium text-13 text-muted-foreground hover:text-foreground",
column.align === "right" &&
"-mr-2 ml-0 flex-row-reverse",
column.align === "center" && "mx-auto",
)}
>
{column.header}
<SortIndicator active={isActive} dir={query.dir} />
</Button>
) : (
column.header
)}
</TableHead>
);
})}
</TableRow>
</TableHeader>
) : null}
<TableBody>
{loading && deferredRows.length === 0 ? (
<LoadingRows
columns={visibleColumns}
expandable={anyExpandable}
selectable={!!selection}
/>
) : null}
{deferredRows.map((row) => {
const id = getRowId(row);
const canExpand = expandable?.isExpandable(row) ?? false;
const isOpen = canExpand && expanded.has(id);
const isSelected = selection?.state.has(id) ?? false;
const clickable = canExpand || !!onRowClick;
const handleClick = () => {
if (canExpand) {
setExpandedIds((prev) => {
const set = new Set(prev ?? []);
if (set.has(id)) set.delete(id);
else set.add(id);
const next = [...set];
return next.length > 0 ? next : null;
});
} else {
onRowClick?.(row, deferredRows);
}
};
return (
<Fragment key={id}>
<TableRow
data-state={isSelected ? "selected" : undefined}
aria-expanded={canExpand ? isOpen : undefined}
onClick={clickable ? handleClick : undefined}
onMouseEnter={
onRowHover ? () => onRowHover(row) : undefined
}
onFocus={onRowHover ? () => onRowHover(row) : undefined}
className={cn(clickable && ROW_ACCENT)}
>
{selection && (
<TableCell
className={cn("w-10 px-3 py-3", COLUMN_LAYOUT_CLASS)}
data-hide-below="sm"
onClick={(event) => event.stopPropagation()}
>
<CellControl>
<Checkbox
checked={isSelected}
onCheckedChange={(checked) =>
selection.state.toggle(id, checked === true)
}
aria-label={
selection.rowLabel
? `Select ${selection.rowLabel(row)}`
: "Select row"
}
/>
</CellControl>
</TableCell>
)}
{anyExpandable && (
<TableCell className="w-10 px-3 py-3 text-center text-muted-foreground">
{canExpand && (
<ChevronRightIcon
size={16}
className={cn(
"inline-block transition-transform",
isOpen && "rotate-90",
)}
/>
)}
</TableCell>
)}
{visibleColumns.map((column) => (
<TableCell
key={column.id}
{...columnLayout(column)}
className={cn(COLUMN_CELL_CLASS, "py-3")}
>
{column.cell(row)}
</TableCell>
))}
</TableRow>
{isOpen &&
expandable?.getSubRows(row).map((sub) => {
const subClickable = !!expandable.onSubRowClick;
return (
<TableRow
key={expandable.getSubRowId(sub, row)}
onClick={
subClickable
? () => expandable.onSubRowClick?.(sub, row)
: undefined
}
className={cn(
"bg-muted/30",
subClickable && ROW_ACCENT,
)}
>
{selection && (
<TableCell
className={cn(
"w-10 px-3 py-2.5",
COLUMN_LAYOUT_CLASS,
)}
data-hide-below="sm"
/>
)}
{anyExpandable && (
<TableCell className="w-10 px-3 py-2.5" />
)}
{visibleColumns.map((column) => (
<TableCell
key={column.id}
{...columnLayout(column)}
className={cn(COLUMN_CELL_CLASS, "py-2.5")}
>
{expandable.renderSubCell(sub, column.id, row)}
</TableCell>
))}
</TableRow>
);
})}
</Fragment>
);
})}
</TableBody>
</Table>
</TableFrame>
{overflow.tooltip}
<TablePagination
page={query.page}
totalPages={totalPages}
pageSize={pageSize}
total={total}
onPageChange={(page) => void query.setPage(page)}
loading={loading}
meta={meta}
/>
</div>
);
}