Table

<?php

use App\Contracts\UserRepository;
use App\Tables\TableBasicBuilder;
use Illuminate\Contracts\View\View;
use Illuminate\Http\Request;
use Pajak\Ui\Table\Services\TableRequestParser;

class UserController extends Controller
{
    public function __construct(private readonly TableBasicBuilder $tableBasic) {
    }

    public function index(Request $request): View
    {
        return view('users.index', $this->tableBasic->build($request));
    }
}

// TableBasicBuilder — app/Tables/TableBasicBuilder.php
class TableBasicBuilder
{
    public function __construct(
        private readonly UserRepository $users,
        private readonly TableRequestParser $parser,
    ) {}

    public function build(Request $request): array
    {
        $table = Table::make('users')
            ->dataUrl(route('users.table'))
            ->searchable()
            ->columns([
                TextColumn::make('name')->label('Name')->sortable(),
                TextColumn::make('role')->label('Role')->sortable(),
                StatusColumn::make('status')->label('Status')->colors([
                    'active' => 'green',
                    'inactive' => 'gray',
                    'pending' => 'yellow',
                ]),
                DateColumn::make('joined')->label('Joined')->sortable(),
            ])
            ->actions([
                LinkAction::make('edit')->label('Edit')->url(fn($row) => route('users.edit', $row))->inlineOnly(),
            ]);

        $tableRequest = $this->parser->parse($request);
        $rows = $this->users->all();

        if ($tableRequest->search) {
            $query = mb_strtolower($tableRequest->search);
            $rows = $rows->filter(fn($user) => str_contains(mb_strtolower($user->name), $query)
                || str_contains(mb_strtolower($user->role), $query));
        }

        if ($tableRequest->sort) {
            $rows = $tableRequest->sort->direction->value === 'desc'
                ? $rows->sortByDesc(fn($user) => $user->{$tableRequest->sort->column})
                : $rows->sortBy(fn($user) => $user->{$tableRequest->sort->column});
        }

        $basicTable = $table;
        $basicPaginator = ArrayPaginator::fromCollection($rows->values(), 10, $tableRequest->page);

        return ['basicTable' => $basicTable, 'basicPaginator' => $basicPaginator];
    }
}

<x-pajak-table::table :table="$basicTable" :paginator="$basicPaginator" />

<?php

use App\Contracts\UserRepository;
use App\Tables\TablePaginationBuilder;
use Illuminate\Contracts\View\View;
use Illuminate\Http\Request;
use Pajak\Ui\Table\Services\TableRequestParser;

class UserController extends Controller
{
    public function __construct(private readonly TablePaginationBuilder $tablePagination) {
    }

    public function index(Request $request): View
    {
        return view('users.index', $this->tablePagination->build($request));
    }
}

// TablePaginationBuilder — app/Tables/TablePaginationBuilder.php
class TablePaginationBuilder
{
    public function __construct(
        private readonly UserRepository $users,
        private readonly TableRequestParser $parser,
    ) {}

    public function build(Request $request): array
    {
        $table = Table::make('users')
            ->dataUrl(route('users.table'))
            ->searchable()
            ->columns([
                TextColumn::make('name')->label('Name')->sortable(),
                TextColumn::make('role')->label('Role')->sortable(),
                DateColumn::make('joined')->label('Joined')->sortable(),
            ])
            ->perPageOptions([5, 10, 25]);

        $tableRequest = $this->parser->parse($request);
        $perPage = $request->integer('per_page') ?: 5;
        $rows = $this->users->all();

        if ($tableRequest->search) {
            $query = mb_strtolower($tableRequest->search);
            $rows = $rows->filter(fn($user) => str_contains(mb_strtolower($user->name), $query)
                || str_contains(mb_strtolower($user->role), $query));
        }

        if ($tableRequest->sort) {
            $rows = $tableRequest->sort->direction->value === 'desc'
                ? $rows->sortByDesc(fn($user) => $user->{$tableRequest->sort->column})
                : $rows->sortBy(fn($user) => $user->{$tableRequest->sort->column});
        }

        $paginationTable = $table;
        $paginationPaginator = ArrayPaginator::fromCollection($rows->values(), $perPage, $tableRequest->page);

        return ['paginationTable' => $paginationTable, 'paginationPaginator' => $paginationPaginator];
    }
}

