Examples
Basic
| Prop | Default | Type | Description |
|---|---|---|---|
columns | [] | array | Table columns. |
data | [] | array | Table data. |
Preview
Code
Data
| First Name | Last Name | Age | Visits | Status | Profile Progress |
|---|---|---|---|---|---|
| Malika | Murray | 19 | 304 | complicated | 91 |
| Genevieve | Ankunding | 11 | 795 | single | 15 |
| Jodie | Brown | 27 | 773 | complicated | 18 |
| Lily | Dickens | 0 | 115 | single | 19 |
| Simone | Stamm | 30 | 286 | complicated | 74 |
<script setup lang="ts">
import type { ColumnDef } from '@tanstack/vue-table'
import type { Person } from './makeData'
import makeData from './makeData'
const data = ref(makeData(5))
const columns: ColumnDef<Person>[] = [
{
header: 'First Name',
accessorKey: 'firstName',
},
{
header: 'Last Name',
accessorKey: 'lastName',
},
{
header: 'Age',
accessorKey: 'age',
},
{
header: 'Visits',
accessorKey: 'visits',
},
{
header: 'Status',
accessorKey: 'status',
},
{
header: 'Profile Progress',
accessorKey: 'progress',
},
]
</script>
<template>
<NTable
:columns
:data
/>
</template>
makeData.ts
import { faker } from '@faker-js/faker'
export interface Person {
id: string
username: string
email: string
firstName?: string
lastName?: string
avatar?: string
age: number
visits: number
progress: number
status: 'relationship' | 'complicated' | 'single'
subRows?: Person[]
}
function range(len: number) {
const arr: number[] = []
for (let i = 0; i < len; i++)
arr.push(i)
return arr
}
function newPerson(): Person {
return {
id: faker.database.mongodbObjectId(),
username: faker.internet.username(),
email: faker.internet.email(),
firstName: faker.person.firstName(),
lastName: faker.person.lastName(),
avatar: faker.image.avatarGitHub(),
age: faker.number.int(40),
visits: faker.number.int(1000),
progress: faker.number.int(100),
status: faker.helpers.shuffle<Person['status']>([
'relationship',
'complicated',
'single',
])[0]!,
}
}
export function makeData(...lens: number[]) {
const makeDataLevel = (depth = 0): Person[] => {
const len = lens[depth]!
return range(len).map((): Person => {
return {
...newPerson(),
subRows: lens[depth + 1] ? makeDataLevel(depth + 1) : undefined,
}
})
}
return makeDataLevel()
}
export default makeData
Row Selection
Row selection allows you to select rows in the table. This is useful when you want to select rows in the table.
| Prop | Default | Type | Description |
|---|---|---|---|
rowSelection | - | object | Selected row state, can be binded with v-model. |
enableRowSelection | false | boolean | Enable row selection. |
enableMultiRowSelection | true | boolean | Enable multiple row selection. |
rowId | id | string | Row id to uniquely identify each row. |
enableSubRowSelection | false | boolean | Enable sub row selection. |
@select | - | event, row | Emitted when a row is selected. |
@select-all | - | event, rows | Emitted when all rows are selected. |
@row | - | event, row | Emitted when a row is clicked. |
When using the @row event, you should stop propagation if you have interactive elements like buttons or links inside the row to prevent triggering the row click event.
Preview
Code
Data
| First Name | Last Name | Age | Visits | Status | Profile Progress | |
|---|---|---|---|---|---|---|
| Felton | Kutch | 24 | 883 | single | 94 | |
| Kamryn | Pollich | 16 | 367 | relationship | 12 | |
| Emerald | Mohr-Connelly | 2 | 74 | complicated | 32 | |
| Elbert | Rolfson | 28 | 190 | relationship | 29 | |
| Maximillia | O'Connell | 25 | 788 | complicated | 50 | |
| Cleora | Considine | 17 | 611 | relationship | 98 | |
| Eloise | Bins | 11 | 386 | relationship | 11 | |
| Justina | Heidenreich | 37 | 583 | single | 17 | |
| Allie | Kris | 9 | 146 | single | 5 | |
| Alena | Mraz | 12 | 367 | single | 38 | |
of row(s) selected.
<script setup lang="ts">
import type { ColumnDef, RowSelectionState, Table } from '@tanstack/vue-table'
import type { Person } from './makeData'
import makeData from './makeData'
const data = ref(makeData(10))
const columns: ColumnDef<Person>[] = [
{
header: 'First Name',
accessorKey: 'firstName',
},
{
header: 'Last Name',
accessorKey: 'lastName',
},
{
header: 'Age',
accessorKey: 'age',
},
{
header: 'Visits',
accessorKey: 'visits',
},
{
header: 'Status',
accessorKey: 'status',
},
{
header: 'Profile Progress',
accessorKey: 'progress',
},
]
const select = ref<RowSelectionState>()
const table = useTemplateRef<Table<Person>>('table')
</script>
<template>
<div class="flex flex-col space-y-4">
<NTable
ref="table"
v-model:row-selection="select"
:columns
:data
enable-row-selection
/>
<div
class="flex items-center justify-between px-2"
>
<div
class="flex-1 text-sm text-muted"
>
{{ table?.getFilteredSelectedRowModel().rows.length }} of
{{ table?.getFilteredRowModel().rows.length }} row(s) selected.
</div>
</div>
</div>
</template>
makeData.ts
import { faker } from '@faker-js/faker'
export interface Person {
id: string
username: string
email: string
firstName?: string
lastName?: string
avatar?: string
age: number
visits: number
progress: number
status: 'relationship' | 'complicated' | 'single'
subRows?: Person[]
}
function range(len: number) {
const arr: number[] = []
for (let i = 0; i < len; i++)
arr.push(i)
return arr
}
function newPerson(): Person {
return {
id: faker.database.mongodbObjectId(),
username: faker.internet.username(),
email: faker.internet.email(),
firstName: faker.person.firstName(),
lastName: faker.person.lastName(),
avatar: faker.image.avatarGitHub(),
age: faker.number.int(40),
visits: faker.number.int(1000),
progress: faker.number.int(100),
status: faker.helpers.shuffle<Person['status']>([
'relationship',
'complicated',
'single',
])[0]!,
}
}
export function makeData(...lens: number[]) {
const makeDataLevel = (depth = 0): Person[] => {
const len = lens[depth]!
return range(len).map((): Person => {
return {
...newPerson(),
subRows: lens[depth + 1] ? makeDataLevel(depth + 1) : undefined,
}
})
}
return makeDataLevel()
}
export default makeData
Read more in Tanstack Row Selection Documentation
Empty
Empty allows you to show a message when the table is empty. This is useful when you want to show a message when the table is empty.
| Prop | Default | Type | Description |
|---|---|---|---|
empty-text | No results. | string | Empty text. |
empty-icon | i-tabler-database-x | string | Empty icon. |
Preview
Code
Data
| First Name | Last Name | Age | Visits | Status | Profile Progress |
|---|---|---|---|---|---|
No data. | |||||
<script setup lang="ts">
import type { ColumnDef } from '@tanstack/vue-table'
import type { Person } from './makeData'
const data = ref<Person[]>([])
const columns: ColumnDef<Person>[] = [
{
header: 'First Name',
accessorKey: 'firstName',
},
{
header: 'Last Name',
accessorKey: 'lastName',
},
{
header: 'Age',
accessorKey: 'age',
},
{
header: 'Visits',
accessorKey: 'visits',
},
{
header: 'Status',
accessorKey: 'status',
},
{
header: 'Profile Progress',
accessorKey: 'progress',
},
]
</script>
<template>
<div class="flex flex-col space-y-2">
<NTable
:columns
:data
empty-text="No data."
empty-icon="i-lucide-package-x"
/>
</div>
</template>
makeData.ts
import { faker } from '@faker-js/faker'
export interface Person {
id: string
username: string
email: string
firstName?: string
lastName?: string
avatar?: string
age: number
visits: number
progress: number
status: 'relationship' | 'complicated' | 'single'
subRows?: Person[]
}
function range(len: number) {
const arr: number[] = []
for (let i = 0; i < len; i++)
arr.push(i)
return arr
}
function newPerson(): Person {
return {
id: faker.database.mongodbObjectId(),
username: faker.internet.username(),
email: faker.internet.email(),
firstName: faker.person.firstName(),
lastName: faker.person.lastName(),
avatar: faker.image.avatarGitHub(),
age: faker.number.int(40),
visits: faker.number.int(1000),
progress: faker.number.int(100),
status: faker.helpers.shuffle<Person['status']>([
'relationship',
'complicated',
'single',
])[0]!,
}
}
export function makeData(...lens: number[]) {
const makeDataLevel = (depth = 0): Person[] => {
const len = lens[depth]!
return range(len).map((): Person => {
return {
...newPerson(),
subRows: lens[depth + 1] ? makeDataLevel(depth + 1) : undefined,
}
})
}
return makeDataLevel()
}
export default makeData
Loading
Loading allows you to show a loading progress indicator in the table. This is useful when you want to show a loading progress indicator in the table.
| Prop | Default | Type | Description |
|---|---|---|---|
loading | false | boolean | Loading state. |
Preview
Code
Data
| First Name | Last Name | Age | Visits | Status | Profile Progress |
|---|---|---|---|---|---|
| Juwan | Steuber | 37 | 291 | relationship | 81 |
| Madonna | Romaguera | 0 | 293 | complicated | 33 |
| Jewell | Jakubowski | 2 | 292 | single | 100 |
| Floyd | Buckridge | 31 | 410 | single | 97 |
| Dessie | Gleichner | 2 | 57 | single | 59 |
| Giovanni | Rath-Jakubowski | 17 | 299 | relationship | 3 |
| Adaline | Bode | 4 | 545 | relationship | 95 |
| Russell | Stanton | 17 | 920 | single | 42 |
| Jarvis | Hegmann | 8 | 274 | single | 24 |
| Jamil | Roob | 10 | 638 | relationship | 16 |
<script setup lang="ts">
import type { ColumnDef } from '@tanstack/vue-table'
import type { Person } from './makeData'
import makeData from './makeData'
const data = ref(makeData(50))
const columns: ColumnDef<Person>[] = [
{
header: 'First Name',
accessorKey: 'firstName',
},
{
header: 'Last Name',
accessorKey: 'lastName',
},
{
header: 'Age',
accessorKey: 'age',
},
{
header: 'Visits',
accessorKey: 'visits',
},
{
header: 'Status',
accessorKey: 'status',
},
{
header: 'Profile Progress',
accessorKey: 'progress',
},
]
const loading = ref(true)
</script>
<template>
<div class="flex flex-col space-y-2">
<NCheckbox
v-model="loading"
label="Loading"
/>
<NTable
:loading
:columns
:data
/>
</div>
</template>
makeData.ts
import { faker } from '@faker-js/faker'
export interface Person {
id: string
username: string
email: string
firstName?: string
lastName?: string
avatar?: string
age: number
visits: number
progress: number
status: 'relationship' | 'complicated' | 'single'
subRows?: Person[]
}
function range(len: number) {
const arr: number[] = []
for (let i = 0; i < len; i++)
arr.push(i)
return arr
}
function newPerson(): Person {
return {
id: faker.database.mongodbObjectId(),
username: faker.internet.username(),
email: faker.internet.email(),
firstName: faker.person.firstName(),
lastName: faker.person.lastName(),
avatar: faker.image.avatarGitHub(),
age: faker.number.int(40),
visits: faker.number.int(1000),
progress: faker.number.int(100),
status: faker.helpers.shuffle<Person['status']>([
'relationship',
'complicated',
'single',
])[0]!,
}
}
export function makeData(...lens: number[]) {
const makeDataLevel = (depth = 0): Person[] => {
const len = lens[depth]!
return range(len).map((): Person => {
return {
...newPerson(),
subRows: lens[depth + 1] ? makeDataLevel(depth + 1) : undefined,
}
})
}
return makeDataLevel()
}
export default makeData
Read more in Tanstack Loading Documentation
Pagination
Pagination allows you to paginate rows in the table. This is useful when you want to paginate rows in the table.
| Prop | Default | Type | Description |
|---|---|---|---|
pagination | {pageIndex: 0, pageSize: 10} | {pageIndex: Number, pageSize: Number} | Pagination state, can be binded with v-model. |
manualPagination | false | boolean | Enable manual pagination, ideal for server-side pagination. |
Preview
Code
Data
| First Name | Last Name | Age | Visits | Status | Profile Progress |
|---|---|---|---|---|---|
| Darryl | Buckridge | 15 | 138 | complicated | 10 |
| Marquise | Ward | 24 | 51 | complicated | 41 |
| Taurean | Ferry | 29 | 637 | complicated | 81 |
| Candido | Schumm | 16 | 737 | relationship | 70 |
| Thelma | Schmidt | 16 | 8 | relationship | 79 |
Page 1 of
<script setup lang="ts">
import type { ColumnDef, Table } from '@tanstack/vue-table'
import type { Person } from './makeData'
import makeData from './makeData'
const data = ref(makeData(50))
const columns: ColumnDef<Person>[] = [
{
header: 'First Name',
accessorKey: 'firstName',
},
{
header: 'Last Name',
accessorKey: 'lastName',
},
{
header: 'Age',
accessorKey: 'age',
},
{
header: 'Visits',
accessorKey: 'visits',
},
{
header: 'Status',
accessorKey: 'status',
},
{
header: 'Profile Progress',
accessorKey: 'progress',
},
]
const pagination = ref({
pageSize: 5,
pageIndex: 0,
})
const table = useTemplateRef<Table<Person>>('table')
</script>
<template>
<div class="flex flex-col space-y-4">
<!-- table -->
<NTable
ref="table"
:pagination="pagination"
:columns
:data
/>
<!-- pagination -->
<div
class="flex flex-wrap items-center justify-between gap-4 overflow-auto px-2"
>
<div
class="flex items-center justify-center text-sm font-medium"
>
Page {{ (table?.getState().pagination.pageIndex ?? 0) + 1 }} of
{{ table?.getPageCount().toLocaleString() }}
</div>
<NPagination
:page="(table?.getState().pagination.pageIndex ?? 0) + 1"
:total="table?.getFilteredRowModel().rows.length"
show-edges
:items-per-page="table?.getState().pagination.pageSize ?? 5"
@update:page="table?.setPageIndex($event - 1)"
/>
</div>
</div>
</template>
makeData.ts
import { faker } from '@faker-js/faker'
export interface Person {
id: string
username: string
email: string
firstName?: string
lastName?: string
avatar?: string
age: number
visits: number
progress: number
status: 'relationship' | 'complicated' | 'single'
subRows?: Person[]
}
function range(len: number) {
const arr: number[] = []
for (let i = 0; i < len; i++)
arr.push(i)
return arr
}
function newPerson(): Person {
return {
id: faker.database.mongodbObjectId(),
username: faker.internet.username(),
email: faker.internet.email(),
firstName: faker.person.firstName(),
lastName: faker.person.lastName(),
avatar: faker.image.avatarGitHub(),
age: faker.number.int(40),
visits: faker.number.int(1000),
progress: faker.number.int(100),
status: faker.helpers.shuffle<Person['status']>([
'relationship',
'complicated',
'single',
])[0]!,
}
}
export function makeData(...lens: number[]) {
const makeDataLevel = (depth = 0): Person[] => {
const len = lens[depth]!
return range(len).map((): Person => {
return {
...newPerson(),
subRows: lens[depth + 1] ? makeDataLevel(depth + 1) : undefined,
}
})
}
return makeDataLevel()
}
export default makeData
Read more in Pagination Component
Read more in Tanstack Pagination Documentation
Sorting
Sorting allows you to sort columns in ascending or descending order. This is useful when you want to sort columns in the table.
| Prop | Default | Type | Description |
|---|---|---|---|
sorting | - | array | Sorting state, can be binded with v-model. |
enableMultiSort | - | boolean | Enable multi-column sorting |
enableSorting | - | boolean | Enable all column sorting |
column.enableSorting | - | boolean | Enable specific column sorting |
enableSortingRemoval | true | boolean | Enables the ability to remove sorting for the table. |
Preview
Code
Data
| Status | |||||
|---|---|---|---|---|---|
| Maximillia | Larkin | 15 | 971 | relationship | 97 |
| Geovanny | Ward | 27 | 192 | single | 38 |
| Kody | Baumbach | 33 | 237 | relationship | 14 |
| Quinton | Connelly | 0 | 12 | relationship | 30 |
| Maximilian | Murphy | 37 | 205 | single | 30 |
| Gilberto | Herzog | 37 | 464 | relationship | 51 |
| Rey | Kuhlman | 24 | 726 | complicated | 76 |
| Hermina | Baumbach | 15 | 238 | complicated | 11 |
| Chasity | Funk | 9 | 847 | single | 44 |
| Viviane | Kunze | 3 | 548 | single | 32 |
<script setup lang="ts">
import type { ColumnDef } from '@tanstack/vue-table'
import type { Person } from './makeData'
import makeData from './makeData'
const data = ref(makeData(50))
const columns: ColumnDef<Person>[] = [
{
header: 'First Name',
accessorKey: 'firstName',
},
{
header: 'Last Name',
accessorKey: 'lastName',
},
{
header: 'Age',
accessorKey: 'age',
},
{
header: 'Visits',
accessorKey: 'visits',
},
{
header: 'Status',
accessorKey: 'status',
enableSorting: false,
},
{
header: 'Profile Progress',
accessorKey: 'progress',
},
]
</script>
<template>
<NTable
:columns
:data
enable-sorting
enable-multi-sort
/>
</template>
makeData.ts
import { faker } from '@faker-js/faker'
export interface Person {
id: string
username: string
email: string
firstName?: string
lastName?: string
avatar?: string
age: number
visits: number
progress: number
status: 'relationship' | 'complicated' | 'single'
subRows?: Person[]
}
function range(len: number) {
const arr: number[] = []
for (let i = 0; i < len; i++)
arr.push(i)
return arr
}
function newPerson(): Person {
return {
id: faker.database.mongodbObjectId(),
username: faker.internet.username(),
email: faker.internet.email(),
firstName: faker.person.firstName(),
lastName: faker.person.lastName(),
avatar: faker.image.avatarGitHub(),
age: faker.number.int(40),
visits: faker.number.int(1000),
progress: faker.number.int(100),
status: faker.helpers.shuffle<Person['status']>([
'relationship',
'complicated',
'single',
])[0]!,
}
}
export function makeData(...lens: number[]) {
const makeDataLevel = (depth = 0): Person[] => {
const len = lens[depth]!
return range(len).map((): Person => {
return {
...newPerson(),
subRows: lens[depth + 1] ? makeDataLevel(depth + 1) : undefined,
}
})
}
return makeDataLevel()
}
export default makeData
Read more in Tanstack Sorting Documentation
Visibility
Visibility allows you to show or hide columns in the table. This is useful when you want to show or hide columns in the table.
| Prop | Default | Type | Description |
|---|---|---|---|
columnVisibility | - | object | Column visibility state, can be binded with v-model. |
Preview
Code
Data
| First Name | Last Name | Age | Visits | Status | Profile Progress |
|---|---|---|---|---|---|
| Grayson | Anderson | 33 | 149 | single | 87 |
| Landen | Hilll | 31 | 33 | single | 42 |
| Elias | Jaskolski | 2 | 549 | relationship | 48 |
| Cloyd | Treutel | 17 | 917 | single | 82 |
| Audreanne | Leffler | 31 | 358 | relationship | 63 |
<script setup lang="ts">
import type { ColumnDef, Table, VisibilityState } from '@tanstack/vue-table'
import type { Person } from './makeData'
import makeData from './makeData'
const data = ref(makeData(5))
const columns = [
{
header: 'First Name',
accessorKey: 'firstName',
},
{
header: 'Last Name',
accessorKey: 'lastName',
},
{
header: 'Age',
accessorKey: 'age',
},
{
header: 'Visits',
accessorKey: 'visits',
},
{
header: 'Status',
accessorKey: 'status',
},
{
header: 'Profile Progress',
accessorKey: 'progress',
},
] satisfies ColumnDef<Person>[]
const table = useTemplateRef<Table<Person>>('table')
const columnVisibility = ref<VisibilityState>({})
</script>
<template>
<div>
<div class="flex flex-wrap gap-4">
<NCheckbox
v-for="tableColumn in table?.getAllLeafColumns()"
:key="tableColumn.id"
:model-value="tableColumn.getIsVisible()"
:label="tableColumn.id"
@update:model-value="tableColumn.toggleVisibility()"
/>
</div>
<NSeparator />
<NTable
ref="table"
:column-visibility="columnVisibility"
:columns
:data
/>
</div>
</template>
makeData.ts
import { faker } from '@faker-js/faker'
export interface Person {
id: string
username: string
email: string
firstName?: string
lastName?: string
avatar?: string
age: number
visits: number
progress: number
status: 'relationship' | 'complicated' | 'single'
subRows?: Person[]
}
function range(len: number) {
const arr: number[] = []
for (let i = 0; i < len; i++)
arr.push(i)
return arr
}
function newPerson(): Person {
return {
id: faker.database.mongodbObjectId(),
username: faker.internet.username(),
email: faker.internet.email(),
firstName: faker.person.firstName(),
lastName: faker.person.lastName(),
avatar: faker.image.avatarGitHub(),
age: faker.number.int(40),
visits: faker.number.int(1000),
progress: faker.number.int(100),
status: faker.helpers.shuffle<Person['status']>([
'relationship',
'complicated',
'single',
])[0]!,
}
}
export function makeData(...lens: number[]) {
const makeDataLevel = (depth = 0): Person[] => {
const len = lens[depth]!
return range(len).map((): Person => {
return {
...newPerson(),
subRows: lens[depth + 1] ? makeDataLevel(depth + 1) : undefined,
}
})
}
return makeDataLevel()
}
export default makeData
Read more in Tanstack Visibility Documentation
Global Filtering
Global filtering allows you to filter rows based on the value entered in the filter input. This is useful when you want to filter rows in the table.
| Prop | Default | Type | Description |
|---|---|---|---|
globalFilter | - | string | Global filter state, can be binded with v-model. |
manualFiltering | - | boolean | Enable manual filtering. Ideal for server-side filtering. |
Preview
Code
Data
| First Name | Last Name | Age | Visits | Status | Profile Progress |
|---|---|---|---|---|---|
| Scot | Beahan | 39 | 347 | single | 46 |
| Milan | Dickinson | 14 | 991 | complicated | 40 |
| Floy | McLaughlin | 26 | 364 | single | 49 |
| Patsy | Pollich-Bergstrom | 21 | 91 | single | 15 |
| Thea | Hessel | 32 | 378 | complicated | 86 |
| Mckayla | Kassulke | 0 | 498 | single | 51 |
| Gilda | Schaden | 4 | 216 | relationship | 81 |
| Vito | Murazik | 33 | 823 | complicated | 25 |
| Ila | Nolan | 12 | 773 | complicated | 57 |
| Arnold | Romaguera | 10 | 8 | complicated | 20 |
<script setup lang="ts">
import type { ColumnDef } from '@tanstack/vue-table'
import type { Person } from './makeData'
import makeData from './makeData'
const data = ref(makeData(10))
const columns: ColumnDef<Person>[] = [
{
header: 'First Name',
accessorKey: 'firstName',
},
{
header: 'Last Name',
accessorKey: 'lastName',
},
{
header: 'Age',
accessorKey: 'age',
},
{
header: 'Visits',
accessorKey: 'visits',
},
{
header: 'Status',
accessorKey: 'status',
},
{
header: 'Profile Progress',
accessorKey: 'progress',
},
]
const search = ref('')
</script>
<template>
<div class="flex flex-col space-y-4">
<div class="flex flex-wrap items-center justify-between gap-4">
<NInput
v-model="search"
placeholder="Search"
:una="{
inputWrapper: 'w-full md:w-80',
}"
/>
<NButton
label="Add new"
disabled
leading="i-radix-icons-plus"
class="w-full md:w-auto"
/>
</div>
<NTable
:columns
:global-filter="search"
:data
/>
</div>
</template>
makeData.ts
import { faker } from '@faker-js/faker'
export interface Person {
id: string
username: string
email: string
firstName?: string
lastName?: string
avatar?: string
age: number
visits: number
progress: number
status: 'relationship' | 'complicated' | 'single'
subRows?: Person[]
}
function range(len: number) {
const arr: number[] = []
for (let i = 0; i < len; i++)
arr.push(i)
return arr
}
function newPerson(): Person {
return {
id: faker.database.mongodbObjectId(),
username: faker.internet.username(),
email: faker.internet.email(),
firstName: faker.person.firstName(),
lastName: faker.person.lastName(),
avatar: faker.image.avatarGitHub(),
age: faker.number.int(40),
visits: faker.number.int(1000),
progress: faker.number.int(100),
status: faker.helpers.shuffle<Person['status']>([
'relationship',
'complicated',
'single',
])[0]!,
}
}
export function makeData(...lens: number[]) {
const makeDataLevel = (depth = 0): Person[] => {
const len = lens[depth]!
return range(len).map((): Person => {
return {
...newPerson(),
subRows: lens[depth + 1] ? makeDataLevel(depth + 1) : undefined,
}
})
}
return makeDataLevel()
}
export default makeData
Read more in Tanstack Global Filtering Documentation
Column Filtering
Column filtering allows you to filter columns based on the value entered in the filter input. This is useful when you want to filter columns in the table.
| Prop | Default | Type | Description |
|---|---|---|---|
columnFilters | - | array | Column filter state, can be binded with v-model. |
enableColumnFilter | - | boolean | Enable all column filtering |
column.enableColumnFilter | - | boolean | Enable specific column filtering |
Preview
Code
Data
| First Name | Last Name | Age | Visits | Status | Profile Progress |
|---|---|---|---|---|---|
| Kaya | Rodriguez | 10 | 140 | complicated | 92 |
| Reina | Larkin | 17 | 766 | complicated | 41 |
| Micheal | Beahan | 28 | 863 | single | 62 |
| Shane | Lindgren | 0 | 236 | complicated | 5 |
| Ayden | Flatley | 3 | 808 | relationship | 85 |
<script setup lang="ts">
import type { ColumnDef } from '@tanstack/vue-table'
import type { Person } from './makeData'
import makeData from './makeData'
const data = ref(makeData(5))
const columns: ColumnDef<Person>[] = [
{
header: 'First Name',
accessorKey: 'firstName',
},
{
header: 'Last Name',
accessorKey: 'lastName',
},
{
header: 'Age',
accessorKey: 'age',
},
{
header: 'Visits',
accessorKey: 'visits',
enableColumnFilter: false,
},
{
header: 'Status',
accessorKey: 'status',
},
{
header: 'Profile Progress',
accessorKey: 'progress',
},
]
</script>
<template>
<NTable
:columns
enable-column-filters
:data
/>
</template>
makeData.ts
import { faker } from '@faker-js/faker'
export interface Person {
id: string
username: string
email: string
firstName?: string
lastName?: string
avatar?: string
age: number
visits: number
progress: number
status: 'relationship' | 'complicated' | 'single'
subRows?: Person[]
}
function range(len: number) {
const arr: number[] = []
for (let i = 0; i < len; i++)
arr.push(i)
return arr
}
function newPerson(): Person {
return {
id: faker.database.mongodbObjectId(),
username: faker.internet.username(),
email: faker.internet.email(),
firstName: faker.person.firstName(),
lastName: faker.person.lastName(),
avatar: faker.image.avatarGitHub(),
age: faker.number.int(40),
visits: faker.number.int(1000),
progress: faker.number.int(100),
status: faker.helpers.shuffle<Person['status']>([
'relationship',
'complicated',
'single',
])[0]!,
}
}
export function makeData(...lens: number[]) {
const makeDataLevel = (depth = 0): Person[] => {
const len = lens[depth]!
return range(len).map((): Person => {
return {
...newPerson(),
subRows: lens[depth + 1] ? makeDataLevel(depth + 1) : undefined,
}
})
}
return makeDataLevel()
}
export default makeData
Read more in Tanstack Column Filtering Documentation
Column Ordering
Column ordering allows you to reorder columns by dragging and dropping them. This is useful when you want to change the order of columns in the table.
| Prop | Default | Type | Description |
|---|---|---|---|
columnOrder | - | array | Column order state, can be binded with v-model. |
Preview
Code
Data
| First Name | Last Name | Age | Visits | Status | Profile Progress |
|---|---|---|---|---|---|
| Afton | Hirthe | 18 | 171 | single | 85 |
| Emmy | McClure | 33 | 584 | single | 94 |
| Chasity | Franey | 33 | 491 | complicated | 31 |
| Rosario | Connelly | 3 | 823 | relationship | 58 |
| Jody | Tremblay | 35 | 393 | relationship | 51 |
<script setup lang="ts">
import type { ColumnDef, Table } from '@tanstack/vue-table'
import type { Person } from './makeData'
import { faker } from '@faker-js/faker'
import makeData from './makeData'
const data = ref(makeData(5))
const columns: ColumnDef<Person>[] = [
{
header: 'First Name',
accessorKey: 'firstName',
},
{
header: 'Last Name',
accessorKey: 'lastName',
},
{
header: () => 'Age',
accessorKey: 'age',
},
{
header: 'Visits',
accessorKey: 'visits',
},
{
header: 'Status',
accessorKey: 'status',
},
{
header: 'Profile Progress',
accessorKey: 'progress',
},
]
const table = useTemplateRef<Table<Person>>('table')
function randomizeColumns() {
table.value?.setColumnOrder(faker.helpers.shuffle(table.value?.getAllLeafColumns().map(d => d.id)))
}
</script>
<template>
<div class="flex justify-end">
<NButton
label="Randomize columns"
class="mb-4"
@click="randomizeColumns"
/>
</div>
<!-- table -->
<NTable
ref="table"
:columns
:data
/>
</template>
makeData.ts
import { faker } from '@faker-js/faker'
export interface Person {
id: string
username: string
email: string
firstName?: string
lastName?: string
avatar?: string
age: number
visits: number
progress: number
status: 'relationship' | 'complicated' | 'single'
subRows?: Person[]
}
function range(len: number) {
const arr: number[] = []
for (let i = 0; i < len; i++)
arr.push(i)
return arr
}
function newPerson(): Person {
return {
id: faker.database.mongodbObjectId(),
username: faker.internet.username(),
email: faker.internet.email(),
firstName: faker.person.firstName(),
lastName: faker.person.lastName(),
avatar: faker.image.avatarGitHub(),
age: faker.number.int(40),
visits: faker.number.int(1000),
progress: faker.number.int(100),
status: faker.helpers.shuffle<Person['status']>([
'relationship',
'complicated',
'single',
])[0]!,
}
}
export function makeData(...lens: number[]) {
const makeDataLevel = (depth = 0): Person[] => {
const len = lens[depth]!
return range(len).map((): Person => {
return {
...newPerson(),
subRows: lens[depth + 1] ? makeDataLevel(depth + 1) : undefined,
}
})
}
return makeDataLevel()
}
export default makeData
Read more in Tanstack Column Ordering Documentation
Column Pinning
Column pinning allows you to pin columns to the left or right of the table. This is useful when you have a large number of columns and you want to keep some columns in view while scrolling.
| Prop | Default | Type | Description |
|---|---|---|---|
columnPinning | - | { left: array, right: array } | Column pinning state, can be binded with v-model. |
Preview
Code
Data
| Status | First Name | Last Name | Age | Visits | Profile Progress |
|---|---|---|---|---|---|
| single | Ernest | Weissnat | 34 | 187 | 49 |
| complicated | Queenie | Grant | 6 | 96 | 80 |
| complicated | Jaylan | Stroman | 3 | 307 | 28 |
| complicated | Darrion | McLaughlin | 20 | 214 | 48 |
| complicated | Dorthy | Runolfsdottir | 21 | 656 | 0 |
<script setup lang="ts">
import type { ColumnDef } from '@tanstack/vue-table'
import type { Person } from './makeData'
import makeData from './makeData'
const data = ref(makeData(5))
const columns: ColumnDef<Person>[] = [
{
header: 'First Name',
accessorKey: 'firstName',
},
{
header: 'Last Name',
accessorKey: 'lastName',
},
{
header: () => 'Age',
accessorKey: 'age',
},
{
header: 'Visits',
accessorKey: 'visits',
},
{
header: 'Status',
accessorKey: 'status',
},
{
header: 'Profile Progress',
accessorKey: 'progress',
},
]
</script>
<template>
<NTable
:columns
:data
:column-pinning="{
left: ['status'],
right: ['priority'],
}"
/>
</template>
makeData.ts
import { faker } from '@faker-js/faker'
export interface Person {
id: string
username: string
email: string
firstName?: string
lastName?: string
avatar?: string
age: number
visits: number
progress: number
status: 'relationship' | 'complicated' | 'single'
subRows?: Person[]
}
function range(len: number) {
const arr: number[] = []
for (let i = 0; i < len; i++)
arr.push(i)
return arr
}
function newPerson(): Person {
return {
id: faker.database.mongodbObjectId(),
username: faker.internet.username(),
email: faker.internet.email(),
firstName: faker.person.firstName(),
lastName: faker.person.lastName(),
avatar: faker.image.avatarGitHub(),
age: faker.number.int(40),
visits: faker.number.int(1000),
progress: faker.number.int(100),
status: faker.helpers.shuffle<Person['status']>([
'relationship',
'complicated',
'single',
])[0]!,
}
}
export function makeData(...lens: number[]) {
const makeDataLevel = (depth = 0): Person[] => {
const len = lens[depth]!
return range(len).map((): Person => {
return {
...newPerson(),
subRows: lens[depth + 1] ? makeDataLevel(depth + 1) : undefined,
}
})
}
return makeDataLevel()
}
export default makeData
Read more in Tanstack Column Pinning Documentation
Expanding
Expanding allows you to expand rows to show additional information. This is useful when you want to show additional information about a row.
| Prop | Default | Type | Description |
|---|---|---|---|
expanded | - | array | Expanded state, can be binded with v-model. |
Preview
Code
Data
| First Name | Last Name | Age | Visits | Status | Profile Progress | |
|---|---|---|---|---|---|---|
| Mittie | Maggio | 11 | 206 | single | 83 | |
| Sammy | Feeney | 8 | 338 | single | 74 | |
| Jerrold | Bruen | 11 | 762 | relationship | 99 | |
| Lavinia | Cormier | 20 | 323 | complicated | 43 | |
| Greta | Schroeder | 22 | 249 | relationship | 88 | |
<script setup lang="ts">
import type { ColumnDef } from '@tanstack/vue-table'
import type { Person } from './makeData'
import makeData from './makeData'
const data = ref(makeData(5))
const columns: ColumnDef<Person>[] = [
{
header: 'First Name',
accessorKey: 'firstName',
},
{
header: 'Last Name',
accessorKey: 'lastName',
},
{
header: 'Age',
accessorKey: 'age',
},
{
header: 'Visits',
accessorKey: 'visits',
},
{
header: 'Status',
accessorKey: 'status',
},
{
header: 'Profile Progress',
accessorKey: 'progress',
},
]
const expanded = ref<Record<string, boolean>>({})
</script>
<template>
<NTable
v-model:expanded="expanded"
:columns
:data
>
<template #expanded="{ row }">
<div class="p-4">
<p class="text-sm text-muted">
Object:
</p>
<p class="text-base">
{{ row }}
</p>
</div>
</template>
</NTable>
</template>
makeData.ts
import { faker } from '@faker-js/faker'
export interface Person {
id: string
username: string
email: string
firstName?: string
lastName?: string
avatar?: string
age: number
visits: number
progress: number
status: 'relationship' | 'complicated' | 'single'
subRows?: Person[]
}
function range(len: number) {
const arr: number[] = []
for (let i = 0; i < len; i++)
arr.push(i)
return arr
}
function newPerson(): Person {
return {
id: faker.database.mongodbObjectId(),
username: faker.internet.username(),
email: faker.internet.email(),
firstName: faker.person.firstName(),
lastName: faker.person.lastName(),
avatar: faker.image.avatarGitHub(),
age: faker.number.int(40),
visits: faker.number.int(1000),
progress: faker.number.int(100),
status: faker.helpers.shuffle<Person['status']>([
'relationship',
'complicated',
'single',
])[0]!,
}
}
export function makeData(...lens: number[]) {
const makeDataLevel = (depth = 0): Person[] => {
const len = lens[depth]!
return range(len).map((): Person => {
return {
...newPerson(),
subRows: lens[depth + 1] ? makeDataLevel(depth + 1) : undefined,
}
})
}
return makeDataLevel()
}
export default makeData
Read more in Tanstack Expanding Documentation
Grouping
Grouping allows you to group rows based on a column value. This is useful when you want to group rows in the table.
| Prop | Default | Type | Description |
|---|---|---|---|
grouping | - | array | Grouping state, can be binded with v-model. |
manualGrouping | - | boolean | Enable manual grouping. |
Preview
Code
Data
| Info | Name | Info | |||
|---|---|---|---|---|---|
| Status | Progress | First Name | Last Name | Age | Visits |
| complicated | 4 | Herbert | Bogan | 28 | 55 |
| complicated | 19 | Rosalinda | Dietrich | 5 | 621 |
| relationship | 2 | Lucie | Wiegand | 37 | 964 |
| single | 23 | Wyman | Rath | 27 | 269 |
| single | 87 | Marjory | Murazik | 14 | 607 |
<script setup lang="ts">
import type { ColumnDef } from '@tanstack/vue-table'
import type { Person } from './makeData'
import { makeData } from './makeData'
const data = ref(makeData(5))
const columns: ColumnDef<Person>[] = [
{
header: 'Name',
enableSorting: false,
columns: [
{
header: 'First Name',
accessorKey: 'firstName',
},
{
header: 'Last Name',
accessorKey: 'lastName',
},
],
},
{
header: 'Info',
columns: [
{
header: () => 'Age',
accessorKey: 'age',
},
{
header: 'Visits',
accessorKey: 'visits',
},
{
header: 'Status',
accessorKey: 'status',
},
{
header: 'Progress',
accessorKey: 'progress',
},
],
},
]
const grouping = ref([
'status',
'progress',
'firstName',
'lastName',
'age',
'visits',
])
</script>
<template>
<NTable
v-model:grouping="grouping"
manual-grouping
:columns
:data
/>
</template>
makeData.ts
import { faker } from '@faker-js/faker'
export interface Person {
id: string
username: string
email: string
firstName?: string
lastName?: string
avatar?: string
age: number
visits: number
progress: number
status: 'relationship' | 'complicated' | 'single'
subRows?: Person[]
}
function range(len: number) {
const arr: number[] = []
for (let i = 0; i < len; i++)
arr.push(i)
return arr
}
function newPerson(): Person {
return {
id: faker.database.mongodbObjectId(),
username: faker.internet.username(),
email: faker.internet.email(),
firstName: faker.person.firstName(),
lastName: faker.person.lastName(),
avatar: faker.image.avatarGitHub(),
age: faker.number.int(40),
visits: faker.number.int(1000),
progress: faker.number.int(100),
status: faker.helpers.shuffle<Person['status']>([
'relationship',
'complicated',
'single',
])[0]!,
}
}
export function makeData(...lens: number[]) {
const makeDataLevel = (depth = 0): Person[] => {
const len = lens[depth]!
return range(len).map((): Person => {
return {
...newPerson(),
subRows: lens[depth + 1] ? makeDataLevel(depth + 1) : undefined,
}
})
}
return makeDataLevel()
}
export default makeData
Read more in Tanstack Grouping Documentation
Server-side
Allows you to fetch data from the server. This is useful when you want to fetch data from the server.
Preview
Code
Data
| Name | Url |
|---|---|
| bulbasaur | https://pokeapi.co/api/v2/pokemon/1/ |
| ivysaur | https://pokeapi.co/api/v2/pokemon/2/ |
| venusaur | https://pokeapi.co/api/v2/pokemon/3/ |
| charmander | https://pokeapi.co/api/v2/pokemon/4/ |
| charmeleon | https://pokeapi.co/api/v2/pokemon/5/ |
Rows per page
Page 1 of 261
<script setup lang="ts">
import type { ColumnDef, Table } from '@tanstack/vue-table'
interface Pokemon {
name: string
url: string
}
interface ResourceMeta {
count: number
next: string | null
previous: string | null
results: Pokemon[]
}
const pagination = ref({
pageSize: 5,
pageIndex: 0,
})
const endpoint = computed (() => {
const { pageSize, pageIndex } = pagination.value
return `https://pokeapi.co/api/v2/pokemon?limit=${pageSize}&offset=${pageSize * pageIndex}`
})
const { data: resource, refresh, status } = await useLazyFetch<ResourceMeta>(endpoint)
const data = computed(() => {
return resource.value?.results ?? []
})
const columns = ref<ColumnDef<Pokemon>[]>([
{
header: 'Name',
accessorKey: 'name',
},
{
header: 'Url',
accessorKey: 'url',
},
])
const pageCount = computed(() => {
const { pageSize } = pagination.value
return Math.ceil((resource.value?.count || 0) / pageSize)
})
const table = useTemplateRef<Table<Pokemon>>('table')
</script>
<template>
<div class="flex flex-col space-y-4">
<!-- header -->
<div class="flex flex-col justify-between gap-4 sm:flex-row sm:items-center">
<div class="flex items-center gap-x-2 sm:ml-auto">
<NButton
:loading="status === 'pending'"
@click="refresh()"
>
Reload
</NButton>
</div>
</div>
<!-- table -->
<NTable
ref="table"
v-model:pagination="pagination"
manual-pagination
:columns
:loading="status === 'pending'"
:page-count
:data
/>
<!-- footer -->
<div
class="flex items-center justify-end px-2"
>
<div class="flex items-center justify-between space-x-6 lg:space-x-8">
<div
class="hidden items-center justify-center text-sm font-medium sm:flex space-x-2"
>
<span class="text-nowrap">
Rows per page
</span>
<NSelect
:items="[5, 10, 20, 30, 40, 50]"
:_select-trigger="{
class: 'w-15',
}"
:model-value="table?.getState().pagination.pageSize"
@update:model-value="table?.setPageSize($event as unknown as number)"
/>
</div>
<div
class="flex items-center justify-center text-sm font-medium"
>
Page {{ (table?.getState().pagination.pageIndex ?? 0) + 1 }} of {{ pageCount }}
</div>
<NPagination
:page="(table?.getState().pagination.pageIndex ?? 0) + 1"
:total="pageCount * pagination.pageSize"
:show-list-item="false"
:items-per-page="table?.getState().pagination.pageSize ?? 5"
@update:page="table?.setPageIndex($event - 1)"
/>
</div>
</div>
</div>
</template>
makeData.ts
import { faker } from '@faker-js/faker'
export interface Person {
id: string
username: string
email: string
firstName?: string
lastName?: string
avatar?: string
age: number
visits: number
progress: number
status: 'relationship' | 'complicated' | 'single'
subRows?: Person[]
}
function range(len: number) {
const arr: number[] = []
for (let i = 0; i < len; i++)
arr.push(i)
return arr
}
function newPerson(): Person {
return {
id: faker.database.mongodbObjectId(),
username: faker.internet.username(),
email: faker.internet.email(),
firstName: faker.person.firstName(),
lastName: faker.person.lastName(),
avatar: faker.image.avatarGitHub(),
age: faker.number.int(40),
visits: faker.number.int(1000),
progress: faker.number.int(100),
status: faker.helpers.shuffle<Person['status']>([
'relationship',
'complicated',
'single',
])[0]!,
}
}
export function makeData(...lens: number[]) {
const makeDataLevel = (depth = 0): Person[] => {
const len = lens[depth]!
return range(len).map((): Person => {
return {
...newPerson(),
subRows: lens[depth + 1] ? makeDataLevel(depth + 1) : undefined,
}
})
}
return makeDataLevel()
}
export default makeData
Read more in Tanstack Table Serve-Side Documentation
Customization
Configure the progress using the una prop and utility classes.
| Prop | Default | Type | Description |
|---|---|---|---|
columns.meta.una | {} | object | Column Una meta data. |
una | {} | object | Global Una attribute. |
Read more in Component Props API
Read more in Component Presets
Preview
Code
Data
| First Name | Last Name | Age | Visits | Status | Profile Progress |
|---|---|---|---|---|---|
| Amina | Schimmel | 16 | 336 | single | 69 |
| Lew | Adams | 20 | 206 | relationship | 88 |
| Tremayne | D'Amore | 36 | 100 | relationship | 32 |
| Osborne | Skiles | 28 | 435 | complicated | 99 |
| Marietta | Nicolas | 7 | 641 | relationship | 32 |
<script setup lang="ts">
import type { ColumnDef } from '@tanstack/vue-table'
import type { Person } from './makeData'
import makeData from './makeData'
const data = ref(makeData(5))
const columns: ColumnDef<Person>[] = [
{
header: 'First Name',
accessorKey: 'firstName',
meta: {
una: {
tableHead: 'text-left bg-primary-700 text-white',
tableCell: 'text-left bg-primary-700 text-white',
},
},
},
{
header: 'Last Name',
accessorKey: 'lastName',
meta: {
una: {
tableHead: 'text-left bg-primary-700 text-white',
tableCell: 'text-left bg-primary-700 text-white',
},
},
},
{
header: 'Age',
accessorKey: 'age',
meta: {
una: {
tableHead: 'text-center',
tableCell: 'text-center',
},
},
},
{
header: 'Visits',
accessorKey: 'visits',
},
{
header: 'Status',
accessorKey: 'status',
},
{
header: 'Profile Progress',
accessorKey: 'progress',
},
]
</script>
<template>
<NTable
:columns
:data
:column-pinning="{
left: ['firstName', 'lastName'],
}"
:una="{
tableHead: 'text-right',
tableCell: 'text-right',
}"
/>
</template>
makeData.ts
import { faker } from '@faker-js/faker'
export interface Person {
id: string
username: string
email: string
firstName?: string
lastName?: string
avatar?: string
age: number
visits: number
progress: number
status: 'relationship' | 'complicated' | 'single'
subRows?: Person[]
}
function range(len: number) {
const arr: number[] = []
for (let i = 0; i < len; i++)
arr.push(i)
return arr
}
function newPerson(): Person {
return {
id: faker.database.mongodbObjectId(),
username: faker.internet.username(),
email: faker.internet.email(),
firstName: faker.person.firstName(),
lastName: faker.person.lastName(),
avatar: faker.image.avatarGitHub(),
age: faker.number.int(40),
visits: faker.number.int(1000),
progress: faker.number.int(100),
status: faker.helpers.shuffle<Person['status']>([
'relationship',
'complicated',
'single',
])[0]!,
}
}
export function makeData(...lens: number[]) {
const makeDataLevel = (depth = 0): Person[] => {
const len = lens[depth]!
return range(len).map((): Person => {
return {
...newPerson(),
subRows: lens[depth + 1] ? makeDataLevel(depth + 1) : undefined,
}
})
}
return makeDataLevel()
}
export default makeData
Slots
| Name | Props | Description |
|---|---|---|
{column}-filter | column | Column filter slot. |
{column}-header | column | Column header slot. |
{column}-cell | cell | Column cell slot. |
{column}-footer | column | Column footer slot. |
header | table | Header slot. |
body | table | Body slot. |
raw | row | Row slot. |
footer | table | Footer slot. |
expanded | row | Expanded slot. |
empty | - | Empty slot. |
loading | - | Loading slot. |
Preview
Code
Data
| Account | |||||
|---|---|---|---|---|---|
 GGGunner Graham Forest55@hotmail.com | Gunner | Graham | complicated | 51% | |
 FBFanny Baumbach Sasha26@gmail.com | Fanny | Baumbach | relationship | 30% | |
 FKFritz Kirlin Dusty.Lubowitz49@yahoo.com | Fritz | Kirlin | single | 30% | |
 PYPearlie Yundt Bernhard_Rogahn98@gmail.com | Pearlie | Yundt | single | 90% | |
 TJTorrey Jones Randi_Schiller88@hotmail.com | Torrey | Jones | single | 94% | |
 KDKeeley Dietrich Dangelo_Lakin17@hotmail.com | Keeley | Dietrich | relationship | 98% | |
 DBDaniella Beer Keaton_Heathcote@yahoo.com | Daniella | Beer | single | 45% | |
 MGMarc Glover Emely_Gleason7@yahoo.com | Marc | Glover | relationship | 44% | |
 SKSadye Kuphal Ulices_Gottlieb@yahoo.com | Sadye | Kuphal | complicated | 25% | |
 CHChesley Huels Kenya15@gmail.com | Chesley | Huels | single | 42% | |
