ImageStorageExtension.php

<?php

declare(strict_types=1);

namespace SixtyEightPublishers\ImageStorage\Bridge\Nette\DI;

use Intervention\Image\ImageManager;
use League\Flysystem\Config as FlysystemConfig;
use League\Flysystem\FilesystemOperator;
use League\Flysystem\Visibility;
use Nette\Application\IPresenterFactory;
use Nette\DI\CompilerExtension;
use Nette\DI\Definitions\Reference;
use Nette\DI\Definitions\ServiceDefinition;
use Nette\DI\Definitions\Statement;
use Nette\Routing\Router;
use Nette\Schema\Expect;
use Nette\Schema\Schema;
use SixtyEightPublishers\FileStorage\Bridge\Nette\DI\Config\FilesystemConfig;
use SixtyEightPublishers\FileStorage\Bridge\Nette\DI\Config\StorageConfig as FileStorageConfig;
use SixtyEightPublishers\FileStorage\Bridge\Nette\DI\FileStorageConsoleExtension;
use SixtyEightPublishers\FileStorage\Bridge\Nette\DI\FileStorageDefinitionFactoryInterface;
use SixtyEightPublishers\FileStorage\Bridge\Nette\DI\FileStorageExtension;
use SixtyEightPublishers\FileStorage\Bridge\Symfony\Console\Configurator\CleanCommandConfiguratorInterface;
use SixtyEightPublishers\FileStorage\Cleaner\StorageCleanerInterface;
use SixtyEightPublishers\FileStorage\Config\ConfigInterface;
use SixtyEightPublishers\FileStorage\Exception\RuntimeException;
use SixtyEightPublishers\FileStorage\Resource\ResourceFactoryInterface;
use SixtyEightPublishers\ImageStorage\Bridge\Intervention\Image\ImageManager\ImageManagerFactory;
use SixtyEightPublishers\ImageStorage\Bridge\Intervention\Image\ImageManager\ImageManagerFactoryInterface;
use SixtyEightPublishers\ImageStorage\Bridge\Nette\Application\ImageServerPresenter;
use SixtyEightPublishers\ImageStorage\Bridge\Nette\Application\ImageServerRoute;
use SixtyEightPublishers\ImageStorage\Bridge\Nette\DI\Config\ImageStorageConfig;
use SixtyEightPublishers\ImageStorage\Bridge\Nette\DI\Config\PresetConfig;
use SixtyEightPublishers\ImageStorage\Bridge\Nette\DI\Config\StorageConfig;
use SixtyEightPublishers\ImageStorage\Bridge\Nette\ImageServer\ResponseFactory;
use SixtyEightPublishers\ImageStorage\Bridge\Symfony\Console\Configurator\CleanCommandConfigurator;
use SixtyEightPublishers\ImageStorage\Cleaner\StorageCleaner;
use SixtyEightPublishers\ImageStorage\Config\Config;
use SixtyEightPublishers\ImageStorage\Config\NoImageConfig;
use SixtyEightPublishers\ImageStorage\Config\NoImageConfigInterface;
use SixtyEightPublishers\ImageStorage\Filesystem\Filesystem;
use SixtyEightPublishers\ImageStorage\Filesystem\MountManager;
use SixtyEightPublishers\ImageStorage\ImageServer\ExternalImageServerFactory;
use SixtyEightPublishers\ImageStorage\ImageServer\ImageServerFactoryInterface;
use SixtyEightPublishers\ImageStorage\ImageServer\LocalImageServerFactory;
use SixtyEightPublishers\ImageStorage\ImageServer\ResponseFactoryInterface;
use SixtyEightPublishers\ImageStorage\ImageStorage;
use SixtyEightPublishers\ImageStorage\ImageStorageInterface;
use SixtyEightPublishers\ImageStorage\Info\InfoFactory;
use SixtyEightPublishers\ImageStorage\Info\InfoFactoryInterface;
use SixtyEightPublishers\ImageStorage\LinkGenerator\LinkGenerator;
use SixtyEightPublishers\ImageStorage\LinkGenerator\LinkGeneratorInterface;
use SixtyEightPublishers\ImageStorage\Modifier;
use SixtyEightPublishers\ImageStorage\Modifier\Applicator;
use SixtyEightPublishers\ImageStorage\Modifier\Codec\Codec;
use SixtyEightPublishers\ImageStorage\Modifier\Codec\PresetCodec;
use SixtyEightPublishers\ImageStorage\Modifier\Collection\ModifierCollection;
use SixtyEightPublishers\ImageStorage\Modifier\Collection\ModifierCollectionFactoryInterface;
use SixtyEightPublishers\ImageStorage\Modifier\Facade\ModifierFacadeFactory;
use SixtyEightPublishers\ImageStorage\Modifier\Facade\ModifierFacadeFactoryInterface;
use SixtyEightPublishers\ImageStorage\Modifier\Facade\ModifierFacadeInterface;
use SixtyEightPublishers\ImageStorage\Modifier\Preset\Preset;
use SixtyEightPublishers\ImageStorage\Modifier\Preset\PresetCollection;
use SixtyEightPublishers\ImageStorage\Modifier\Preset\PresetCollectionFactoryInterface;
use SixtyEightPublishers\ImageStorage\Modifier\Validator;
use SixtyEightPublishers\ImageStorage\NoImage\NoImageResolver;
use SixtyEightPublishers\ImageStorage\NoImage\NoImageResolverInterface;
use SixtyEightPublishers\ImageStorage\Persistence\ImagePersister;
use SixtyEightPublishers\ImageStorage\Persistence\ImagePersisterInterface;
use SixtyEightPublishers\ImageStorage\Resource\ResourceFactory;
use SixtyEightPublishers\ImageStorage\Responsive\Descriptor\WDescriptor;
use SixtyEightPublishers\ImageStorage\Responsive\Descriptor\XDescriptor;
use SixtyEightPublishers\ImageStorage\Responsive\SrcSetGeneratorFactoryInterface;
use SixtyEightPublishers\ImageStorage\Security\KnownModifiers;
use SixtyEightPublishers\ImageStorage\Security\SignatureStrategy;
use SixtyEightPublishers\ImageStorage\Security\SignatureStrategyInterface;
use function array_diff;
use function array_fill_keys;
use function array_keys;
use function array_map;
use function array_merge;
use function array_unique;
use function assert;
use function is_array;
use function is_string;
use function is_subclass_of;
use function sprintf;