<x-pajak-table::table :table="$paginationTable" :paginator="$paginationPaginator" />

<?php

use App\Contracts\MemberRepository;
use App\Tables\TableCellTypesBuilder;
use Illuminate\Contracts\View\View;
use Illuminate\Http\Request;
use Pajak\Ui\Table\Services\TableRequestParser;

class MemberController extends Controller
{
    public function __construct(private readonly TableCellTypesBuilder $tableCellTypes) {
    }

    public function index(Request $request): View
    {
        return view('members.index', $this->tableCellTypes->build($request));
    }
}

// TableCellTypesBuilder — app/Tables/TableCellTypesBuilder.php
class TableCellTypesBuilder
{
    public function __construct(
        private readonly MemberRepository $members,
        private readonly TableRequestParser $parser,
    ) {}

    public function build(Request $request): array
    {
        $table = Table::make('members')
            ->dataUrl(route('members.table'))
            ->columns([
                AvatarColumn::make('name')->label('Avatar')->image('avatar')->subtitle('role'),
                TwoLineColumn::make('name')->label('Two-line')->secondary('role'),
                StatusColumn::make('status')->label('Status')->colors([
                    'paid' => 'green',
                    'pending' => 'yellow',
                    'cancelled' => 'red',
                ]),
                BadgeColumn::make('type')->label('Badge')->colors([
                    'design' => 'blue',
                    'backend' => 'gray',
                    'qa' => 'yellow',
                    'frontend' => 'green',
                ]),
                AmountColumn::make('amount')->label('Amount')->sortable(),
                DateColumn::make('joined')->label('Date')->sortable(),
            ]);

        $tableRequest = $this->parser->parse($request);
        $rows = $this->members->all();

        if ($tableRequest->sort) {
            $desc = $tableRequest->sort->direction->value === 'desc';
            $column = $tableRequest->sort->column;
            $getValue = $column === 'amount'
                ? fn($member) => $member->amount->minorUnits
                : fn($member) => $member->{$column};
            $rows = $desc ? $rows->sortByDesc($getValue) : $rows->sortBy($getValue);
        }

        $cellTypesTable = $table;
        $cellTypesPaginator = ArrayPaginator::fromCollection($rows->values(), 10, $tableRequest->page);

        return ['cellTypesTable' => $cellTypesTable, 'cellTypesPaginator' => $cellTypesPaginator];
    }
}

<x-pajak-table::table :table="$cellTypesTable" :paginator="$cellTypesPaginator" />

<?php

use Illuminate\Contracts\View\View;
use Illuminate\Http\Request;
use Pajak\Ui\Table\Columns\AvatarColumn;
use Pajak\Ui\Table\Columns\BadgeListColumn;
use Pajak\Ui\Table\Columns\DateColumn;
use Pajak\Ui\Table\Columns\StatusColumn;
use Pajak\Ui\Table\Pagination\ArrayPaginator;
use Pajak\Ui\Table\Table;

class UserController extends Controller
{
    public function __construct(private readonly TableColumnOptionsBuilder $tableColumnOptions) {
    }

    public function index(Request $request): View
    {
        return view('users.index', $this->tableColumnOptions->build($request));
    }
}

