ConfigurationService.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * 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.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Form\Domain\Configuration;
 
use ‪TYPO3\CMS\Core\Cache\CacheManager;
use ‪TYPO3\CMS\Core\Cache\Frontend\FrontendInterface;
use ‪TYPO3\CMS\Core\SingletonInterface;
use ‪TYPO3\CMS\Core\Utility\ArrayUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Form\Domain\Configuration\ArrayProcessing\ArrayProcessing;
use ‪TYPO3\CMS\Form\Domain\Configuration\ArrayProcessing\ArrayProcessor;
use ‪TYPO3\CMS\Form\Domain\Configuration\Exception\PropertyException;
use ‪TYPO3\CMS\Form\Domain\Configuration\Exception\PrototypeNotFoundException;
use ‪TYPO3\CMS\Form\Domain\Configuration\FormDefinition\Validators\ValidationDto;
use ‪TYPO3\CMS\Form\Domain\Configuration\FrameworkConfiguration\Extractors\AdditionalElementPropertyPathsExtractor;
use ‪TYPO3\CMS\Form\Domain\Configuration\FrameworkConfiguration\Extractors\ExtractorDto;
use ‪TYPO3\CMS\Form\Domain\Configuration\FrameworkConfiguration\Extractors\FormElement\IsCreatableFormElementExtractor;
use ‪TYPO3\CMS\Form\Domain\Configuration\FrameworkConfiguration\Extractors\FormElement\MultiValuePropertiesExtractor;
use ‪TYPO3\CMS\Form\Domain\Configuration\FrameworkConfiguration\Extractors\FormElement\PredefinedDefaultsExtractor;
use ‪TYPO3\CMS\Form\Domain\Configuration\FrameworkConfiguration\Extractors\FormElement\PropertyPathsExtractor;
use ‪TYPO3\CMS\Form\Domain\Configuration\FrameworkConfiguration\Extractors\FormElement\SelectOptionsExtractor;
use ‪TYPO3\CMS\Form\Domain\Configuration\FrameworkConfiguration\Extractors\PropertyCollectionElement\IsCreatablePropertyCollectionElementExtractor;
use ‪TYPO3\CMS\Form\Domain\Configuration\FrameworkConfiguration\Extractors\PropertyCollectionElement\MultiValuePropertiesExtractor as CollectionMultiValuePropertiesExtractor;
use ‪TYPO3\CMS\Form\Domain\Configuration\FrameworkConfiguration\Extractors\PropertyCollectionElement\PredefinedDefaultsExtractor as CollectionPredefinedDefaultsExtractor;
use ‪TYPO3\CMS\Form\Domain\Configuration\FrameworkConfiguration\Extractors\PropertyCollectionElement\PropertyPathsExtractor as CollectionPropertyPathsExtractor;
use ‪TYPO3\CMS\Form\Domain\Configuration\FrameworkConfiguration\Extractors\PropertyCollectionElement\SelectOptionsExtractor as CollectionSelectOptionsExtractor;
use ‪TYPO3\CMS\Form\Mvc\Configuration\ConfigurationManagerInterface;
use ‪TYPO3\CMS\Form\Service\TranslationService;
 
class ‪ConfigurationService implements ‪SingletonInterface
{
    protected ‪$formSettings;
 
    protected ‪$firstLevelCache = [];
 
    protected ‪$translationService;
 
    public function ‪__construct(‪ConfigurationManagerInterface $configurationManager)
    {
        $this->formSettings = $configurationManager->‪getConfiguration(‪ConfigurationManagerInterface::CONFIGURATION_TYPE_YAML_SETTINGS, 'form');
    }
 
    public function ‪getPrototypeConfiguration(string $prototypeName): array
    {
        if (!isset($this->formSettings['prototypes'][$prototypeName])) {
            throw new ‪PrototypeNotFoundException(
                sprintf('The Prototype "%s" was not found.', $prototypeName),
                1475924277
            );
        }
        return $this->formSettings['prototypes'][$prototypeName];
    }
 