final class ImageStorageExtension extends CompilerExtension implements FileStorageDefinitionFactoryInterface
{
    public const DRIVER_GD = 'gd';
    public const DRIVER_IMAGICK = 'imagick';
    public const DRIVER_68PUBLISHERS_IMAGICK = '68publishers.imagick';

    public const IMAGE_SERVER_LOCAL = 'local';
    public const IMAGE_SERVER_EXTERNAL = 'external';

    /** @var array<string> */
    private array $managed = [];

    /** @var array<string, mixed> */
    private array $routes = [];

    private bool $imageServerPresenterRegistered = false;

    public function getConfigSchema(): Schema
    {
        return Expect::structure([
            'driver' => Expect::anyOf(Statement::class, self::DRIVER_GD, self::DRIVER_IMAGICK, self::DRIVER_68PUBLISHERS_IMAGICK)
                ->default(self::DRIVER_GD)
                ->dynamic(),
            'storages' => Expect::arrayOf(
                Expect::structure([
                    'source_filesystem' => Expect::structure([
                        'adapter' => Expect::anyOf(Expect::string(), Expect::type(Statement::class))
                            ->required()
                            ->before(static function ($factory) {
                                return $factory instanceof Statement ? $factory : new Statement($factory);
                            }),
                        'config' => Expect::array([ # @phpstan-ignore-line
                            FlysystemConfig::OPTION_VISIBILITY => Visibility::PRIVATE,
                            FlysystemConfig::OPTION_DIRECTORY_VISIBILITY => Visibility::PRIVATE,
                        ])->mergeDefaults(),
                    ])->castTo(FilesystemConfig::class),

                    'server' => Expect::anyOf(self::IMAGE_SERVER_LOCAL, self::IMAGE_SERVER_EXTERNAL)
                        ->default(self::IMAGE_SERVER_LOCAL),
                    'route' => Expect::bool(false),

                    'no_image' => Expect::arrayOf('string', 'string')
                        ->default([]),
                    'no_image_patterns' => Expect::arrayOf('string', 'string')
                        ->default([]),
                    'presets' => Expect::arrayOf(
                        Expect::structure([
                            'modifiers' => Expect::arrayOf(Expect::scalar(), 'string'),
                            'w' => Expect::listOf(Expect::int())->default([]),
                            'x' => Expect::listOf(Expect::anyOf(Expect::int(), Expect::float()))->default([]),
                            'defaultW' => Expect::int()->nullable(),
                            'defaultX' => Expect::anyOf(Expect::int(), Expect::float())->nullable(),
                        ])->castTo(PresetConfig::class)
                            ->assert(
                                handler: static fn (PresetConfig $preset): bool => !([] !== $preset->w && [] !== $preset->x),
                                description: 'A preset cannot have both "w" and "x" properties.',
                            ),
                        'string',
                    )->default([]),

                    'modifiers' => Expect::listOf('string|' . Statement::class),
                    'applicators' => Expect::listOf('string|' . Statement::class),
                    'validators' => Expect::listOf('string|' . Statement::class),
                ])->before(function (array $config): array {
                    $config['modifiers'] = $this->normalizeListOfStatementsWithDefaults(
                        is_array($config['modifiers'] ?? null) ? $config['modifiers'] : ['@default'],
                        [
                            new Statement(Modifier\Original::class),
                            new Statement(Modifier\Height::class),
                            new Statement(Modifier\Width::class),
                            new Statement(Modifier\AspectRatio::class),
                            new Statement(Modifier\Fit::class),
                            new Statement(Modifier\PixelDensity::class),
                            new Statement(Modifier\Orientation::class),
                            new Statement(Modifier\Quality::class),
                        ],
                    );

                    $config['applicators'] = $this->normalizeListOfStatementsWithDefaults(
                        is_array($config['applicators'] ?? null) ? $config['applicators'] : ['@default'],
                        [
                            new Statement(Applicator\Orientation::class),
                            new Statement(Applicator\Resize::class),
                            new Statement(Applicator\Format::class),
                            new Statement(Applicator\StripMeta::class), # must be last
                        ],
                    );

                    $config['validators'] = $this->normalizeListOfStatementsWithDefaults(
                        is_array($config['validators'] ?? null) ? $config['validators'] : ['@default'],
                        [
                            new Statement(Validator\AllowedResolutionValidator::class),
                            new Statement(Validator\AllowedPixelDensityValidator::class),
                            new Statement(Validator\AllowedQualityValidator::class),
                        ],
                    );

                    return $config;
                })->castTo(StorageConfig::class),
            ),
        ])->castTo(ImageStorageConfig::class);
    }