// TableColumnOptionsBuilder — app/Tables/TableColumnOptionsBuilder.php
class TableColumnOptionsBuilder
{
    public function build(Request $request): array
    {
        $table = Table::make('users')
            ->dataUrl(route('users.table'))
            ->columns([
                // Name computed from the row; initials default to two letters ("AM")
                AvatarColumn::make('last_name')
                    ->label('Person')
                    ->name(fn(array $row): string => sprintf('%s %s', $row['first_name'], $row['last_name']))
                    ->subtitle('email'),

                // Value computed from the row, mapped to a label and a colour
                StatusColumn::make('active')
                    ->label('Status')
                    ->value(fn(array $row): bool => $row['active'])
                    ->labels([1 => 'Active', 0 => 'Disabled'])
                    ->colors([1 => 'green', 0 => 'gray']),

                // One badge per item of an array value
                BadgeListColumn::make('roles')
                    ->label('Roles')
                    ->labels(['admin' => 'Admin', 'editor' => 'Editor', 'billing' => 'Billing'])
                    ->colors(['admin' => 'purple', 'editor' => 'blue'])
                    ->empty('No roles'),

                DateColumn::make('last_login_utc')->label('Last login (UTC)')->format('d.m.Y H:i'),

                // Converted for display - PHP's global timezone is untouched
                DateColumn::make('last_login')
                    ->label('Last login (Bratislava)')
                    ->format('d.m.Y H:i')
                    ->timezone('Europe/Bratislava'),
            ]);

        $paginator = ArrayPaginator::fromArray([
            [
                'id' => 1,
                'first_name' => 'Alice',
                'last_name' => 'Martin',
                'email' => '[email protected]',
                'active' => true,
                'roles' => ['admin', 'editor'],
                'last_login' => '2026-06-15 22:30:00+00:00',
                'last_login_utc' => '2026-06-15 22:30:00+00:00',
            ],
            // …
        ]);

        return ['columnOptionsTable' => $table, 'columnOptionsPaginator' => $paginator];
    }
}

<x-pajak-table::table :table="$columnOptionsTable" :paginator="$columnOptionsPaginator" />

<?php

use App\Contracts\EmployeeRepository;
use App\Tables\TableFiltersChipsBuilder;
use Illuminate\Contracts\View\View;
use Illuminate\Http\Request;
use Pajak\Ui\Table\Services\TableFilters;
use Pajak\Ui\Table\Services\TableRequestParser;

class EmployeeController extends Controller
{
    public function __construct(private readonly TableFiltersChipsBuilder $tableFiltersChips) {
    }

    public function index(Request $request): View
    {
        return view('employees.index', $this->tableFiltersChips->build($request));
    }
}

// TableFiltersChipsBuilder — app/Tables/TableFiltersChipsBuilder.php
class TableFiltersChipsBuilder
{
    public function __construct(
        private readonly EmployeeRepository $employees,
        private readonly TableRequestParser $parser,
        private readonly TableFilters $tableFilters,
    ) {}

    public function build(Request $request): array
    {
        $filters = [
            TextFilter::make('name')->label('Name'),
            SelectFilter::make('department')->label('Department')->options([
                'Engineering' => 'Engineering',
                'Design' => 'Design',
                'Marketing' => 'Marketing',
                'HR' => 'HR',
            ]),
            NumberFilter::make('salary')->label('Min salary'),
            DateFilter::make('hired')->label('Hired after'),
        ];

        $table = Table::make('employees')
            ->dataUrl(route('employees.table'))
            ->searchable()
            ->columns([
                TextColumn::make('name')->label('Name')->sortable(),
                TextColumn::make('department')->label('Department')->sortable(),
                StatusColumn::make('status')->label('Status')->colors([
                    'active' => 'green',
                    'inactive' => 'gray',
                    'pending' => 'yellow',
                ]),
                AmountColumn::make('salary')->label('Salary')->sortable(),
                DateColumn::make('hired')->label('Hired')->sortable(),
            ])
            ->filters($filters);

        $tableRequest = $this->parser->parse($request);
        $rows = $this->tableFilters->apply($this->employees->all(), $tableRequest->filters);

        if ($tableRequest->search) {
            $query = mb_strtolower($tableRequest->search);
            $rows = $rows->filter(fn($employee) => str_contains(mb_strtolower($employee->name), $query)
                || str_contains(mb_strtolower($employee->department), $query));
        }

        if ($tableRequest->sort) {
            $rows = $tableRequest->sort->direction->value === 'desc'
                ? $rows->sortByDesc(fn($employee) => $employee->{$tableRequest->sort->column})
                : $rows->sortBy(fn($employee) => $employee->{$tableRequest->sort->column});
        }

        $filtersChipsTable = $table;
        $filtersChipsPaginator = ArrayPaginator::fromCollection($rows->values(), 10, $tableRequest->page);

        return ['filtersChipsTable' => $filtersChipsTable, 'filtersChipsPaginator' => $filtersChipsPaginator];
    }
}