    public function ‪getSelectablePrototypeNamesDefinedInFormEditorSetup(): array
    {
        $returnValue = GeneralUtility::makeInstance(
            ArrayProcessor::class,
            $this->formSettings['formManager']['selectablePrototypesConfiguration'] ?? []
        )->forEach(
            GeneralUtility::makeInstance(
                ArrayProcessing::class,
                'selectablePrototypeNames',
                '^([\d]+)\.identifier$',
                static function ($_, $value) {
                    return $value;
                }
            )
        );
 
        return array_values($returnValue['selectablePrototypeNames'] ?? []);
    }
 
    public function ‪isFormElementPropertyDefinedInFormEditorSetup(‪ValidationDto $dto): bool
    {
        $formDefinitionValidationConfiguration = $this->‪buildFormDefinitionValidationConfigurationFromFormEditorSetup(
            $dto->‪getPrototypeName()
        );
 
        $subConfig = $formDefinitionValidationConfiguration['formElements'][$dto->‪getFormElementType()] ?? [];
        return $this->‪isPropertyDefinedInFormEditorSetup($dto->‪getPropertyPath(), $subConfig);
    }
 
    public function ‪isPropertyCollectionPropertyDefinedInFormEditorSetup(‪ValidationDto $dto): bool
    {
        $formDefinitionValidationConfiguration = $this->‪buildFormDefinitionValidationConfigurationFromFormEditorSetup(
            $dto->‪getPrototypeName()
        );
        $subConfig = $formDefinitionValidationConfiguration['formElements'][$dto->‪getFormElementType()]['collections'][$dto->‪getPropertyCollectionName()][$dto->‪getPropertyCollectionElementIdentifier()] ?? [];
 
        return $this->‪isPropertyDefinedInFormEditorSetup($dto->‪getPropertyPath(), $subConfig);
    }
 
    public function ‪formElementPropertyHasLimitedAllowedValuesDefinedWithinFormEditorSetup(
        ‪ValidationDto $dto
    ): bool {
        $formDefinitionValidationConfiguration = $this->‪buildFormDefinitionValidationConfigurationFromFormEditorSetup(
            $dto->‪getPrototypeName()
        );
 
        $propertyPath = $this->‪getBasePropertyPathFromMultiValueFormElementProperty($dto);
        return isset(
            $formDefinitionValidationConfiguration['formElements'][$dto->‪getFormElementType()]['selectOptions'][$propertyPath]
        );
    }
 
    public function ‪getAllowedValuesForFormElementPropertyFromFormEditorSetup(
        ‪ValidationDto $dto,
        bool $translated = true
    ): array {
        if (!$this->‪formElementPropertyHasLimitedAllowedValuesDefinedWithinFormEditorSetup($dto)) {
            throw new ‪PropertyException(
                sprintf(
                    'No selectOptions found for form element type "%s" and property path "%s"',
                    $dto->‪getFormElementType(),
                    $dto->‪getPropertyPath()
                ),
                1614264312
            );
        }
 
        $formDefinitionValidationConfiguration = $this->‪buildFormDefinitionValidationConfigurationFromFormEditorSetup(
            $dto->‪getPrototypeName()
        );
 
        $property = $translated ? 'selectOptions' : 'untranslatedSelectOptions';
        $propertyPath = $this->‪getBasePropertyPathFromMultiValueFormElementProperty($dto);
        return $formDefinitionValidationConfiguration['formElements'][$dto->‪getFormElementType()][$property][$propertyPath];
    }
 
    public function ‪propertyCollectionPropertyHasLimitedAllowedValuesDefinedWithinFormEditorSetup(
        ‪ValidationDto $dto
    ): bool {
        $formDefinitionValidationConfiguration = $this->‪buildFormDefinitionValidationConfigurationFromFormEditorSetup(
            $dto->‪getPrototypeName()
        );
 
        $propertyPath = $this->‪getBasePropertyPathFromMultiValuePropertyCollectionElement($dto);
        return isset(
            $formDefinitionValidationConfiguration['collections'][$dto->‪getPropertyCollectionName()][$dto->‪getPropertyCollectionElementIdentifier()]['selectOptions'][$propertyPath]
        );
    }
 