    public function loadConfiguration(): void
    {
        if (0 >= count($this->compiler->getExtensions(FileStorageExtension::class))) {
            throw new RuntimeException(sprintf(
                'The extension %s can be used only with %s.',
                self::class,
                FileStorageExtension::class,
            ));
        }

        $builder = $this->getContainerBuilder();
        $config = $this->getConfig();
        assert($config instanceof ImageStorageConfig);

        # Image manager
        $builder->addDefinition($this->prefix('image_manager_factory'))
            ->setAutowired(false)
            ->setType(ImageManagerFactoryInterface::class)
            ->setFactory(ImageManagerFactory::class);

        $builder->addDefinition($this->prefix('image_manager'))
            ->setType(ImageManager::class)
            ->setFactory([$this->prefix('@image_manager_factory'), 'create'], [
                ['driver' => $config->driver],
            ]);

        # Modifier collection factory
        $builder->addFactoryDefinition($this->prefix('modifiers.modifier_collection_factory'))
            ->setAutowired(false)
            ->setImplement(ModifierCollectionFactoryInterface::class)
            ->getResultDefinition()
            ->setFactory(ModifierCollection::class);

        # Preset collection factory
        $builder->addFactoryDefinition($this->prefix('modifiers.preset_collection_factory'))
            ->setAutowired(false)
            ->setImplement(PresetCollectionFactoryInterface::class)
            ->getResultDefinition()
            ->setFactory(PresetCollection::class);

        # Modifier facade factory
        $builder->addDefinition($this->prefix('modifiers.modifier_facade_factory'))
            ->setAutowired(false)
            ->setType(ModifierFacadeFactoryInterface::class)
            ->setFactory(ModifierFacadeFactory::class, [
                new Reference($this->prefix('modifiers.preset_collection_factory')),
                new Reference($this->prefix('modifiers.modifier_collection_factory')),
            ]);

        # Responsive - srcset generator factory
        $builder->addFactoryDefinition($this->prefix('responsive.srcset_generator_factory'))
            ->setAutowired(false)
            ->setImplement(SrcSetGeneratorFactoryInterface::class);

        # Image server - response factory
        $builder->addDefinition($this->prefix('image_server_response_factory'))
            ->setAutowired(false)
            ->setType(ResponseFactoryInterface::class)
            ->setFactory(ResponseFactory::class);

        # Custom storage cleaner
        $builder->addDefinition($this->prefix('storage_cleaner'))
            ->setAutowired(false)
            ->setType(StorageCleanerInterface::class)
            ->setFactory(StorageCleaner::class);

        # Console - extends clean command configurator if the FileStorageConsoleExtension is registered
        if (0 < \count($this->compiler->getExtensions(FileStorageConsoleExtension::class))) {
            $builder->addDefinition($this->prefix('configurator.clean_command'))
                ->setType(CleanCommandConfiguratorInterface::class)
                ->setFactory(CleanCommandConfigurator::class)
                ->addTag(FileStorageConsoleExtension::TAG_CLEAN_COMMAND_CONFIGURATOR)
                ->setAutowired(false);
        }
    }