<x-pajak-table::table :table="$filtersChipsTable" :paginator="$filtersChipsPaginator" />

<?php

use App\Contracts\InvoiceRepository;
use App\Tables\TableActionsBuilder;
use Illuminate\Contracts\View\View;
use Illuminate\Http\Request;
use Pajak\Ui\Table\Services\TableFilters;
use Pajak\Ui\Table\Services\TableRequestParser;

class InvoiceController extends Controller
{
    public function __construct(private readonly TableActionsBuilder $tableActions) {
    }

    public function index(Request $request): View
    {
        return view('invoices.index', $this->tableActions->build($request));
    }
}

// TableActionsBuilder — app/Tables/TableActionsBuilder.php
class TableActionsBuilder
{
    public function __construct(
        private readonly InvoiceRepository $invoices,
        private readonly TableRequestParser $parser,
        private readonly TableFilters $tableFilters,
    ) {}

    public function build(Request $request): array
    {
        $filters = [
            SelectFilter::make('status')->label('Status')->options([
                'paid' => 'Paid',
                'pending' => 'Pending',
                'draft' => 'Draft',
            ]),
        ];

        $table = Table::make('invoices')
            ->dataUrl(route('invoices.table'))
            ->columns([
                TextColumn::make('number')->label('Invoice')->sortable(),
                TextColumn::make('client')->label('Client'),
                StatusColumn::make('status')->label('Status')->sortable()->colors([
                    'paid' => 'green',
                    'pending' => 'yellow',
                    'draft' => 'gray',
                ]),
                AmountColumn::make('amount')->label('Amount')->sortable(),
                DateColumn::make('due')->label('Due date')->sortable(),
            ])
            ->filters($filters)
            ->actions([
                LinkAction::make('view')->label('View')->url(fn($row) => route('invoices.show', $row))->inlineOnly(),
                LinkAction::make('edit')->label('Edit')->url(fn($row) => route('invoices.edit', $row)),
                ConfirmAction::make('delete')
                    ->label('Delete')
                    ->url(fn($row) => route('invoices.destroy', $row))
                    ->method(Method::Delete)
                    ->danger()
                    ->confirmTitle('Delete invoice?')
                    ->confirmMessage('This will permanently remove the invoice and cannot be undone.')
                    ->confirmButton('Delete'),
            ]);

        $tableRequest = $this->parser->parse($request);
        $rows = $this->tableFilters->apply($this->invoices->all(), $tableRequest->filters);

        if ($tableRequest->sort) {
            $rows = $tableRequest->sort->direction->value === 'desc'
                ? $rows->sortByDesc(fn($invoice) => $invoice->{$tableRequest->sort->column})
                : $rows->sortBy(fn($invoice) => $invoice->{$tableRequest->sort->column});
        }

        $actionsTable = $table;
        $actionsPaginator = ArrayPaginator::fromCollection($rows->values(), 10, $tableRequest->page);

        return ['actionsTable' => $actionsTable, 'actionsPaginator' => $actionsPaginator];
    }
}

<x-pajak-table::table :table="$actionsTable" :paginator="$actionsPaginator" />

<?php

use Illuminate\Contracts\View\View;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Pajak\Ui\Common\Dto\ToastData;
use Pajak\Ui\Common\Enums\Method;
use Pajak\Ui\Table\Actions\ConfirmAction;
use Pajak\Ui\Table\Actions\FormAction;
use Pajak\Ui\Table\Columns\BadgeColumn;
use Pajak\Ui\Table\Columns\TextColumn;
use Pajak\Ui\Table\Pagination\ArrayPaginator;
use Pajak\Ui\Table\Table;

class InvitationController extends Controller
{
    public function __construct(private readonly TableAsyncActionsBuilder $tableAsyncActions) {
    }

    public function index(Request $request): View
    {
        return view('invitations.index', $this->tableAsyncActions->build($request));
    }

    // Async actions get JSON back: a `toast` on success, or `message` (+ `errors`) on failure
    public function resend(string $invitation): JsonResponse
    {
        return new JsonResponse(['toast' => ToastData::success('Done', 'The invitation was resent.')]);
    }
}

