Kurs Next.js · Moduł 9: Integracje i zaawansowane funkcje

Next.js z TanStack Table - Zaawansowane tabele danych

21 min czytania ·
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-core

Pakiet @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:

  1. Headless UI - pełna kontrola nad stylingiem
  2. TypeScript-first - bezpieczeństwo typów
  3. Feature-rich - sortowanie, filtrowanie, paginacja
  4. Performance - optymalizacje, a wirtualizacja z TanStack Virtual
  5. 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. 1. TanStack Table oferuje:

  2. 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.

  1. PytanieTanStack Table
  2. PytanieTanStack Table features
  3. Zadanie z kodemPraktyka: Tabela danych z TanStack Table
  4. Zadanie z kodemTanStack Table setup

Przydatne artykuły