    public function beforeCompile(): void
    {
        $builder = $this->getContainerBuilder();
        $config = $this->getConfig();
        assert($config instanceof ImageStorageConfig);

        $diff = array_diff(array_keys($config->storages), $this->managed);

        if (0 < \count($diff)) {
            throw new RuntimeException(sprintf(
                'Missing definition for a storage with the name "%s" in the configuration of the extension %s.',
                array_shift($diff),
                FileStorageExtension::class,
            ));
        }

        $storageCleanerDecorator = $builder->getDefinition($this->prefix('storage_cleaner'));
        $defaultStorageCleaner = $builder->getDefinitionByType(StorageCleanerInterface::class);
        assert($storageCleanerDecorator instanceof ServiceDefinition && $defaultStorageCleaner instanceof ServiceDefinition);

        $storageCleanerDecorator->setArguments([$defaultStorageCleaner]);
        $storageCleanerDecorator->setAutowired();
        $defaultStorageCleaner->setAutowired(false);

        if (empty($this->routes)) {
            return;
        }

        $presenterFactory = $builder->getDefinitionByType(IPresenterFactory::class);
        $router = $builder->getDefinitionByType(Router::class);
        assert($presenterFactory instanceof ServiceDefinition && $router instanceof ServiceDefinition);

        $presenterFactory->addSetup('setMapping', [
            [
                'ImageStorage' => ['SixtyEightPublishers\\ImageStorage\\Bridge\\Nette\\Application', '*', '*Presenter'],
            ],
        ]);

        foreach ($this->routes as $storageName => $basePath) {
            $router->addSetup('prepend', [
                'router' => new Statement(ImageServerRoute::class, [
                    $storageName,
                    $basePath,
                ]),
            ]);
        }
    }

    public function canCreateFileStorage(string $name, FileStorageConfig $config): bool
    {
        $extensionConfig = $this->getConfig();
        assert($extensionConfig instanceof ImageStorageConfig);

        return isset($extensionConfig->storages[$name]);
    }