of row(s) selected.
Rows per page
Page 1 of
<script setup lang="ts">
import type { ColumnDef, RowSelectionState, Table } from '@tanstack/vue-table'
import type { Person } from './makeData'
import { NAvatar } from '#components'
import { faker } from '@faker-js/faker'
import makeData from './makeData'
const data = ref(makeData(50))
const columns: ColumnDef<Person>[] = [
{
header: 'Account',
accessorKey: 'account',
accessorFn: (row) => {
return {
fullname: `${row.firstName} ${row.lastName}`,
avatar: faker.image.avatar(),
email: row.email,
}
},
// you can customize the cell renderer like this as an alternative to slot 😉
cell: (info: any) => {
const fullname = info.getValue().fullname
return h('div', {
class: 'flex items-center',
}, [
h(NAvatar, {
src: info.getValue().avatar,
alt: fullname,
}),
[
h('div', {
class: 'ml-2',
}, [
h('div', {
class: 'text-sm font-semibold leading-none',
}, fullname),
h('span', {
class: 'text-sm text-muted',
}, info.getValue().email),
]),
],
])
},
enableSorting: false,
enableColumnFilter: false,
},
{
header: 'First Name',
accessorKey: 'firstName',
},
{
header: 'Last Name',
accessorKey: 'lastName',
},
{
header: 'Status',
accessorKey: 'status',
},
{
header: 'Progress',
accessorKey: 'progress',
},
]
const search = ref('')
const select = ref<RowSelectionState>()
const table = useTemplateRef<Table<Person>>('table')
</script>
<template>
<div class="flex flex-col space-y-4">
<!-- header -->
<div class="flex flex-col justify-between gap-4 sm:flex-row sm:items-center">
<NInput
v-model="search"
leading="i-radix-icons-magnifying-glass"
placeholder="Search"
:una="{
inputWrapper: 'w-full md:w-80',
}"
/>
<div class="flex items-center gap-x-2 sm:ml-auto">
<NButton
label="Rerender"
btn="solid-gray"
leading="i-radix-icons-update"
class="w-full sm:w-auto sm:shrink-0 active:translate-y-0.5"
@click="data = makeData(20_000)"
/>
<NButton
label="Add 1000"
btn="solid-primary"
leading="i-radix-icons-plus"
class="w-full sm:w-auto sm:shrink-0 active:translate-y-0.5"
@click="data = [...makeData(1_000), ...data]"
/>
</div>
</div>
<!-- table -->
<NTable
ref="table"
v-model:row-selection="select"
:columns
:data
:global-filter="search"
enable-row-selection enable-column-filters enable-sorting
row-id="username"
>
<!-- filters -->
<template #status-filter="{ column }">
<NSelect
:items="['Relationship', 'Complicated', 'Single']"
placeholder="All"
:model-value="column.getFilterValue()"
@update:model-value="column?.setFilterValue($event)"
/>
</template>
<template #progress-filter="{ column }">
<div class="flex items-center space-x-2">
<NInput
type="number"
placeholder="min"
:model-value="column.getFilterValue()?.[0] ?? ''"
@update:model-value="column?.setFilterValue((old: [number, number]) => [
$event,
old?.[1],
])"
/>
<NInput
type="number"
placeholder="max"
:model-value="column.getFilterValue()?.[1] ?? ''"
@update:model-value="column?.setFilterValue((old: [number, number]) => [
old?.[0],
$event,
])"
/>
</div>
</template>
<!-- end filter -->
<!-- cells -->
<template #status-cell="{ cell }">
<NBadge
:una="{
badgeDefaultVariant: cell.row.original.status === 'relationship'
? 'badge-soft-success' : cell.row.original.status === 'single'
? 'badge-soft-info' : 'badge-soft-warning' }"
class="capitalize"
:label="cell.row.original.status"
/>
</template>
<template #progress-cell="{ cell }">
<div class="flex items-center">
<NProgress
:model-value="cell.row.original.progress"
:una="{
progressRoot: cell.row.original.progress >= 85
? 'progress-success' : cell.row.original.progress >= 70
? 'progress-info' : cell.row.original.progress >= 55
? 'progress-warning' : 'progress-error' }"
/>
<span class="ml-2 text-sm text-muted">{{ cell.row.original.progress }}%</span>
</div>
</template>
<!-- end cell -->
</NTable>
<!-- footer -->
<div
class="flex items-center justify-between px-2"
>
<div
class="hidden text-sm text-muted sm:block"
>
{{ table?.getFilteredSelectedRowModel().rows.length.toLocaleString() }} of
{{ table?.getFilteredRowModel().rows.length.toLocaleString() }} row(s) selected.
</div>
<div class="flex items-center space-x-6 lg:space-x-8">
<div
class="hidden items-center justify-center text-sm font-medium sm:flex space-x-2"
>
<span class="text-nowrap">
Rows per page
</span>
<NSelect
:items="[10, 20, 30, 40, 50]"
:_select-trigger="{
class: 'w-15',
}"
:model-value="table?.getState().pagination.pageSize"
@update:model-value="table?.setPageSize($event as unknown as number)"
/>
</div>
<div
class="flex items-center justify-center text-sm font-medium"
>
Page {{ (table?.getState().pagination.pageIndex ?? 0) + 1 }} of
{{ table?.getPageCount().toLocaleString() }}
</div>
<NPagination
:page="(table?.getState().pagination.pageIndex ?? 0) + 1"
:total="table?.getFilteredRowModel().rows.length"
:show-list-item="false"
:items-per-page="table?.getState().pagination.pageSize ?? 5"
@update:page="table?.setPageIndex($event - 1)"
/>
</div>
</div>
</div>
</template>
makeData.ts
import { faker } from '@faker-js/faker'
export interface Person {
id: string
username: string
email: string
firstName?: string
lastName?: string
avatar?: string
age: number
visits: number
progress: number
status: 'relationship' | 'complicated' | 'single'
subRows?: Person[]
}
function range(len: number) {
const arr: number[] = []
for (let i = 0; i < len; i++)
arr.push(i)
return arr
}
function newPerson(): Person {
return {
id: faker.database.mongodbObjectId(),
username: faker.internet.username(),
email: faker.internet.email(),
firstName: faker.person.firstName(),
lastName: faker.person.lastName(),
avatar: faker.image.avatarGitHub(),
age: faker.number.int(40),
visits: faker.number.int(1000),
progress: faker.number.int(100),
status: faker.helpers.shuffle<Person['status']>([
'relationship',
'complicated',
'single',
])[0]!,
}
}
export function makeData(...lens: number[]) {
const makeDataLevel = (depth = 0): Person[] => {
const len = lens[depth]!
return range(len).map((): Person => {
return {
...newPerson(),
subRows: lens[depth + 1] ? makeDataLevel(depth + 1) : undefined,
}
})
}
return makeDataLevel()
}
export default makeData
Presets
shortcuts/table.ts
type TablePrefix = 'table'
export const staticTable: Record<`${TablePrefix}-${string}` | TablePrefix, string> = {
// config
'table-default-variant': 'table-solid-gray',
// table-root
'table-root': 'relative w-full overflow-x-auto overflow-y-hidden border border-base rounded-md',
'table': 'w-full caption-bottom text-sm',
'table-body': '[&_tr:last-child]:border-0',
'table-caption': 'mt-4 text-sm text-muted',
// table-head
'table-head': 'h-12 px-4 text-left align-middle font-medium text-muted [&:has([role=checkbox])]:pr-0 [&>[role=checkbox]]:translate-y-0.5',
'table-head-pinned': 'sticky bg-base',
'table-head-pinned-left': 'left-0',
'table-head-pinned-right': 'right-0',
// table-header
'table-header': '[&_tr]:border-b [&_tr]:border-base',
// table-row
'table-row': 'border-b border-base transition-colors hover:bg-muted data-[filter=true]:hover:bg-base data-[state=selected]:bg-muted',
// table-cell
'table-cell': 'p-4 align-middle [&:has([role=checkbox])]:pr-0 [&>[role=checkbox]]:translate-y-0.5',
'table-cell-pinned': 'sticky bg-base',
'table-cell-pinned-left': 'left-0',
'table-cell-pinned-right': 'right-0',
// table-empty
'table-empty-row': '',
'table-empty-cell': 'p-4 whitespace-nowrap align-middle text-sm text-muted bg-base',
'table-empty': 'flex items-center flex-col justify-center py-10 gap-4',
'table-empty-text': 'text-center text-wrap',
'table-empty-icon-name': 'i-tabler-database-x size-2xl',
// table-loading
'table-loading-icon': 'animate-spin text-lg', // TODO: to add
'table-loading-icon-name': 'i-lucide-refresh-ccw', // TODO: to add
'table-loading-row': 'data-[loading=true]:border-0 absolute inset-x-0 -mt-1.5px',
'table-loading-cell': '',
'table-loading': 'absolute inset-x-0 overflow-hidden p-0',
// table-footer
'table-footer': 'border-t border-base bg-muted font-medium [&>tr]:last:border-b-0',
}
export const dynamicTable: [RegExp, (params: RegExpExecArray) => string][] = [
]
export const table = [
...dynamicTable,
staticTable,
]
Props
types/table.ts
import type {
ColumnDef,
CoreOptions,
GroupColumnDef,
} from '@tanstack/vue-table'
import type { PrimitiveProps } from 'reka-ui'
import type { HTMLAttributes } from 'vue'
import type { NProgressProps } from './progress'
import type { NScrollAreaProps, NScrollAreaUnaProps } from './scroll-area'
export interface NTableProps<TData, TValue> extends Omit<CoreOptions<TData>, 'data' | 'columns' | 'getCoreRowModel' | 'state' | 'onStateChange' | 'renderFallbackValue'>, Pick<NTableEmptyProps, 'emptyText' | 'emptyIcon'> {
class?: HTMLAttributes['class']
/**
* @see https://tanstack.com/table/latest/docs/api/core/table#state
*/
state?: CoreOptions<TData>['state']
/**
* @see https://tanstack.com/table/latest/docs/api/core/table#onstatechange
*/
onStateChange?: CoreOptions<TData>['onStateChange']
/**
* @see https://tanstack.com/table/latest/docs/api/core/table#renderfallbackvalue
*/
renderFallbackValue?: CoreOptions<TData>['renderFallbackValue']
/**
* @see https://tanstack.com/table/latest/docs/guide/data
*/
data: TData[]
/**
* @see https://tanstack.com/table/latest/docs/api/core/column
*/
columns: ColumnDef<TData, TValue>[] | GroupColumnDef<TData, TValue>[]
/**
* @see https://tanstack.com/table/latest/docs/api/core/table#getrowid
*/
rowId?: string
/**
* @see https://tanstack.com/table/latest/docs/api/core/table#autoresetall
*/
autoResetAll?: boolean
/**
* @see https://tanstack.com/table/latest/docs/api/features/row-selection#enablerowselection
*/
enableRowSelection?: boolean
/**
* @see https://tanstack.com/table/latest/docs/api/features/row-selection#enablemultirowselection
*/
enableMultiRowSelection?: boolean
/**
* @see https://tanstack.com/table/latest/docs/api/features/row-selection#enablesubrowselection
*/
enableSubRowSelection?: boolean
/**
* @see https://tanstack.com/table/latest/docs/api/features/column-filtering#enablecolumnfilters
*/
enableColumnFilters?: boolean
/**
* @see https://tanstack.com/table/latest/docs/api/features/column-filtering#manualfiltering
*/
manualFiltering?: boolean
/**
* @see https://tanstack.com/table/latest/docs/api/features/sorting#enablesorting
*/
enableSorting?: boolean
/**
* @see https://tanstack.com/table/latest/docs/api/features/sorting#enablemultisort
*/
enableMultiSort?: boolean
/**
* @see https://tanstack.com/table/latest/docs/api/features/sorting#enablemultiremove
*/
enableMultiRemove?: boolean
/**
* @see https://tanstack.com/table/latest/docs/api/features/sorting#enablesortingremoval
*/
enableSortingRemoval?: boolean
/**
* @see https://tanstack.com/table/latest/docs/api/features/sorting#manualsorting
*/
manualSorting?: boolean
/**
* @see https://tanstack.com/table/latest/docs/api/features/sorting#maxmultisortcolcount
*/
maxMultiSortColCount?: number
/**
* @see https://tanstack.com/table/latest/docs/api/features/pagination#manualpagination
*/
manualPagination?: boolean
/**
* @see https://tanstack.com/table/latest/docs/api/features/pagination#pagecount
*/
pageCount?: number
/**
* @see https://tanstack.com/table/latest/docs/api/features/pagination#rowcount
*/
rowCount?: number
/**
* @see https://tanstack.com/table/latest/docs/api/features/pagination#autoresetpageindex
*/
autoResetPageIndex?: boolean
/**
* @see https://tanstack.com/table/latest/docs/api/features/sorting#sortingfns
*/
sortingFns?: Record<string, (a: any, b: any) => number>
/**
* @see https://tanstack.com/table/latest/docs/api/features/sorting#sortdescfirst-1
*/
sortDescFirst?: boolean
/**
* @see https://tanstack.com/table/latest/docs/api/features/sorting#ismultisortevent
*/
isMultiSortEvent?: (e: unknown) => boolean
// sub-components props
_tableHead?: NTableHeadProps
_tableHeader?: NTableHeaderProps
_tableFooter?: NTableFooterProps
_tableBody?: NTableBodyProps
_tableCaption?: NTableCaptionProps
_tableRow?: NTableRowProps | ((row?: TData) => NTableRowProps)
_tableCell?: NTableCellProps
_tableEmpty?: NTableEmptyProps
_tableLoading?: NTableLoadingProps
_scrollArea?: NScrollAreaProps
/**
* Whether the table is loading.
*/
loading?: boolean
/**
* `UnaUI` preset configuration
*
* @see https://github.com/una-ui/una-ui/blob/main/packages/preset/src/_shortcuts/table.ts
*/
una?: NTableUnaProps & NScrollAreaUnaProps
}
export interface NTableBodyProps extends PrimitiveProps {
[key: string]: any
class?: HTMLAttributes['class']
una?: Pick<NTableUnaProps, 'tableBody'>
}
export interface NTableHeadProps extends PrimitiveProps {
[key: string]: any
class?: HTMLAttributes['class']
dataPinned?: 'left' | 'right' | false
una?: Pick<NTableUnaProps, 'tableHead'>
}
export interface NTableHeaderProps extends PrimitiveProps {
[key: string]: any
class?: HTMLAttributes['class']
una?: Pick<NTableUnaProps, 'tableHeader'>
}
export interface NTableFooterProps extends PrimitiveProps {
[key: string]: any
class?: HTMLAttributes['class']
una?: Pick<NTableUnaProps, 'tableFooter'>
}
export interface NTableRowProps extends PrimitiveProps {
[key: string]: any
class?: HTMLAttributes['class']
una?: Pick<NTableUnaProps, 'tableRow'>
}
export interface NTableCellProps extends PrimitiveProps {
[key: string]: any
class?: HTMLAttributes['class']
dataPinned?: 'left' | 'right' | false
una?: Pick<NTableUnaProps, 'tableCell'>
}
export interface NTableEmptyProps {
[key: string]: any
class?: HTMLAttributes['class']
colspan?: number
/**
* The text to display when the table is empty.
*/
emptyText?: string
/**
* The icon to display when the table is empty.
*/
emptyIcon?: string
_tableCell?: NTableCellProps
_tableRow?: NTableRowProps
una?: Pick<NTableUnaProps, 'tableEmpty' | 'tableRow' | 'tableCell' | 'tableEmptyText' | 'tableEmptyIcon'>
}
export interface NTableLoadingProps {
[key: string]: any
size?: HTMLAttributes['class']
enabled?: boolean
class?: HTMLAttributes['class']
colspan?: number
_tableCell?: NTableCellProps
_tableRow?: NTableRowProps
_tableProgress?: NProgressProps
una?: Pick<NTableUnaProps, 'tableLoading' | 'tableLoadingCell' | 'tableLoadingRow'>
}
export interface NTableCaptionProps extends PrimitiveProps {
[key: string]: any
class?: HTMLAttributes['class']
una?: Pick<NTableUnaProps, 'tableCaption'>
}
interface NTableUnaProps {
table?: HTMLAttributes['class']
tableRoot?: HTMLAttributes['class']
tableBody?: HTMLAttributes['class']
tableHead?: HTMLAttributes['class']
tableHeader?: HTMLAttributes['class']
tableFooter?: HTMLAttributes['class']
tableRow?: HTMLAttributes['class']
tableCell?: HTMLAttributes['class']
tableCaption?: HTMLAttributes['class']
tableLoading?: HTMLAttributes['class']
tableLoadingRow?: HTMLAttributes['class']
tableLoadingCell?: HTMLAttributes['class']
tableEmpty?: HTMLAttributes['class']
tableEmptyText?: HTMLAttributes['class']
tableEmptyIcon?: HTMLAttributes['class']
}
Components
Table.vue
TableRoot.vue
TableHeader.vue
TableHead.vue
TableBody.vue
TableFooter.vue
TableCell.vue
TableRow.vue
TableEmpty.vue
TableLoading.vue
TableCaption.vue
<script setup lang="ts" generic="TData, TValue">
import type {
ColumnFiltersState,
ColumnOrderState,
ColumnPinningState,
ExpandedState,
GroupingState,
Header,
PaginationState,
Row,
RowSelectionState,
SortingState,
Table,
VisibilityState,
} from '@tanstack/vue-table'
import type { NTableProps } from '../../../types'
import {
FlexRender,
getCoreRowModel,
getExpandedRowModel,
getFilteredRowModel,
getPaginationRowModel,
getSortedRowModel,
useVueTable,
} from '@tanstack/vue-table'
import { computed, h } from 'vue'
import { cn, valueUpdater } from '../../../utils'
import Button from '../../elements/Button.vue'
import Checkbox from '../../forms/Checkbox.vue'
import Input from '../../forms/Input.vue'
import ScrollArea from '../../scroll-area/ScrollArea.vue'
import TableBody from './TableBody.vue'
import TableCell from './TableCell.vue'
import TableEmpty from './TableEmpty.vue'
import TableFooter from './TableFooter.vue'
import TableHead from './TableHead.vue'
import TableHeader from './TableHeader.vue'
import TableLoading from './TableLoading.vue'
import TableRow from './TableRow.vue'
const props = withDefaults(defineProps <NTableProps<TData, TValue>>(), {
enableMultiRowSelection: true,
enableSortingRemoval: true,
})
const emit = defineEmits<{
select: [row: TData]
selectAll: [rows: TData[]]
expand: [row: TData]
row: [event: Event, row: TData]
}>()
const slots = defineSlots()
const rowSelection = defineModel<RowSelectionState>('rowSelection')
const sorting = defineModel<SortingState>('sorting')
const columnVisibility = defineModel<VisibilityState>('columnVisibility')
const columnFilters = defineModel<ColumnFiltersState>('columnFilters')
const globalFilter = defineModel<string>('globalFilter')
const columnOrder = defineModel<ColumnOrderState>('columnOrder')
const columnPinning = defineModel<ColumnPinningState>('columnPinning')
const expanded = defineModel<ExpandedState>('expanded')
const grouping = defineModel<GroupingState>('grouping')
const pagination = defineModel<PaginationState>('pagination', {
default: () => ({
pageIndex: 0,
pageSize: 10,
}),
})
const columnsWithMisc = computed(() => {
let data = []
// add selection column
data = props.enableRowSelection
? [
{
accessorKey: 'selection',
header: props.enableMultiRowSelection
? ({ table }: { table: Table<TData> }) => h(Checkbox, {
'modelValue': table.getIsAllPageRowsSelected() || (table.getIsSomePageRowsSelected() && 'indeterminate'),
'onUpdate:modelValue': (value: boolean | 'indeterminate' | null) => {
table.toggleAllPageRowsSelected(!!value)
emit('selectAll', table.getRowModel().rows.map(row => row.original))
},
'areaLabel': 'Select all rows',
'onClick': (event: Event) => {
event.stopPropagation()
},
})
: '',
cell: ({ row }: { row: Row<TData> }) => h(Checkbox, {
'modelValue': row.getIsSelected() ?? false,
'onUpdate:modelValue': (value: boolean | 'indeterminate' | null) => {
row.toggleSelected(!!value)
emit('select', row.original)
},
'areaLabel': 'Select row',
'onClick': (event: Event) => {
event.stopPropagation()
},
}),
enableSorting: false,
},
...props.columns,
]
: props.columns
// add expanded column
data = slots.expanded
? [
{
accessorKey: 'expanded',
header: '',
cell: ({ row }: any) => h(Button, {
size: 'xs',
icon: true,
square: true,
btn: 'ghost-gray',
label: 'i-radix-icons-chevron-down',
onClick: () => {
row.toggleExpanded()
emit('expand', row)
},
una: {
btnIconLabel: cn(
'transform transition-transform duration-200',
row.getIsExpanded() ? '-rotate-180' : 'rotate-0',
),
},
}),
enableSorting: false,
enableHiding: false,
},
...data,
]
: data
return data
})
const table = useVueTable({
get data() {
return props.data ?? []
},
get columns() {
return columnsWithMisc.value ?? []
},
state: {
get sorting() { return sorting.value },
get columnFilters() { return columnFilters.value },
get globalFilter() { return globalFilter.value },
get rowSelection() { return rowSelection.value },
get columnVisibility() { return columnVisibility.value },
get pagination() { return pagination.value },
get columnOrder() { return columnOrder.value },
get columnPinning() { return columnPinning.value },
get expanded() { return expanded.value },
get grouping() { return grouping.value },
},
enableMultiRowSelection: props.enableMultiRowSelection,
enableSubRowSelection: props.enableSubRowSelection,
autoResetAll: props.autoResetAll,
enableRowSelection: props.enableRowSelection,
enableColumnFilters: props.enableColumnFilters,
manualPagination: props.manualPagination,
manualSorting: props.manualSorting,
manualFiltering: props.manualFiltering,
pageCount: props.pageCount,
rowCount: props.rowCount,
autoResetPageIndex: props.autoResetPageIndex,
enableSorting: props.enableSorting,
enableSortingRemoval: props.enableSortingRemoval,
enableMultiSort: props.enableMultiSort,
enableMultiRemove: props.enableMultiRemove,
maxMultiSortColCount: props.maxMultiSortColCount,
sortingFns: props.sortingFns,
isMultiSortEvent: props.isMultiSortEvent,
getCoreRowModel: getCoreRowModel(),
getSortedRowModel: getSortedRowModel(),
getFilteredRowModel: getFilteredRowModel(),
getPaginationRowModel: getPaginationRowModel(),
getRowId: (row: any) => props.rowId ? row[props.rowId] : row.id,
getSubRows: (row: any) => row.subRows,
getExpandedRowModel: getExpandedRowModel(),
onSortingChange: updaterOrValue => valueUpdater(updaterOrValue, sorting),
onRowSelectionChange: updaterOrValue => valueUpdater(updaterOrValue, rowSelection),
onColumnVisibilityChange: updaterOrValue => valueUpdater(updaterOrValue, columnVisibility),
onColumnFiltersChange: updaterOrValue => valueUpdater(updaterOrValue, columnFilters),
onGlobalFilterChange: updaterOrValue => valueUpdater(updaterOrValue, globalFilter),
onPaginationChange: updaterOrValue => valueUpdater(updaterOrValue, pagination),
onColumnOrderChange: updaterOrValue => valueUpdater(updaterOrValue, columnOrder),
onColumnPinningChange: updaterOrValue => valueUpdater(updaterOrValue, columnPinning),
onExpandedChange: updaterOrValue => valueUpdater(updaterOrValue, expanded),
onGroupingChange: updaterOrValue => valueUpdater(updaterOrValue, grouping),
})
function getHeaderColumnFiltersCount(headers: Header<unknown, unknown>[]): number {
let count = 0
headers.forEach((header) => {
if (header.column.columnDef.enableColumnFilter)
count++
})
return count
}
function getRowAttrs(data?: TData) {
if (typeof props._tableRow === 'function') {
return props._tableRow(data)
}
return props._tableRow
}
defineExpose({
...table,
})
</script>
<template>
<div
:class="cn('table-root', props.una?.tableRoot)"
>
<ScrollArea
orientation="horizontal"
v-bind="props._scrollArea"
:una
>
<table
v-bind="$attrs"
:class="cn(
'table',
props.una?.table,
props.class,
)"
>
<!-- header -->
<TableHeader
:una
v-bind="props._tableHeader"
>
<slot name="header" :table="table">
<TableRow
v-for="headerGroup in table.getHeaderGroups()"
:key="headerGroup.id"
:una
v-bind="getRowAttrs()"
>
<!-- headers -->
<TableHead
v-for="header in headerGroup.headers"
:key="header.id"
:colspan="header.colSpan"
:data-pinned="header.column.getIsPinned()"
:una
v-bind="{ ...props._tableHead, ...header.column.columnDef.meta }"
>
<Button
v-if="header.column.columnDef.enableSorting || (header.column.columnDef.enableSorting !== false && enableSorting)"
btn="ghost-gray"
size="sm"
class="font-normal -ml-1em"
:una="{
btnTrailing: 'text-sm',
}"
:trailing="header.column.getIsSorted() === 'asc'
? 'i-lucide-arrow-up-wide-narrow' : header.column.getIsSorted() === 'desc'
? 'i-lucide-arrow-down-narrow-wide' : 'i-lucide-arrow-up-down'"
@click="header.column.getToggleSortingHandler()?.($event)"
>
<slot
:name="`${header.id}-header`"
:column="header.column"
>
<FlexRender
v-if="!header.isPlaceholder"
:render="header.column.columnDef.header"
:props="header.getContext()"
/>
</slot>
</Button>
<slot
v-else
:name="`${header.id}-header`"
:column="header.column"
>
<FlexRender
v-if="!header.isPlaceholder"
:render="header.column.columnDef.header"
:props="header.getContext()"
/>
</slot>
</TableHead>
</TableRow>
<!-- column filters -->
<template
v-for="headerGroup in table.getHeaderGroups()"
:key="headerGroup.id"
>
<TableRow
v-if="getHeaderColumnFiltersCount(headerGroup.headers) > 0 || enableColumnFilters"
data-filter="true"
:una
v-bind="getRowAttrs()"
>
<TableHead
v-for="header in headerGroup.headers"
:key="header.id"
:una
:colspan="header.colSpan"
class="font-normal"
:data-pinned="header.column.getIsPinned()"
v-bind="{ ...props._tableHead, ...header.column.columnDef.meta }"
>
<slot
v-if="header.id !== 'selection' && ((header.column.columnDef.enableColumnFilter !== false && enableColumnFilters) || header.column.columnDef.enableColumnFilter)"
:name="`${header.id}-filter`"
:column="header.column"
>
<Input
class="w-auto"
:model-value="header.column.getFilterValue() as string"
:placeholder="header.column.columnDef.header"
@update:model-value="header.column.setFilterValue($event)"
/>
</slot>
</TableHead>
</TableRow>
</template>
</slot>
<TableLoading
:enabled="props.loading"
:una
v-bind="props._tableLoading"
>
<slot name="loading" />
</TableLoading>
</TableHeader>
<!-- body -->
<TableBody
:una
v-bind="props._tableBody"
>
<slot name="body" :table="table">
<template v-if="table.getRowModel().rows?.length">
<template
v-for="row in table.getRowModel().rows"
:key="row.id"
>
<TableRow
:data-state="row.getIsSelected() && 'selected'"
:una
v-bind="getRowAttrs(row.original)"
@click="emit('row', $event, row.original)"
>
<slot
name="row"
:row="row"
>
<!-- rows -->
<TableCell
v-for="cell in row.getVisibleCells()"
:key="cell.id"
:data-pinned="cell.column.getIsPinned()"
:una
v-bind="{ ...props._tableCell, ...cell.column.columnDef.meta }"
>
<slot
:name="`${cell.column.id}-cell`"
:cell="cell"
>
<FlexRender
:render="cell.column.columnDef.cell"
:props="cell.getContext()"
/>
</slot>
</TableCell>
</slot>
</TableRow>
<!-- expanded -->
<TableRow
v-if="row.getIsExpanded() && $slots.expanded"
:una
v-bind="getRowAttrs(row.original)"
>
<TableCell
:colspan="row.getAllCells().length"
:una
v-bind="props._tableCell"
>
<slot name="expanded" :row="row" />
</TableCell>
</TableRow>
</template>
</template>
<TableEmpty
v-else
:colspan="table.getAllLeafColumns().length"
:una
:empty-text="props.emptyText"
:empty-icon="props.emptyIcon"
v-bind="props._tableEmpty"
>
<slot name="empty" />
</TableEmpty>
</slot>
</TableBody>
<!-- footer -->
<TableFooter
v-if="table.getFooterGroups().length > 0"
:una
v-bind="props._tableFooter"
>
<slot name="footer" :table="table">
<template
v-for="footerGroup in table.getFooterGroups()"
:key="footerGroup.id"
>
<TableRow
v-if="footerGroup.headers.length > 0"
:una
v-bind="getRowAttrs()"
>
<template
v-for="header in footerGroup.headers"
:key="header.id"
>
<TableHead
v-if="header.column.columnDef.footer"
:colspan="header.colSpan"
:una
v-bind="{ ...props._tableHead, ...header.column.columnDef.meta }"
>
<slot :name="`${header.id}-footer`" :column="header.column">
<FlexRender
v-if="!header.isPlaceholder"
:render="header.column.columnDef.footer"
:props="header.getContext()"
/>
</slot>
</TableHead>
</template>
</TableRow>
</template>
</slot>
</TableFooter>
</table>
</ScrollArea>
</div>
</template>
🔴 ../packages/nuxt/src/runtime/components/data/table/TableRoot.vue | Snippet does not exist 🔴
<script setup lang="ts">
import type { NTableHeaderProps } from '../../../types'
import { reactiveOmit } from '@vueuse/core'
import { Primitive } from 'reka-ui'
import { cn } from '../../../utils'
const props = withDefaults(defineProps<NTableHeaderProps>(), {
as: 'thead',
})
const rootProps = reactiveOmit(props, ['una', 'class'])
</script>
<template>
<Primitive
:class="cn(
'table-header',
props?.una?.tableHeader,
props.class,
)"
v-bind="{ ...rootProps, ...$attrs }"
>
<slot />
</Primitive>
</template>
<script setup lang="ts">
import type { NTableHeadProps } from '../../../types'
import { reactiveOmit } from '@vueuse/core'
import { Primitive } from 'reka-ui'
import { cn } from '../../../utils'
const props = withDefaults(defineProps<NTableHeadProps>(), {
as: 'th',
})
const rootProps = reactiveOmit(props, ['una', 'class'])
</script>
<template>
<Primitive
:class="cn(
'table-head',
props.una?.tableHead,
props.class,
{ 'table-head-pinned': props.dataPinned },
props.dataPinned === 'left' ? 'table-head-pinned-left' : 'table-head-pinned-right',
)"
v-bind="{ ...rootProps, ...$attrs }"
>
<slot />
</Primitive>
</template>
<script setup lang="ts">
import type { NTableBodyProps } from '../../../types'
import { reactiveOmit } from '@vueuse/core'
import { Primitive } from 'reka-ui'
import { cn } from '../../../utils'
const props = withDefaults(defineProps<NTableBodyProps>(), {
as: 'tbody',
})
const rootProps = reactiveOmit(props, ['una', 'class'])
</script>
<template>
<Primitive
:class="cn(
'table-body',
props?.una?.tableBody,
props.class,
)"
v-bind="{ ...rootProps, ...$attrs }"
>
<slot />
</Primitive>
</template>
<script setup lang="ts">
import type { NTableFooterProps } from '../../../types'
import { reactiveOmit } from '@vueuse/core'
import { Primitive } from 'reka-ui'
import { cn } from '../../../utils'
const props = withDefaults(defineProps<NTableFooterProps>(), {
as: 'tfoot',
})
const rootProps = reactiveOmit(props, ['una', 'class'])
</script>
<template>
<Primitive
:class="cn(
'table-footer',
props.una?.tableFooter,
props.class,
)"
v-bind="{ ...rootProps, ...$attrs }"
>
<slot />
</Primitive>
</template>
<script setup lang="ts">
import type { NTableCellProps } from '../../../types'
import { reactiveOmit } from '@vueuse/core'
import { Primitive } from 'reka-ui'
import { cn } from '../../../utils'
const props = withDefaults(defineProps<NTableCellProps>(), {
as: 'td',
})
const rootProps = reactiveOmit(props, ['una', 'class'])
</script>
<template>
<Primitive
:class="
cn(
'table-cell',
props?.una?.tableCell,
props.class,
{ 'table-cell-pinned': dataPinned },
dataPinned === 'left' ? 'table-cell-pinned-left' : 'table-cell-pinned-right',
)
"
v-bind="{ ...rootProps, ...$attrs }"
>
<slot />
</Primitive>
</template>
<script setup lang="ts">
import type { NTableRowProps } from '../../../types'
import { reactiveOmit } from '@vueuse/core'
import { Primitive } from 'reka-ui'
import { cn } from '../../../utils'
const props = withDefaults(defineProps<NTableRowProps>(), {
as: 'tr',
})
const rootProps = reactiveOmit(props, ['una', 'class'])
</script>
<template>
<Primitive
role="row"
:class="cn(
'table-row',
props.una?.tableRow,
props.class,
)"
v-bind="{ ...rootProps, ...$attrs }"
>
<slot />
</Primitive>
</template>
<style>
/* the builtin unocss utility is overwritten, so it has to be defined here */
.table-row {
display: table-row;
}
</style>
<script setup lang="ts">
import type { NTableEmptyProps } from '../../../types'
import { reactiveOmit } from '@vueuse/core'
import { cn, omitProps } from '../../../utils'
import TableCell from './TableCell.vue'
import TableRow from './TableRow.vue'
const props = withDefaults(defineProps<NTableEmptyProps>(), {
colspan: 1,
emptyText: 'No results.',
emptyIcon: 'table-empty-icon-name',
})
const delegatedProps = reactiveOmit(props, ['class'])
</script>
<template>
<TableRow
:class="cn(
'table-empty-row',
props.una?.tableRow,
)"
v-bind="delegatedProps._tableRow"
>
<TableCell
:class="
cn(
'table-empty-cell',
props.una?.tableCell,
)
"
:colspan="props.colspan"
v-bind="delegatedProps._tableCell"
>
<div
:class="cn(
'table-empty',
props.una?.tableEmpty,
props.class,
)"
v-bind="omitProps(delegatedProps, ['_tableRow', '_tableCell', 'colspan'])"
>
<slot>
<NIcon
:name="props.emptyIcon"
:class="cn(
'table-empty-icon',
props.una?.tableEmptyIcon,
)"
/>
<span
:class="cn(
'table-empty-text',
props.una?.tableEmptyText,
)"
>
{{ props.emptyText }}
</span>
</slot>
</div>
</TableCell>
</TableRow>
</template>
<script setup lang="ts">
import type { NTableLoadingProps } from '../../../types'
import { reactiveOmit } from '@vueuse/core'
import { cn } from '../../../utils'
import Progress from '../../elements/Progress.vue'
import TableRow from './TableRow.vue'
const props = withDefaults(defineProps<NTableLoadingProps>(), {
size: '2.5px',
})
const delegatedProps = reactiveOmit(props, ['class'])
</script>
<template>
<TableRow
:class="cn(
'table-loading-row',
props.una?.tableLoadingRow,
)"
data-loading="true"
v-bind="delegatedProps._tableRow"
>
<td
:class="
cn(
'table-loading-cell',
props.una?.tableLoadingCell,
)
"
:colspan="0"
v-bind="delegatedProps._tableCell"
>
<div
v-if="enabled"
:class="cn(
'table-loading',
props.una?.tableLoading,
)"
>
<slot>
<Progress
:size
v-bind="props._tableProgress"
:class="cn(
props._tableProgress?.class,
)"
/>
</slot>
</div>
</td>
</TableRow>
</template>
<script setup lang="ts">
import type { NTableCaptionProps } from '../../../types'
import { reactiveOmit } from '@vueuse/core'
import { Primitive } from 'reka-ui'
import { cn } from '../../../utils'
const props = withDefaults(defineProps<NTableCaptionProps>(), {
as: 'caption',
})
const rootProps = reactiveOmit(props, ['una', 'class'])
</script>
<template>
<Primitive
:class="cn(
'table-caption',
props?.una?.tableCaption,
props.class,
)"
v-bind="{ ...rootProps, ...$attrs } "
>
<slot />
</Primitive>
</template>
On This Page