    public function ‪getAllowedValuesForPropertyCollectionPropertyFromFormEditorSetup(
        ‪ValidationDto $dto,
        bool $translated = true
    ): array {
        if (!$this->‪propertyCollectionPropertyHasLimitedAllowedValuesDefinedWithinFormEditorSetup($dto)) {
            throw new ‪PropertyException(
                sprintf(
                    'No selectOptions found for property collection "%s" and identifier "%s" and property path "%s"',
                    $dto->‪getPropertyCollectionName(),
                    $dto->‪getPropertyCollectionElementIdentifier(),
                    $dto->‪getPropertyPath()
                ),
                1614264313
            );
        }
 
        $formDefinitionValidationConfiguration = $this->‪buildFormDefinitionValidationConfigurationFromFormEditorSetup(
            $dto->‪getPrototypeName()
        );
 
        $property = $translated ? 'selectOptions' : 'untranslatedSelectOptions';
        $propertyPath = $this->‪getBasePropertyPathFromMultiValuePropertyCollectionElement($dto);
        return $formDefinitionValidationConfiguration['collections'][$dto->‪getPropertyCollectionName()][$dto->‪getPropertyCollectionElementIdentifier()][$property][$propertyPath];
    }
 
    protected function ‪getBasePropertyPathFromMultiValueFormElementProperty(
        ‪ValidationDto $dto
    ): string {
        $formDefinitionValidationConfiguration = $this->‪buildFormDefinitionValidationConfigurationFromFormEditorSetup(
            $dto->‪getPrototypeName()
        );
 
        $propertyPath = $dto->‪getPropertyPath();
        $multiValueProperties = $formDefinitionValidationConfiguration['formElements'][$dto->‪getFormElementType()]['multiValueProperties'] ?? [];
        foreach ($multiValueProperties as $multiValueProperty) {
            if (strpos($propertyPath, $multiValueProperty) === 0) {
                $propertyPath = $multiValueProperty;
                continue;
            }
        }
 
        return $propertyPath;
    }
 
    protected function ‪getBasePropertyPathFromMultiValuePropertyCollectionElement(
        ‪ValidationDto $dto
    ): string {
        $formDefinitionValidationConfiguration = $this->‪buildFormDefinitionValidationConfigurationFromFormEditorSetup(
            $dto->‪getPrototypeName()
        );
 
        $propertyPath = $dto->‪getPropertyPath();
        $multiValueProperties = $formDefinitionValidationConfiguration['collections'][$dto->‪getPropertyCollectionName()][$dto->‪getPropertyCollectionElementIdentifier()]['multiValueProperties'] ?? [];
        foreach ($multiValueProperties as $multiValueProperty) {
            if (strpos($propertyPath, $multiValueProperty) === 0) {
                $propertyPath = $multiValueProperty;
                continue;
            }
        }
 
        return $propertyPath;
    }
 
    public function ‪isFormElementPropertyDefinedInPredefinedDefaultsInFormEditorSetup(
        ‪ValidationDto $dto
    ): bool {
        $formDefinitionValidationConfiguration = $this->‪buildFormDefinitionValidationConfigurationFromFormEditorSetup(
            $dto->‪getPrototypeName()
        );
        return isset(
            $formDefinitionValidationConfiguration['formElements'][$dto->‪getFormElementType()]['predefinedDefaults'][$dto->‪getPropertyPath()]
        );
    }
 
    public function ‪getFormElementPredefinedDefaultValueFromFormEditorSetup(‪ValidationDto $dto, bool $translated = true)
    {
        if (!$this->‪isFormElementPropertyDefinedInPredefinedDefaultsInFormEditorSetup($dto)) {
            throw new ‪PropertyException(
                sprintf(
                    'No predefinedDefaults found for form element type "%s" and property path "%s"',
                    $dto->‪getFormElementType(),
                    $dto->‪getPropertyPath()
                ),
                1528578401
            );
        }
 
        $formDefinitionValidationConfiguration = $this->‪buildFormDefinitionValidationConfigurationFromFormEditorSetup(
            $dto->‪getPrototypeName()
        );
 
        $property = $translated ? 'predefinedDefaults' : 'untranslatedPredefinedDefaults';
        return $formDefinitionValidationConfiguration['formElements'][$dto->‪getFormElementType()][$property][$dto->‪getPropertyPath()];
    }
 