    public function createFileStorage(string $name, FileStorageConfig $config): ServiceDefinition
    {
        $builder = $this->getContainerBuilder();
        $extensionConfig = $this->getConfig();
        assert($extensionConfig instanceof ImageStorageConfig);

        $this->managed[] = $name;
        $imageStorageConfig = $extensionConfig->storages[$name];

        $builder->addDefinition($this->prefix('filesystem.' . $name))
            ->setType(FilesystemOperator::class)
            ->setFactory(MountManager::class, [
                [
                    ImagePersisterInterface::FILESYSTEM_NAME_CACHE => new Statement(Filesystem::class, [
                        $config->filesystem->adapter,
                        $config->filesystem->config,
                    ]),
                    ImagePersisterInterface::FILESYSTEM_NAME_SOURCE => new Statement(Filesystem::class, [
                        $imageStorageConfig->source_filesystem->adapter,
                        $imageStorageConfig->source_filesystem->config,
                    ]),
                ],
            ])
            ->setAutowired(false);

        $builder->addDefinition($this->prefix('config.' . $name))
            ->setType(ConfigInterface::class)
            ->setFactory(Config::class, [$config->config])
            ->setAutowired(false);

        $presets = array_map(
            callback: static fn (PresetConfig $preset): Statement => new Statement(Preset::class, [
                'modifiers' => $preset->modifiers,
                'descriptor' => match (true) {
                    [] !== $preset->w => new Statement(WDescriptor::class, $preset->w),
                    [] !== $preset->x => new Statement(XDescriptor::class, $preset->x),
                    default => null,
                },
                'defaultDescriptorValue' => match (true) {
                    [] !== $preset->w => $preset->defaultW,
                    [] !== $preset->x => $preset->defaultX,
                    default => null,
                },
            ]),
            array: $imageStorageConfig->presets,
        );

        $builder->addDefinition($this->prefix('modifier_facade.' . $name))
            ->setType(ModifierFacadeInterface::class)
            ->setFactory(new Statement([$this->prefix('@modifiers.modifier_facade_factory'), 'create'], [
                new Reference($this->prefix('config.' . $name)),
            ]))
            ->addSetup('setModifiers', [$imageStorageConfig->modifiers])
            ->addSetup('setPresets', [$presets])
            ->addSetup('setApplicators', [$imageStorageConfig->applicators])
            ->addSetup('setValidators', [$imageStorageConfig->validators])
            ->setAutowired(false);

        $builder->addDefinition($this->prefix('resource_factory.' . $name))
            ->setType(ResourceFactoryInterface::class)
            ->setFactory(ResourceFactory::class, [
                new Reference($this->prefix('filesystem.' . $name)),
                new Reference($this->prefix('image_manager')),
                new Reference($this->prefix('modifier_facade.' . $name)),
            ])
            ->setAutowired(false);

        # signature enabled
        if (!empty($config->config[Config::SIGNATURE_KEY] ?? '')) {
            $signatureStrategyDefinition = $builder->addDefinition($this->prefix('signature_strategy.' . $name))
                ->setType(SignatureStrategyInterface::class)
                ->setFactory(SignatureStrategy::class, [
                    'config' => new Reference($this->prefix('config.' . $name)),
                    'knownModifiers' => new Statement(KnownModifiers::class, [
                        'list' => $this->buildKnownModifiers(
                            config: $config,
                            extConfig: $imageStorageConfig,
                        ),
                    ]),
                ])
                ->setAutowired(false);
        }

        $builder->addDefinition($this->prefix('link_generator.' . $name))
            ->setType(LinkGeneratorInterface::class)
            ->setFactory(LinkGenerator::class, [
                new Reference($this->prefix('config.' . $name)),
                new Reference($this->prefix('modifier_facade.' . $name)),
                new Reference($this->prefix('responsive.srcset_generator_factory')),
                $signatureStrategyDefinition ?? null,
            ])
            ->setAutowired(false);

        $builder->addDefinition($this->prefix('image_persister.' . $name))
            ->setType(ImagePersisterInterface::class)
            ->setFactory(ImagePersister::class, [
                new Reference($this->prefix('filesystem.' . $name)),
                new Reference($this->prefix('config.' . $name)),
            ])
            ->setAutowired(false);

        $builder->addDefinition($this->prefix('info_factory.' . $name))
            ->setType(InfoFactoryInterface::class)
            ->setFactory(InfoFactory::class, [
                new Reference($this->prefix('modifier_facade.' . $name)),
                new Reference($this->prefix('link_generator.' . $name)),
                $name,
            ])
            ->setAutowired(false);

        $noImages = $imageStorageConfig->no_image;
        $defaultNoImage = $noImages['default'] ?? null;

        if (null !== $defaultNoImage) {
            unset($noImages['default']);
        }

        $builder->addDefinition($this->prefix('no_image_config.' . $name))
            ->setType(NoImageConfigInterface::class)
            ->setFactory(NoImageConfig::class, [
                $defaultNoImage,
                $noImages,
                $imageStorageConfig->no_image_patterns,
            ])
            ->setAutowired(false);

        $builder->addDefinition($this->prefix('no_image_resolver.' . $name))
            ->setType(NoImageResolverInterface::class)
            ->setFactory(NoImageResolver::class, [
                new Reference($this->prefix('info_factory.' . $name)),
                new Reference($this->prefix('no_image_config.' . $name)),
            ])
            ->setAutowired(false);

        $imageServerDefinition = $builder->addDefinition($this->prefix('image_server_factory.' . $name))
            ->setType(ImageServerFactoryInterface::class)
            ->setAutowired(false);

        switch ($imageStorageConfig->server) {
            case self::IMAGE_SERVER_LOCAL:
                if ($imageStorageConfig->route && '' === ($config->config[ConfigInterface::BASE_PATH] ?? '')) {
                    throw new RuntimeException(sprintf(
                        'Unable to register a route for an image storage with the name "%s". Please set a configuration option "%s".',
                        $name,
                        ConfigInterface::BASE_PATH,
                    ));
                }

                if ($imageStorageConfig->route) {
                    $this->registerImageServerPresenter();
                    $this->routes[$name] = $config->config[ConfigInterface::BASE_PATH];
                }

                $imageServerDefinition->setFactory(LocalImageServerFactory::class, [
                    new Reference($this->prefix('image_server_response_factory')),
                ]);

                break;
            case self::IMAGE_SERVER_EXTERNAL:
                if ($imageStorageConfig->route) {
                    throw new RuntimeException(sprintf(
                        'Unable to register a route for an image storage with the name "%s" because a server is set as external.',
                        $name,
                    ));
                }

                $imageServerDefinition->setFactory(ExternalImageServerFactory::class);

                break;
        }

        return $builder->addDefinition($this->prefix('image_storage.' . $name))
            ->setType(ImageStorageInterface::class)
            ->setFactory(ImageStorage::class, [
                $name,
                new Reference($this->prefix('config.' . $name)),
                new Reference($this->prefix('resource_factory.' . $name)),
                new Reference($this->prefix('link_generator.' . $name)),
                new Reference($this->prefix('image_persister.' . $name)),
                new Reference($this->prefix('no_image_resolver.' . $name)),
                new Reference($this->prefix('info_factory.' . $name)),
                $imageServerDefinition,
            ])
            ->setAutowired(false);
    }

