# Table

A responsive table component.

Source: https://webjs.dev/ui/docs/components/table

```ts
import { html } from '@webjsdev/core';
import { cn } from '#lib/utils/cn.ts';
import {
  tableContainerClass, tableClass, tableHeaderClass, tableBodyClass, tableFooterClass,
  tableRowClass, tableHeadClass, tableCellClass, tableCaptionClass,
} from '#components/ui/table.ts';

const invoices = [
  {
    invoice: 'INV001',
    paymentStatus: 'Paid',
    totalAmount: '$250.00',
    paymentMethod: 'Credit Card',
  },
  {
    invoice: 'INV002',
    paymentStatus: 'Pending',
    totalAmount: '$150.00',
    paymentMethod: 'PayPal',
  },
  {
    invoice: 'INV003',
    paymentStatus: 'Unpaid',
    totalAmount: '$350.00',
    paymentMethod: 'Bank Transfer',
  },
  {
    invoice: 'INV004',
    paymentStatus: 'Paid',
    totalAmount: '$450.00',
    paymentMethod: 'Credit Card',
  },
  {
    invoice: 'INV005',
    paymentStatus: 'Paid',
    totalAmount: '$550.00',
    paymentMethod: 'PayPal',
  },
  {
    invoice: 'INV006',
    paymentStatus: 'Pending',
    totalAmount: '$200.00',
    paymentMethod: 'Bank Transfer',
  },
  {
    invoice: 'INV007',
    paymentStatus: 'Unpaid',
    totalAmount: '$300.00',
    paymentMethod: 'Credit Card',
  },
];

export default function TableDemo() {
  return html`
    <div data-slot="table-container" class=${tableContainerClass()}>
      <table data-slot="table" class=${tableClass()}>
        <caption data-slot="table-caption" class=${tableCaptionClass()}>A list of your recent invoices.</caption>
        <thead data-slot="table-header" class=${tableHeaderClass()}>
          <tr data-slot="table-row" class=${tableRowClass()}>
            <th scope="col" data-slot="table-head" class=${cn(tableHeadClass(), 'w-[100px]')}>Invoice</th>
            <th scope="col" data-slot="table-head" class=${tableHeadClass()}>Status</th>
            <th scope="col" data-slot="table-head" class=${tableHeadClass()}>Method</th>
            <th scope="col" data-slot="table-head" class=${cn(tableHeadClass(), 'text-right')}>Amount</th>
          </tr>
        </thead>
        <tbody data-slot="table-body" class=${tableBodyClass()}>
          ${invoices.map((invoice) => html`
            <tr data-slot="table-row" class=${tableRowClass()}>
              <td data-slot="table-cell" class=${cn(tableCellClass(), 'font-medium')}>${invoice.invoice}</td>
              <td data-slot="table-cell" class=${tableCellClass()}>${invoice.paymentStatus}</td>
              <td data-slot="table-cell" class=${tableCellClass()}>${invoice.paymentMethod}</td>
              <td data-slot="table-cell" class=${cn(tableCellClass(), 'text-right')}>${invoice.totalAmount}</td>
            </tr>
          `)}
        </tbody>
        <tfoot data-slot="table-footer" class=${tableFooterClass()}>
          <tr data-slot="table-row" class=${tableRowClass()}>
            <td colspan="3" data-slot="table-cell" class=${tableCellClass()}>Total</td>
            <td data-slot="table-cell" class=${cn(tableCellClass(), 'text-right')}>$2,500.00</td>
          </tr>
        </tfoot>
      </table>
    </div>
  `;
}
```

## Installation

```bash
npx @webjsdev/ui add table
```

### Copy and paste the following code into your project.