// TableAsyncActionsBuilder — app/Tables/TableAsyncActionsBuilder.php
class TableAsyncActionsBuilder
{
    public function build(Request $request): array
    {
        $table = Table::make('invitations')
            ->dataUrl(route('invitations.table'))
            ->columns([
                TextColumn::make('email')->label('Invitation'),
                BadgeColumn::make('status')->label('Status')->colors([
                    'pending' => 'yellow',
                    'expired' => 'red',
                ]),
            ])
            ->actions([
                // Sent with fetch (JSON); the toast is shown and the table page is re-fetched
                FormAction::make('resend')
                    ->label('Resend invitation')
                    ->url(fn(array $row): string => route('invitations.resend', $row['id']))
                    ->async(),

                ConfirmAction::make('revoke')
                    ->label('Revoke')
                    ->url(fn(array $row): string => route('invitations.revoke', $row['id']))
                    ->method(Method::Delete)
                    ->async()
                    ->danger()
                    ->confirmTitle('Revoke invitation?')
                    ->confirmMessage('The invitee will no longer be able to join.')
                    ->confirmButton('Revoke'),
            ]);

        $paginator = ArrayPaginator::fromArray([
            ['id' => 1, 'email' => '[email protected]', 'status' => 'pending'],
            // …
        ]);

        return ['asyncActionsTable' => $table, 'asyncActionsPaginator' => $paginator];
    }
}

<x-pajak-table::table :table="$asyncActionsTable" :paginator="$asyncActionsPaginator" />

<?php

declare(strict_types=1);

use App\Contracts\InvoiceRepository;
use Illuminate\Contracts\View\View;
use Illuminate\Http\Request;
use Pajak\Ui\Common\Enums\Method;
use Pajak\Ui\Table\Actions\ConfirmAction;
use Pajak\Ui\Table\Actions\LinkAction;
use Pajak\Ui\Table\Pagination\ArrayPaginator;
use Pajak\Ui\Table\Services\TableFilters;
use Pajak\Ui\Table\Services\TableRequestParser;
use Pajak\Ui\Table\Table;

class InvoiceController extends Controller
{
    public function __construct(private readonly TableIconActionsBuilder $tableIconActions) {
    }

    public function index(Request $request): View
    {
        return view('invoices.index', $this->tableIconActions->build($request));
    }
}

class TableIconActionsBuilder
{
    public function __construct(
        private readonly InvoiceRepository $invoices,
        private readonly TableRequestParser $parser,
        private readonly TableFilters $tableFilters,
    ) {}

    /** @return array<string, mixed> */
    public function build(Request $request): array
    {
        $table = Table::make('invoices')
            ->dataUrl(route('invoices.table'))
            ->columns([
                TextColumn::make('number')->label('Invoice')->sortable(),
                TextColumn::make('client')->label('Client'),
                StatusColumn::make('status')->label('Status')->sortable()->colors([
                    'paid' => 'green',
                    'pending' => 'yellow',
                    'draft' => 'gray',
                ]),
                AmountColumn::make('amount')->label('Amount')->sortable(),
                DateColumn::make('due')->label('Due date')->sortable(),
            ])
            ->actions([
                LinkAction::make('view')
                    ->label('View')
                    ->icon('heroicon-o-eye')
                    ->iconOnly()
                    ->inlineOnly()
                    ->url(fn($row) => route('invoices.show', $row)),
                LinkAction::make('edit')
                    ->label('Edit')
                    ->icon('heroicon-o-pencil')
                    ->iconOnly()
                    ->inlineOnly()
                    ->url(fn($row) => route('invoices.edit', $row)),
                ConfirmAction::make('delete')
                    ->label('Delete')
                    ->icon('heroicon-o-trash')
                    ->iconOnly()
                    ->inlineOnly()
                    ->danger()
                    ->url(fn($row) => route('invoices.destroy', $row))
                    ->method(Method::Delete)
                    ->confirmTitle('Delete invoice?')
                    ->confirmMessage('This will permanently remove the invoice and cannot be undone.')
                    ->confirmButton('Delete'),
            ]);

        $tableRequest = $this->parser->parse($request);
        $rows = $this->tableFilters->apply($this->invoices->all(), $tableRequest->filters);

        if ($tableRequest->sort) {
            $rows = $tableRequest->sort->direction->value === 'desc'
                ? $rows->sortByDesc(fn($invoice) => $invoice->{$tableRequest->sort->column})
                : $rows->sortBy(fn($invoice) => $invoice->{$tableRequest->sort->column});
        }

        return [
            'iconActionsTable' => $table,
            'iconActionsPaginator' => ArrayPaginator::fromCollection($rows->values(), 10, $tableRequest->page),
        ];
    }
}

