Final Class Yiisoft\Yii\DataView\GridView\GridView

                public function __construct(
    ContainerInterface $columnRenderersDependencyContainer,
    ?TranslatorInterface $translator = null,
) {
    $this->filterFormId = Html::generateId();
    $this->columnRendererContainer = new RendererContainer($columnRenderersDependencyContainer);
    parent::__construct($translator);
}

            

                public function addColumnRendererConfigs(array $configs): self
{
    $new = clone $this;
    $new->columnRendererContainer = $this->columnRendererContainer->addConfigs($configs);
    return $new;
}

            

                public function addTableClass(?string ...$class): self
{
    $new = clone $this;
    Html::addCssClass($new->tableAttributes, $class);
    return $new;
}

            

                public function addTbodyClass(?string ...$class): self
{
    $new = clone $this;
    Html::addCssClass($new->tbodyAttributes, $class);
    return $new;
}

            

                public function afterRow(?Closure $callback): self
{
    $new = clone $this;
    $new->afterRowCallback = $callback;
    return $new;
}

            

                public function beforeRow(?Closure $callback): self
{
    $new = clone $this;
    $new->beforeRowCallback = $callback;
    return $new;
}

            

                public function bodyCellAttributes(array $attributes): self
{
    $new = clone $this;
    $new->bodyCellAttributes = $attributes;
    return $new;
}

            

                public function bodyRowAttributes(Closure|array $attributes): self
{
    $new = clone $this;
    $new->bodyRowAttributes = $attributes;
    return $new;
}

            

                public function columnGrouping(bool $enabled = true): self
{
    $new = clone $this;
    $new->columnGrouping = $enabled;
    return $new;
}

            

                public function columns(ColumnInterface ...$columns): self
{
    $new = clone $this;
    $new->columns = $columns;
    return $new;
}

            

                public function emptyCell(string $content, ?array $attributes = null): self
{
    $new = clone $this;
    $new->emptyCell = $content;
    if ($attributes !== null) {
        $new->emptyCellAttributes = $attributes;
    }
    return $new;
}

            

                public function emptyCellAttributes(array $attributes): self
{
    $new = clone $this;
    $new->emptyCellAttributes = $attributes;
    return $new;
}

            

                public function enableFooter(bool $enabled = true): self
{
    $new = clone $this;
    $new->isFooterEnabled = $enabled;
    return $new;
}

            

                public function enableHeader(bool $enabled = true): self
{
    $new = clone $this;
    $new->isHeaderEnabled = $enabled;
    return $new;
}

            

                public function filterCellAttributes(array $attributes): self
{
    $new = clone $this;
    $new->filterCellAttributes = $attributes;
    return $new;
}

            

                public function filterCellInvalidClass(?string $class): self
{
    $new = clone $this;
    $new->filterCellInvalidClass = $class;
    return $new;
}

            

                public function filterErrorsContainerAttributes(array $attributes): self
{
    $new = clone $this;
    $new->filterErrorsContainerAttributes = $attributes;
    return $new;
}

            

                public function filterFormAttributes(array $attributes): self
{
    $new = clone $this;
    $new->filterFormAttributes = $attributes;
    return $new;
}

            

                public function filterFormId(string $id): self
{
    $new = clone $this;
    $new->filterFormId = $id;
    return $new;
}

            

                public function footerRowAttributes(array $attributes): self
{
    $new = clone $this;
    $new->footerRowAttributes = $attributes;
    return $new;
}

            

                public function headerCellAttributes(array $attributes): self
{
    $new = clone $this;
    $new->headerCellAttributes = $attributes;
    return $new;
}

            

                public function headerRowAttributes(array $attributes): self
{
    $new = clone $this;
    $new->headerRowAttributes = $attributes;
    return $new;
}

            

                public function keepPageOnSort(bool $enabled = true): self
{
    $new = clone $this;
    $new->keepPageOnSort = $enabled;
    return $new;
}

            

                protected function makeFilters(): array
{
    $columns = $this->getColumns();
    $renderers = $this->getColumnRenderers();
    $validationResult = new ValidationResult();
    $context = new MakeFilterContext($validationResult, $this->urlParameterProvider);
    $filters = [];
    foreach ($columns as $i => $column) {
        if ($renderers[$i] instanceof FilterableColumnRendererInterface) {
            try {
                $filter = $renderers[$i]->makeFilter($column, $context);
            } catch (IncorrectValueException) {
                $filters = null;
                break;
            }
            if ($filter !== null) {
                $filters[] = $filter;
            }
        }
    }
    return [$filters, $validationResult];
}

            

                public function noResultsCellAttributes(array $attributes): self
{
    $new = clone $this;
    $new->noResultsCellAttributes = $attributes;
    return $new;
}

            

                protected function prepareOrder(array $order): array
{
    $columns = $this->getColumns();
    $renderers = $this->getColumnRenderers();
    $allowedProperties = [];
    foreach ($columns as $i => $column) {
        if ($renderers[$i] instanceof SortableColumnRendererInterface) {
            $allowedProperties[] = $renderers[$i]->getOrderProperties($column);
        }
    }
    $allowedProperties = array_merge(...$allowedProperties);
    return array_filter(
        $order,
        static fn(string $property): bool => in_array($property, $allowedProperties, true),
        ARRAY_FILTER_USE_KEY,
    );
}

            

                protected function renderItems(
    array $items,
    ValidationResult $filterValidationResult,
    ?ReadableDataInterface $preparedDataReader,
): string {
    $columns = $this->getColumns();
    $renderers = $this->getColumnRenderers();
    $blocks = [];
    $filtersForm = '';
    $dataReader = $this->getDataReader();
    if ($preparedDataReader instanceof PaginatorInterface) {
        $pageToken = $preparedDataReader->isOnFirstPage() ? null : $preparedDataReader->getToken();
        $pageSize = $preparedDataReader->getPageSize();
        if ($pageSize === $this->getDefaultPageSize()) {
            $pageSize = null;
        }
    } else {
        $pageToken = null;
        $pageSize = null;
    }
    $globalContext = new GlobalContext(
        $this->getSort($dataReader),
        $this->getSort($preparedDataReader),
        $this->getAllowedPropertiesForSort(),
        $this->sortableHeaderClass,
        $this->sortableHeaderPrepend,
        $this->sortableHeaderAppend,
        $this->sortableHeaderAscClass,
        $this->sortableHeaderAscPrepend,
        $this->sortableHeaderAscAppend,
        $this->sortableHeaderDescClass,
        $this->sortableHeaderDescPrepend,
        $this->sortableHeaderDescAppend,
        $this->sortableLinkAttributes,
        $this->sortableLinkAscClass,
        $this->sortableLinkDescClass,
        $this->keepPageOnSort ? $pageToken : null,
        $pageSize,
        $this->multiSort,
        $this->urlConfig,
        $this->urlCreator,
        $this->translator,
        $this->translationCategory,
    );
    $tags = [];
    $hasFilters = false;
    $filterContext = new FilterContext(
        formId: $this->filterFormId,
        validationResult: $filterValidationResult,
        cellInvalidClass: $this->filterCellInvalidClass,
        errorsContainerAttributes: $this->filterErrorsContainerAttributes,
        urlParameterProvider: $this->urlParameterProvider,
    );
    foreach ($columns as $i => $column) {
        $cell = $renderers[$i] instanceof FilterableColumnRendererInterface
            ? $renderers[$i]->renderFilter($column, new Cell(attributes: $this->filterCellAttributes), $filterContext)
            : null;
        if ($cell === null) {
            $tags[] = Html::td(' ')->encode(false);
        } else {
            $tags[] = Html::td(attributes: $cell->getAttributes())
                ->content(...$cell->getContent())
                ->encode($cell->shouldEncode())
                ->doubleEncode($cell->shouldDoubleEncode());
            $hasFilters = true;
        }
    }
    if ($hasFilters) {
        $sort = $this->urlParameterProvider->get(
            $this->urlConfig->getSortParameterName(),
            $this->urlConfig->getSortParameterType(),
        );
        $url = $this->urlCreator === null ? '' : call_user_func_array(
            $this->urlCreator,
            UrlParametersFactory::create(
                null,
                $this->urlConfig->getPageSizeParameterType() === UrlParameterType::Path ? $pageSize : null,
                $this->urlConfig->getSortParameterType() === UrlParameterType::Path ? $sort : null,
                $this->urlConfig,
            ),
        );
        $content = [Html::submitButton()];
        if (!empty($pageSize) && $this->urlConfig->getPageSizeParameterType() === UrlParameterType::Query) {
            $content[] = Html::hiddenInput($this->urlConfig->getPageSizeParameterName(), $pageSize);
        }
        if (!empty($sort) && $this->urlConfig->getSortParameterType() === UrlParameterType::Query) {
            $content[] = Html::hiddenInput($this->urlConfig->getSortParameterName(), $sort);
        }
        $formAttributes = $this->filterFormAttributes;
        $formAttributes['id'] = $filterContext->formId;
        Html::addCssStyle($formAttributes, 'display:none');
        $filtersForm = Html::form($url, 'GET', $formAttributes)
            ->content(...$content)
            ->render();
        $filterRow = Html::tr()->cells(...$tags);
    } else {
        $filterRow = null;
    }
    if ($this->columnGrouping) {
        $tags = [];
        foreach ($columns as $i => $column) {
            $cell = $renderers[$i]->renderColumn($column, new Cell(), $globalContext);
            $tags[] = Html::col($cell->getAttributes());
        }
        $blocks[] = Html::colgroup()->columns(...$tags)->render();
    }
    if ($this->isHeaderEnabled) {
        $tags = [];
        foreach ($columns as $i => $column) {
            $cell = $renderers[$i]->renderHeader($column, new Cell($this->headerCellAttributes), $globalContext);
            $tags[] = $cell === null
                ? Html::th(' ')->encode(false)
                : Html::th(attributes: $cell->getAttributes())
                    ->content(...$cell->getContent())
                    ->encode($cell->shouldEncode())
                    ->doubleEncode($cell->shouldDoubleEncode());
        }
        $headerRow = Html::tr($this->headerRowAttributes)->cells(...$tags);
        $thead = Html::thead()->rows($headerRow);
        if ($filterRow !== null) {
            $thead = $thead->addRows($filterRow);
        }
        $blocks[] = $thead->render();
    }
    if ($this->isFooterEnabled) {
        $tags = [];
        foreach ($columns as $i => $column) {
            $cell = $renderers[$i]->renderFooter(
                $column,
                (new Cell())->content(' ')->encode(false),
                $globalContext,
            );
            $tags[] = Html::td(attributes: $cell->getAttributes())
                ->content(...$cell->getContent())
                ->encode($cell->shouldEncode())
                ->doubleEncode($cell->shouldDoubleEncode());
        }
        $footerRow = Html::tr($this->footerRowAttributes)->cells(...$tags);
        $blocks[] = Html::tfoot()->rows($footerRow)->render();
    }
    $rows = [];
    $index = 0;
    foreach ($items as $key => $value) {
        if ($this->beforeRowCallback !== null) {
            /**
             * @psalm-suppress InvalidArgument
             */
            $row = ($this->beforeRowCallback)($value, $key, $index, $this);
            if (!empty($row)) {
                $rows[] = $row;
            }
        }
        $tags = [];
        foreach ($columns as $i => $column) {
            $context = new DataContext($preparedDataReader, $column, $value, $key, $index);
            $cell = $renderers[$i]->renderBody($column, new Cell($this->bodyCellAttributes), $context);
            $tags[] = $cell->isEmptyContent()
                ? Html::td($this->emptyCell, $this->emptyCellAttributes)->encode(false)
                : Html::td(attributes: $this->prepareBodyCellAttributes($cell->getAttributes(), $context))
                    ->content(...$cell->getContent())
                    ->encode($cell->shouldEncode())
                    ->doubleEncode($cell->shouldDoubleEncode());
        }
        $bodyRowAttributes = $this->prepareBodyRowAttributes(
            $this->bodyRowAttributes,
            new BodyRowContext($value, $key, $index),
        );
        $rows[] = Html::tr($bodyRowAttributes)->cells(...$tags);
        if ($this->afterRowCallback !== null) {
            /**
             * @psalm-suppress InvalidArgument
             */
            $row = ($this->afterRowCallback)($value, $key, $index, $this);
            if (!empty($row)) {
                $rows[] = $row;
            }
        }
        $index++;
    }
    $blocks[] = empty($rows)
        ? Html::tbody($this->tbodyAttributes)
            ->rows(Html::tr()->cells($this->renderEmptyCell(count($columns))))
            ->render()
        : Html::tbody($this->tbodyAttributes)->rows(...$rows)->render();
    return
        $filtersForm
        . Html::tag('table', attributes: $this->tableAttributes)->open()
        . "\n"
        . implode("\n", $blocks)
        . "\n"
        . '</table>';
}

            

                public function sortableHeaderAppend(string|Stringable $content): self
{
    $new = clone $this;
    $new->sortableHeaderAppend = $content;
    return $new;
}

            

                public function sortableHeaderAscAppend(string|Stringable $content): self
{
    $new = clone $this;
    $new->sortableHeaderAscAppend = $content;
    return $new;
}

            

                public function sortableHeaderAscPrepend(string|Stringable $content): self
{
    $new = clone $this;
    $new->sortableHeaderAscPrepend = $content;
    return $new;
}

            

                public function sortableHeaderDescAppend(string|Stringable $content): self
{
    $new = clone $this;
    $new->sortableHeaderDescAppend = $content;
    return $new;
}

            

                public function sortableHeaderDescPrepend(string|Stringable $content): self
{
    $new = clone $this;
    $new->sortableHeaderDescPrepend = $content;
    return $new;
}

            

                public function sortableHeaderPrepend(string|Stringable $content): self
{
    $new = clone $this;
    $new->sortableHeaderPrepend = $content;
    return $new;
}

            

                public function sortableLinkAttributes(array $attributes): self
{
    $new = clone $this;
    $new->sortableLinkAttributes = $attributes;
    return $new;
}

            

                public function tableAttributes(array $attributes): self
{
    $new = clone $this;
    $new->tableAttributes = $attributes;
    return $new;
}

            

                public function tableClass(?string ...$class): self
{
    $new = clone $this;
    $new->tableAttributes['class'] = array_filter($class, static fn($c) => $c !== null);
    return $new;
}

            

                public function tbodyAttributes(array $attributes): self
{
    $new = clone $this;
    $new->tbodyAttributes = $attributes;
    return $new;
}

            

                public function tbodyClass(?string ...$class): self
{
    $new = clone $this;
    $new->tbodyAttributes['class'] = array_filter($class, static fn($c) => $c !== null);
    return $new;
}