````ts title="components/ui/table.ts"
/**
 * Table: semantic data table with shadcn styling. Tier-1 class helpers;
 * compose with native `<table>`, `<thead>`, `<tbody>`, `<tfoot>`, `<tr>`,
 * `<th>`, `<td>`, `<caption>`. Native semantics + accessibility tree
 * work out of the box.
 *
 * shadcn parity:
 *   Table container (scroll wrapper)  → tableContainerClass()
 *   Table                             → tableClass()
 *   TableHeader / TableBody / TableFooter
 *                                     → tableHeaderClass() / tableBodyClass() / tableFooterClass()
 *   TableRow                          → tableRowClass()
 *   TableHead / TableCell / TableCaption
 *                                     → tableHeadClass() / tableCellClass() / tableCaptionClass()
 *
 * A11y (required for accessible output): every header cell needs a scope
 * (scope="col" on a column header, scope="row" on a row header) so screen
 * readers map cells to their headers. Add a <caption> naming the table's
 * purpose (it can be visually hidden if a heading already names it).
 *
 * Design tokens used: --muted, --muted-foreground, --foreground.
 *
 * @example
 * ```html
 * <div class=${tableContainerClass()}>
 *   <table class=${tableClass()}>
 *     <thead class=${tableHeaderClass()}>
 *       <tr class=${tableRowClass()}>
 *         <th scope="col" class=${tableHeadClass()}>Name</th>
 *         <th scope="col" class=${tableHeadClass()}>Status</th>
 *       </tr>
 *     </thead>
 *     <tbody class=${tableBodyClass()}>
 *       <tr class=${tableRowClass()}>
 *         <td class=${tableCellClass()}>Vivek</td>
 *         <td class=${tableCellClass()}>Active</td>
 *       </tr>
 *     </tbody>
 *     <caption class=${tableCaptionClass()}>Users</caption>
 *   </table>
 * </div>
 * ```
 */

export const tableContainerClass = (): string => 'relative w-full overflow-x-auto';

export const tableClass = (): string => 'w-full caption-bottom text-sm';

export const tableHeaderClass = (): string => '[&_tr]:border-b';

export const tableBodyClass = (): string => '[&_tr:last-child]:border-0';

export const tableFooterClass = (): string =>
  'border-t bg-muted/50 font-medium [&>tr]:last:border-b-0';

export const tableRowClass = (): string =>
  'border-b transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted has-aria-expanded:bg-muted/50';

// The ported styles write a physical text-left; the logical one here keeps an
// RTL table's headings at its start, as shadcn's RTL install does.
export const tableHeadClass = (): string =>
  'h-10 px-2 text-start align-middle font-medium whitespace-nowrap text-foreground [&:has([role=checkbox])]:pe-0 [&>[role=checkbox]]:translate-y-[2px]';

export const tableCellClass = (): string =>
  'p-2 align-middle whitespace-nowrap [&:has([role=checkbox])]:pe-0 [&>[role=checkbox]]:translate-y-[2px]';

export const tableCaptionClass = (): string => 'mt-4 text-sm text-muted-foreground';
````

### Update the import paths to match your project setup.

## Usage

```ts
import {
  tableContainerClass,
  tableClass,
  tableBodyClass,
  tableCaptionClass,
  tableCellClass,
  tableHeadClass,
  tableHeaderClass,
  tableRowClass,
} from '#components/ui/table.ts';
import { cn } from '#lib/utils/cn.ts';
```

```ts
<div class=${tableContainerClass()}>
  <table class=${tableClass()}>
    <caption class=${tableCaptionClass()}>A list of your recent invoices.</caption>
    <thead class=${tableHeaderClass()}>
      <tr class=${tableRowClass()}>
        <th scope="col" class=${cn(tableHeadClass(), 'w-[100px]')}>Invoice</th>
        <th scope="col" class=${tableHeadClass()}>Status</th>
        <th scope="col" class=${tableHeadClass()}>Method</th>
        <th scope="col" class=${cn(tableHeadClass(), 'text-right')}>Amount</th>
      </tr>
    </thead>
    <tbody class=${tableBodyClass()}>
      <tr class=${tableRowClass()}>
        <td class=${cn(tableCellClass(), 'font-medium')}>INV001</td>
        <td class=${tableCellClass()}>Paid</td>
        <td class=${tableCellClass()}>Credit Card</td>
        <td class=${cn(tableCellClass(), 'text-right')}>$250.00</td>
      </tr>
    </tbody>
  </table>
</div>
```

## Composition

Use the following composition to build a table, each part a native table element with its helper:

