Property [$hasLazyEnabled] not found

[caiochami]

Have you searched through other issues to see if your problem is already reported or has been fixed?

Yes, I did not find it.

Did you read the documentation?

Yes, I did not find it.

Have you tried to publish the views?

Yes - I didn't work.

Is there an error in the console?

[No](powergrid.js:2 PowerGrid: Unable to load icons in javascript window in row: [null])

PHP Version

8.3.14

PowerGrid

6.1.7

Laravel

11.33.2

Livewire

3.5.6

Alpine JS

No response

Theme

Tailwind 3.x

Describe the bug.

I ran into multiple issues after upgrading the package

I get the following error on export:

Livewire\Exceptions\PropertyNotFoundException: Property [$hasLazyEnabled] not found on component: [] in project-path-here/vendor/livewire/livewire/src/Component.php:105

If I manually set this property, I get the following
Livewire\Exceptions\PropertyNotFoundException: Property [$realPrimaryKey] not found on component: [] in.../vendor/livewire/livewire/src/Component.php:105

To Reproduce...

Extra information

<?php

namespace App\Livewire\Payments;

use App\Enums\Payments\Method;
use App\Enums\Payments\Status;
use App\Enums\Queue;
use App\Enums\Source;
use App\Livewire\Billing\Concerns\WithCustomerPageUrl;
use App\Livewire\Clients\Show as ClientDetailsPage;
use App\Livewire\Companies\Show as CompanyDetailsPage;
use App\Livewire\Payments\Concerns\HasSourceUrl;
use App\Livewire\Payments\Concerns\WithProductOptions;
use App\Models\Client;
use App\Models\Company;
use App\Models\Payment;
use Carbon\Carbon;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Blade;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Gate;
use PowerComponents\LivewirePowerGrid\Button;
use PowerComponents\LivewirePowerGrid\Column;
use PowerComponents\LivewirePowerGrid\Components\SetUp\Exportable;
use PowerComponents\LivewirePowerGrid\Facades\Filter;
use PowerComponents\LivewirePowerGrid\Facades\PowerGrid;
use PowerComponents\LivewirePowerGrid\Facades\Rule;
use PowerComponents\LivewirePowerGrid\PowerGridComponent;
use PowerComponents\LivewirePowerGrid\PowerGridFields;
use PowerComponents\LivewirePowerGrid\Traits\WithExport;
use WireUi\Traits\WireUiActions as Actions;

final class DataTable extends PowerGridComponent
{
    use WithExport;
    use Actions;
    use WithCustomerPageUrl;
    use WithProductOptions;
    use HasSourceUrl;

    public int $teamId;

    public bool $deferLoading = true;

    public string $loadingComponent = 'components.data-tables.loading';

    public string $tableName = 'payments-table';

    protected function getListeners(): array
    {
        return array_merge(
            parent::getListeners(),
            [
                "echo-private:teams.{$this->teamId}.payments,.App\\Events\\Payments\\ImportFinished" => 'importFinished',
                "echo-private:teams.{$this->teamId}.payments,.App\\Events\\Payments\\StatusChanged"  => '$refresh',
                'payment-deleted'                                                                    => '$refresh',
                'payment-updated'                                                                    => '$refresh',
            ]
        );
    }

    public function boot(): void
    {
        config(['livewire-powergrid.filter' => 'outside']);
    }

    public function importFinished(): void
    {
        $this->notification()->success(__('import.notifications.finished'));
    }

    public function header(): array
    {
        return [
            Button::add('import-payments')
                ->icon('arrow-up-tray')
                ->can(Gate::allows('import', Payment::class))
                ->class('pg-btn-white dark:ring-pg-primary-600 dark:border-pg-primary-600 dark:hover:bg-pg-primary-700 dark:ring-offset-pg-primary-800 dark:text-pg-primary-400 dark:bg-pg-primary-700')
                ->dispatch('import-payments', []),
        ];
    }

    public function setUp(): array
    {
        $this->persist(
            tableItems: ['columns'],
            prefix: 'payments-' . Auth::id()
        );

        return [
            PowerGrid::exportable(fileName: strtolower(__('payments.index.title')))
                ->striped()
                ->type(Exportable::TYPE_XLS, Exportable::TYPE_CSV)
                ->queues(1)
                ->onQueue(Queue::LONG_TIMEOUT->value),
            PowerGrid::footer()
                ->showPerPage(perPage: 10, perPageValues: [10, 50, 100])
                ->showRecordCount('full'),
            PowerGrid::header()
                ->showToggleColumns()
                ->withoutLoading(),
            PowerGrid::detail()
                ->view('livewire.payments.data-table.detail')
                ->params([])
                ->collapseOthers()
                ->showCollapseIcon(),
        ];
    }