    public function ‪isPropertyCollectionPropertyDefinedInPredefinedDefaultsInFormEditorSetup(
        ‪ValidationDto $dto
    ): bool {
        $formDefinitionValidationConfiguration = $this->‪buildFormDefinitionValidationConfigurationFromFormEditorSetup(
            $dto->‪getPrototypeName()
        );
        return isset(
            $formDefinitionValidationConfiguration['collections'][$dto->‪getPropertyCollectionName()][$dto->‪getPropertyCollectionElementIdentifier()]['predefinedDefaults'][$dto->‪getPropertyPath()]
        );
    }
 
    public function ‪getPropertyCollectionPredefinedDefaultValueFromFormEditorSetup(‪ValidationDto $dto, bool $translated = true)
    {
        if (!$this->‪isPropertyCollectionPropertyDefinedInPredefinedDefaultsInFormEditorSetup($dto)) {
            throw new ‪PropertyException(
                sprintf(
                    'No predefinedDefaults found for property collection "%s" and identifier "%s" and property path "%s"',
                    $dto->‪getPropertyCollectionName(),
                    $dto->‪getPropertyCollectionElementIdentifier(),
                    $dto->‪getPropertyPath()
                ),
                1528578402
            );
        }
 
        $formDefinitionValidationConfiguration = $this->‪buildFormDefinitionValidationConfigurationFromFormEditorSetup(
            $dto->‪getPrototypeName()
        );
 
        $property = $translated ? 'predefinedDefaults' : 'untranslatedPredefinedDefaults';
        return $formDefinitionValidationConfiguration['collections'][$dto->‪getPropertyCollectionName()][$dto->‪getPropertyCollectionElementIdentifier()][$property][$dto->‪getPropertyPath()];
    }
 
    public function ‪isFormElementTypeCreatableByFormEditor(‪ValidationDto $dto): bool
    {
        if ($dto->‪getFormElementType() === 'Form') {
            return true;
        }
        $formDefinitionValidationConfiguration = $this->‪buildFormDefinitionValidationConfigurationFromFormEditorSetup(
            $dto->‪getPrototypeName()
        );
        return $formDefinitionValidationConfiguration['formElements'][$dto->‪getFormElementType()]['creatable'] ?? false;
    }
 
    public function ‪isPropertyCollectionElementIdentifierCreatableByFormEditor(‪ValidationDto $dto): bool
    {
        $formDefinitionValidationConfiguration = $this->‪buildFormDefinitionValidationConfigurationFromFormEditorSetup(
            $dto->‪getPrototypeName()
        );
        return $formDefinitionValidationConfiguration['formElements'][$dto->‪getFormElementType()]['collections'][$dto->‪getPropertyCollectionName()][$dto->‪getPropertyCollectionElementIdentifier()]['creatable'] ?? false;
    }
 
    public function ‪isFormElementTypeDefinedInFormSetup(‪ValidationDto $dto): bool
    {
        $prototypeConfiguration = $this->‪getPrototypeConfiguration($dto->‪getPrototypeName());
        return ‪ArrayUtility::isValidPath(
            $prototypeConfiguration,
            'formElementsDefinition.' . $dto->‪getFormElementType(),
            '.'
        );
    }
 
    public function ‪getAllBackendTranslationsForTranslationKeys(array $keys, string $prototypeName): array
    {
        $translations = [];
        foreach ($keys as $key) {
            if (!is_string($key)) {
                continue;
            }
 
            $translations[$key] = $this->‪getAllBackendTranslationsForTranslationKey($key, $prototypeName);
        }
 
        return $translations;
    }
 
    public function ‪getAllBackendTranslationsForTranslationKey(string $key, string $prototypeName): array
    {
        $prototypeConfiguration = $this->‪getPrototypeConfiguration($prototypeName);
 
        return $this->‪getTranslationService()->‪translateToAllBackendLanguages(
            $key,
            [],
            $prototypeConfiguration['formEditor']['translationFiles'] ?? []
        );
    }
 