```text
div (tableContainerClass)
└── table (tableClass)
    ├── caption (tableCaptionClass)
    ├── thead (tableHeaderClass)
    │   └── tr (tableRowClass)
    │       ├── th (tableHeadClass)
    │       ├── th (tableHeadClass)
    │       ├── th (tableHeadClass)
    │       └── th (tableHeadClass)
    ├── tbody (tableBodyClass)
    │   ├── tr (tableRowClass)
    │   │   ├── td (tableCellClass)
    │   │   ├── td (tableCellClass)
    │   │   ├── td (tableCellClass)
    │   │   └── td (tableCellClass)
    │   └── tr (tableRowClass)
    │       ├── td (tableCellClass)
    │       ├── td (tableCellClass)
    │       ├── td (tableCellClass)
    │       └── td (tableCellClass)
    └── tfoot (tableFooterClass)
```

## Footer

Use a `<tfoot>` with `tableFooterClass()` to add a footer to the table.

```ts
import { html } from '@webjsdev/core';
import { cn } from '#lib/utils/cn.ts';
import {
  tableContainerClass, tableClass, tableHeaderClass, tableBodyClass, tableFooterClass,
  tableRowClass, tableHeadClass, tableCellClass, tableCaptionClass,
} from '#components/ui/table.ts';

const invoices = [
  {
    invoice: 'INV001',
    paymentStatus: 'Paid',
    totalAmount: '$250.00',
    paymentMethod: 'Credit Card',
  },
  {
    invoice: 'INV002',
    paymentStatus: 'Pending',
    totalAmount: '$150.00',
    paymentMethod: 'PayPal',
  },
  {
    invoice: 'INV003',
    paymentStatus: 'Unpaid',
    totalAmount: '$350.00',
    paymentMethod: 'Bank Transfer',
  },
  {
    invoice: 'INV004',
    paymentStatus: 'Paid',
    totalAmount: '$450.00',
    paymentMethod: 'Credit Card',
  },
  {
    invoice: 'INV005',
    paymentStatus: 'Paid',
    totalAmount: '$550.00',
    paymentMethod: 'PayPal',
  },
  {
    invoice: 'INV006',
    paymentStatus: 'Pending',
    totalAmount: '$200.00',
    paymentMethod: 'Bank Transfer',
  },
  {
    invoice: 'INV007',
    paymentStatus: 'Unpaid',
    totalAmount: '$300.00',
    paymentMethod: 'Credit Card',
  },
];

export default function TableFooterExample() {
  return html`
    <div data-slot="table-container" class=${tableContainerClass()}>
      <table data-slot="table" class=${tableClass()}>
        <caption data-slot="table-caption" class=${tableCaptionClass()}>A list of your recent invoices.</caption>
        <thead data-slot="table-header" class=${tableHeaderClass()}>
          <tr data-slot="table-row" class=${tableRowClass()}>
            <th scope="col" data-slot="table-head" class=${cn(tableHeadClass(), 'w-[100px]')}>Invoice</th>
            <th scope="col" data-slot="table-head" class=${tableHeadClass()}>Status</th>
            <th scope="col" data-slot="table-head" class=${tableHeadClass()}>Method</th>
            <th scope="col" data-slot="table-head" class=${cn(tableHeadClass(), 'text-right')}>Amount</th>
          </tr>
        </thead>
        <tbody data-slot="table-body" class=${tableBodyClass()}>
          ${invoices.slice(0, 3).map((invoice) => html`
            <tr data-slot="table-row" class=${tableRowClass()}>
              <td data-slot="table-cell" class=${cn(tableCellClass(), 'font-medium')}>${invoice.invoice}</td>
              <td data-slot="table-cell" class=${tableCellClass()}>${invoice.paymentStatus}</td>
              <td data-slot="table-cell" class=${tableCellClass()}>${invoice.paymentMethod}</td>
              <td data-slot="table-cell" class=${cn(tableCellClass(), 'text-right')}>${invoice.totalAmount}</td>
            </tr>
          `)}
        </tbody>
        <tfoot data-slot="table-footer" class=${tableFooterClass()}>
          <tr data-slot="table-row" class=${tableRowClass()}>
            <td colspan="3" data-slot="table-cell" class=${tableCellClass()}>Total</td>
            <td data-slot="table-cell" class=${cn(tableCellClass(), 'text-right')}>$2,500.00</td>
          </tr>
        </tfoot>
      </table>
    </div>
  `;
}
```

## Actions

A table showing actions for each row using a `<ui-dropdown-menu>` element.