    /**
     * @param array<string|Statement> $items
     * @param array<Statement>        $defaults
     *
     * @return array<Statement>
     */
    private function normalizeListOfStatementsWithDefaults(array $items, array $defaults): array
    {
        $statements = [];
        $defaultsMerged = false;

        foreach ($items as $item) {
            if (!$defaultsMerged && '@default' === $item) {
                foreach ($defaults as $default) {
                    $statements[] = $default;
                }

                $defaultsMerged = true;

                continue;
            }

            if (!$item instanceof Statement) {
                $item = new Statement($item);
            }

            $statements[] = $item;
        }

        return $statements;
    }

    private function registerImageServerPresenter(): void
    {
        if ($this->imageServerPresenterRegistered) {
            return;
        }

        $this->getContainerBuilder()
            ->addDefinition($this->prefix('presenter.image_server'))
            ->setType(ImageServerPresenter::class);

        $this->imageServerPresenterRegistered = true;
    }

    /**
     * @return array<string, true>
     */
    private function buildKnownModifiers(FileStorageConfig $config, StorageConfig $extConfig): array
    {
        $presets = array_map(
            callback: static function (PresetConfig $conf): Preset {
                $descriptor = match (true) {
                    [] !== $conf->w => new WDescriptor(...$conf->w),
                    [] !== $conf->x => new XDescriptor(...$conf->x),
                    default => null,
                };

                $defaultDescriptorValue = match (true) {
                    [] !== $conf->w => $conf->defaultW,
                    [] !== $conf->x => $conf->defaultX,
                    default => null,
                };

                return new Preset(
                    modifiers: $conf->modifiers,
                    descriptor: $descriptor,
                    defaultDescriptorValue: $defaultDescriptorValue,
                );
            },
            array: $extConfig->presets,
        );

        $modifiers = array_map(
            callback: static function (Statement $modifier): Modifier\ModifierInterface {
                $entity = $modifier->getEntity();
                $params = $modifier->arguments;
                assert(is_string($entity) && is_subclass_of($entity, Modifier\AbstractModifier::class) && is_array($params));

                return new $entity(...$params);
            },
            array: $extConfig->modifiers,
        );

        $presetsCollection = new PresetCollection();

        foreach ($presets as $name => $preset) {
            $presetsCollection->add(presetAlias: $name, preset: $preset);
        }

        $modifierCollection = new ModifierCollection();

        foreach ($modifiers as $modifier) {
            $modifierCollection->add(modifier: $modifier);
        }

        $cnf = new Config($config->config);

        $codec = new PresetCodec(
            codec: new Codec(
                config: $cnf,
                modifierCollection: $modifierCollection,
            ),
            config: $cnf,
            modifierCollection: $modifierCollection,
            presetCollection: $presetsCollection,
        );

        $known = [];

        foreach ($presets as $preset) {
            if (null === $preset->descriptor) {
                $known[] = $codec->modifiersToPath($preset->modifiers);

                continue;
            }

            $modifiers = $preset->modifiers;

            foreach ($preset->descriptor->iterateModifiers($modifierCollection) as $mod) {
                $known[] = $codec->modifiersToPath(array_merge(
                    $modifiers,
                    $mod,
                ));
            }
        }

        return array_fill_keys(
            keys: array_unique($known),
            value: true,
        );
    }
}