    protected function ‪buildFormDefinitionValidationConfigurationFromFormEditorSetup(string $prototypeName): array
    {
        $cacheKey = implode('_', ['buildFormDefinitionValidationConfigurationFromFormEditorSetup', $prototypeName]);
        $configuration = $this->‪getCacheEntry($cacheKey);
 
        if ($configuration === null) {
            $prototypeConfiguration = $this->‪getPrototypeConfiguration($prototypeName);
            $extractorDto = GeneralUtility::makeInstance(ExtractorDto::class, $prototypeConfiguration);
 
            GeneralUtility::makeInstance(ArrayProcessor::class, $prototypeConfiguration)->forEach(
                GeneralUtility::makeInstance(
                    ArrayProcessing::class,
                    'formElementPropertyPaths',
                    '^formElementsDefinition\.(.*)\.formEditor\.editors\.([\d]+)\.(propertyPath|.*\.propertyPath)$',
                    GeneralUtility::makeInstance(PropertyPathsExtractor::class, $extractorDto)
                ),
                GeneralUtility::makeInstance(
                    ArrayProcessing::class,
                    'formElementAdditionalElementPropertyPaths',
                    '^formElementsDefinition\.(.*)\.formEditor\.editors\.([\d]+)\.additionalElementPropertyPaths\.([\d]+)',
                    GeneralUtility::makeInstance(AdditionalElementPropertyPathsExtractor::class, $extractorDto)
                ),
                GeneralUtility::makeInstance(
                    ArrayProcessing::class,
                    'formElementRelativeMultiValueProperties',
                    '^formElementsDefinition\.(.*)\.formEditor\.editors\.([\d]+)\.templateName$',
                    GeneralUtility::makeInstance(MultiValuePropertiesExtractor::class, $extractorDto)
                ),
                GeneralUtility::makeInstance(
                    ArrayProcessing::class,
                    'formElementSelectOptions',
                    '^formElementsDefinition\.(.*)\.formEditor\.editors\.([\d]+)\.selectOptions\.([\d]+)\.value$',
                    GeneralUtility::makeInstance(SelectOptionsExtractor::class, $extractorDto)
                ),
                GeneralUtility::makeInstance(
                    ArrayProcessing::class,
                    'formElementPredefinedDefaults',
                    '^formElementsDefinition\.(.*)\.formEditor\.predefinedDefaults\.(.+)$',
                    GeneralUtility::makeInstance(PredefinedDefaultsExtractor::class, $extractorDto)
                ),
                GeneralUtility::makeInstance(
                    ArrayProcessing::class,
                    'formElementCreatable',
                    '^formElementsDefinition\.(.*)\.formEditor.group$',
                    GeneralUtility::makeInstance(IsCreatableFormElementExtractor::class, $extractorDto)
                ),
                GeneralUtility::makeInstance(
                    ArrayProcessing::class,
                    'propertyCollectionCreatable',
                    '^formElementsDefinition\.(.*)\.formEditor\.editors\.([\d]+)\.templateName$',
                    GeneralUtility::makeInstance(IsCreatablePropertyCollectionElementExtractor::class, $extractorDto)
                ),
                GeneralUtility::makeInstance(
                    ArrayProcessing::class,
                    'propertyCollectionPropertyPaths',
                    '^formElementsDefinition\.(.*)\.formEditor\.propertyCollections\.(finishers|validators)\.([\d]+)\.editors\.([\d]+)\.(propertyPath|.*\.propertyPath)$',
                    GeneralUtility::makeInstance(CollectionPropertyPathsExtractor::class, $extractorDto)
                ),
                GeneralUtility::makeInstance(
                    ArrayProcessing::class,
                    'propertyCollectionAdditionalElementPropertyPaths',
                    '^formElementsDefinition\.(.*)\.formEditor\.propertyCollections\.(finishers|validators)\.([\d]+)\.editors\.([\d]+)\.additionalElementPropertyPaths\.([\d]+)',
                    GeneralUtility::makeInstance(AdditionalElementPropertyPathsExtractor::class, $extractorDto)
                ),
                GeneralUtility::makeInstance(
                    ArrayProcessing::class,
                    'propertyCollectionRelativeMultiValueProperties',
                    '^formElementsDefinition\.(.*)\.formEditor\.propertyCollections\.(finishers|validators)\.([\d]+)\.editors\.([\d]+)\.templateName$',
                    GeneralUtility::makeInstance(CollectionMultiValuePropertiesExtractor::class, $extractorDto)
                ),
                GeneralUtility::makeInstance(
                    ArrayProcessing::class,
                    'propertyCollectionSelectOptions',
                    '^formElementsDefinition\.(.*)\.formEditor\.propertyCollections\.(finishers|validators)\.([\d]+)\.editors\.([\d]+)\.selectOptions\.([\d]+)\.value$',
                    GeneralUtility::makeInstance(CollectionSelectOptionsExtractor::class, $extractorDto)
                ),
                GeneralUtility::makeInstance(
                    ArrayProcessing::class,
                    'propertyCollectionPredefinedDefaults',
                    '^(validatorsDefinition|finishersDefinition)\.(.*)\.formEditor\.predefinedDefaults\.(.+)$',
                    GeneralUtility::makeInstance(CollectionPredefinedDefaultsExtractor::class, $extractorDto)
                )
            );
            $configuration = $extractorDto->getResult();
 
            $configuration = $this->‪translateValues($prototypeConfiguration, $configuration);
 
            $configuration = $this->‪executeBuildFormDefinitionValidationConfigurationHooks(
                $prototypeName,
                $configuration
            );
 
            $this->‪setCacheEntry($cacheKey, $configuration);
        }
 
        return $configuration;
    }
 