    public function datasource(array $parameters = []): Builder
    {
        return Payment::query()
            ->whereHas('customer')
            ->with([
                'customer.card',
                'invoice.items',
                'carnet.items',
            ])
            ->where('team_id', $parameters['teamId'] ?? Auth::user()->current_team_id)
            ->select([
                'payments.*',
                DB::raw('payments.amount + payments.fine_amount + payments.interest_amount as net_amount'),
            ]);
    }

    public function fields(): PowerGridFields
    {
        return PowerGrid::fields()
            ->add('id')
            ->add('identification_number')
            ->add('gross_amount', fn (Payment $payment) => e($payment->formatted_amount))
            ->add('fine', fn (Payment $payment) => e(formatCents($payment->fine_amount)))
            ->add('interest', fn (Payment $payment) => e(formatCents($payment->interest_amount)))
            ->add('net_amount', fn (Payment $payment) => e(formatCents($payment->net_amount)))
            ->add('method', fn (Payment $payment) => e($payment->formatted_method))
            ->add('status', fn (Payment $payment) => e(Status::from($payment->custom_status)->labels()))
            ->add('source', fn (Payment $payment) => e($payment->formatted_source))
            ->add('source_as_link', fn (Payment $payment) => $this->getSourceUrl($payment))
            ->add('customer_name', fn (Payment $payment) => e($payment->customer->name))
            ->add('customer_name_as_html_link', function (Payment $payment) {
                $route = $this->getCustomerDetailsPageUrl(
                    $payment->customer,
                    $payment->customer->isCompany() ? CompanyDetailsPage::TAB_PAYMENTS : ClientDetailsPage::TAB_PAYMENTS
                );

                return sprintf('<a href="' . $route . '" class="hover:underline">%s</a>', e($payment->customer->name));
            })
            ->add('products', fn (Payment $payment) => e($payment->products_name))
            ->add(
                'paid_at_formatted',
                fn (Payment $payment) => e(Carbon::parse($payment->getRawOriginal('paid_at'))->format('d/m/Y'))
            )
            ->add(
                'due_date_formatted',
                fn (Payment $payment) => e(Carbon::parse($payment->getRawOriginal('due_date'))->format('d/m/Y'))
            )
            ->add(
                'issue_date_formatted',
                fn (Payment $payment) => e(Carbon::parse($payment->getRawOriginal('issue_date'))->format('d/m/Y'))
            );
    }

    public function columns(): array
    {
        return [
            Column::add()
                ->title(__('Number'))
                ->field('identification_number', 'payments.identification_number'),
            Column::make(__('Customer'), 'customer_name')
                ->visibleInExport(true)
                ->hidden(true),
            Column::make(__('Customer'), 'customer_name_as_html_link')
                ->visibleInExport(false),
            Column::make(__('Origin'), 'source', 'payments.source')
                ->hidden(true)
                ->visibleInExport(true),
            Column::make(__('Origin'), 'source_as_link', 'payments.source')
                ->visibleInExport(false)
                ->sortable(),
            Column::add()
                ->title(__('Gross amount'))
                ->field('gross_amount', 'payments.amount')
                ->withSum(__('Sum amount'), header: true, footer: false)
                ->withAvg(__('Avg amount'), header: true, footer: false)
                ->withMin(__('Min amount'), header: false, footer: true)
                ->withMax(__('Max amount'), header: false, footer: true)
                ->sortable(),
            Column::add()
                ->title(__('Fine'))
                ->field('fine', 'payments.fine_amount')
                ->sortable(),
            Column::add()
                ->title(__('Interest'))
                ->field('interest', 'payments.interest_amount')
                ->sortable(),
            Column::add()
                ->title(__('Net amount'))
                ->field('net_amount', 'net_amount')
                ->sortable(),
            Column::add()
                ->title(__('Method'))
                ->field('method', 'method')
                ->sortable(),
            Column::add()
                ->title(__('Products'))
                ->field('products'),
            Column::make(__('Status'), 'status', 'status')
                ->sortable(),
            Column::add()
                ->field('paid_at_formatted', 'paid_at')
                ->title(__('Paid at'))
                ->sortable(),
            Column::add()
                ->field('due_date_formatted', 'due_date')
                ->title(__('Due date'))
                ->sortable(),
            Column::add()
                ->field('issue_date_formatted', 'issue_date')
                ->title(__('Issue date'))
                ->sortable(),
            // Column::action(__('Actions'))
            //     ->visibleInExport(false),
        ];
    }

