PageRendererHook.php

<?php

declare(strict_types=1);

namespace B13\Http2;

/*
 * This file is part of TYPO3 CMS-based extension "http2" by b13.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 */

use Psr\Http\Message\ServerRequestInterface;
use Symfony\Component\DependencyInjection\Attribute\Autoconfigure;
use Symfony\Component\DependencyInjection\Attribute\Autowire;
use TYPO3\CMS\Core\Cache\CacheDataCollector;
use TYPO3\CMS\Core\Cache\CacheTag;
use TYPO3\CMS\Core\Cache\Frontend\FrontendInterface;
use TYPO3\CMS\Core\Http\ApplicationType;
use TYPO3\CMS\Core\Page\PageRenderer;
use TYPO3\CMS\Core\Utility\GeneralUtility;

/**
 * Hooks into PageRenderer before the rendering is taken care of, and remember the files
 * that can be sent as resources.
 *
 * This considers that everything is required, thus is marked as "preload", not via "prefetch".
 */
#[Autoconfigure(public: true)]
class PageRendererHook
{
    public function __construct(
        #[Autowire(service: 'cache.tx_http2')]
        private readonly FrontendInterface $cache,
        protected ResourceMatcher $matcher
    ) {}

    /**
     * @param array $params
     * @param PageRenderer $pageRenderer
     * @internal this is just a hook implementation.
     */
    public function accumulateResources(array $params, PageRenderer $pageRenderer)
    {
        $request = $this->getRequest();
        if ($request === null) {
            return;
        }
        // If this is a second run (non-cached cObjects adding more data), then the existing cached data is fetched
        if (ApplicationType::fromRequest($request)->isFrontend()) {
            $allResources = $this->getFromCached($request);
        } else {
            $allResources = [];
        }
        foreach ($params['headerData'] as $headerData) {
            $allResources = array_merge_recursive($allResources, $this->matcher->match($headerData));
        }
        foreach ($params['footerData'] as $footerData) {
            $allResources = array_merge_recursive($allResources, $this->matcher->match($footerData));
        }
        foreach (['jsLibs', 'jsFiles', 'jsFooterLibs', 'jsFooterFiles', 'cssLibs', 'cssFiles'] as $part) {
            if (empty($params[$part])) {
                continue;
            }
            $allResources = array_merge_recursive($allResources, $this->matcher->match($params[$part]));
        }

        $allResources['scripts'] = array_unique($allResources['scripts'] ?? []);
        $allResources['styles'] = array_unique($allResources['styles'] ?? []);

        $this->process($allResources, $request);
    }

    /**
     * In FE the data is stored in TSFE->config.
     * In BE it is sent directly to the HTTP response.
     *
     * @param array $allResources
     */
    protected function process(array $allResources, ServerRequestInterface $request): void
    {
        if (ApplicationType::fromRequest($request)->isFrontend()) {
            $this->addToCached($request, $allResources);
        } elseif (GeneralUtility::getIndpEnv('TYPO3_SSL')) {
            // Push directly into the TYPO3 Backend, but only if TYPO3 is running in SSL
            GeneralUtility::makeInstance(ResourcePusher::class)->pushAll($allResources);
        }
    }

    protected function getFromCached(ServerRequestInterface $request): array
    {
        /** @var CacheDataCollector $cacheDataCollector */
        $cacheDataCollector = $request->getAttribute('frontend.cache.collector');
        $identifier = $cacheDataCollector->getPageCacheIdentifier();
        if ($this->cache->has($identifier)) {
            return $this->cache->get($identifier);
        }
        return [];
    }

    protected function addToCached(ServerRequestInterface $request, array $data): void
    {
        /** @var CacheDataCollector $cacheDataCollector */
        $cacheDataCollector = $request->getAttribute('frontend.cache.collector');
        $identifier = $cacheDataCollector->getPageCacheIdentifier();
        $cacheTags = array_map(fn(CacheTag $cacheTag) => $cacheTag->name, $cacheDataCollector->getCacheTags());
        $cacheTimeout = $cacheDataCollector->resolveLifetime();
        $this->cache->set($identifier, $data, $cacheTags, $cacheTimeout);
    }

    protected function getRequest(): ?ServerRequestInterface
    {
        return $GLOBALS['TYPO3_REQUEST'] ?? null;
    }
}