<x-pajak-table::table :table="$iconActionsTable" :paginator="$iconActionsPaginator" />

<?php

use App\Contracts\InvoiceRepository;
use App\Tables\TableModalActionBuilder;
use Illuminate\Contracts\View\View;
use Illuminate\Http\Request;
use Pajak\Ui\Table\Services\TableRequestParser;

class InvoiceController extends Controller
{
    public function __construct(private readonly TableModalActionBuilder $tableModalAction) {
    }

    public function index(Request $request): View
    {
        return view('invoices.index', $this->tableModalAction->build($request));
    }
}

// TableModalActionBuilder — app/Tables/TableModalActionBuilder.php
class TableModalActionBuilder
{
    public function __construct(
        private readonly InvoiceRepository $invoices,
        private readonly TableRequestParser $parser,
    ) {}

    public function build(Request $request): array
    {
        $table = Table::make('invoices')
            ->dataUrl(route('invoices.table'))
            ->columns([
                TextColumn::make('number')->label('Invoice')->sortable(),
                TextColumn::make('client')->label('Client'),
                StatusColumn::make('status')->label('Status')->sortable()->colors([
                    'paid' => 'green',
                    'pending' => 'yellow',
                    'draft' => 'gray',
                ]),
                AmountColumn::make('amount')->label('Amount')->sortable(),
                DateColumn::make('due')->label('Due date')->sortable(),
            ])
            ->actions([
                ModalAction::make('send')
                    ->label('Send')
                    ->modalId(fn($invoice) => sprintf('send-invoice-%d', $invoice->id))
                    ->inlineOnly(),
                ConfirmAction::make('delete')
                    ->label('Delete')
                    ->url(fn($invoice) => route('invoices.destroy', $invoice))
                    ->method(Method::Delete)
                    ->danger()
                    ->confirmTitle('Delete invoice?')
                    ->confirmMessage('This will permanently remove the invoice and cannot be undone.')
                    ->confirmButton('Delete'),
            ]);

        $tableRequest = $this->parser->parse($request);
        $invoices = $this->invoices->all();

        if ($tableRequest->sort) {
            $invoices = $tableRequest->sort->direction->value === 'desc'
                ? $invoices->sortByDesc(fn($invoice) => $invoice->{$tableRequest->sort->column})
                : $invoices->sortBy(fn($invoice) => $invoice->{$tableRequest->sort->column});
        }

        $modalActionTable = $table;
        $modalActionPaginator = ArrayPaginator::fromCollection($invoices->values(), 10, $tableRequest->page);
        $modalActionInvoices = $invoices->values();

        return ['modalActionTable' => $modalActionTable, 'modalActionPaginator' => $modalActionPaginator, 'modalActionInvoices' => $modalActionInvoices];
    }
}

@use('Pajak\Ui\Common\Enums\Variant')

@foreach($modalActionInvoices as $invoice)
    <x-pajak::modal :id="'send-invoice-' . $invoice->id" :title="'Send ' . $invoice->number">
        <x-slot:description>
            Send this invoice to <strong>{{ $invoice->client }}</strong>. They will receive an email with a payment link.
        </x-slot:description>
        <x-slot:footer>
            <x-pajak::button :variant="Variant::Ghost" data-pajak-modal-close>Cancel</x-pajak::button>
            <x-pajak::button>Send invoice</x-pajak::button>
        </x-slot:footer>
    </x-pajak::modal>
@endforeach

