"use client"
import type { ComponentProps, ReactNode } from "react"
import {
FlexRender,
columnFilteringFeature,
columnVisibilityFeature,
createColumnHelper,
createFilteredRowModel,
createPaginatedRowModel,
createSortedRowModel,
filterFn_arrIncludesSome,
filterFn_equalsString,
filterFn_includesString,
globalFilteringFeature,
rowPaginationFeature,
rowSelectionFeature,
rowSortingFeature,
sortFn_alphanumeric,
sortFn_basic,
sortFn_datetime,
sortFn_text,
tableFeatures,
useTable,
type Column,
type DisplayColumnDef,
type ReactTable,
type RowData,
type TableOptions,
} from "@tanstack/react-table"
import * as stylex from "@stylexjs/stylex"
import type { StyleXStyles } from "@stylexjs/stylex"
import { ArrowDownIcon } from "@phosphor-icons/react/dist/csr/ArrowDown"
import { ArrowUpIcon } from "@phosphor-icons/react/dist/csr/ArrowUp"
import { CaretDoubleLeftIcon } from "@phosphor-icons/react/dist/csr/CaretDoubleLeft"
import { CaretDoubleRightIcon } from "@phosphor-icons/react/dist/csr/CaretDoubleRight"
import { CaretLeftIcon } from "@phosphor-icons/react/dist/csr/CaretLeft"
import { CaretRightIcon } from "@phosphor-icons/react/dist/csr/CaretRight"
import { CaretUpDownIcon } from "@phosphor-icons/react/dist/csr/CaretUpDown"
import { SlidersHorizontalIcon } from "@phosphor-icons/react/dist/csr/SlidersHorizontal"
import { Button } from "@/components/ui/button"
import { Checkbox } from "@/components/ui/checkbox"
import {
DropdownMenu,
DropdownMenuCheckboxItem,
DropdownMenuContent,
DropdownMenuGroup,
DropdownMenuLabel,
DropdownMenuTrigger,
} from "@/components/ui/dropdown-menu"
import {
Select,
SelectContent,
SelectGroup,
SelectItem,
SelectTrigger,
SelectValue,
} from "@/components/ui/select"
import { HStack } from "@/components/ui/stack"
import {
Table,
TableBody,
TableCell,
TableHead,
TableHeader,
TableRow,
type TableAlign,
} from "@/components/ui/table"
import { Text } from "@/components/ui/text"
import { color, space } from "@/theme/tokens.stylex"
const styles = stylex.create({
empty: { height: space.s24, color: color.mutedForeground },
sortStart: {
marginInlineStart: `calc(-1 * ${space.s2})`,
marginBlock: `calc(-1 * ${space.s1})`,
},
sortEnd: {
marginInlineEnd: `calc(-1 * ${space.s2})`,
marginBlock: `calc(-1 * ${space.s1})`,
},
})
const dataTableStyles = {
empty: styles.empty,
sort: { start: styles.sortStart, end: styles.sortEnd },
}
type DataTableColumnMeta = {
label?: string
align?: TableAlign
}
const dataTableFeatures = tableFeatures({
rowSortingFeature,
sortedRowModel: createSortedRowModel(),
sortFns: {
alphanumeric: sortFn_alphanumeric,
basic: sortFn_basic,
datetime: sortFn_datetime,
text: sortFn_text,
},
columnFilteringFeature,
globalFilteringFeature,
filteredRowModel: createFilteredRowModel(),
filterFns: {
arrIncludesSome: filterFn_arrIncludesSome,
equalsString: filterFn_equalsString,
includesString: filterFn_includesString,
},
rowPaginationFeature,
paginatedRowModel: createPaginatedRowModel(),
rowSelectionFeature,
columnVisibilityFeature,
columnMeta: {} as DataTableColumnMeta,
})
type DataTableFeatures = typeof dataTableFeatures
type DataTableInstance<TData extends RowData> = ReactTable<DataTableFeatures, TData>
type DataTableOptions<TData extends RowData> = Omit<
TableOptions<DataTableFeatures, TData>,
"features"
>
function useDataTable<TData extends RowData>(options: DataTableOptions<TData>) {
return useTable({ features: dataTableFeatures, ...options })
}
function createDataTableColumnHelper<TData extends RowData>() {
return createColumnHelper<DataTableFeatures, TData>()
}
function columnLabel<TData extends RowData, TValue>(
column: Column<DataTableFeatures, TData, TValue>,
) {
return column.columnDef.meta?.label ?? column.id
}
const ariaSorts = { asc: "ascending", desc: "descending" } as const
function ariaSort<TData extends RowData, TValue>(column: Column<DataTableFeatures, TData, TValue>) {
if (!column.getCanSort()) return undefined
const sorted = column.getIsSorted()
return sorted ? ariaSorts[sorted] : "none"
}
type Overrides = { xstyle?: StyleXStyles; className?: string }
type DataTableProps<TData extends RowData> = Omit<ComponentProps<typeof Table>, "children"> & {
table: DataTableInstance<TData>
empty?: ReactNode
}
function DataTable<TData extends RowData>({
table,
empty = "No results.",
...props
}: DataTableProps<TData>) {
const rows = table.getRowModel().rows
return (
<Table data-slot="data-table" {...props}>
<TableHeader>
{table.getHeaderGroups().map((group) => (
<TableRow key={group.id}>
{group.headers.map((header) => (
<TableHead
key={header.id}
colSpan={header.colSpan}
align={header.column.columnDef.meta?.align}
aria-sort={ariaSort(header.column)}
>
{header.isPlaceholder ? null : <FlexRender header={header} />}
</TableHead>
))}
</TableRow>
))}
</TableHeader>
<TableBody>
{rows.length > 0 ? (
rows.map((row) => (
<TableRow key={row.id} selected={row.getIsSelected()}>
{row.getVisibleCells().map((cell) => (
<TableCell key={cell.id} align={cell.column.columnDef.meta?.align}>
<FlexRender cell={cell} />
</TableCell>
))}
</TableRow>
))
) : (
<TableRow>
<TableCell
colSpan={table.getVisibleLeafColumns().length}
align="center"
xstyle={styles.empty}
>
{empty}
</TableCell>
</TableRow>
)}
</TableBody>
</Table>
)
}
type DataTableColumnHeaderProps<TData extends RowData, TValue> = Overrides & {
column: Column<DataTableFeatures, TData, TValue>
children?: ReactNode
}
function DataTableColumnHeader<TData extends RowData, TValue>({
column,
children = columnLabel(column),
xstyle,
className,
}: DataTableColumnHeaderProps<TData, TValue>) {
if (!column.getCanSort()) return children
const sorted = column.getIsSorted()
const Icon = sorted === "asc" ? ArrowUpIcon : sorted === "desc" ? ArrowDownIcon : CaretUpDownIcon
const align = column.columnDef.meta?.align === "end" ? "end" : "start"
return (
<Button
data-slot="data-table-column-header"
variant="ghost"
size="xs"
iconPosition="end"
xstyle={[dataTableStyles.sort[align], xstyle]}
className={className}
onClick={column.getToggleSortingHandler()}
>
{children}
<Icon aria-hidden="true" />
</Button>
)
}
function dataTableSelectColumn<TData extends RowData>(): DisplayColumnDef<
DataTableFeatures,
TData,
unknown
> {
return {
id: "select",
enableSorting: false,
enableHiding: false,
header: ({ table }) => (
<Checkbox
checked={table.getIsAllPageRowsSelected()}
indeterminate={table.getIsSomePageRowsSelected() && !table.getIsAllPageRowsSelected()}
onCheckedChange={(checked) => table.toggleAllPageRowsSelected(checked)}
aria-label="Select all rows on this page"
/>
),
cell: ({ row }) => (
<Checkbox
checked={row.getIsSelected()}
disabled={!row.getCanSelect()}
onCheckedChange={(checked) => row.toggleSelected(checked)}
aria-label="Select row"
/>
),
}
}
type DataTableViewOptionsProps<TData extends RowData> = {
table: DataTableInstance<TData>
children?: ReactNode
}
function DataTableViewOptions<TData extends RowData>({
table,
children = "View",
}: DataTableViewOptionsProps<TData>) {
return (
<DropdownMenu>
<DropdownMenuTrigger
data-slot="data-table-view-options"
render={<Button variant="outline" size="sm" iconPosition="start" />}
>
<SlidersHorizontalIcon aria-hidden="true" />
{children}
</DropdownMenuTrigger>
<DropdownMenuContent align="end">
<DropdownMenuGroup>
<DropdownMenuLabel>Toggle columns</DropdownMenuLabel>
{table
.getAllLeafColumns()
.filter((column) => column.getCanHide())
.map((column) => (
<DropdownMenuCheckboxItem
key={column.id}
checked={column.getIsVisible()}
onCheckedChange={(visible) => column.toggleVisibility(visible)}
>
{columnLabel(column)}
</DropdownMenuCheckboxItem>
))}
</DropdownMenuGroup>
</DropdownMenuContent>
</DropdownMenu>
)
}
const rows = (count: number) => `${count} ${count === 1 ? "row" : "rows"}`
type DataTablePaginationProps<TData extends RowData> = Overrides & {
table: DataTableInstance<TData>
pageSizes?: ReadonlyArray<number>
}
function DataTablePagination<TData extends RowData>({
table,
pageSizes = [10, 20, 30, 40, 50],
xstyle,
className,
}: DataTablePaginationProps<TData>) {
const { pageIndex, pageSize } = table.state.pagination
const total = table.getFilteredRowModel().rows.length
const selected = table.getFilteredSelectedRowModel().rows.length
const sizes = pageSizes.map((size) => ({ label: String(size), value: size }))
return (
<HStack
data-slot="data-table-pagination"
justify="between"
align="center"
gap={4}
wrap="wrap"
xstyle={xstyle}
className={className}
>
<Text size="sm" tone="muted">
{selected > 0 ? `${selected} of ${rows(total)} selected` : rows(total)}
</Text>
<HStack align="center" gap={6} wrap="wrap">
<HStack align="center" gap={2}>
<Text size="sm" weight="medium">
Rows per page
</Text>
<Select
items={sizes}
value={pageSize}
onValueChange={(size) => size != null && table.setPageSize(size)}
>
<SelectTrigger size="sm" aria-label="Rows per page">
<SelectValue />
</SelectTrigger>
<SelectContent>
<SelectGroup>
{sizes.map((size) => (
<SelectItem key={size.value} value={size.value}>
{size.label}
</SelectItem>
))}
</SelectGroup>
</SelectContent>
</Select>
</HStack>
<Text size="sm" weight="medium">
Page {pageIndex + 1} of {Math.max(1, table.getPageCount())}
</Text>
<HStack align="center" gap={2}>
<Button
variant="outline"
size="icon-sm"
aria-label="First page"
disabled={!table.getCanPreviousPage()}
onClick={() => table.firstPage()}
>
<CaretDoubleLeftIcon aria-hidden="true" />
</Button>
<Button
variant="outline"
size="icon-sm"
aria-label="Previous page"
disabled={!table.getCanPreviousPage()}
onClick={() => table.previousPage()}
>
<CaretLeftIcon aria-hidden="true" />
</Button>
<Button
variant="outline"
size="icon-sm"
aria-label="Next page"
disabled={!table.getCanNextPage()}
onClick={() => table.nextPage()}
>
<CaretRightIcon aria-hidden="true" />
</Button>
<Button
variant="outline"
size="icon-sm"
aria-label="Last page"
disabled={!table.getCanNextPage()}
onClick={() => table.lastPage()}
>
<CaretDoubleRightIcon aria-hidden="true" />
</Button>
</HStack>
</HStack>
</HStack>
)
}
export {
DataTable,
DataTableColumnHeader,
DataTablePagination,
DataTableViewOptions,
createDataTableColumnHelper,
dataTableFeatures,
dataTableSelectColumn,
dataTableStyles,
useDataTable,
type DataTableColumnMeta,
type DataTableFeatures,
type DataTableInstance,
type DataTableOptions,
}