Kurs Next.js · Moduł 9: Integracje i zaawansowane funkcje
Next.js z TanStack Table - Zaawansowane tabele danych
W tej lekcji11
Panel strażników Metropolii Quantum pokazuje tysiące rekordów: użytkowników, role, statusy. Zwykły element table z pętlą map wystarcza przez tydzień, a potem ktoś prosi o sortowanie, wyszukiwarkę, paginację i zaznaczanie wielu wierszy naraz. Pisanie tego ręcznie to setki linii kruchej logiki. Matrix, architekt danych Metropolii, rozwiązuje to TanStack Table - biblioteką, która liczy logikę tabeli, a wygląd zostawia Tobie.
Czym jest TanStack Table?
TanStack Table (wcześniej React Table) to headless biblioteka do budowania tabel, która oferuje:
- Headless UI - pełna kontrola nad wyglądem
- TypeScript-first - pełne wsparcie typowania
- Framework agnostic - działa z React, Vue, Svelte
- Feature-rich - sortowanie, filtrowanie, paginacja, grouping
- Performance - optymalizacje dla dużych zbiorów danych
- Extensible - bogaty system pluginów
"Headless" oznacza, że biblioteka nie renderuje żadnego HTML-a. Dostajesz API ze stanem i metodami, a znaczniki i style piszesz sam.
Zalety TanStack Table
- Brak zależności UI - żadnych gotowych komponentów ani stylów
- Tree-shakable - tylko potrzebne funkcje w bundlu
- Server-side support - idealny dla SSR/SSG
- Accessibility - dostępność zależy od Twojego HTML-a, bo to Ty go piszesz
- Mobile-friendly - responsywne tabele
Czego TanStack Table NIE robi: nie pobiera danych i nie ma wbudowanej wirtualizacji. Dane dostarczasz sam (np. przez TanStack Query), a wirtualizację długich list zapewnia osobna biblioteka TanStack Virtual.
Instalacja i podstawowa konfiguracja
Instalacja
W projekcie React instalujesz adapter @tanstack/react-table, który zawiera już rdzeń biblioteki:
# Zainstaluj TanStack Table
npm install @tanstack/react-table
# Rdzeń niezależny od frameworka (react-table instaluje go automatycznie)
npm install @tanstack/table-corePakiet @tanstack/table-core to rdzeń niezależny od frameworka. Adapter React instaluje go automatycznie, więc osobna instalacja jest opcjonalna.
Podstawowa tabela
Każda tabela zaczyna się od typu danych. Interfejs User opisuje jeden wiersz, a unie literałów, jak 'admin' | 'user' | 'moderator', ograniczają dozwolone wartości:
// types/User.ts
export interface User {
id: string;
name: string;
email: string;
role: 'admin' | 'user' | 'moderator';
status: 'active' | 'inactive' | 'pending';
createdAt: string;
lastLogin?: string;
}Na tej podstawie TypeScript podpowie nazwy kolumn i złapie literówki w kluczach.
Teraz definiujemy kolumny. Funkcja createColumnHelper<User>() tworzy pomocnika, którego metoda accessor wskazuje pole obiektu, a cell decyduje, jak wyrenderować wartość:
// components/UsersTable.tsx
'use client';
import {
createColumnHelper,
flexRender,
getCoreRowModel,
useReactTable,
} from '@tanstack/react-table';
import { User } from '@/types/User';
const columnHelper = createColumnHelper<User>();
const columns = [
columnHelper.accessor('name', {
header: 'Nazwa użytkownika',
cell: (info) => info.getValue(),
}),
columnHelper.accessor('email', {
header: 'Email',
cell: (info) => (
<a href={`mailto:${info.getValue()}`} className="text-blue-600 hover:underline">
{info.getValue()}
</a>
),
}),
columnHelper.accessor('role', {
header: 'Rola',
cell: (info) => {
const role = info.getValue();
const roleColors = {
admin: 'bg-red-100 text-red-800',
moderator: 'bg-yellow-100 text-yellow-800',
user: 'bg-green-100 text-green-800',
};
return (
<span className={`px-2 py-1 rounded-full text-xs font-medium ${roleColors[role]}`}>
{role}
</span>
);
},
}),
columnHelper.accessor('status', {
header: 'Status',
cell: (info) => {
const status = info.getValue();
const statusColors = {
active: 'bg-green-100 text-green-800',
inactive: 'bg-gray-100 text-gray-800',
pending: 'bg-yellow-100 text-yellow-800',
};
return (
<span className={`px-2 py-1 rounded-full text-xs font-medium ${statusColors[status]}`}>
{status}
</span>
);
},
}),
columnHelper.accessor('createdAt', {
header: 'Data utworzenia',
cell: (info) => new Date(info.getValue()).toLocaleDateString('pl-PL'),
}),
];
Kolumny to zwykła tablica konfiguracji, jeszcze bez żadnej tabeli. Rola i status dostają kolorowe etykiety, a data jest formatowana dla polskiej lokalizacji.
Komponent łączy dane z kolumnami hookiem useReactTable. Minimalna konfiguracja to data, columns i getCoreRowModel, czyli podstawowy model wierszy:
interface UsersTableProps {
data: User[];
}
export default function UsersTable({ data }: UsersTableProps) {
const table = useReactTable({
data,
columns,
getCoreRowModel: getCoreRowModel(),
});
return (
<div className="overflow-x-auto">
<table className="min-w-full bg-white border border-gray-200">
<thead className="bg-gray-50">
{table.getHeaderGroups().map((headerGroup) => (
<tr key={headerGroup.id}>
{headerGroup.headers.map((header) => (
<th
key={header.id}
className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider"
>
{header.isPlaceholder
? null
: flexRender(header.column.columnDef.header, header.getContext())}
</th>
))}
</tr>
))}
</thead>
<tbody className="bg-white divide-y divide-gray-200">
{table.getRowModel().rows.map((row) => (
<tr key={row.id} className="hover:bg-gray-50">
{row.getVisibleCells().map((cell) => (
<td key={cell.id} className="px-6 py-4 whitespace-nowrap text-sm text-gray-900">
{flexRender(cell.column.columnDef.cell, cell.getContext())}
</td>
))}
</tr>
))}
</tbody>
</table>
</div>
);
}flexRender renderuje nagłówek lub komórkę niezależnie od tego, czy w definicji jest tekst, czy funkcja. Cały HTML i klasy Tailwind są nasze: biblioteka dała tylko grupy nagłówków i wiersze.
Sortowanie i filtrowanie
Sortowanie
Każda funkcja tabeli działa według tego samego schematu: stan w useState, podpięcie go przez state i on...Change oraz dodanie odpowiedniego modelu wierszy. Dla sortowania to SortingState i getSortedRowModel:
// components/SortableUsersTable.tsx
'use client';
import {
createColumnHelper,
flexRender,
getCoreRowModel,
getSortedRowModel,
SortingState,
useReactTable,
} from '@tanstack/react-table';
import { useState } from 'react';
import { ChevronUpIcon, ChevronDownIcon } from '@heroicons/react/24/outline';
import { User } from '@/types/User';
const columnHelper = createColumnHelper<User>();
const columns = [
columnHelper.accessor('name', {
header: 'Nazwa użytkownika',
enableSorting: true,
}),
columnHelper.accessor('email', {
header: 'Email',
enableSorting: true,
}),
columnHelper.accessor('role', {
header: 'Rola',
enableSorting: true,
}),
columnHelper.accessor('status', {
header: 'Status',
enableSorting: true,
}),
columnHelper.accessor('createdAt', {
header: 'Data utworzenia',
enableSorting: true,
sortingFn: 'datetime',
cell: (info) => new Date(info.getValue()).toLocaleDateString('pl-PL'),
}),
];
interface SortableUsersTableProps {
data: User[];
}
export default function SortableUsersTable({ data }: SortableUsersTableProps) {
const [sorting, setSorting] = useState<SortingState>([]);
const table = useReactTable({
data,
columns,
state: {
sorting,
},
onSortingChange: setSorting,
getCoreRowModel: getCoreRowModel(),
getSortedRowModel: getSortedRowModel(),
});
return (
<div className="overflow-x-auto">
<table className="min-w-full bg-white border border-gray-200">
<thead className="bg-gray-50">
{table.getHeaderGroups().map((headerGroup) => (
<tr key={headerGroup.id}>
{headerGroup.headers.map((header) => (
<th
key={header.id}
className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider"
>
<div
className={
header.column.getCanSort()
? 'flex items-center cursor-pointer select-none hover:text-gray-700'
: ''
}
onClick={header.column.getToggleSortingHandler()}
>
{flexRender(header.column.columnDef.header, header.getContext())}
{header.column.getCanSort() && (
<span className="ml-1">
{header.column.getIsSorted() === 'asc' ? (
<ChevronUpIcon className="w-4 h-4" />
) : header.column.getIsSorted() === 'desc' ? (
<ChevronDownIcon className="w-4 h-4" />
) : (
<div className="w-4 h-4" />
)}
</span>
)}
</div>
</th>
))}
</tr>
))}
</thead>
<tbody className="bg-white divide-y divide-gray-200">
{table.getRowModel().rows.map((row) => (
<tr key={row.id} className="hover:bg-gray-50">
{row.getVisibleCells().map((cell) => (
<td key={cell.id} className="px-6 py-4 whitespace-nowrap text-sm text-gray-900">
{flexRender(cell.column.columnDef.cell, cell.getContext())}
</td>
))}
</tr>
))}
</tbody>
</table>
</div>
);
}Kliknięcie nagłówka woła getToggleSortingHandler(), który przełącza kolejność: rosnąco, malejąco, bez sortowania. sortingFn: 'datetime' sortuje daty chronologicznie, a nie alfabetycznie.
Filtrowanie
Filtrowanie dodaje dwa rodzaje stanu: filtry kolumn (ColumnFiltersState) i jeden filtr globalny dla wyszukiwarki. Najpierw konfiguracja z własną funkcją globalFilterFn:
// components/FilterableUsersTable.tsx
'use client';
import {
createColumnHelper,
flexRender,
getCoreRowModel,
getFilteredRowModel,
getSortedRowModel,
SortingState,
ColumnFiltersState,
useReactTable,
GlobalFilterTableState,
} from '@tanstack/react-table';
import { useState } from 'react';
import { MagnifyingGlassIcon } from '@heroicons/react/24/outline';
import { User } from '@/types/User';
// Global filter function
function globalFilterFn(row: any, columnId: string, value: string) {
const search = value.toLowerCase();
return (
row.getValue('name')?.toLowerCase().includes(search) ||
row.getValue('email')?.toLowerCase().includes(search) ||
row.getValue('role')?.toLowerCase().includes(search)
);
}
const columnHelper = createColumnHelper<User>();
const columns = [
columnHelper.accessor('name', {
header: 'Nazwa użytkownika',
enableColumnFilter: true,
filterFn: 'includesString',
}),
columnHelper.accessor('email', {
header: 'Email',
enableColumnFilter: true,
}),
columnHelper.accessor('role', {
header: 'Rola',
enableColumnFilter: true,
filterFn: 'equals',
}),
columnHelper.accessor('status', {
header: 'Status',
enableColumnFilter: true,
filterFn: 'equals',
}),
columnHelper.accessor('createdAt', {
header: 'Data utworzenia',
enableColumnFilter: false,
cell: (info) => new Date(info.getValue()).toLocaleDateString('pl-PL'),
}),
];
interface FilterableUsersTableProps {
data: User[];
}
export default function FilterableUsersTable({ data }: FilterableUsersTableProps) {
const [sorting, setSorting] = useState<SortingState>([]);
const [columnFilters, setColumnFilters] = useState<ColumnFiltersState>([]);
const [globalFilter, setGlobalFilter] = useState('');
const table = useReactTable({
data,
columns,
state: {
sorting,
columnFilters,
globalFilter,
},
onSortingChange: setSorting,
onColumnFiltersChange: setColumnFilters,
onGlobalFilterChange: setGlobalFilter,
globalFilterFn,
getCoreRowModel: getCoreRowModel(),
getSortedRowModel: getSortedRowModel(),
getFilteredRowModel: getFilteredRowModel(),
});
Wbudowane funkcje filtrów, jak includesString czy equals, wybierasz nazwą. Model getFilteredRowModel odrzuca wiersze niepasujące do filtrów, a sortowanie działa dalej na tym, co zostało.
Interfejs filtrów to zwykłe pola formularza, które ustawiają wartości przez API tabeli:
return (
<div className="space-y-4">
{/* Global Search */}
<div className="flex items-center space-x-4">
<div className="relative flex-1 max-w-sm">
<MagnifyingGlassIcon className="absolute left-3 top-1/2 transform -translate-y-1/2 w-4 h-4 text-gray-400" />
<input
value={globalFilter ?? ''}
onChange={(e) => setGlobalFilter(e.target.value)}
className="pl-10 pr-4 py-2 border border-gray-300 rounded-md focus:ring-blue-500 focus:border-blue-500 w-full"
/>
</div>
{/* Role Filter */}
<select
value={(table.getColumn('role')?.getFilterValue() as string) ?? ''}
onChange={(e) =>
table.getColumn('role')?.setFilterValue(e.target.value || undefined)
}
className="px-3 py-2 border border-gray-300 rounded-md focus:ring-blue-500 focus:border-blue-500"
>
<option value="">Wszystkie role</option>
<option value="admin">Admin</option>
<option value="moderator">Moderator</option>
<option value="user">User</option>
</select>
{/* Status Filter */}
<select
value={(table.getColumn('status')?.getFilterValue() as string) ?? ''}
onChange={(e) =>
table.getColumn('status')?.setFilterValue(e.target.value || undefined)
}
className="px-3 py-2 border border-gray-300 rounded-md focus:ring-blue-500 focus:border-blue-500"
>
<option value="">Wszystkie statusy</option>
<option value="active">Aktywny</option>
<option value="inactive">Nieaktywny</option>
<option value="pending">Oczekujący</option>
</select>
</div>
{/* Results Info */}
<div className="text-sm text-gray-600">
Wyświetlono {table.getFilteredRowModel().rows.length} z {data.length} użytkowników
</div>
{/* Table */}
<div className="overflow-x-auto">
<table className="min-w-full bg-white border border-gray-200">
<thead className="bg-gray-50">
{table.getHeaderGroups().map((headerGroup) => (
<tr key={headerGroup.id}>
{headerGroup.headers.map((header) => (
<th
key={header.id}
className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider"
>
<div
className={
header.column.getCanSort()
? 'flex items-center cursor-pointer select-none hover:text-gray-700'
: ''
}
onClick={header.column.getToggleSortingHandler()}
>
{flexRender(header.column.columnDef.header, header.getContext())}
</div>
</th>
))}
</tr>
))}
</thead>
<tbody className="bg-white divide-y divide-gray-200">
{table.getRowModel().rows.map((row) => (
<tr key={row.id} className="hover:bg-gray-50">
{row.getVisibleCells().map((cell) => (
<td key={cell.id} className="px-6 py-4 whitespace-nowrap text-sm text-gray-900">
{flexRender(cell.column.columnDef.cell, cell.getContext())}
</td>
))}
</tr>
))}
</tbody>
</table>
</div>
</div>
);
}W tbody używamy getRowModel(), bo zwraca końcowy wynik po filtrowaniu i sortowaniu. getFilteredRowModel() pominąłby sortowanie, dlatego służy tu tylko do licznika wyników.
Paginacja
Paginacja trzyma w stanie numer strony (pageIndex, liczony od zera) i jej rozmiar (pageSize). Model getPaginationRowModel tnie wiersze na strony:
// components/PaginatedUsersTable.tsx
'use client';
import {
createColumnHelper,
flexRender,
getCoreRowModel,
getPaginationRowModel,
getSortedRowModel,
getFilteredRowModel,
PaginationState,
useReactTable,
} from '@tanstack/react-table';
import { useState } from 'react';
import {
ChevronLeftIcon,
ChevronRightIcon,
ChevronDoubleLeftIcon,
ChevronDoubleRightIcon
} from '@heroicons/react/24/outline';
import { User } from '@/types/User';
const columnHelper = createColumnHelper<User>();
const columns = [
columnHelper.accessor('name', {
header: 'Nazwa użytkownika',
}),
columnHelper.accessor('email', {
header: 'Email',
}),
columnHelper.accessor('role', {
header: 'Rola',
cell: (info) => {
const role = info.getValue();
return (
<span className="px-2 py-1 rounded-full text-xs font-medium bg-blue-100 text-blue-800">
{role}
</span>
);
},
}),
columnHelper.accessor('status', {
header: 'Status',
cell: (info) => {
const status = info.getValue();
const colors = {
active: 'bg-green-100 text-green-800',
inactive: 'bg-gray-100 text-gray-800',
pending: 'bg-yellow-100 text-yellow-800',
};
return (
<span className={`px-2 py-1 rounded-full text-xs font-medium ${colors[status]}`}>
{status}
</span>
);
},
}),
columnHelper.accessor('createdAt', {
header: 'Data utworzenia',
cell: (info) => new Date(info.getValue()).toLocaleDateString('pl-PL'),
}),
];
interface PaginatedUsersTableProps {
data: User[];
}
export default function PaginatedUsersTable({ data }: PaginatedUsersTableProps) {
const [pagination, setPagination] = useState<PaginationState>({
pageIndex: 0,
pageSize: 10,
});
const table = useReactTable({
data,
columns,
state: {
pagination,
},
onPaginationChange: setPagination,
getCoreRowModel: getCoreRowModel(),
getSortedRowModel: getSortedRowModel(),
getFilteredRowModel: getFilteredRowModel(),
getPaginationRowModel: getPaginationRowModel(),
});
Tabela sama liczy liczbę stron na podstawie liczby wierszy i pageSize. Nie musisz trzymać wycinka danych w osobnej zmiennej.
Kontrolki nawigacji korzystają z gotowych metod, jak previousPage(), nextPage() i setPageIndex():
return (
<div className="space-y-4">
{/* Table */}
<div className="overflow-x-auto">
<table className="min-w-full bg-white border border-gray-200">
<thead className="bg-gray-50">
{table.getHeaderGroups().map((headerGroup) => (
<tr key={headerGroup.id}>
{headerGroup.headers.map((header) => (
<th
key={header.id}
className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider"
>
{flexRender(header.column.columnDef.header, header.getContext())}
</th>
))}
</tr>
))}
</thead>
<tbody className="bg-white divide-y divide-gray-200">
{table.getRowModel().rows.map((row) => (
<tr key={row.id} className="hover:bg-gray-50">
{row.getVisibleCells().map((cell) => (
<td key={cell.id} className="px-6 py-4 whitespace-nowrap text-sm text-gray-900">
{flexRender(cell.column.columnDef.cell, cell.getContext())}
</td>
))}
</tr>
))}
</tbody>
</table>
</div>
{/* Pagination */}
<div className="flex items-center justify-between">
<div className="flex items-center space-x-2">
<span className="text-sm text-gray-700">
Wyświetlono{' '}
<span className="font-medium">
{table.getState().pagination.pageIndex * table.getState().pagination.pageSize + 1}
</span>{' '}
-{' '}
<span className="font-medium">
{Math.min(
(table.getState().pagination.pageIndex + 1) * table.getState().pagination.pageSize,
table.getFilteredRowModel().rows.length
)}
</span>{' '}
z{' '}
<span className="font-medium">{table.getFilteredRowModel().rows.length}</span> wyników
</span>
<select
value={table.getState().pagination.pageSize}
onChange={(e) => {
table.setPageSize(Number(e.target.value));
}}
className="px-3 py-1 border border-gray-300 rounded text-sm"
>
{[10, 20, 30, 40, 50].map((pageSize) => (
<option key={pageSize} value={pageSize}>
{pageSize} na stronę
</option>
))}
</select>
</div>
<div className="flex items-center space-x-2">
<button
onClick={() => table.setPageIndex(0)}
disabled={!table.getCanPreviousPage()}
className="p-2 border border-gray-300 rounded disabled:opacity-50 disabled:cursor-not-allowed hover:bg-gray-50"
>
<ChevronDoubleLeftIcon className="w-4 h-4" />
</button>
<button
onClick={() => table.previousPage()}
disabled={!table.getCanPreviousPage()}
className="p-2 border border-gray-300 rounded disabled:opacity-50 disabled:cursor-not-allowed hover:bg-gray-50"
>
<ChevronLeftIcon className="w-4 h-4" />
</button>
<div className="flex items-center space-x-1">
<span className="text-sm text-gray-700">Strona</span>
<input
type="number"
value={table.getState().pagination.pageIndex + 1}
onChange={(e) => {
const page = e.target.value ? Number(e.target.value) - 1 : 0;
table.setPageIndex(page);
}}
className="w-16 px-2 py-1 border border-gray-300 rounded text-sm text-center"
min={1}
max={table.getPageCount()}
/>
<span className="text-sm text-gray-700">z {table.getPageCount()}</span>
</div>
<button
onClick={() => table.nextPage()}
disabled={!table.getCanNextPage()}
className="p-2 border border-gray-300 rounded disabled:opacity-50 disabled:cursor-not-allowed hover:bg-gray-50"
>
<ChevronRightIcon className="w-4 h-4" />
</button>
<button
onClick={() => table.setPageIndex(table.getPageCount() - 1)}
disabled={!table.getCanNextPage()}
className="p-2 border border-gray-300 rounded disabled:opacity-50 disabled:cursor-not-allowed hover:bg-gray-50"
>
<ChevronDoubleRightIcon className="w-4 h-4" />
</button>
</div>
</div>
</div>
);
}getCanPreviousPage() i getCanNextPage() blokują przyciski na krańcach. Pole z numerem strony odejmuje 1, bo użytkownik liczy od jedynki, a tabela od zera.
Selekcja wierszy
Selekcja dodaje kolumnę z checkboxami. Metoda columnHelper.display tworzy kolumnę bez pola danych, idealną na checkboxy i przyciski akcji:
// components/SelectableUsersTable.tsx
'use client';
import {
createColumnHelper,
flexRender,
getCoreRowModel,
useReactTable,
RowSelectionState,
} from '@tanstack/react-table';
import { useState } from 'react';
import { TrashIcon, UserGroupIcon } from '@heroicons/react/24/outline';
import { User } from '@/types/User';
const columnHelper = createColumnHelper<User>();
interface SelectableUsersTableProps {
data: User[];
onDeleteSelected?: (selectedUsers: User[]) => void;
onBulkAction?: (action: string, selectedUsers: User[]) => void;
}
export default function SelectableUsersTable({
data,
onDeleteSelected,
onBulkAction
}: SelectableUsersTableProps) {
const [rowSelection, setRowSelection] = useState<RowSelectionState>({});
const columns = [
// Selection column
columnHelper.display({
id: 'select',
header: ({ table }) => (
<input
type="checkbox"
checked={table.getIsAllRowsSelected()}
onChange={table.getToggleAllRowsSelectedHandler()}
className="rounded border-gray-300 text-blue-600 focus:ring-blue-500"
/>
),
cell: ({ row }) => (
<input
type="checkbox"
checked={row.getIsSelected()}
onChange={row.getToggleSelectedHandler()}
className="rounded border-gray-300 text-blue-600 focus:ring-blue-500"
/>
),
}),
columnHelper.accessor('name', {
header: 'Nazwa użytkownika',
}),
columnHelper.accessor('email', {
header: 'Email',
}),
columnHelper.accessor('role', {
header: 'Rola',
}),
columnHelper.accessor('status', {
header: 'Status',
}),
// Actions column
columnHelper.display({
id: 'actions',
header: 'Akcje',
cell: ({ row }) => (
<div className="flex space-x-2">
<button
onClick={() => console.log('Edit user:', row.original)}
className="text-blue-600 hover:text-blue-800 text-sm"
>
Edytuj
</button>
<button
onClick={() => console.log('Delete user:', row.original)}
className="text-red-600 hover:text-red-800 text-sm"
>
Usuń
</button>
</div>
),
}),
];
const table = useReactTable({
data,
columns,
state: {
rowSelection,
},
onRowSelectionChange: setRowSelection,
getCoreRowModel: getCoreRowModel(),
enableRowSelection: true,
});
const selectedUsers = table.getFilteredSelectedRowModel().rows.map(row => row.original);
Stan RowSelectionState to obiekt, w którym kluczem jest id wiersza. Kolumny są tu zdefiniowane w komponencie, więc warto je owinąć w useMemo, o czym mówią dobre praktyki na końcu lekcji.
Pasek akcji zbiorczych pojawia się tylko wtedy, gdy coś jest zaznaczone:
return (
<div className="space-y-4">
{/* Bulk Actions */}
{Object.keys(rowSelection).length > 0 && (
<div className="bg-blue-50 border border-blue-200 rounded-lg p-4">
<div className="flex items-center justify-between">
<div className="flex items-center space-x-2">
<UserGroupIcon className="w-5 h-5 text-blue-600" />
<span className="text-sm font-medium text-blue-900">
Zaznaczono {selectedUsers.length} użytkowników
</span>
</div>
<div className="flex space-x-2">
<button
onClick={() => onBulkAction?.('activate', selectedUsers)}
className="px-3 py-1 bg-green-600 text-white text-sm rounded hover:bg-green-700"
>
Aktywuj
</button>
<button
onClick={() => onBulkAction?.('deactivate', selectedUsers)}
className="px-3 py-1 bg-yellow-600 text-white text-sm rounded hover:bg-yellow-700"
>
Dezaktywuj
</button>
<button
onClick={() => onDeleteSelected?.(selectedUsers)}
className="px-3 py-1 bg-red-600 text-white text-sm rounded hover:bg-red-700 flex items-center space-x-1"
>
<TrashIcon className="w-4 h-4" />
<span>Usuń</span>
</button>
</div>
</div>
</div>
)}
{/* Table */}
<div className="overflow-x-auto">
<table className="min-w-full bg-white border border-gray-200">
<thead className="bg-gray-50">
{table.getHeaderGroups().map((headerGroup) => (
<tr key={headerGroup.id}>
{headerGroup.headers.map((header) => (
<th
key={header.id}
className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider"
>
{flexRender(header.column.columnDef.header, header.getContext())}
</th>
))}
</tr>
))}
</thead>
<tbody className="bg-white divide-y divide-gray-200">
{table.getRowModel().rows.map((row) => (
<tr
key={row.id}
className={`hover:bg-gray-50 ${row.getIsSelected() ? 'bg-blue-50' : ''}`}
>
{row.getVisibleCells().map((cell) => (
<td key={cell.id} className="px-6 py-4 whitespace-nowrap text-sm text-gray-900">
{flexRender(cell.column.columnDef.cell, cell.getContext())}
</td>
))}
</tr>
))}
</tbody>
</table>
</div>
</div>
);
}getFilteredSelectedRowModel() zwraca zaznaczone wiersze, a row.original to oryginalny obiekt User. Tabela nie usuwa danych sama, przekazuje je do funkcji z propsów.
Server-side data fetching
Przy dziesiątkach tysięcy rekordów sortowanie i filtrowanie przenosimy na serwer. Kolejność jest stała: endpoint API, ręczny stan sortowania i filtrów w tabeli, przetwarzanie na serwerze i obsługa odpowiedzi w komponencie. Dane pobiera TanStack Query:
// hooks/useUsersData.ts
import { useQuery, keepPreviousData } from '@tanstack/react-query';
import { useState } from 'react';
interface UseUsersDataParams {
page: number;
pageSize: number;
sorting?: Array<{ id: string; desc: boolean }>;
filters?: Array<{ id: string; value: any }>;
globalFilter?: string;
}
interface UsersResponse {
data: User[];
totalCount: number;
pageCount: number;
}
export function useUsersData(params: UseUsersDataParams) {
return useQuery({
queryKey: ['users', params],
queryFn: async (): Promise<UsersResponse> => {
const searchParams = new URLSearchParams({
page: params.page.toString(),
pageSize: params.pageSize.toString(),
...(params.globalFilter && { search: params.globalFilter }),
...(params.sorting?.length && {
sort: JSON.stringify(params.sorting)
}),
...(params.filters?.length && {
filters: JSON.stringify(params.filters)
}),
});
const response = await fetch(`/api/users?${searchParams}`);
if (!response.ok) {
throw new Error('Failed to fetch users');
}
return response.json();
},
placeholderData: keepPreviousData,
});
}queryKey zawiera parametry, więc każda zmiana strony czy sortowania pobiera nowe dane. placeholderData: keepPreviousData to zapis z TanStack Query 5, który pokazuje poprzednią stronę do czasu nadejścia nowej, starsza opcja keepPreviousData: true już nie działa.
Komponent przekazuje stan tabeli do hooka i włącza tryb ręczny flagami manualPagination, manualSorting i manualFiltering:
// components/ServerSideUsersTable.tsx
'use client';
import {
createColumnHelper,
flexRender,
getCoreRowModel,
useReactTable,
PaginationState,
SortingState,
ColumnFiltersState,
} from '@tanstack/react-table';
import { useState } from 'react';
import { useUsersData } from '@/hooks/useUsersData';
import { User } from '@/types/User';
const columnHelper = createColumnHelper<User>();
const columns = [
columnHelper.accessor('name', {
header: 'Nazwa użytkownika',
enableSorting: true,
}),
columnHelper.accessor('email', {
header: 'Email',
enableSorting: true,
}),
columnHelper.accessor('role', {
header: 'Rola',
enableSorting: true,
}),
columnHelper.accessor('status', {
header: 'Status',
enableSorting: true,
}),
columnHelper.accessor('createdAt', {
header: 'Data utworzenia',
enableSorting: true,
cell: (info) => new Date(info.getValue()).toLocaleDateString('pl-PL'),
}),
];
export default function ServerSideUsersTable() {
const [pagination, setPagination] = useState<PaginationState>({
pageIndex: 0,
pageSize: 10,
});
const [sorting, setSorting] = useState<SortingState>([]);
const [columnFilters, setColumnFilters] = useState<ColumnFiltersState>([]);
const [globalFilter, setGlobalFilter] = useState('');
const { data, isLoading, error } = useUsersData({
page: pagination.pageIndex,
pageSize: pagination.pageSize,
sorting,
filters: columnFilters,
globalFilter,
});
const table = useReactTable({
data: data?.data ?? [],
columns,
pageCount: data?.pageCount ?? -1,
state: {
pagination,
sorting,
columnFilters,
globalFilter,
},
onPaginationChange: setPagination,
onSortingChange: setSorting,
onColumnFiltersChange: setColumnFilters,
onGlobalFilterChange: setGlobalFilter,
getCoreRowModel: getCoreRowModel(),
manualPagination: true,
manualSorting: true,
manualFiltering: true,
});
if (isLoading) {
return (
<div className="flex items-center justify-center h-64">
<div className="animate-spin rounded-full h-32 w-32 border-b-2 border-blue-600"></div>
</div>
);
}
if (error) {
return (
<div className="text-center text-red-600 p-8">
Wystąpił błąd podczas ładowania danych
</div>
);
}
W trybie ręcznym tabela nie sortuje ani nie filtruje sama, tylko zgłasza zmiany stanu. pageCount pochodzi z serwera, bo tylko serwer zna liczbę wszystkich rekordów.
Widok wygląda prawie tak samo jak w wersji klienckiej:
return (
<div className="space-y-4">
{/* Search */}
<div className="flex items-center space-x-4">
<input
value={globalFilter ?? ''}
onChange={(e) => setGlobalFilter(e.target.value)}
className="px-3 py-2 border border-gray-300 rounded-md focus:ring-blue-500 focus:border-blue-500 flex-1 max-w-sm"
/>
</div>
{/* Table */}
<div className="overflow-x-auto">
<table className="min-w-full bg-white border border-gray-200">
<thead className="bg-gray-50">
{table.getHeaderGroups().map((headerGroup) => (
<tr key={headerGroup.id}>
{headerGroup.headers.map((header) => (
<th
key={header.id}
className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider"
>
<div
className={
header.column.getCanSort()
? 'flex items-center cursor-pointer select-none hover:text-gray-700'
: ''
}
onClick={header.column.getToggleSortingHandler()}
>
{flexRender(header.column.columnDef.header, header.getContext())}
</div>
</th>
))}
</tr>
))}
</thead>
<tbody className="bg-white divide-y divide-gray-200">
{table.getRowModel().rows.map((row) => (
<tr key={row.id} className="hover:bg-gray-50">
{row.getVisibleCells().map((cell) => (
<td key={cell.id} className="px-6 py-4 whitespace-nowrap text-sm text-gray-900">
{flexRender(cell.column.columnDef.cell, cell.getContext())}
</td>
))}
</tr>
))}
</tbody>
</table>
</div>
{/* Pagination */}
<div className="flex items-center justify-between">
<div className="text-sm text-gray-700">
Wyświetlono {data?.data.length ?? 0} z {data?.totalCount ?? 0} użytkowników
</div>
<div className="flex items-center space-x-2">
<button
onClick={() => table.setPageIndex(0)}
disabled={!table.getCanPreviousPage()}
className="px-3 py-1 border border-gray-300 rounded disabled:opacity-50"
>
Pierwsza
</button>
<button
onClick={() => table.previousPage()}
disabled={!table.getCanPreviousPage()}
className="px-3 py-1 border border-gray-300 rounded disabled:opacity-50"
>
Poprzednia
</button>
<span className="text-sm">
Strona {table.getState().pagination.pageIndex + 1} z{' '}
{table.getPageCount()}
</span>
<button
onClick={() => table.nextPage()}
disabled={!table.getCanNextPage()}
className="px-3 py-1 border border-gray-300 rounded disabled:opacity-50"
>
Następna
</button>
<button
onClick={() => table.setPageIndex(table.getPageCount() - 1)}
disabled={!table.getCanNextPage()}
className="px-3 py-1 border border-gray-300 rounded disabled:opacity-50"
>
Ostatnia
</button>
</div>
</div>
</div>
);
}Różnica jest niewidoczna dla użytkownika: każde kliknięcie strony wysyła nowe zapytanie do API.
API Routes dla server-side table
Po stronie serwera Route Handler czyta parametry z searchParams i wykonuje tę samą pracę co wcześniej biblioteka:
// app/api/users/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { User } from '@/types/User';
// Symulowane dane
const mockUsers: User[] = [
// ... dane użytkowników
];
export async function GET(request: NextRequest) {
const searchParams = request.nextUrl.searchParams;
const page = parseInt(searchParams.get('page') || '0');
const pageSize = parseInt(searchParams.get('pageSize') || '10');
const search = searchParams.get('search') || '';
const sortParam = searchParams.get('sort');
const filtersParam = searchParams.get('filters');
let filteredUsers = [...mockUsers];
// Global search
if (search) {
filteredUsers = filteredUsers.filter(user =>
user.name.toLowerCase().includes(search.toLowerCase()) ||
user.email.toLowerCase().includes(search.toLowerCase()) ||
user.role.toLowerCase().includes(search.toLowerCase())
);
}
// Column filters
if (filtersParam) {
const filters = JSON.parse(filtersParam);
filters.forEach((filter: { id: string; value: any }) => {
filteredUsers = filteredUsers.filter(user => {
const value = user[filter.id as keyof User];
return value === filter.value;
});
});
}
// Sorting
if (sortParam) {
const sorting = JSON.parse(sortParam);
sorting.forEach((sort: { id: string; desc: boolean }) => {
filteredUsers.sort((a, b) => {
const aVal = a[sort.id as keyof User];
const bVal = b[sort.id as keyof User];
if (aVal < bVal) return sort.desc ? 1 : -1;
if (aVal > bVal) return sort.desc ? -1 : 1;
return 0;
});
});
}
// Pagination
const totalCount = filteredUsers.length;
const pageCount = Math.ceil(totalCount / pageSize);
const startIndex = page * pageSize;
const endIndex = startIndex + pageSize;
const paginatedUsers = filteredUsers.slice(startIndex, endIndex);
return NextResponse.json({
data: paginatedUsers,
totalCount,
pageCount,
});
}Kolejno: wyszukiwanie, filtry kolumn, sortowanie i wycięcie strony. W prawdziwej aplikacji te kroki wykonałaby baza danych zapytaniem z WHERE, ORDER BY i LIMIT.
Responsywne tabele
Na telefonie szeroka tabela się nie mieści. Ten komponent pokazuje tabelę od punktu md, a na mniejszych ekranach karty z rozwijanymi szczegółami:
// components/ResponsiveUsersTable.tsx
'use client';
import { useState } from 'react';
import { User } from '@/types/User';
interface ResponsiveUsersTableProps {
data: User[];
}
export default function ResponsiveUsersTable({ data }: ResponsiveUsersTableProps) {
const [expandedRows, setExpandedRows] = useState<Set<string>>(new Set());
const toggleRow = (userId: string) => {
const newExpanded = new Set(expandedRows);
if (newExpanded.has(userId)) {
newExpanded.delete(userId);
} else {
newExpanded.add(userId);
}
setExpandedRows(newExpanded);
};
return (
<div className="w-full">
{/* Desktop Table */}
<div className="hidden md:block overflow-x-auto">
<table className="min-w-full bg-white border border-gray-200">
{/* Standardowa tabela dla desktop */}
</table>
</div>
{/* Mobile Cards */}
<div className="md:hidden space-y-4">
{data.map((user) => (
<div key={user.id} className="bg-white border border-gray-200 rounded-lg shadow">
<div className="p-4">
<div className="flex items-center justify-between">
<div className="flex-1">
<h3 className="font-medium text-gray-900">{user.name}</h3>
<p className="text-sm text-gray-600">{user.email}</p>
</div>
<button
onClick={() => toggleRow(user.id)}
className="ml-4 text-blue-600 text-sm"
>
{expandedRows.has(user.id) ? 'Mniej' : 'Więcej'}
</button>
</div>
{expandedRows.has(user.id) && (
<div className="mt-4 pt-4 border-t border-gray-200">
<div className="grid grid-cols-2 gap-4 text-sm">
<div>
<span className="font-medium text-gray-700">Rola:</span>
<span className="ml-1">{user.role}</span>
</div>
<div>
<span className="font-medium text-gray-700">Status:</span>
<span className="ml-1">{user.status}</span>
</div>
<div className="col-span-2">
<span className="font-medium text-gray-700">Utworzono:</span>
<span className="ml-1">
{new Date(user.createdAt).toLocaleDateString('pl-PL')}
</span>
</div>
</div>
</div>
)}
</div>
</div>
))}
</div>
</div>
);
}Stan rozwinięcia to Set identyfikatorów. Tworzymy nowy Set przy każdej zmianie, zamiast mutować stary, żeby React zauważył zmianę.
Eksport danych
Eksport do CSV i JSON nie wymaga biblioteki. Hook tworzy plik jako Blob i pobiera go przez tymczasowy link:
// hooks/useTableExport.ts
import { User } from '@/types/User';
export function useTableExport() {
const exportToCSV = (data: User[], filename = 'users.csv') => {
const headers = ['ID', 'Nazwa', 'Email', 'Rola', 'Status', 'Data utworzenia'];
const csvContent = [
headers.join(','),
...data.map(user => [
user.id,
user.name,
user.email,
user.role,
user.status,
new Date(user.createdAt).toLocaleDateString('pl-PL')
].join(','))
].join('\n');
const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
const link = document.createElement('a');
const url = URL.createObjectURL(blob);
link.setAttribute('href', url);
link.setAttribute('download', filename);
link.style.visibility = 'hidden';
document.body.appendChild(link);
link.click();
document.body.removeChild(link);
};
const exportToJSON = (data: User[], filename = 'users.json') => {
const jsonContent = JSON.stringify(data, null, 2);
const blob = new Blob([jsonContent], { type: 'application/json' });
const link = document.createElement('a');
const url = URL.createObjectURL(blob);
link.setAttribute('href', url);
link.setAttribute('download', filename);
link.style.visibility = 'hidden';
document.body.appendChild(link);
link.click();
document.body.removeChild(link);
};
return { exportToCSV, exportToJSON };
}Wiersze CSV łączymy znakiem nowej linii. Ten prosty eksport nie obsługuje przecinków wewnątrz wartości, w produkcji ujmij takie pola w cudzysłowy.
Najlepsze praktyki
1. Performance optimization
Tabela porównuje data i columns przez referencję, więc nowe tablice przy każdym renderze wymuszają ponowne przeliczenie:
// Dobrze - używaj memo dla kolumn
const columns = useMemo(() => [
// definicje kolumn
], []);
// Dobrze - memo dla data
const data = useMemo(() => users, [users]);useMemo utrzymuje tę samą referencję między renderami, dopóki zależności się nie zmienią.
2. Accessibility
Headless oznacza, że dostępność zależy od Ciebie. Używaj prawdziwych znaczników tabeli i atrybutów ARIA:
// Dobrze - aria labels
<table role="table" aria-label="Tabela użytkowników">
<thead>
<tr role="row">
<th role="columnheader" aria-sort="ascending">
Nazwa
</th>
</tr>
</thead>
</table>aria-sort mówi czytnikom ekranu, po której kolumnie i w jakim kierunku posortowano dane.
3. TypeScript integration
Pomocnik kolumn z typem danych daje podpowiedzi i sprawdzanie nazw pól:
// Dobrze - silne typowanie
const columnHelper = createColumnHelper<User>();
const columns = [
columnHelper.accessor('name', {
// Pełne wsparcie IntelliSense
}),
];Literówka w nazwie pola to błąd kompilacji, a nie pusta kolumna w produkcji.
Podsumowanie
TanStack Table z Next.js tworzy potężną kombinację do budowania zaawansowanych tabel:
- Headless UI - pełna kontrola nad stylingiem
- TypeScript-first - bezpieczeństwo typów
- Feature-rich - sortowanie, filtrowanie, paginacja
- Performance - optymalizacje, a wirtualizacja z TanStack Virtual
- Server-side support - idealne dla dużych zbiorów danych
Moja rada: do kilku tysięcy wierszy trzymaj logikę po stronie klienta, a powyżej przełącz się na tryb ręczny z API. W następnej lekcji poznasz Typed Routes, które chronią linki przed literówkami.
Zapamiętaj: TanStack Table to silnik obliczeniowy tabeli, a wygląd każdej komórki należy do Ciebie.
Kod do tej lekcji: App.tsx
import React, { useState, useMemo } from 'react';
interface User {
id: number;
name: string;
email: string;
role: 'admin' | 'user' | 'moderator';
status: 'active' | 'inactive' | 'pending';
lastLogin: string;
}
const mockUsers: User[] = [
{ id: 1, name: 'Jan Kowalski', email: 'jan@quantum.city', role: 'admin', status: 'active', lastLogin: '2025-03-01' },
{ id: 2, name: 'Anna Nowak', email: 'anna@quantum.city', role: 'moderator', status: 'active', lastLogin: '2025-02-28' },
{ id: 3, name: 'Piotr Wiśniewski', email: 'piotr@quantum.city', role: 'user', status: 'pending', lastLogin: '2025-02-25' },
{ id: 4, name: 'Maria Zielińska', email: 'maria@quantum.city', role: 'user', status: 'active', lastLogin: '2025-03-02' },
{ id: 5, name: 'Tomasz Dąbrowski', email: 'tomasz@quantum.city', role: 'moderator', status: 'inactive', lastLogin: '2025-01-15' },
{ id: 6, name: 'Katarzyna Lewandowska', email: 'kasia@quantum.city', role: 'user', status: 'active', lastLogin: '2025-03-03' },
{ id: 7, name: 'Michał Wójcik', email: 'michal@quantum.city', role: 'admin', status: 'active', lastLogin: '2025-03-02' },
{ id: 8, name: 'Agnieszka Kamińska', email: 'aga@quantum.city', role: 'user', status: 'pending', lastLogin: '2025-02-20' },
{ id: 9, name: 'Robert Szymański', email: 'robert@quantum.city', role: 'user', status: 'inactive', lastLogin: '2024-12-01' },
{ id: 10, name: 'Ewa Woźniak', email: 'ewa@quantum.city', role: 'moderator', status: 'active', lastLogin: '2025-03-01' },
];
type SortDir = 'asc' | 'desc' | null;
const statusColors: Record<string, string> = { active: '#4caf50', inactive: '#f44336', pending: '#ff9800' };
const roleColors: Record<string, string> = { admin: '#7c4dff', moderator: '#64ffda', user: '#888' };
const TanStackTableDemo = () => {
const [data] = useState<User[]>(mockUsers);
const [sortKey, setSortKey] = useState<keyof User | null>(null);
const [sortDir, setSortDir] = useState<SortDir>(null);
const [searchQuery, setSearchQuery] = useState('');
const [roleFilter, setRoleFilter] = useState<string>('all');
const [statusFilter, setStatusFilter] = useState<string>('all');
const [page, setPage] = useState(0);
const pageSize = 5;
const handleSort = (key: keyof User) => {
if (sortKey === key) {
setSortDir(prev => prev === 'asc' ? 'desc' : prev === 'desc' ? null : 'asc');
if (sortDir === 'desc') setSortKey(null);
} else {
setSortKey(key);
setSortDir('asc');
}
};
const filtered = useMemo(() => {
let result = [...data];
if (searchQuery) result = result.filter(u => u.name.toLowerCase().includes(searchQuery.toLowerCase()) || u.email.toLowerCase().includes(searchQuery.toLowerCase()));
if (roleFilter !== 'all') result = result.filter(u => u.role === roleFilter);
if (statusFilter !== 'all') result = result.filter(u => u.status === statusFilter);
if (sortKey && sortDir) {
result.sort((a, b) => {
const va = a[sortKey], vb = b[sortKey];
const cmp = String(va).localeCompare(String(vb));
return sortDir === 'asc' ? cmp : -cmp;
});
}
return result;
}, [data, searchQuery, roleFilter, statusFilter, sortKey, sortDir]);
const paged = filtered.slice(page * pageSize, (page + 1) * pageSize);
const totalPages = Math.ceil(filtered.length / pageSize);
const sortIcon = (key: keyof User) => {
if (sortKey !== key) return ' ↕';
return sortDir === 'asc' ? ' ↑' : ' ↓';
};
return (
<div style={{ background: '#0f0f23', minHeight: '100vh', padding: '20px', color: '#fff', fontFamily: 'sans-serif' }}>
<h1 style={{ color: '#64ffda', textAlign: 'center' }}>Next.js + TanStack Table</h1>
<p style={{ textAlign: 'center', color: '#888', marginBottom: '20px' }}>Sorting, Filtering, Pagination</p>
<div style={{ maxWidth: '900px', margin: '0 auto' }}>
<div style={{ display: 'flex', gap: '8px', marginBottom: '16px', flexWrap: 'wrap' }}>
<input value={searchQuery} onChange={e => { setSearchQuery(e.target.value); setPage(0); }} placeholder="Search by name or email..."
style={{ flex: 1, minWidth: '200px', padding: '10px', background: '#16213e', border: '1px solid #444', borderRadius: '6px', color: '#fff' }} />
<select value={roleFilter} onChange={e => { setRoleFilter(e.target.value); setPage(0); }}
style={{ padding: '10px', background: '#16213e', border: '1px solid #444', borderRadius: '6px', color: '#fff' }}>
<option value="all">All Roles</option>
<option value="admin">Admin</option>
<option value="moderator">Moderator</option>
<option value="user">User</option>
</select>
<select value={statusFilter} onChange={e => { setStatusFilter(e.target.value); setPage(0); }}
style={{ padding: '10px', background: '#16213e', border: '1px solid #444', borderRadius: '6px', color: '#fff' }}>
<option value="all">All Statuses</option>
<option value="active">Active</option>
<option value="inactive">Inactive</option>
<option value="pending">Pending</option>
</select>
</div>
<div style={{ overflowX: 'auto', borderRadius: '10px', border: '1px solid #333' }}>
<table style={{ width: '100%', borderCollapse: 'collapse' }}>
<thead>
<tr style={{ background: '#1a1a2e' }}>
{[
{ key: 'name' as keyof User, label: 'Name' },
{ key: 'email' as keyof User, label: 'Email' },
{ key: 'role' as keyof User, label: 'Role' },
{ key: 'status' as keyof User, label: 'Status' },
{ key: 'lastLogin' as keyof User, label: 'Last Login' },
].map(col => (
<th key={col.key} onClick={() => handleSort(col.key)}
style={{ padding: '12px', textAlign: 'left', color: '#64ffda', cursor: 'pointer', borderBottom: '2px solid #333', userSelect: 'none', whiteSpace: 'nowrap' }}>
{col.label}{sortIcon(col.key)}
</th>
))}
</tr>
</thead>
<tbody>
{paged.map(user => (
<tr key={user.id} style={{ borderBottom: '1px solid #1a1a2e' }}>
<td style={{ padding: '10px 12px' }}>{user.name}</td>
<td style={{ padding: '10px 12px', color: '#7c4dff' }}>{user.email}</td>
<td style={{ padding: '10px 12px' }}>
<span style={{ background: roleColors[user.role] + '33', color: roleColors[user.role], padding: '3px 10px', borderRadius: '12px', fontSize: '12px' }}>{user.role}</span>
</td>
<td style={{ padding: '10px 12px' }}>
<span style={{ color: statusColors[user.status], fontWeight: 'bold', fontSize: '13px' }}>{user.status}</span>
</td>
<td style={{ padding: '10px 12px', color: '#888' }}>{user.lastLogin}</td>
</tr>
))}
{paged.length === 0 && (
<tr><td colSpan={5} style={{ textAlign: 'center', padding: '30px', color: '#555' }}>No results found</td></tr>
)}
</tbody>
</table>
</div>
<div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginTop: '12px' }}>
<span style={{ color: '#888', fontSize: '13px' }}>Showing {paged.length} of {filtered.length} users</span>
<div style={{ display: 'flex', gap: '6px' }}>
<button onClick={() => setPage(p => Math.max(0, p - 1))} disabled={page === 0}
style={{ padding: '6px 12px', background: page === 0 ? '#222' : '#7c4dff', border: 'none', borderRadius: '4px', color: '#fff', cursor: page === 0 ? 'default' : 'pointer' }}>Prev</button>
<span style={{ padding: '6px 12px', color: '#888' }}>{page + 1} / {totalPages || 1}</span>
<button onClick={() => setPage(p => Math.min(totalPages - 1, p + 1))} disabled={page >= totalPages - 1}
style={{ padding: '6px 12px', background: page >= totalPages - 1 ? '#222' : '#7c4dff', border: 'none', borderRadius: '4px', color: '#fff', cursor: page >= totalPages - 1 ? 'default' : 'pointer' }}>Next</button>
</div>
</div>
</div>
</div>
);
};
export default TanStackTableDemo;Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. TanStack Table oferuje:
2. Która funkcja NIE jest wbudowana w TanStack Table?
Zadania praktyczne w grze
- Edytor kodu
Zaimplementuj tabelę danych z sortowaniem i filtrowaniem używając TanStack Table
- Edytor kodu
Stwórz tabelę z kolumnami i data source.