<x-pajak-table::table :table="$modalActionTable" :paginator="$modalActionPaginator" />

<?php

use App\Contracts\UserRepository;
use App\Tables\TableBulkActionsBuilder;
use Illuminate\Contracts\View\View;
use Illuminate\Http\Request;
use Pajak\Ui\Table\Services\TableFilters;
use Pajak\Ui\Table\Services\TableRequestParser;

class UserController extends Controller
{
    public function __construct(private readonly TableBulkActionsBuilder $tableBulkActions) {
    }

    public function index(Request $request): View
    {
        return view('users.index', $this->tableBulkActions->build($request));
    }
}

// TableBulkActionsBuilder — app/Tables/TableBulkActionsBuilder.php
class TableBulkActionsBuilder
{
    public function __construct(
        private readonly UserRepository $users,
        private readonly TableRequestParser $parser,
        private readonly TableFilters $tableFilters,
    ) {}

    public function build(Request $request): array
    {
        $filters = [
            TextFilter::make('name')->label('Name'),
            SelectFilter::make('role')->label('Role')->options([
                'Admin' => 'Admin',
                'Editor' => 'Editor',
                'Viewer' => 'Viewer',
            ]),
            SelectFilter::make('status')->label('Status')->options([
                'active' => 'Active',
                'inactive' => 'Inactive',
                'pending' => 'Pending',
            ]),
        ];

        $table = Table::make('users')
            ->dataUrl(route('users.table'))
            ->searchable()
            ->columns([
                AvatarColumn::make('name')->label('Name')->image('avatar'),
                TextColumn::make('role')->label('Role')->sortable(),
                StatusColumn::make('status')->label('Status')->sortable()->colors([
                    'active' => 'green',
                    'inactive' => 'gray',
                    'pending' => 'yellow',
                ]),
                DateColumn::make('joined')->label('Joined')->sortable(),
            ])
            ->filters($filters)
            ->actions([
                LinkAction::make('edit')->label('Edit')->url(fn($row) => route('users.edit', $row))->inlineOnly(),
                ConfirmAction::make('deactivate')
                    ->label('Deactivate')
                    ->url(fn($row) => route('users.deactivate', $row))
                    ->danger()
                    ->confirmTitle('Deactivate user?')
                    ->confirmMessage('The user will lose access immediately.')
                    ->confirmButton('Deactivate'),
            ])
            ->bulkActions([
                FormAction::make('export')
                    ->label('Export selected')
                    ->url(fn($row) => route('users.export'))
                    ->method(Method::Post),
                ConfirmAction::make('bulk-delete')
                    ->label('Delete selected')
                    ->url(fn($row) => route('users.bulk-destroy'))
                    ->method(Method::Delete)
                    ->danger()
                    ->confirmTitle('Delete users?')
                    ->confirmMessage('All selected users will be permanently removed.')
                    ->confirmButton('Delete all'),
            ]);

        $tableRequest = $this->parser->parse($request);
        $rows = $this->tableFilters->apply($this->users->all(), $tableRequest->filters);

        if ($tableRequest->search) {
            $query = mb_strtolower($tableRequest->search);
            $rows = $rows->filter(fn($user) => str_contains(mb_strtolower($user->name), $query));
        }

        if ($tableRequest->sort) {
            $rows = $tableRequest->sort->direction->value === 'desc'
                ? $rows->sortByDesc(fn($user) => $user->{$tableRequest->sort->column})
                : $rows->sortBy(fn($user) => $user->{$tableRequest->sort->column});
        }

        $bulkTable = $table;
        $bulkPaginator = ArrayPaginator::fromCollection($rows->values(), 10, $tableRequest->page);

        return ['bulkTable' => $bulkTable, 'bulkPaginator' => $bulkPaginator];
    }
}

<x-pajak-table::table :table="$bulkTable" :paginator="$bulkPaginator" />

<?php

declare(strict_types=1);

use App\Contracts\InvoiceRepository;
use Illuminate\Contracts\View\View;
use Illuminate\Http\Request;
use Pajak\Ui\Table\Services\TableFilters;
use Pajak\Ui\Table\Services\TableRequestParser;