    protected function ‪executeBuildFormDefinitionValidationConfigurationHooks(
        string $prototypeName,
        array $configuration
    ): array {
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['ext/form']['buildFormDefinitionValidationConfiguration'] ?? [] as $className) {
            $hookObj = GeneralUtility::makeInstance($className);
            if (method_exists($hookObj, 'addAdditionalPropertyPaths')) {
                $validationDto = GeneralUtility::makeInstance(ValidationDto::class, $prototypeName);
                $propertyPathsFromHook = $hookObj->addAdditionalPropertyPaths($validationDto);
                if (!is_array($propertyPathsFromHook)) {
                    $message = 'Return value of "%s->addAdditionalPropertyPaths() must be type "array"';
                    throw new ‪PropertyException(sprintf($message, $className), 1528633965);
                }
                $configuration = $this->‪addAdditionalPropertyPathsFromHook(
                    $className,
                    $prototypeName,
                    $propertyPathsFromHook,
                    $configuration
                );
            }
        }
 
        return $configuration;
    }
 
    protected function ‪addAdditionalPropertyPathsFromHook(
        string $hookClassName,
        string $prototypeName,
        array $propertyPathsFromHook,
        array $configuration
    ): array {
        foreach ($propertyPathsFromHook as $index => $validationDto) {
            if (!($validationDto instanceof ‪ValidationDto)) {
                $message = 'Return value of "%s->addAdditionalPropertyPaths()[%s] must be an instance of "%s"';
                throw new ‪PropertyException(
                    sprintf($message, $hookClassName, $index, ValidationDto::class),
                    1528633966
                );
            }
 
            if ($validationDto->getPrototypeName() !== $prototypeName) {
                $message = 'The prototype name "%s" does not match "%s" on "%s->addAdditionalPropertyPaths()[%s]';
                throw new ‪PropertyException(
                    sprintf(
                        $message,
                        $validationDto->getPrototypeName(),
                        $prototypeName,
                        $hookClassName,
                        $index,
                        ValidationDto::class
                    ),
                    1528634966
                );
            }
 
            $formElementType = $validationDto->getFormElementType();
            if (!$this->‪isFormElementTypeDefinedInFormSetup($validationDto)) {
                $message = 'Form element type "%s" does not exist in prototype configuration "%s"';
                throw new ‪PropertyException(
                    sprintf($message, $formElementType, $validationDto->getPrototypeName()),
                    1528633967
                );
            }
 
            if ($validationDto->hasPropertyCollectionName() &&
                $validationDto->hasPropertyCollectionElementIdentifier()) {
                $propertyCollectionName = $validationDto->getPropertyCollectionName();
                $propertyCollectionElementIdentifier = $validationDto->getPropertyCollectionElementIdentifier();
 
                if ($propertyCollectionName !== 'finishers' && $propertyCollectionName !== 'validators') {
                    $message = 'The property collection name "%s" for form element "%s" must be "finishers" or "validators"';
                    throw new ‪PropertyException(
                        sprintf($message, $propertyCollectionName, $formElementType),
                        1528636941
                    );
                }
 
                $configuration['formElements'][$formElementType]['collections'][$propertyCollectionName][$propertyCollectionElementIdentifier]['additionalPropertyPaths'][]
                    = $validationDto->getPropertyPath();
            } else {
                $configuration['formElements'][$formElementType]['additionalPropertyPaths'][]
                    = $validationDto->getPropertyPath();
            }
        }
 
        return $configuration;
    }
 
    protected function ‪isPropertyDefinedInFormEditorSetup(string $propertyPath, array $subConfig): bool
    {
        if (empty($subConfig)) {
            return false;
        }
        if (
            in_array($propertyPath, $subConfig['propertyPaths'] ?? [], true)
            || in_array($propertyPath, $subConfig['additionalElementPropertyPaths'] ?? [], true)
            || in_array($propertyPath, $subConfig['additionalPropertyPaths'] ?? [], true)
        ) {
            return true;
        }
        foreach ($subConfig['multiValueProperties'] ?? [] as $relativeMultiValueProperty) {
            if (strpos($propertyPath, $relativeMultiValueProperty) === 0) {
                return true;
            }
        }
 
        return false;
    }
 
    protected function ‪translateValues(array $prototypeConfiguration, array $configuration): array
    {
        if (isset($configuration['formElements'])) {
            $configuration['formElements'] = $this->‪translatePredefinedDefaults(
                $prototypeConfiguration,
                $configuration['formElements']
            );
 
            $configuration['formElements'] = $this->‪translateSelectOptions(
                $prototypeConfiguration,
                $configuration['formElements']
            );
        }
 
        foreach ($configuration['collections'] ?? [] as $name => $collections) {
            $configuration['collections'][$name] = $this->‪translatePredefinedDefaults($prototypeConfiguration, $collections);
            $configuration['collections'][$name] = $this->‪translateSelectOptions($prototypeConfiguration, $configuration['collections'][$name]);
        }
        return $configuration;
    }
 
    protected function ‪translatePredefinedDefaults(array $prototypeConfiguration, array $formElements): array
    {
        foreach ($formElements ?? [] as $name => $formElement) {
            if (!isset($formElement['predefinedDefaults'])) {
                continue;
            }
            $formElement['untranslatedPredefinedDefaults'] = $formElement['predefinedDefaults'];
            $formElement['predefinedDefaults'] = $this->‪getTranslationService()->‪translateValuesRecursive(
                $formElement['predefinedDefaults'],
                $prototypeConfiguration['formEditor']['translationFiles'] ?? []
            );
            $formElements[$name] = $formElement;
        }
        return $formElements;
    }
 
    protected function ‪translateSelectOptions(array $prototypeConfiguration, array $formElements): array
    {
        foreach ($formElements ?? [] as $name => $formElement) {
            if (empty($formElement['selectOptions']) || !is_array($formElement['selectOptions'])) {
                continue;
            }
            $formElement['untranslatedSelectOptions'] = $formElement['selectOptions'];
 
            $formElement['selectOptions'] = $this->‪getTranslationService()->‪translateValuesRecursive(
                $formElement['selectOptions'],
                $prototypeConfiguration['formEditor']['translationFiles'] ?? []
            );
            $formElements[$name] = $formElement;
        }
        return $formElements;
    }
 
    protected function ‪getCacheEntry(string $cacheKey)
    {
        if (isset($this->firstLevelCache[$cacheKey])) {
            return $this->firstLevelCache[$cacheKey];
        }
        $cacheValue = $this->‪getCacheFrontend()->‪get('form_' . $cacheKey);
        return $cacheValue === false ? null : $cacheValue;
    }
 
    protected function ‪setCacheEntry(string $cacheKey, $value): void
    {
        $this->‪getCacheFrontend()->‪set('form_' . $cacheKey, $value);
        $this->firstLevelCache[$cacheKey] = $value;
    }
 
    protected function ‪getTranslationService(): ‪TranslationService
    {
        return $this->translationService instanceof ‪TranslationService
            ? $this->translationService
            : GeneralUtility::makeInstance(TranslationService::class);
    }
 
    protected function ‪getCacheFrontend(): ‪FrontendInterface
    {
        return GeneralUtility::makeInstance(CacheManager::class)->getCache('assets');
    }
}