    public function summarizeFormat(): array
    {
        return [
            'gross_amount.{sum,avg,min,max}' => fn (int $value) => formatCents($value),
        ];
    }

    public function filters(): array
    {
        return [
            Filter::inputText('identification_number')
                ->operators(['contains'])
                ->builder(function (Builder $builder, array $data) {
                    $builder->where(
                        'payments.identification_number',
                        'like',
                        '%' . $data['value'] . '%'
                    );
                }),
            Filter::inputText('customer_name_as_html_link')
                ->operators(['contains'])
                ->placeholder(__('Search by name, CPF, CNPJ or email'))
                ->builder(
                    function (Builder $builder, array $data) {
                        $builder->whereMorphRelation(
                            'customer',
                            [Client::class, Company::class],
                            function (Builder $builder) use ($data) {
                                $builder->where('name', 'like', '%' . $data['value'] . '%')
                                    ->orWhere('email', 'like', '%' . $data['value'] . '%')
                                    ->orWhere('identification_number', 'like', '%' . $data['value'] . '%');
                            }
                        );
                    }
                ),
            Filter::multiSelect('source_as_link', 'payments.source')
                ->dataSource([
                    [
                        'value' => Source::IMPORT->value,
                        'label' => Source::IMPORT->labels(),
                    ],
                    [
                        'value' => Source::USER->value,
                        'label' => Source::USER->labels(),
                    ],
                    [
                        'value' => Source::INVOICE->value,
                        'label' => Source::INVOICE->labels(),
                    ],
                    [
                        'value' => Source::CARNET_PARCEL->value,
                        'label' => Source::CARNET_PARCEL->labels(),
                    ],
                ])
                ->optionLabel('label')
                ->optionValue('value'),
            Filter::datepicker('paid_at', 'paid_at')
                ->builder(function (Builder $builder, array $period) {
                    return $builder->whereDate('paid_at', '>=', Carbon::parse($period['start']))
                        ->whereDate('paid_at', '<=', Carbon::parse($period['end']));
                }),
            Filter::datepicker('due_date', 'due_date')
                ->builder(function (Builder $builder, array $period) {
                    return $builder->whereDate('due_date', '>=', Carbon::parse($period['start']))
                        ->whereDate('due_date', '<=', Carbon::parse($period['end']));
                }),
            Filter::datepicker('issue_date', 'issue_date')
                ->builder(function (Builder $builder, array $period) {
                    return $builder->whereDate('issue_date', '>=', Carbon::parse($period['start']))
                        ->whereDate('issue_date', '<=', Carbon::parse($period['end']));
                }),
            Filter::multiSelect('status', 'payments.status')
                ->dataSource(Status::dataSource())
                ->optionLabel('label')
                ->optionValue('value')
                ->builder(function (Builder $builder, array $statuses) {
                    $builder->whereIn('status', $statuses)
                        ->when(
                            in_array(Status::PENDING->value, $statuses),
                            fn (Builder $builder) => $builder->orWhere(fn (Builder $builder) => $builder->pending())
                        )
                        ->when(
                            in_array(Status::UP_TO_DATE->value, $statuses),
                            fn (Builder $builder) => $builder->orWhere(fn (Builder $builder) => $builder->upToDate())
                        )
                        ->when(
                            in_array(Status::OVERDUE->value, $statuses),
                            fn (Builder $builder) => $builder->orWhere(fn (Builder $builder) => $builder->overdue())
                        );
                }),
            Filter::multiSelect('products')
                ->dataSource($this->products ?? [])
                ->optionLabel('name')
                ->optionValue('id')
                ->builder(function (Builder $builder, array $planIds) {
                    $builder->products($planIds);
                }),
            Filter::multiSelectAsync('salesperson', 'payments.user_id')
                ->url(route('users.search'))
                ->method('POST')
                ->optionValue('id')
                ->optionLabel('name'),
            Filter::multiSelect('method', )
                ->dataSource(collect(Method::cases())->map(fn (Method $method) => [
                    'label' => $method->label(),
                    'value' => $method->value,
                ]))
                ->optionLabel('label')
                ->optionValue('value'),
        ];
    }
}

[luanfreitasdev]

Fixed: #1819