```ts
import { html } from '@webjsdev/core';
import { cn } from '#lib/utils/cn.ts';
import { buttonClass } from '#components/ui/button.ts';
import {
  tableContainerClass, tableClass, tableHeaderClass, tableBodyClass,
  tableRowClass, tableHeadClass, tableCellClass,
} from '#components/ui/table.ts';
import { MoreHorizontalIcon } from '#lib/ui/lucide.ts';

const products = [
  { name: 'Wireless Mouse', price: '$29.99' },
  { name: 'Mechanical Keyboard', price: '$129.99' },
  { name: 'USB-C Hub', price: '$49.99' },
];

export default function TableActions() {
  return html`
    <div data-slot="table-container" class=${tableContainerClass()}>
      <table data-slot="table" class=${tableClass()}>
        <thead data-slot="table-header" class=${tableHeaderClass()}>
          <tr data-slot="table-row" class=${tableRowClass()}>
            <th scope="col" data-slot="table-head" class=${tableHeadClass()}>Product</th>
            <th scope="col" data-slot="table-head" class=${tableHeadClass()}>Price</th>
            <th scope="col" data-slot="table-head" class=${cn(tableHeadClass(), 'text-right')}>Actions</th>
          </tr>
        </thead>
        <tbody data-slot="table-body" class=${tableBodyClass()}>
          ${products.map((product) => html`
            <tr data-slot="table-row" class=${tableRowClass()}>
              <td data-slot="table-cell" class=${cn(tableCellClass(), 'font-medium')}>${product.name}</td>
              <td data-slot="table-cell" class=${tableCellClass()}>${product.price}</td>
              <td data-slot="table-cell" class=${cn(tableCellClass(), 'text-right')}>
                <ui-dropdown-menu>
                  <ui-dropdown-menu-trigger>
                    <button type="button" data-slot="button" data-variant="ghost" data-size="icon" class=${cn(buttonClass({ variant: 'ghost', size: 'icon' }), 'size-8')}>
                      ${MoreHorizontalIcon()}
                      <span class="sr-only">Open menu</span>
                    </button>
                  </ui-dropdown-menu-trigger>
                  <ui-dropdown-menu-content align="end">
                    <ui-dropdown-menu-item>Edit</ui-dropdown-menu-item>
                    <ui-dropdown-menu-item>Duplicate</ui-dropdown-menu-item>
                    <ui-dropdown-menu-separator></ui-dropdown-menu-separator>
                    <ui-dropdown-menu-item variant="destructive">
                      Delete
                    </ui-dropdown-menu-item>
                  </ui-dropdown-menu-content>
                </ui-dropdown-menu>
              </td>
            </tr>
          `)}
        </tbody>
      </table>
    </div>
  `;
}
```

## Data Table

You can use the table helpers to build more complex data tables. Add sorting, filtering and pagination on the server, which can sort and slice the rows before it renders them, driven by the query string, which keeps the table working with JavaScript off.