class InvoiceController extends Controller
{
    public function __construct(private readonly TableAsyncBuilder $tableAsync) {
    }

    public function index(Request $request): View
    {
        return view('invoices.index', $this->tableAsync->build($request));
    }
}

class TableAsyncBuilder
{
    public function __construct(
        private readonly InvoiceRepository $invoices,
        private readonly TableRequestParser $parser,
        private readonly TableFilters $tableFilters,
    ) {}

    /** @return array<string, mixed> */
    public function build(Request $request): array
    {
        $table = Table::make('invoices')
            ->dataUrl(route('invoices.table'))
            ->async()
            ->searchable()
            ->columns([
                TextColumn::make('number')->label('Number')->sortable(),
                TextColumn::make('client')->label('Client')->sortable(),
                StatusColumn::make('status')->label('Status')->sortable()->colors([
                    'paid' => 'green',
                    'pending' => 'yellow',
                    'draft' => 'gray',
                ]),
                DateColumn::make('due')->label('Date')->sortable(),
            ])
            ->filters([
                TextFilter::make('client')->label('Client'),
                SelectFilter::make('status')->label('Status')->options([
                    'paid' => 'Paid',
                    'pending' => 'Pending',
                    'draft' => 'Draft',
                ]),
            ])
            ->actions([
                LinkAction::make('view')->label('View')->url(fn($row) => route('invoices.show', $row))->inlineOnly(),
            ]);

        $tableRequest = $this->parser->parse($request);
        $rows = $this->tableFilters->apply($this->invoices->all(), $tableRequest->filters);

        if ($tableRequest->search) {
            $query = mb_strtolower($tableRequest->search);
            $rows = $rows->filter(fn($invoice) => str_contains(mb_strtolower($invoice->client), $query)
                || str_contains(mb_strtolower($invoice->number), $query));
        }

        if ($tableRequest->sort) {
            $rows = $tableRequest->sort->direction->value === 'desc'
                ? $rows->sortByDesc(fn($invoice) => $invoice->{$tableRequest->sort->column})
                : $rows->sortBy(fn($invoice) => $invoice->{$tableRequest->sort->column});
        }

        return [
            'asyncTable' => $table,
            'asyncPaginator' => ArrayPaginator::fromCollection($rows->values(), 10, $tableRequest->page),
        ];
    }
}

<x-pajak-table::table :table="$asyncTable" :paginator="$asyncPaginator" />

<?php

use App\Tables\TableEmptyBuilder;
use Illuminate\Contracts\View\View;
use Illuminate\Http\Request;
use Pajak\Ui\Table\Services\TableFilters;
use Pajak\Ui\Table\Services\TableRequestParser;

class InvoiceController extends Controller
{
    public function __construct(private readonly TableEmptyBuilder $tableEmpty) {
    }

    public function index(Request $request): View
    {
        return view('invoices.index', $this->tableEmpty->build($request));
    }
}

// TableEmptyBuilder — app/Tables/TableEmptyBuilder.php
class TableEmptyBuilder
{
    public function __construct(
        private readonly TableRequestParser $parser,
        private readonly TableFilters $tableFilters,
    ) {}

    public function build(Request $request): array
    {
        $table = Table::make('invoices')
            ->dataUrl(route('invoices.table'))
            ->columns([
                TextColumn::make('number')->label('Number')->sortable(),
                TextColumn::make('client')->label('Client')->sortable(),
                StatusColumn::make('status')->label('Status')->colors([
                    'paid' => 'green',
                    'pending' => 'yellow',
                    'draft' => 'gray',
                ]),
            ])
            ->filters([
                TextFilter::make('number')->label('Number'),
            ]);

        $tableRequest = $this->parser->parse($request);
        $rows = $this->tableFilters->apply(new Collection([]), $tableRequest->filters);
        $emptyTable = $table;
        $emptyPaginator = ArrayPaginator::fromCollection($rows, 10, $tableRequest->page);

        return ['emptyTable' => $emptyTable, 'emptyPaginator' => $emptyPaginator];
    }
}

<x-pajak-table::table :table="$emptyTable" :paginator="$emptyPaginator" />