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->has('per_page') ? $tableRequest->perPage : 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);
        $cellTypesTable = $table;
        $cellTypesPaginator = ArrayPaginator::fromCollection($this->members->all(), 10, $tableRequest->page);

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

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

<?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 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

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" />