<?php

namespace PTC\CoreBundle\Form\Type;

...

class BlueimpFileType extends AbstractType
{
    public function __construct(
        private readonly string $uploadDir,
        private readonly EntityManagerInterface $em,
        private readonly LoggerInterface $logger
    ) {
    }

    /**
     * {@inheritdoc}
     */
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $uploadDir = $this->uploadDir;

        if ($options['module'] !== null) {
            $uploadDir .= '/'.$options['module'];
        }

        if ($options['userId'] !== null) {
            $uploadDir .= '/'.$options['userId'];
        }

        if (!$options['multiple']) {
            $options['max_number_of_files'] = 1;
        }

        $builder
            ->addEventSubscriber(new BlueimpFileListener($uploadDir, $options['type'], $this->em, $this->logger))
            //->addViewTransformer(new CollectionToArrayTransformer())
            ->setAttribute('btnlabel', $options['btnlabel'])
            ->setAttribute('edit_title', $options['edit_title'])
            ->setAttribute('attr_title', $options['attr_title'])
            ->setAttribute('multiple', $options['multiple'])
            ->setAttribute('max_number_of_files', $options['max_number_of_files'])
            ->setAttribute('module', $options['module'])
            ->setAttribute('userId', $options['userId'])
            ->setAttribute('type', $options['type'])
            ->setAttribute('download_route', $options['download_route'])
            ->setAttribute('download_route_params', $options['download_route_params']);

        if ($options['multiple']) {
            $builder->addViewTransformer(new CollectionToArrayTransformer());
        }
    }

    /**
     * {@inheritdoc}
     */
    public function buildView(FormView $view, FormInterface $form, array $options)
    {
        $data = $form->getViewData();
        $config = $form->getConfig();

        $files = array();

        $this->logger->info('buildView');
        //$this->logger->info(print_r($data, true));

        if (false === empty($data)) {
            if ($data instanceof EntityFile) {
                $this->logger->info('data is an EntityFile');
                $files[] = $data;
            } elseif (\is_array($data)) {
                $this->logger->info('data is a array');
            //} elseif ($data instanceof PersistentCollection) {
                //$this->logger->info('data is a PersistentCollection');
                foreach($data as $dataFile) {
                    if ($dataFile instanceof EntityFile) {
                        $this->logger->info('EntityFile');
                        $files[] = $dataFile;
                    }
                }
            }
        }

        $view->vars = \array_replace($view->vars, array(
            'files' => $files,
            'btnlabel' => $config->getAttribute('btnlabel'),
            'edit_title' => $config->getAttribute('edit_title'),
            'attr_title' => $config->getAttribute('attr_title'),
            'max_number_of_files' => $config->getAttribute('max_number_of_files'),
            'module' => $config->getAttribute('module'),
            'userId' => $config->getAttribute('userId'),
            'download_route' => $config->getAttribute('download_route'),
            'download_route_params' => $config->getAttribute('download_route_params'),
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function configureOptions(OptionsResolver $resolver)
    {
        // data_class must be mapped as :
        // - PTC\CoreBundle\Entity\File if the field is not multiple
        // - null if the field is not multiple because the collection can be:
        //      - Doctrine\ORM\PersistentCollection: if the entity containing the files exists
        //      - Doctrine\Common\Collections\ArrayCollection: if the entity containing the files doesn't exist

        $dataClass = function (Options $options) {
            return (!$options['multiple'])
                ? File::class
                //: 'Doctrine\ORM\PersistentCollection';
                : null;
        };

        $resolver->setDefaults(array(
            'data_class' => $dataClass,
            'compound' => false,
            'files' => array(),
            'btnlabel' => 'Add File',
            'edit_title' => false,
            'attr_title' => array(),
            'multiple' => false,
            'max_number_of_files' => 5,
            'module' => 'FILE',
            'userId' => null,
            'type' => 'FILE',
            'download_route' => 'get_file',
            'download_route_params' => array(),
        ));
    }

}

<?php

namespace PTC\CoreBundle\Form\EventListener;

...

class BlueimpFileListener implements EventSubscriberInterface
{
    public function __construct(
        private readonly string $uploadDir,
        private readonly string $type,
        private readonly EntityManagerInterface $em,
        private readonly LoggerInterface $logger
    ) {
    }

    public function onSubmit(FormEvent $event)
    {
        $data = $event->getData();
        $config = $event->getForm()->getConfig();

        $this->logger->info('onSubmit');

        if (true === empty($data)) {
            return;
        }

        if (!$config->getAttribute('multiple')) {

            $this->logger->info('SINGLE FILES');
            //$this->logger->info(print_r($data, true));

            if ($data instanceof EntityFile) {
                $event->setData(null);
                return;
            }

            $file = $this->createEntityWithFormData($event, $data[0]);
            $event->setData($file);

        } else {

            $this->logger->info('MULTI FILES');
            //$this->logger->info(print_r($data, true));

            $files = array();
            foreach ($data as $formDataFile) {
                $files[] = $this->createEntityWithFormData($event, $formDataFile);
            }

            $event->setData($files);
        }
    }

    /**
     * Data posted from the form
     */
    private function createEntityWithFormData(FormEvent $event, EntityFile|array $data): ?EntityFile
    {
        $entity = null;

        if (!$data instanceof EntityFile) {

            if ($data['id'] !== null && trim($data['id']) !== '') {

                $entity = $this->em->getRepository(EntityFile::class)->findOneBy(array('id' => $data['id'], 'type' => $this->type));

            } elseif (true === \is_file($this->uploadDir.'/'.$data['name'])) {

                $handle = new File($this->uploadDir.'/'.$data['name']);

                $entity = new EntityFile();
                $entity->setType($this->type);
                $entity->setMimetype($handle->getMimeType());
                $entity->setName($handle->getFilename());
                $entity->setContent(file_get_contents($handle->getPathname()));
                $entity->setSize($handle->getSize());

                if (!$event->getForm()->isRoot() && \is_object($event->getForm()->getRoot()->getData())) {
                    // Used to link the File to the root entity (Loggable)
                    $entity->setParent($event->getForm()->getRoot()->getData());
                }

                if (isset($data['title'])) {
                    $entity->setTitle($data['title']);
                }
            }
        }

        return $entity;
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents(): array
    {
        return array(FormEvents::SUBMIT => 'onSubmit');
    }
}