# jch-optimize/trunk/lib/src/Service/Provider/PageCache.php

JCH Optimize, version trunk. 222 lines.

- Page: https://pluginprobe.com/plugins/jch-optimize/trunk/code/lib/src/Service/Provider/PageCache.php
- Raw: https://pluginprobe.com/plugins/jch-optimize/trunk/raw/lib/src/Service/Provider/PageCache.php
- Modified: 2026-08-22T22:53:50+00:00

Line numbers below start at 1. Link to a line or a range by appending a fragment to the
page URL, for example `https://pluginprobe.com/plugins/jch-optimize/trunk/code/lib/src/Service/Provider/PageCache.php#L10-L20`.

```php
<?php

/**
 * JCH Optimize - Performs several front-end optimizations for fast downloads
 *
 * @package   jchoptimize/core
 * @author    Samuel Marshall <samuel@jch-optimize.net>
 * @copyright Copyright (c) 2022 Samuel Marshall / JCH Optimize
 * @license   GNU/GPLv3, or later. See LICENSE file
 *
 *  If LICENSE file missing, see <http://www.gnu.org/licenses/>.
 */

namespace JchOptimize\Core\Service\Provider;

use _JchOptimizeVendor\V91\Joomla\DI\Container;
use _JchOptimizeVendor\V91\Joomla\DI\ServiceProviderInterface;
use _JchOptimizeVendor\V91\Joomla\Input\Input;
use _JchOptimizeVendor\V91\Laminas\Cache\Pattern\CaptureCache as LaminasCaptureCache;
use _JchOptimizeVendor\V91\Laminas\Cache\Storage\StorageInterface;
use _JchOptimizeVendor\V91\Laminas\Cache\Storage\TaggableInterface;
use _JchOptimizeVendor\V91\Psr\Log\LoggerInterface;
use JchOptimize\Core\Cloudflare\CloudflareManager;
use JchOptimize\Core\PageCache\CachedResponseEmitter;
use JchOptimize\Core\PageCache\CaptureCache as CoreCaptureCache;
use JchOptimize\Core\PageCache\CaptureCacheHtaccessManager;
use JchOptimize\Core\PageCache\CaptureCachePolicy;
use JchOptimize\Core\PageCache\CaptureCacheStore;
use JchOptimize\Core\PageCache\CurrentPageResolver;
use JchOptimize\Core\PageCache\PageCache as CorePageCache;
use JchOptimize\Core\PageCache\PageCacheInvalidator;
use JchOptimize\Core\PageCache\PageCacheItemQuery;
use JchOptimize\Core\PageCache\PageCacheKeyFactory;
use JchOptimize\Core\PageCache\PageCachePolicy;
use JchOptimize\Core\PageCache\PageCacheRepository;
use JchOptimize\Core\Platform\CacheInterface;
use JchOptimize\Core\Platform\HooksInterface;
use JchOptimize\Core\Platform\PathsInterface;
use JchOptimize\Core\Platform\UtilityInterface;
use JchOptimize\Core\Registry;
use JchOptimize\Core\SystemUri\SystemUriResolverInterface;
use ReflectionClass;

use function defined;

use const JCH_PRO;

defined('_JCH_EXEC') or die('Restricted access');

class PageCache implements ServiceProviderInterface
{
    public function register(Container $container): void
    {
        $container->share(CorePageCache::class, [$this, 'getPageCacheService']);
        $container->share(CoreCaptureCache::class, [$this, 'getCaptureCacheService']);

        $container->share(CurrentPageResolver::class, [$this, 'getCurrentPageResolverService']);
        $container->share(PageCacheKeyFactory::class, [$this, 'getPageCacheKeyFactoryService']);
        $container->set(PageCachePolicy::class, [$this, 'getPageCachePolicyService']);
        $container->share(PageCacheRepository::class, [$this, 'getPageCacheRepositoryService']);
        $container->set(PageCacheItemQuery::class, [$this, 'getPageCacheItemQueryService']);
        $container->share(CachedResponseEmitter::class, [$this, 'getCachedResponseEmitterService']);
        $container->set(PageCacheInvalidator::class, [$this, 'getPageCacheInvalidatorService']);

        $container->set(CaptureCachePolicy::class, [$this, 'getCaptureCachePolicyService']);
        $container->share(CaptureCacheStore::class, [$this, 'getCaptureCacheStoreService']);
        $container->set(CaptureCacheHtaccessManager::class, [$this, 'getCaptureCacheHtaccessManagerService']);
    }

    /**
     * @psalm-suppress InvalidArgument
     */
    public function getPageCacheService(Container $container): CorePageCache
    {
        if (JCH_PRO) {
            return $container->get(CoreCaptureCache::class);
        }

        $pageCache = (new CorePageCache(
            $container->get(Input::class),
            $container->get(UtilityInterface::class),
            $this->getPageCacheAdapterName($container),
            $container->get(CurrentPageResolver::class),
            $container->get(PageCacheKeyFactory::class),
            $container->get(PageCachePolicy::class),
            $container->get(PageCacheRepository::class),
            $container->get(PageCacheItemQuery::class),
            $container->get(CachedResponseEmitter::class),
            $container->get(PageCacheInvalidator::class)
        ));

        return $pageCache;
    }

    /**
     * @psalm-suppress InvalidArgument
     */
    public function getCaptureCacheService(Container $container): CoreCaptureCache
    {
        $captureCache = (new CoreCaptureCache(
            $container->get(Input::class),
            $container->get(UtilityInterface::class),
            $this->getPageCacheAdapterName($container),
            $container->get(CurrentPageResolver::class),
            $container->get(PageCacheKeyFactory::class),
            $container->get(PageCachePolicy::class),
            $container->get(PageCacheRepository::class),
            $container->get(PageCacheItemQuery::class),
            $container->get(CachedResponseEmitter::class),
            $container->get(PageCacheInvalidator::class),
            $container->get(CaptureCacheStore::class),
            $container->get(CaptureCachePolicy::class),
            $container->get(CaptureCacheHtaccessManager::class)
        ));

        return $captureCache;
    }

    public function getCurrentPageResolverService(Container $container): CurrentPageResolver
    {
        return new CurrentPageResolver(
            $container->get(Registry::class),
            $container->get(SystemUriResolverInterface::class)
        );
    }

    public function getPageCacheKeyFactoryService(Container $container): PageCacheKeyFactory
    {
        return new PageCacheKeyFactory(
            $container->get(Registry::class),
            $container->get(HooksInterface::class),
            $container->get(UtilityInterface::class),
            $this->getPageCacheAdapterName($container)
        );
    }

    public function getPageCachePolicyService(Container $container): PageCachePolicy
    {
        return new PageCachePolicy(
            $container->get(Registry::class),
            $container->get(Input::class),
            $container->get('page_cache'),
            $container->get(CacheInterface::class),
            $container->get(HooksInterface::class),
            $container->get(UtilityInterface::class),
            $container->get(CurrentPageResolver::class)
        );
    }

    public function getPageCacheRepositoryService(Container $container): PageCacheRepository
    {
        return new PageCacheRepository(
            $container->get('page_cache'),
            $container->get(TaggableInterface::class),
            $this->getPageCacheAdapterName($container),
            fn(string $adapter): StorageInterface => $container->get($adapter)
        );
    }

    public function getPageCacheItemQueryService(Container $container): PageCacheItemQuery
    {
        return new PageCacheItemQuery($container->get(PageCacheRepository::class));
    }

    public function getCachedResponseEmitterService(Container $container): CachedResponseEmitter
    {
        return new CachedResponseEmitter($container->get(CacheInterface::class));
    }

    public function getPageCacheInvalidatorService(Container $container): PageCacheInvalidator
    {
        return new PageCacheInvalidator(
            $container->get(PageCacheRepository::class),
            null,
            $container->get(CloudflareManager::class)
        );
    }

    public function getCaptureCachePolicyService(Container $container): CaptureCachePolicy
    {
        return new CaptureCachePolicy(
            $container->get(Registry::class),
            $container->get(Input::class),
            $container->get(CacheInterface::class),
            $container->get(UtilityInterface::class),
            $container->get(CurrentPageResolver::class)
        );
    }

    public function getCaptureCacheStoreService(Container $container): CaptureCacheStore
    {
        $store = new CaptureCacheStore(
            $container->get(LaminasCaptureCache::class),
            $container->get(PathsInterface::class),
            $container->get(CurrentPageResolver::class),
            $container->get(Registry::class),
            $container->get(UtilityInterface::class)
        );
        $store->setLogger($container->get(LoggerInterface::class));

        return $store;
    }

    public function getCaptureCacheHtaccessManagerService(Container $container): CaptureCacheHtaccessManager
    {
        return new CaptureCacheHtaccessManager(
            $container->get(Registry::class),
            $container->get(CacheInterface::class),
            $container->get(PathsInterface::class),
            $container->get(CaptureCachePolicy::class),
            $container->get(UtilityInterface::class)
        );
    }

    private function getPageCacheAdapterName(Container $container): string
    {
        $reflection = new ReflectionClass($container->get('page_cache'));

        return $reflection->getShortName();
    }
}

```