See the [Data Table](https://webjs.dev/ui/docs/components/data-table) documentation for more information.

## RTL

To enable RTL support, see the [RTL configuration guide](https://webjs.dev/ui/docs/rtl).

```ts
import { html } from '@webjsdev/core';
import { cn } from '#lib/utils/cn.ts';
import {
  tableContainerClass, tableClass, tableHeaderClass, tableBodyClass, tableFooterClass,
  tableRowClass, tableHeadClass, tableCellClass, tableCaptionClass,
} from '#components/ui/table.ts';

const translations = {
  en: {
    dir: 'ltr',
    values: {
      caption: 'A list of your recent invoices.',
      invoice: 'Invoice',
      status: 'Status',
      method: 'Method',
      amount: 'Amount',
      paid: 'Paid',
      pending: 'Pending',
      unpaid: 'Unpaid',
      creditCard: 'Credit Card',
      paypal: 'PayPal',
      bankTransfer: 'Bank Transfer',
      total: 'Total',
    },
  },
  ar: {
    dir: 'rtl',
    values: {
      caption: 'قائمة بفواتيرك الأخيرة.',
      invoice: 'الفاتورة',
      status: 'الحالة',
      method: 'الطريقة',
      amount: 'المبلغ',
      paid: 'مدفوع',
      pending: 'قيد الانتظار',
      unpaid: 'غير مدفوع',
      creditCard: 'بطاقة ائتمانية',
      paypal: 'PayPal',
      bankTransfer: 'تحويل بنكي',
      total: 'المجموع',
    },
  },
  he: {
    dir: 'rtl',
    values: {
      caption: 'רשימת החשבוניות האחרונות שלך.',
      invoice: 'חשבונית',
      status: 'סטטוס',
      method: 'שיטה',
      amount: 'סכום',
      paid: 'שולם',
      pending: 'ממתין',
      unpaid: 'לא שולם',
      creditCard: 'כרטיס אשראי',
      paypal: 'PayPal',
      bankTransfer: 'העברה בנקאית',
      total: 'סה"כ',
    },
  },
};

const invoices = [
  { invoice: 'INV001', paymentStatus: 'paid', totalAmount: '$250.00', paymentMethod: 'creditCard' },
  { invoice: 'INV002', paymentStatus: 'pending', totalAmount: '$150.00', paymentMethod: 'paypal' },
  { invoice: 'INV003', paymentStatus: 'unpaid', totalAmount: '$350.00', paymentMethod: 'bankTransfer' },
  { invoice: 'INV004', paymentStatus: 'paid', totalAmount: '$450.00', paymentMethod: 'creditCard' },
  { invoice: 'INV005', paymentStatus: 'paid', totalAmount: '$550.00', paymentMethod: 'paypal' },
  { invoice: 'INV006', paymentStatus: 'pending', totalAmount: '$200.00', paymentMethod: 'bankTransfer' },
  { invoice: 'INV007', paymentStatus: 'unpaid', totalAmount: '$300.00', paymentMethod: 'creditCard' },
] as const;

export default function TableRtl() {
  const lang = 'ar';
  const { dir, values: t } = translations[lang];

  return html`
    <div data-slot="table-container" class=${tableContainerClass()}>
      <table data-slot="table" dir=${dir} lang=${lang} class=${tableClass()}>
        <caption data-slot="table-caption" class=${tableCaptionClass()}>${t.caption}</caption>
        <thead data-slot="table-header" class=${tableHeaderClass()}>
          <tr data-slot="table-row" class=${tableRowClass()}>
            <th scope="col" data-slot="table-head" class=${cn(tableHeadClass(), 'w-[100px]')}>${t.invoice}</th>
            <th scope="col" data-slot="table-head" class=${tableHeadClass()}>${t.status}</th>
            <th scope="col" data-slot="table-head" class=${tableHeadClass()}>${t.method}</th>
            <th scope="col" data-slot="table-head" class=${cn(tableHeadClass(), 'text-end')}>${t.amount}</th>
          </tr>
        </thead>
        <tbody data-slot="table-body" class=${tableBodyClass()}>
          ${invoices.map((invoice) => html`
            <tr data-slot="table-row" class=${tableRowClass()}>
              <td data-slot="table-cell" class=${cn(tableCellClass(), 'font-medium')}>${invoice.invoice}</td>
              <td data-slot="table-cell" class=${tableCellClass()}>${t[invoice.paymentStatus]}</td>
              <td data-slot="table-cell" class=${tableCellClass()}>${t[invoice.paymentMethod]}</td>
              <td data-slot="table-cell" class=${cn(tableCellClass(), 'text-end')}>${invoice.totalAmount}</td>
            </tr>
          `)}
        </tbody>
        <tfoot data-slot="table-footer" class=${tableFooterClass()}>
          <tr data-slot="table-row" class=${tableRowClass()}>
            <td colspan="3" data-slot="table-cell" class=${tableCellClass()}>${t.total}</td>
            <td data-slot="table-cell" class=${cn(tableCellClass(), 'text-end')}>$2,500.00</td>
          </tr>
        </tfoot>
      </table>
    </div>
  `;
}
```

## API Reference

Each helper returns the classes for one native table element. The native elements keep their semantics, so the accessibility tree works without extra roles. Give every header cell a `scope` and the table a `<caption>`.

| Helper | Element | Part |
| --- | --- | --- |
| `tableContainerClass()` | `<div>` | The scroll wrapper |
| `tableClass()` | `<table>` | The table |
| `tableHeaderClass()` | `<thead>` | The header rows |
| `tableBodyClass()` | `<tbody>` | The body rows |
| `tableFooterClass()` | `<tfoot>` | The footer rows |
| `tableRowClass()` | `<tr>` | A row |
| `tableHeadClass()` | `<th>` | A header cell |
| `tableCellClass()` | `<td>` | A data cell |
| `tableCaptionClass()` | `<caption>` | The caption |
