├── Classes
    ├── Configuration
    │   └── Extension.php
    ├── Event
    │   └── CopyVariantEvent.php
    ├── EventListener
    │   └── AdaptVariantConditionEventListener.php
    ├── Finisher
    │   └── SaveToDatabaseFinisher.php
    ├── FormElements
    │   ├── RepeatableContainer.php
    │   └── RepeatableContainerInterface.php
    ├── Hooks
    │   └── FormHooks.php
    └── Service
    │   └── CopyService.php
├── Configuration
    ├── .htaccess
    ├── Icons.php
    ├── JavaScriptModules.php
    ├── Services.yaml
    ├── Sets
    │   └── RepeatableFormElements
    │   │   ├── config.yaml
    │   │   └── setup.typoscript
    ├── TCA
    │   └── Overrides
    │   │   └── sys_template.php
    ├── TypoScript
    │   └── setup.typoscript
    └── Yaml
    │   ├── FormSetup.yaml
    │   └── FormSetupBackend.yaml
├── LICENSE.txt
├── README.md
├── Resources
    ├── Private
    │   ├── ExampleFormDefinitions
    │   │   └── extended-save-to-database-finisher.form.yaml
    │   ├── Frontend
    │   │   └── Partials
    │   │   │   └── RepeatableContainer.html
    │   └── Language
    │   │   ├── Database.xlf
    │   │   ├── de.Database.xlf
    │   │   ├── de.locallang.xlf
    │   │   └── locallang.xlf
    └── Public
    │   ├── Icons
    │       ├── Extension.svg
    │       └── t3-form-icon-repeatable-container.svg
    │   ├── JavaScript
    │       ├── backend
    │       │   └── form-editor
    │       │   │   └── view-model.js
    │       └── frontend
    │       │   └── repeatable-container.js
    │   └── StyleSheets
    │       └── app.css
├── composer.json
├── ext_emconf.php
└── ext_localconf.php


/Classes/Configuration/Extension.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | /*
 6 |  * This file is part of the TYPO3 CMS extension "repeatable_form_elements".
 7 |  *
 8 |  * Copyright (C) 2018 Ralf Zimmermann dreistrom.land AG <r.zimmermann@dreistrom.land>
 9 |  * Copyright (C) 2021 Elias Häußler <elias@haeussler.dev>
10 |  *
11 |  * This program is free software: you can redistribute it and/or modify
12 |  * it under the terms of the GNU General Public License as published by
13 |  * the Free Software Foundation, either version 2 of the License, or
14 |  * (at your option) any later version.
15 |  *
16 |  * This program is distributed in the hope that it will be useful,
17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 |  * GNU General Public License for more details.
20 |  *
21 |  * You should have received a copy of the GNU General Public License
22 |  * along with this program. If not, see <https://www.gnu.org/licenses/>.
23 |  */
24 | 
25 | namespace TRITUM\RepeatableFormElements\Configuration;
26 | 
27 | use TRITUM\RepeatableFormElements\Hooks\FormHooks;
28 | use TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
29 | 
30 | /**
31 |  * Extension
32 |  *
33 |  * @author Ralf Zimmermann | dreistrom.land AG <r.zimmermann@dreistrom.land>
34 |  * @author Elias Häußler <elias@haeussler.dev>
35 |  * @author Christian Seyfferth | dreistrom.land AG <c.seyfferth@dreistrom.land>
36 |  * @license GPL-2.0-or-later
37 |  */
38 | final class Extension
39 | {
40 |     public const KEY = 'repeatable_form_elements';
41 | 
42 |     public static function addTypoScriptSetup(): void
43 |     {
44 |         // @todo: maybe move this to 'EXT:repeatable_form_elements/ext_typoscript_setup.typoscript'
45 |         ExtensionManagementUtility::addTypoScriptSetup(trim('
46 |             module.tx_form {
47 |                 settings {
48 |                     yamlConfigurations {
49 |                         1511193633 = EXT:repeatable_form_elements/Configuration/Yaml/FormSetup.yaml
50 |                         1511193634 = EXT:repeatable_form_elements/Configuration/Yaml/FormSetupBackend.yaml
51 |                     }
52 |                 }
53 |             }
54 |         '));
55 |     }
56 | 
57 |     public static function registerHooks(): void
58 |     {
59 |         $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['ext/form']['afterInitializeCurrentPage'][1511196413] = FormHooks::class;
60 |         $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['ext/form']['beforeRendering'][1511196413] = FormHooks::class;
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/Classes/Event/CopyVariantEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace TRITUM\RepeatableFormElements\Event;
 6 | 
 7 | /**
 8 |  * This file is part of the "repeatable_form_elements" Extension for TYPO3 CMS.
 9 |  *
10 |  * For the full copyright and license information, please read the
11 |  * LICENSE.txt file that was distributed with this source code.
12 |  */
13 | 
14 | use TYPO3\CMS\Form\Domain\Model\FormElements\FormElementInterface;
15 | 
16 | /**
17 |  * Use this event to manipulate variantOptions on copying form elements
18 |  */
19 | class CopyVariantEvent
20 | {
21 |     private array $options;
22 |     private FormElementInterface $originalFormElement;
23 |     private FormElementInterface $newFormElement;
24 |     private string $newIdentifier;
25 |     private bool $variantEnabled = true;
26 | 
27 |     public function __construct(
28 |         array $options,
29 |         FormElementInterface $originalFormElement,
30 |         FormElementInterface $newFormElement,
31 |         string $newIdentifier,
32 |     ) {
33 |         $this->options = $options;
34 |         $this->originalFormElement = $originalFormElement;
35 |         $this->newFormElement = $newFormElement;
36 |         $this->newIdentifier = $newIdentifier;
37 |     }
38 | 
39 |     public function getOptions(): array
40 |     {
41 |         return $this->options;
42 |     }
43 | 
44 |     public function setOptions(array $options): void
45 |     {
46 |         $this->options = $options;
47 |     }
48 | 
49 |     public function getOriginalFormElement(): FormElementInterface
50 |     {
51 |         return $this->originalFormElement;
52 |     }
53 | 
54 |     public function getNewFormElement(): FormElementInterface
55 |     {
56 |         return $this->newFormElement;
57 |     }
58 | 
59 |     public function getNewIdentifier(): string
60 |     {
61 |         return $this->newIdentifier;
62 |     }
63 | 
64 |     public function isVariantEnabled(): bool
65 |     {
66 |         return $this->variantEnabled;
67 |     }
68 | 
69 |     public function setVariantEnabled(bool $variantEnabled): void
70 |     {
71 |         $this->variantEnabled = $variantEnabled;
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/Classes/EventListener/AdaptVariantConditionEventListener.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace TRITUM\RepeatableFormElements\EventListener;
 6 | 
 7 | /**
 8 |  * This file is part of the "repeatable_form_elements" Extension for TYPO3 CMS.
 9 |  *
10 |  * For the full copyright and license information, please read the
11 |  * LICENSE.txt file that was distributed with this source code.
12 |  */
13 | 
14 | use TRITUM\RepeatableFormElements\Event\CopyVariantEvent;
15 | 
16 | /**
17 |  * Replace original identifiers inside variant condition with identifiers of new element
18 |  *
19 |  * @param CopyVariantEvent $event
20 |  */
21 | final class AdaptVariantConditionEventListener
22 | {
23 |     public function __invoke(CopyVariantEvent $event): void
24 |     {
25 |         $options            = $event->getOptions();
26 |         $originalIdentifier = $event->getOriginalFormElement()->getIdentifier();
27 | 
28 |         // get path strings for identifiers for replacement in condition
29 |         // e.g. for `traverse(formValues, 'repeatablecontainer-1.0.checkbox-1')`
30 |         $originalIdentifierAsPath = str_replace('.', '/', $originalIdentifier);
31 |         $newIdentifierAsPath = str_replace('.', '/', $event->getNewIdentifier());
32 | 
33 |         // adapt original condition to match identifier of the copied form element
34 |         $options['condition'] = str_replace(
35 |             [
36 |                 $originalIdentifier,
37 |                 $originalIdentifierAsPath,
38 |             ],
39 |             [
40 |                 $event->getNewIdentifier(),
41 |                 $newIdentifierAsPath,
42 |             ],
43 |             $options['condition'],
44 |         );
45 | 
46 |         $event->setOptions($options);
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/Classes/Finisher/SaveToDatabaseFinisher.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * This file is part of the "repeatable_form_elements" Extension for TYPO3 CMS.
  5 |  *
  6 |  * For the full copyright and license information, please read the
  7 |  * LICENSE.txt file that was distributed with this source code.
  8 |  */
  9 | 
 10 | declare(strict_types=1);
 11 | 
 12 | namespace TRITUM\RepeatableFormElements\Finisher;
 13 | 
 14 | use DateTimeInterface;
 15 | use TYPO3\CMS\Core\Database\ConnectionPool;
 16 | use TYPO3\CMS\Core\Utility\ArrayUtility;
 17 | use TYPO3\CMS\Core\Utility\GeneralUtility;
 18 | use TYPO3\CMS\Extbase\Domain\Model\FileReference;
 19 | use TYPO3\CMS\Form\Domain\Model\FormElements\FormElementInterface;
 20 | 
 21 | /**
 22 |  * This finisher is an extension to the default SaveToDatabaseFinisher.
 23 |  * It is intentionally registered as a new identifier to keep compatibility with existing forms.
 24 |  */
 25 | class SaveToDatabaseFinisher extends \TYPO3\CMS\Form\Domain\Finishers\SaveToDatabaseFinisher
 26 | {
 27 |     protected function process(int $iterationCount): void
 28 |     {
 29 |         $this->throwExceptionOnInconsistentConfiguration();
 30 | 
 31 |         $table = $this->parseOption('table');
 32 |         $table = is_string($table) ? $table : '';
 33 |         $elementsConfiguration = $this->parseOption('elements');
 34 |         $elementsConfiguration  = is_array($elementsConfiguration) ? $elementsConfiguration : [];
 35 |         $databaseColumnMappingsConfiguration = $this->parseOption('databaseColumnMappings');
 36 | 
 37 |         $this->databaseConnection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable($table);
 38 | 
 39 |         $databaseData = [];
 40 |         foreach ($databaseColumnMappingsConfiguration as $databaseColumnName => $databaseColumnConfiguration) {
 41 |             $value = $this->parseOption('databaseColumnMappings.' . $databaseColumnName . '.value');
 42 |             if (
 43 |                 empty($value)
 44 |                 && ($databaseColumnConfiguration['skipIfValueIsEmpty'] ?? false) === true
 45 |             ) {
 46 |                 continue;
 47 |             }
 48 | 
 49 |             $databaseData[$databaseColumnName] = $value;
 50 |         }
 51 | 
 52 |         // decide which strategy to use
 53 |         $containerConfiguration = $this->parseOption('container');
 54 |         if (!empty($containerConfiguration) && is_string($containerConfiguration)) {
 55 |             $this->processContainer($containerConfiguration, $elementsConfiguration, $databaseData, $table, $iterationCount);
 56 |         } else {
 57 |             $databaseData = $this->prepareData($elementsConfiguration, $databaseData);
 58 | 
 59 |             $this->saveToDatabase($databaseData, $table, $iterationCount);
 60 |         }
 61 | 
 62 |     }
 63 | 
 64 |     /**
 65 |      * This action will do mostly the same processing as the default processing but we need to set prefix for the finisher to find the correct element
 66 |      * @param string $containerPath the identifier of the container to process, can be for example `RootContainer` or `RootContainer.0.NestedContainer`
 67 |      * @param array $elementsConfiguration finisher-element-configuration
 68 |      * @param array $databaseData prepared data
 69 |      * @param string $table Tablename to save data to
 70 |      * @param int $iterationCount finisher iteration
 71 |      */
 72 |     protected function processContainer(
 73 |         string $containerPath,
 74 |         array $elementsConfiguration,
 75 |         array $databaseData,
 76 |         string $table,
 77 |         int $iterationCount,
 78 |     ): void {
 79 |         $containerValues = ArrayUtility::getValueByPath($this->getFormValues(), $containerPath, '.');
 80 |         foreach ($containerValues as $copyId => $containerItem) {
 81 |             $prefix = $containerPath . '.' . $copyId . '.';
 82 |             // store data inside new array to keep prepared $databaseData for all iterations
 83 |             $itemDatabaseData = $this->prepareData($elementsConfiguration, $databaseData, $containerItem, $prefix);
 84 | 
 85 |             $this->saveToDatabase($itemDatabaseData, $table, $iterationCount, $copyId);
 86 |         }
 87 |     }
 88 | 
 89 |     /**
 90 |      * Adapted method for container data.
 91 |      * @param array $elementsConfiguration finisher element configuration
 92 |      * @param array $databaseData prepared data
 93 |      * @param array $values optional filled Array with form values to use
 94 |      * @param string $prefix prefix to get the form element object by a full identifier
 95 |      * @return array the filled database data
 96 |      */
 97 |     protected function prepareData(
 98 |         array $elementsConfiguration,
 99 |         array $databaseData,
100 |         array $values = [],
101 |         string $prefix = '',
102 |     ): array {
103 |         if (empty($values)) {
104 |             $values = $this->getFormValues();
105 |         }
106 | 
107 |         foreach ($values as $elementIdentifier => $elementValue) {
108 |             if (!$this->canValueBeHandled($elementValue, $elementsConfiguration, $elementIdentifier, $prefix)) {
109 |                 continue;
110 |             }
111 | 
112 |             if ($elementValue instanceof FileReference) {
113 |                 if (isset($elementsConfiguration[$elementIdentifier]['saveFileIdentifierInsteadOfUid'])) {
114 |                     $saveFileIdentifierInsteadOfUid = (bool)$elementsConfiguration[$elementIdentifier]['saveFileIdentifierInsteadOfUid'];
115 |                 } else {
116 |                     $saveFileIdentifierInsteadOfUid = false;
117 |                 }
118 | 
119 |                 if ($saveFileIdentifierInsteadOfUid) {
120 |                     $elementValue = $elementValue->getOriginalResource()->getCombinedIdentifier();
121 |                 } else {
122 |                     $elementValue = $elementValue->getOriginalResource()->getProperty('uid_local');
123 |                 }
124 |             } elseif (is_array($elementValue)) {
125 |                 $elementValue = implode(',', $elementValue);
126 |             } elseif ($elementValue instanceof DateTimeInterface) {
127 |                 $format = $elementsConfiguration[$elementIdentifier]['dateFormat'] ?? 'U';
128 |                 $elementValue = $elementValue->format($format);
129 |             }
130 | 
131 |             $databaseData[$elementsConfiguration[$elementIdentifier]['mapOnDatabaseColumn']] = $elementValue;
132 |         }
133 | 
134 |         return $databaseData;
135 |     }
136 | 
137 |     /**
138 |      * Save or insert the values from
139 |      * $databaseData into the table $table
140 |      * and provide some finisher variables
141 |      */
142 |     protected function saveToDatabase(
143 |         array $databaseData,
144 |         string $table,
145 |         int $iterationCount,
146 |         ?int $containerItemKey = null,
147 |     ): void {
148 |         if (!empty($databaseData)) {
149 |             if ($this->parseOption('mode') === 'update') {
150 |                 $whereClause = $this->parseOption('whereClause');
151 |                 foreach ($whereClause as $columnName => $columnValue) {
152 |                     $whereClause[$columnName] = $this->parseOption('whereClause.' . $columnName);
153 |                 }
154 |                 $this->databaseConnection->update(
155 |                     $table,
156 |                     $databaseData,
157 |                     $whereClause,
158 |                 );
159 |             } else {
160 |                 $this->databaseConnection->insert($table, $databaseData);
161 |                 $insertedUid = (int)$this->databaseConnection->lastInsertId($table);
162 |                 $this->finisherContext->getFinisherVariableProvider()->add(
163 |                     $this->shortFinisherIdentifier,
164 |                     'insertedUids.' . $iterationCount . (is_int($containerItemKey) ? '.' . $containerItemKey : ''),
165 |                     $insertedUid,
166 |                 );
167 | 
168 |                 $currentCount = $this->finisherContext->getFinisherVariableProvider()->get(
169 |                     $this->shortFinisherIdentifier,
170 |                     'countInserts.',
171 |                     $iterationCount,
172 |                     0,
173 |                 );
174 |                 $this->finisherContext->getFinisherVariableProvider()->addOrUpdate(
175 |                     $this->shortFinisherIdentifier,
176 |                     'countInserts.' . $iterationCount,
177 |                     $currentCount++,
178 |                 );
179 |             }
180 |         }
181 |     }
182 | 
183 |     /**
184 |      * This will check if a element shall or can be handled
185 |      * @param mixed $elementValue
186 |      * @param array $elementsConfiguration
187 |      * @param string $elementIdentifier
188 |      * @param string $prefix
189 |      * @return array
190 |      */
191 |     private function canValueBeHandled(mixed $elementValue, array $elementsConfiguration, string $elementIdentifier, string $prefix): bool
192 |     {
193 |         $elementConfig = $elementsConfiguration[$elementIdentifier];
194 |         if (!isset($elementConfig)) {
195 |             return false;
196 |         }
197 | 
198 |         if (
199 |             ($elementValue === null || $elementValue === '')
200 |             && isset($elementConfig['skipIfValueIsEmpty'])
201 |             && $elementConfig['skipIfValueIsEmpty'] === true
202 |         ) {
203 |             return false;
204 |         }
205 | 
206 |         $element = $this->getElementByIdentifier($prefix . $elementIdentifier);
207 |         if (!($element instanceof FormElementInterface) || !isset($elementConfig['mapOnDatabaseColumn'])) {
208 |             return false;
209 |         }
210 | 
211 |         return true;
212 |     }
213 | }
214 | 


--------------------------------------------------------------------------------
/Classes/FormElements/RepeatableContainer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace TRITUM\RepeatableFormElements\FormElements;
 6 | 
 7 | /**
 8 |  * This file is part of the "repeatable_form_elements" Extension for TYPO3 CMS.
 9 |  *
10 |  * For the full copyright and license information, please read the
11 |  * LICENSE.txt file that was distributed with this source code.
12 |  */
13 | use TYPO3\CMS\Form\Domain\Model\FormElements\Section;
14 | 
15 | class RepeatableContainer extends Section implements RepeatableContainerInterface {}
16 | 


--------------------------------------------------------------------------------
/Classes/FormElements/RepeatableContainerInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace TRITUM\RepeatableFormElements\FormElements;
 6 | 
 7 | /**
 8 |  * This file is part of the "repeatable_form_elements" Extension for TYPO3 CMS.
 9 |  *
10 |  * For the full copyright and license information, please read the
11 |  * LICENSE.txt file that was distributed with this source code.
12 |  */
13 | use TYPO3\CMS\Form\Domain\Model\Renderable\CompositeRenderableInterface;
14 | 
15 | interface RepeatableContainerInterface extends CompositeRenderableInterface {}
16 | 


--------------------------------------------------------------------------------
/Classes/Hooks/FormHooks.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace TRITUM\RepeatableFormElements\Hooks;
  6 | 
  7 | /**
  8 |  * This file is part of the "repeatable_form_elements" Extension for TYPO3 CMS.
  9 |  *
 10 |  * For the full copyright and license information, please read the
 11 |  * LICENSE.txt file that was distributed with this source code.
 12 |  */
 13 | use TRITUM\RepeatableFormElements\FormElements\RepeatableContainerInterface;
 14 | use TRITUM\RepeatableFormElements\Service\CopyService;
 15 | use TYPO3\CMS\Core\Utility\GeneralUtility;
 16 | use TYPO3\CMS\Extbase\Validation\Validator\ValidatorInterface;
 17 | use TYPO3\CMS\Form\Domain\Model\Exception\DuplicateFormElementException;
 18 | use TYPO3\CMS\Form\Domain\Model\FormElements\AbstractFormElement;
 19 | use TYPO3\CMS\Form\Domain\Model\FormElements\FormElementInterface;
 20 | use TYPO3\CMS\Form\Domain\Model\Renderable\CompositeRenderableInterface;
 21 | use TYPO3\CMS\Form\Domain\Model\Renderable\RenderableInterface;
 22 | use TYPO3\CMS\Form\Domain\Model\Renderable\RootRenderableInterface;
 23 | use TYPO3\CMS\Form\Domain\Runtime\FormRuntime;
 24 | 
 25 | class FormHooks
 26 | {
 27 |     /**
 28 |      * @param FormRuntime $formRuntime
 29 |      * @param CompositeRenderableInterface|null $currentPage
 30 |      * @param CompositeRenderableInterface|null $lastPage
 31 |      * @param array $rawRequestArguments
 32 |      *
 33 |      * @return CompositeRenderableInterface|null
 34 |      * @throws DuplicateFormElementException
 35 |      */
 36 |     public function afterInitializeCurrentPage(
 37 |         FormRuntime $formRuntime,
 38 |         CompositeRenderableInterface $currentPage = null,
 39 |         CompositeRenderableInterface $lastPage = null,
 40 |         array $rawRequestArguments = [],
 41 |     ): ?CompositeRenderableInterface {
 42 |         foreach ($formRuntime->getPages() as $page) {
 43 |             $this->setRootRepeatableContainerIdentifiers($page, $formRuntime);
 44 |         }
 45 | 
 46 |         // first request
 47 |         if (!$lastPage) {
 48 |             return $currentPage;
 49 |         }
 50 | 
 51 |         $copyService = GeneralUtility::makeInstance(CopyService::class, $formRuntime);
 52 |         if ($this->userWentBackToPreviousStep($formRuntime, $currentPage, $lastPage)) {
 53 |             $copyService->createCopiesFromFormState();
 54 |         } else {
 55 |             $copyService->createCopiesFromCurrentRequest();
 56 |         }
 57 | 
 58 |         return $currentPage;
 59 |     }
 60 | 
 61 |     /**
 62 |      * @param FormRuntime $formRuntime
 63 |      * @param RootRenderableInterface $renderable
 64 |      */
 65 |     public function beforeRendering(FormRuntime $formRuntime, RootRenderableInterface $renderable): void
 66 |     {
 67 |         if ($renderable instanceof FormElementInterface) {
 68 |             $properties = $renderable->getProperties();
 69 | 
 70 |             $fluidAdditionalAttributes = $properties['fluidAdditionalAttributes'] ?? [];
 71 |             $fluidAdditionalAttributes['data-element-type'] = $renderable->getType();
 72 |             if ($renderable->getType() === 'DatePicker') {
 73 |                 $fluidAdditionalAttributes['data-element-datepicker-enabled'] = (int)$renderable->getProperties()['enableDatePicker'];
 74 |                 $fluidAdditionalAttributes['data-element-datepicker-date-format'] = $renderable->getProperties()['dateFormat'];
 75 |             }
 76 | 
 77 |             $renderable->setProperty('fluidAdditionalAttributes', $fluidAdditionalAttributes);
 78 |         }
 79 |     }
 80 | 
 81 |     /**
 82 |      * @param RenderableInterface $renderable
 83 |      * @param FormRuntime $formRuntime
 84 |      * @param array $repeatableContainerIdentifiers
 85 |      *
 86 |      * @throws DuplicateFormElementException
 87 |      */
 88 |     protected function setRootRepeatableContainerIdentifiers(
 89 |         RenderableInterface $renderable,
 90 |         FormRuntime $formRuntime,
 91 |         array $repeatableContainerIdentifiers = [],
 92 |     ): void {
 93 |         $isRepeatableContainer = $renderable instanceof RepeatableContainerInterface;
 94 | 
 95 |         $hasOriginalIdentifier = isset($renderable->getRenderingOptions()['_originalIdentifier']);
 96 |         if ($isRepeatableContainer) {
 97 |             $repeatableContainerIdentifiers[] = $renderable->getIdentifier();
 98 |             if (!$hasOriginalIdentifier) {
 99 |                 $renderable->setRenderingOption('_isRootRepeatableContainer', true);
100 |                 $renderable->setRenderingOption('_isReferenceContainer', true);
101 |             }
102 |         }
103 | 
104 |         if (!empty($repeatableContainerIdentifiers) && !$hasOriginalIdentifier) {
105 |             $newIdentifier = implode('.0.', $repeatableContainerIdentifiers) . '.0';
106 |             if (!$isRepeatableContainer) {
107 |                 $newIdentifier .= '.' . $renderable->getIdentifier();
108 |             }
109 |             $originalIdentifier = $renderable->getIdentifier();
110 |             $renderable->setRenderingOption('_originalIdentifier', $originalIdentifier);
111 | 
112 |             if ($renderable instanceof AbstractFormElement && $renderable->getDefaultValue()) {
113 |                 $formRuntime->getFormDefinition()->addElementDefaultValue($newIdentifier, $renderable->getDefaultValue());
114 |             }
115 | 
116 |             $formRuntime->getFormDefinition()->unregisterRenderable($renderable);
117 |             $renderable->setIdentifier($newIdentifier);
118 |             $formRuntime->getFormDefinition()->registerRenderable($renderable);
119 | 
120 |             $copyService = GeneralUtility::makeInstance(CopyService::class, $formRuntime);
121 |             [$originalProcessingRule] = $copyService->copyProcessingRule($originalIdentifier, $newIdentifier);
122 | 
123 |             /** @var ValidatorInterface $validator */
124 |             foreach ($originalProcessingRule->getValidators() as $validator) {
125 |                 $renderable->addValidator($validator);
126 |             }
127 | 
128 |             foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['ext/form']['afterBuildingFinished'] ?? [] as $className) {
129 |                 $hookObj = GeneralUtility::makeInstance($className);
130 |                 if (method_exists($hookObj, 'afterBuildingFinished')) {
131 |                     $hookObj->afterBuildingFinished($renderable);
132 |                 }
133 |             }
134 |         }
135 | 
136 |         if ($renderable instanceof CompositeRenderableInterface) {
137 |             foreach ($renderable->getElements() as $childRenderable) {
138 |                 $this->setRootRepeatableContainerIdentifiers($childRenderable, $formRuntime, $repeatableContainerIdentifiers);
139 |             }
140 |         }
141 |     }
142 | 
143 |     /**
144 |      * returns TRUE if the user went back to any previous step in the form.
145 |      *
146 |      * @param FormRuntime $formRuntime
147 |      * @param CompositeRenderableInterface|null $currentPage
148 |      * @param CompositeRenderableInterface|null $lastPage
149 |      *
150 |      * @return bool
151 |      */
152 |     protected function userWentBackToPreviousStep(
153 |         FormRuntime $formRuntime,
154 |         CompositeRenderableInterface $currentPage = null,
155 |         CompositeRenderableInterface $lastPage = null,
156 |     ): bool {
157 |         return $currentPage !== null
158 |                 && $lastPage !== null
159 |                 && $currentPage->getIndex() < $lastPage->getIndex();
160 |     }
161 | }
162 | 


--------------------------------------------------------------------------------
/Classes/Service/CopyService.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace TRITUM\RepeatableFormElements\Service;
  6 | 
  7 | /**
  8 |  * This file is part of the "repeatable_form_elements" Extension for TYPO3 CMS.
  9 |  *
 10 |  * For the full copyright and license information, please read the
 11 |  * LICENSE.txt file that was distributed with this source code.
 12 |  */
 13 | 
 14 | use Psr\EventDispatcher\EventDispatcherInterface;
 15 | use TRITUM\RepeatableFormElements\Event\CopyVariantEvent;
 16 | use TRITUM\RepeatableFormElements\FormElements\RepeatableContainerInterface;
 17 | use TYPO3\CMS\Core\Configuration\Features;
 18 | use TYPO3\CMS\Core\Utility\ArrayUtility;
 19 | use TYPO3\CMS\Core\Utility\GeneralUtility;
 20 | use TYPO3\CMS\Extbase\Error\Error;
 21 | use TYPO3\CMS\Extbase\Property\PropertyMappingConfiguration;
 22 | use TYPO3\CMS\Extbase\Validation\Validator\ValidatorInterface;
 23 | use TYPO3\CMS\Form\Domain\Model\FormDefinition;
 24 | use TYPO3\CMS\Form\Domain\Model\FormElements\FormElementInterface;
 25 | use TYPO3\CMS\Form\Domain\Model\Renderable\CompositeRenderableInterface;
 26 | use TYPO3\CMS\Form\Domain\Model\Renderable\RenderableVariant;
 27 | use TYPO3\CMS\Form\Domain\Runtime\FormRuntime;
 28 | use TYPO3\CMS\Form\Domain\Runtime\FormState;
 29 | use TYPO3\CMS\Form\Mvc\ProcessingRule;
 30 | use TYPO3\CMS\Form\Service\TranslationService;
 31 | 
 32 | class CopyService
 33 | {
 34 |     protected FormRuntime $formRuntime;
 35 |     protected ?FormState $formState;
 36 |     protected FormDefinition $formDefinition;
 37 |     protected array $repeatableContainersByOriginalIdentifier = [];
 38 |     protected array $typeDefinitions = [];
 39 |     protected mixed $features;
 40 | 
 41 |     /**
 42 |      * @param FormRuntime $formRuntime
 43 |      */
 44 |     public function __construct(FormRuntime $formRuntime)
 45 |     {
 46 |         $this->formRuntime = $formRuntime;
 47 |         $this->formState = $formRuntime->getFormState();
 48 |         $this->formDefinition = $formRuntime->getFormDefinition();
 49 |         $this->typeDefinitions = $this->formDefinition->getTypeDefinitions();
 50 |         $this->features = GeneralUtility::makeInstance(Features::class);
 51 |     }
 52 | 
 53 |     /**
 54 |      * @return CopyService
 55 |      * @api
 56 |      */
 57 |     public function createCopiesFromCurrentRequest(): CopyService
 58 |     {
 59 |         $requestArguments = $this->formRuntime->getRequest()->getArguments();
 60 |         $this->removeDeletedRepeatableContainersFromFormValuesByRequest($requestArguments);
 61 |         $requestArguments = array_replace_recursive(
 62 |             $this->formState->getFormValues(),
 63 |             $requestArguments,
 64 |         );
 65 | 
 66 |         $this->copyRepeatableContainersFromArguments($requestArguments);
 67 |         return $this;
 68 |     }
 69 | 
 70 |     /**
 71 |      * @return CopyService
 72 |      * @api
 73 |      */
 74 |     public function createCopiesFromFormState(): CopyService
 75 |     {
 76 |         $this->copyRepeatableContainersFromArguments($this->formState->getFormValues());
 77 |         return $this;
 78 |     }
 79 | 
 80 |     /**
 81 |      * @param string $originalFormElement
 82 |      * @param string $newElementCopy
 83 |      * @return ProcessingRule[]
 84 |      * @internal
 85 |      */
 86 |     public function copyProcessingRule(
 87 |         string $originalFormElement,
 88 |         string $newElementCopy,
 89 |     ): array {
 90 |         $originalProcessingRule = $this->formRuntime->getFormDefinition()->getProcessingRule($originalFormElement);
 91 | 
 92 |         GeneralUtility::addInstance(PropertyMappingConfiguration::class, $originalProcessingRule->getPropertyMappingConfiguration());
 93 |         $newProcessingRule = $this->formRuntime->getFormDefinition()->getProcessingRule($newElementCopy);
 94 | 
 95 |         try {
 96 |             $newProcessingRule->setDataType($originalProcessingRule->getDataType());
 97 |         } catch (\TypeError $error) {
 98 |         }
 99 | 
100 |         return [$originalProcessingRule, $newProcessingRule];
101 |     }
102 | 
103 |     /**
104 |      * @param array $requestArguments
105 |      * @param array $argumentPath
106 |      */
107 |     protected function copyRepeatableContainersFromArguments(
108 |         array $requestArguments,
109 |         array $argumentPath = [],
110 |     ): void {
111 |         foreach ($requestArguments as $argumentKey => $argumentValue) {
112 |             if (is_array($argumentValue)) {
113 |                 $originalContainer = $this->getRepeatableContainerByOriginalIdentifier((string)$argumentKey);
114 |                 $copyIndexes = array_keys($argumentValue);
115 |                 unset($copyIndexes[0]);
116 |                 $argumentPath[] = $argumentKey;
117 | 
118 |                 if (
119 |                     $originalContainer
120 |                     && count(array_filter(array_keys($copyIndexes), 'is_string')) === 0
121 |                 ) {
122 |                     $copyIndexes = ArrayUtility::sortArrayWithIntegerKeys($copyIndexes);
123 | 
124 |                     if (count($argumentPath) <= 1) {
125 |                         $referenceContainer = $originalContainer;
126 |                     } else {
127 |                         $referenceContainerPath = $argumentPath;
128 |                         $referenceContainerPath[] = 0;
129 |                         $referenceContainerIdentifier = implode('.', $referenceContainerPath);
130 |                         $referenceContainer = $this->formDefinition->getElementByIdentifier($referenceContainerIdentifier);
131 |                     }
132 | 
133 |                     $firstReferenceContainer = $referenceContainer;
134 |                     $firstReferenceContainer->setRenderingOption('_isReferenceContainer', true);
135 |                     $firstReferenceContainer->setRenderingOption('_copyMother', $originalContainer->getIdentifier());
136 | 
137 |                     $minimumCopies = (int)$firstReferenceContainer->getProperties()['minimumCopies'];
138 |                     $maximumCopies = (int)$firstReferenceContainer->getProperties()['maximumCopies'];
139 | 
140 |                     $copyNumber = 1;
141 |                     foreach ($copyIndexes as $copyIndex) {
142 |                         $contextPath = $argumentPath;
143 |                         $contextPath[] = $copyIndex;
144 |                         $newIdentifier = implode('.', $contextPath);
145 | 
146 |                         $referenceContainer = $this->copyRepeatableContainer($originalContainer, $referenceContainer, $newIdentifier);
147 |                         $referenceContainer->setRenderingOption('_copyReference', $firstReferenceContainer->getIdentifier());
148 | 
149 |                         if ($copyNumber > $maximumCopies) {
150 |                             $this->addError($referenceContainer, 1518701681, 'The maximum number of copies has been reached');
151 |                         }
152 |                         $copyNumber++;
153 |                     }
154 | 
155 |                     if ($copyNumber - 1 < $minimumCopies) {
156 |                         $this->addError($firstReferenceContainer, 1518701682, 'The minimum number of copies has not yet been reached');
157 |                     }
158 |                 }
159 | 
160 |                 $this->copyRepeatableContainersFromArguments($argumentValue, $argumentPath);
161 |                 array_pop($argumentPath);
162 |             }
163 |         }
164 |     }
165 | 
166 |     /**
167 |      * @param RepeatableContainerInterface $copyFromContainer
168 |      * @param RepeatableContainerInterface $moveAfterContainer
169 |      * @param string $newIdentifier
170 |      *
171 |      * @return RepeatableContainerInterface
172 |      */
173 |     protected function copyRepeatableContainer(
174 |         RepeatableContainerInterface $copyFromContainer,
175 |         RepeatableContainerInterface $moveAfterContainer,
176 |         string $newIdentifier,
177 |     ): RepeatableContainerInterface {
178 |         $typeName = $copyFromContainer->getType();
179 |         $implementationClassName = $this->typeDefinitions[$typeName]['implementationClassName'];
180 |         $parentRenderableForNewContainer = $moveAfterContainer->getParentRenderable();
181 | 
182 |         $newContainer = GeneralUtility::makeInstance($implementationClassName, $newIdentifier, $typeName);
183 |         $this->copyOptions($newContainer, $copyFromContainer);
184 | 
185 |         $parentRenderableForNewContainer->addElement($newContainer);
186 |         $parentRenderableForNewContainer->moveElementAfter($newContainer, $moveAfterContainer);
187 | 
188 |         foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['ext/form']['afterBuildingFinished'] ?? [] as $className) {
189 |             $hookObj = GeneralUtility::makeInstance($className);
190 |             if (method_exists($hookObj, 'afterBuildingFinished')) {
191 |                 $hookObj->afterBuildingFinished($newContainer);
192 |             }
193 |         }
194 | 
195 |         foreach ($copyFromContainer->getElements() as $originalFormElement) {
196 |             $this->createNestedElements($originalFormElement, $newContainer, $copyFromContainer->getIdentifier(), $newIdentifier);
197 |         }
198 | 
199 |         return $newContainer;
200 |     }
201 | 
202 |     /**
203 |      * @param FormElementInterface $newElementCopy
204 |      * @param FormElementInterface $originalFormElement
205 |      */
206 |     protected function copyOptions(
207 |         FormElementInterface $newElementCopy,
208 |         FormElementInterface $originalFormElement,
209 |     ): void {
210 |         $newElementCopy->setLabel($originalFormElement->getLabel());
211 |         $newElementCopy->setDefaultValue($originalFormElement->getDefaultValue());
212 |         foreach ($originalFormElement->getProperties() as $key => $value) {
213 |             $newElementCopy->setProperty($key, $value);
214 |         }
215 |         foreach ($originalFormElement->getRenderingOptions() as $key => $value) {
216 |             if (
217 |                 $key === '_isRootRepeatableContainer'
218 |                 || $key === '_originalIdentifier'
219 |                 || $key === '_isReferenceContainer'
220 |             ) {
221 |                 continue;
222 |             }
223 |             $newElementCopy->setRenderingOption($key, $value);
224 |         }
225 | 
226 |         [$originalProcessingRule] = $this->copyProcessingRule($originalFormElement->getIdentifier(), $newElementCopy->getIdentifier());
227 | 
228 |         /** @var ValidatorInterface $validator */
229 |         foreach ($originalProcessingRule->getValidators() as $validator) {
230 |             $newElementCopy->addValidator($validator);
231 |         }
232 |     }
233 | 
234 |     /**
235 |      * @param FormElementInterface $originalFormElement
236 |      * @param CompositeRenderableInterface $parentFormElementCopy
237 |      * @param string $identifierOriginal
238 |      * @param string $identifierReplacement
239 |      */
240 |     protected function createNestedElements(
241 |         FormElementInterface $originalFormElement,
242 |         CompositeRenderableInterface $parentFormElementCopy,
243 |         string $identifierOriginal,
244 |         string $identifierReplacement,
245 |     ): void {
246 |         $newIdentifier = str_replace($identifierOriginal, $identifierReplacement, $originalFormElement->getIdentifier());
247 |         $newFormElement = $parentFormElementCopy->createElement(
248 |             $newIdentifier,
249 |             $originalFormElement->getType(),
250 |         );
251 |         $this->copyOptions($newFormElement, $originalFormElement);
252 |         $this->copyProcessingRule($originalFormElement->getIdentifier(), $newIdentifier);
253 |         $this->copyVariants($originalFormElement, $newFormElement, $newIdentifier);
254 | 
255 |         foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['ext/form']['afterBuildingFinished'] ?? [] as $className) {
256 |             $hookObj = GeneralUtility::makeInstance($className);
257 |             if (method_exists($hookObj, 'afterBuildingFinished')) {
258 |                 $hookObj->afterBuildingFinished($newFormElement);
259 |             }
260 |         }
261 | 
262 |         if ($originalFormElement instanceof CompositeRenderableInterface) {
263 |             foreach ($originalFormElement->getElements() as $originalChildFormElement) {
264 |                 $this->createNestedElements($originalChildFormElement, $newFormElement, $identifierOriginal, $identifierReplacement);
265 |             }
266 |         }
267 |     }
268 | 
269 |     /**
270 |      * @param string $originalIdentifier
271 |      * @return RepeatableContainerInterface|null
272 |      */
273 |     protected function getRepeatableContainerByOriginalIdentifier(string $originalIdentifier): ?RepeatableContainerInterface
274 |     {
275 |         if (
276 |             !isset($this->repeatableContainersByOriginalIdentifier[$originalIdentifier])
277 |             || $this->repeatableContainersByOriginalIdentifier[$originalIdentifier] === null
278 |         ) {
279 |             foreach ($this->formDefinition->getRenderablesRecursively() as $formElement) {
280 |                 $renderingOptions = $formElement->getRenderingOptions();
281 |                 if (
282 |                     $formElement instanceof RepeatableContainerInterface
283 |                     && ($renderingOptions['_originalIdentifier'] ?? null) === $originalIdentifier
284 |                     && (bool)$renderingOptions['_isRootRepeatableContainer'] === true
285 |                 ) {
286 |                     $this->repeatableContainersByOriginalIdentifier[$originalIdentifier] = $formElement;
287 |                 }
288 |             }
289 |             if (!isset($this->repeatableContainersByOriginalIdentifier[$originalIdentifier])) {
290 |                 $this->repeatableContainersByOriginalIdentifier[$originalIdentifier] = null;
291 |             }
292 |         }
293 | 
294 |         return $this->repeatableContainersByOriginalIdentifier[$originalIdentifier];
295 |     }
296 | 
297 |     /**
298 |      * @param FormElementInterface $formElement
299 |      * @param int $timestamp
300 |      * @param string $defaultMessage
301 |      */
302 |     protected function addError(
303 |         FormElementInterface $formElement,
304 |         int $timestamp,
305 |         string $defaultMessage = '',
306 |     ): void {
307 |         $error = GeneralUtility::makeInstance(
308 |             Error::class,
309 |             GeneralUtility::makeInstance(TranslationService::class)->translateFormElementError(
310 |                 $formElement,
311 |                 $timestamp,
312 |                 [],
313 |                 $defaultMessage,
314 |                 $this->formRuntime,
315 |             ),
316 |             $timestamp,
317 |         );
318 |         $this->formDefinition
319 |             ->getProcessingRule($formElement->getIdentifier())
320 |             ->getProcessingMessages()
321 |             ->addError($error);
322 |     }
323 | 
324 |     /**
325 |      * @param array $requestArguments
326 |      * @param array $argumentPath
327 |      */
328 |     protected function removeDeletedRepeatableContainersFromFormValuesByRequest(
329 |         array $requestArguments,
330 |         array $argumentPath = [],
331 |     ): void {
332 |         foreach ($requestArguments as $argumentKey => $argumentValue) {
333 |             if (is_array($argumentValue)) {
334 |                 $originalContainer = $this->getRepeatableContainerByOriginalIdentifier((string)$argumentKey);
335 |                 $argumentPath[] = $argumentKey;
336 |                 $copyIndexes = array_keys($argumentValue);
337 | 
338 |                 if (
339 |                     $originalContainer
340 |                     && count(array_filter(array_keys($copyIndexes), 'is_string')) === 0
341 |                 ) {
342 |                     $currentArgumentPath = implode('.', $argumentPath);
343 |                     $formValue = $this->formState->getFormValue($currentArgumentPath);
344 |                     if ($formValue !== null) {
345 |                         foreach ($formValue as $key => $_) {
346 |                             if (!in_array($key, $copyIndexes)) {
347 |                                 unset($formValue[$key]);
348 |                             }
349 |                         }
350 |                         $this->formState->setFormValue($currentArgumentPath, $formValue);
351 |                     }
352 |                 }
353 | 
354 |                 $this->removeDeletedRepeatableContainersFromFormValuesByRequest($argumentValue, $argumentPath);
355 |                 array_pop($argumentPath);
356 |             }
357 |         }
358 |     }
359 | 
360 |     /**
361 |      * This function fetches variants of the original form element and copies them into the
362 |      * new form element.
363 |      * Extendable by listening for @see CopyVariantEvent
364 |      *
365 |      * @param FormElementInterface $originalFormElement
366 |      * @param FormElementInterface $newFormElement
367 |      * @param string $newIdentifier
368 |      */
369 |     protected function copyVariants(
370 |         FormElementInterface $originalFormElement,
371 |         FormElementInterface $newFormElement,
372 |         string $newIdentifier,
373 |     ): void {
374 |         if (!$this->features->isFeatureEnabled('repeatableFormElements.copyVariants')) {
375 |             return;
376 |         }
377 | 
378 |         $originalVariants = $originalFormElement->getVariants();
379 |         foreach ($originalVariants as $originalIdentifier => $originalVariant) {
380 |             // make sure that we only copy variants that are missing in the copied element
381 |             if ($originalVariant instanceof RenderableVariant
382 |                 && !in_array($originalIdentifier, array_keys($newFormElement->getVariants()))
383 |             ) {
384 |                 // variant properties are protected and class is marked internal,
385 |                 // so we use reflection
386 |                 $reflectionClass = new \ReflectionClass(RenderableVariant::class);
387 |                 $propOption = $reflectionClass->getProperty('options');
388 |                 $propCondition = $reflectionClass->getProperty('condition');
389 |                 $options = $propOption->getValue($originalVariant);
390 |                 $options['condition'] = $propCondition->getValue($originalVariant);
391 |                 $options['identifier'] = $originalIdentifier;
392 | 
393 |                 $eventDispatcher = GeneralUtility::makeInstance(EventDispatcherInterface::class);
394 |                 /** @var CopyVariantEvent $event */
395 |                 $event = $eventDispatcher->dispatch(
396 |                     new CopyVariantEvent($options, $originalFormElement, $newFormElement, $newIdentifier),
397 |                 );
398 | 
399 |                 // only add this variant, if it did not get disabled.
400 |                 if (!$event->isVariantEnabled()) {
401 |                     continue;
402 |                 }
403 | 
404 |                 $options = $event->getOptions();
405 |                 $newFormElement->createVariant($options);
406 |             }
407 |         }
408 |     }
409 | 
410 | }
411 | 


--------------------------------------------------------------------------------
/Configuration/.htaccess:
--------------------------------------------------------------------------------
1 | Order deny,allow
2 | Deny from all


--------------------------------------------------------------------------------
/Configuration/Icons.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | use TYPO3\CMS\Core\Imaging\IconProvider\SvgIconProvider;
 6 | 
 7 | return [
 8 |     't3-form-icon-repeatable-container' => [
 9 |         'provider' => SvgIconProvider::class,
10 |         'source' => 'EXT:repeatable_form_elements/Resources/Public/Icons/t3-form-icon-repeatable-container.svg',
11 |     ],
12 | ];
13 | 


--------------------------------------------------------------------------------
/Configuration/JavaScriptModules.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | return [
4 |     'dependencies' => ['form'],
5 |     'imports' => [
6 |         '@tritum/repeatable-form-elements/' => 'EXT:repeatable_form_elements/Resources/Public/JavaScript/',
7 |     ],
8 | ];
9 | 


--------------------------------------------------------------------------------
/Configuration/Services.yaml:
--------------------------------------------------------------------------------
 1 | services:
 2 |   _defaults:
 3 |     autowire: true
 4 |     autoconfigure: true
 5 |     public: false
 6 | 
 7 |   TRITUM\RepeatableFormElements\:
 8 |     resource: '../Classes/*'
 9 | 
10 |   TRITUM\RepeatableFormElements\EventListener\AdaptVariantConditionEventListener:
11 |     tags:
12 |       - name: event.listener
13 |         identifier: 'repeatableFormElements/copyVariants/adaptCondition'
14 | 


--------------------------------------------------------------------------------
/Configuration/Sets/RepeatableFormElements/config.yaml:
--------------------------------------------------------------------------------
1 | name: tritum/repeatable-form-elements
2 | label: "Form: Repeatable form elements"
3 | dependencies:
4 |   - typo3/form
5 | 


--------------------------------------------------------------------------------
/Configuration/Sets/RepeatableFormElements/setup.typoscript:
--------------------------------------------------------------------------------
1 | @import 'EXT:repeatable_form_elements/Configuration/TypoScript/setup.typoscript'
2 | 


--------------------------------------------------------------------------------
/Configuration/TCA/Overrides/sys_template.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | defined('TYPO3') or die();
 4 | 
 5 | call_user_func(function () {
 6 |     \TYPO3\CMS\Core\Utility\ExtensionManagementUtility::addStaticFile(
 7 |         \TRITUM\RepeatableFormElements\Configuration\Extension::KEY,
 8 |         'Configuration/TypoScript',
 9 |         'Repeatable form configuration',
10 |     );
11 | });
12 | 


--------------------------------------------------------------------------------
/Configuration/TypoScript/setup.typoscript:
--------------------------------------------------------------------------------
 1 | plugin.tx_form {
 2 |     settings {
 3 |         yamlConfigurations {
 4 |             1511193633 = EXT:repeatable_form_elements/Configuration/Yaml/FormSetup.yaml
 5 |         }
 6 |     }
 7 | }
 8 | 
 9 | page {
10 |     includeJSFooter {
11 |         1511193639 = EXT:repeatable_form_elements/Resources/Public/JavaScript/frontend/repeatable-container.js
12 |     }
13 | 
14 |     includeCSS {
15 |         repeatableFormElements = EXT:repeatable_form_elements/Resources/Public/StyleSheets/app.css
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/Configuration/Yaml/FormSetup.yaml:
--------------------------------------------------------------------------------
 1 | prototypes:
 2 |   standard:
 3 |     finishersDefinition:
 4 |       ExtendedSaveToDatabase:
 5 |         formEngine:
 6 |           label: 'Extended SaveToDatabase Finisher'
 7 |         implementationClassName: 'TRITUM\RepeatableFormElements\Finisher\SaveToDatabaseFinisher'
 8 | 
 9 |     formElementsDefinition:
10 |       Form:
11 |         renderingOptions:
12 |           translation:
13 |             translationFile:
14 |               10: 'EXT:form/Resources/Private/Language/locallang.xlf'
15 |               1595333290: 'EXT:repeatable_form_elements/Resources/Private/Language/locallang.xlf'
16 |             translationFiles:
17 |               1595333290: 'EXT:repeatable_form_elements/Resources/Private/Language/locallang.xlf'
18 |           partialRootPaths:
19 |             1595333290: 'EXT:repeatable_form_elements/Resources/Private/Frontend/Partials'
20 | 
21 |       RepeatableContainer:
22 |         __inheritances:
23 |           10: 'TYPO3.CMS.Form.prototypes.standard.formElementsDefinition.Fieldset'
24 |         implementationClassName: 'TRITUM\RepeatableFormElements\FormElements\RepeatableContainer'
25 |         properties:
26 |           minimumCopies: 0
27 |           maximumCopies: 10
28 |           showRemoveButton: true
29 |           elementClassAttribute: 'repeatable-container'
30 | 


--------------------------------------------------------------------------------
/Configuration/Yaml/FormSetupBackend.yaml:
--------------------------------------------------------------------------------
 1 | prototypes:
 2 |   standard:
 3 |     formElementsDefinition:
 4 |       RepeatableContainer:
 5 |         formEditor:
 6 |           predefinedDefaults:
 7 |             properties:
 8 |               minimumCopies: 0
 9 |               maximumCopies: 10
10 |               showRemoveButton: true
11 |               copyButtonLabel: 'formEditor.elements.RepeatableContainer.editor.copyButtonLabel.value'
12 |               removeButtonLabel: 'formEditor.elements.RepeatableContainer.editor.removeButtonLabel.value'
13 |           label: 'formEditor.elements.RepeatableContainer.label'
14 |           groupSorting: 150
15 |           iconIdentifier: 't3-form-icon-repeatable-container'
16 |           editors:
17 |             200:
18 |               label: 'formEditor.elements.RepeatableContainer.editor.label.label'
19 |             400:
20 |               identifier: 'copyButtonLabel'
21 |               templateName: 'Inspector-TextEditor'
22 |               label: 'formEditor.elements.RepeatableContainer.editor.copyButtonLabel.label'
23 |               propertyPath: 'properties.copyButtonLabel'
24 |             500:
25 |               identifier: 'removeButtonLabel'
26 |               templateName: 'Inspector-TextEditor'
27 |               label: 'formEditor.elements.RepeatableContainer.editor.removeButtonLabel.label'
28 |               propertyPath: 'properties.removeButtonLabel'
29 |             600:
30 |               identifier: 'minimumCopies'
31 |               templateName: 'Inspector-TextEditor'
32 |               label: 'formEditor.elements.RepeatableContainer.editor.minimumCopies.label'
33 |               propertyPath: 'properties.minimumCopies'
34 |               propertyValidatorsMode: 'OR'
35 |               propertyValidators:
36 |                 10: 'Integer'
37 |                 20: 'FormElementIdentifierWithinCurlyBracesExclusive'
38 |             700:
39 |               identifier: 'maximumCopies'
40 |               templateName: 'Inspector-TextEditor'
41 |               label: 'formEditor.elements.RepeatableContainer.editor.maximumCopies.label'
42 |               propertyPath: 'properties.maximumCopies'
43 |               propertyValidatorsMode: 'OR'
44 |               propertyValidators:
45 |                 10: 'Integer'
46 |                 20: 'FormElementIdentifierWithinCurlyBracesExclusive'
47 |             800:
48 |               identifier: 'showRemoveButton'
49 |               templateName: 'Inspector-CheckboxEditor'
50 |               label: 'formEditor.elements.RepeatableContainer.editor.showRemoveButton.label'
51 |               propertyPath: 'properties.showRemoveButton'
52 |     formEditor:
53 |       translationFile:
54 |         10: 'EXT:form/Resources/Private/Language/Database.xlf'
55 |         1595333290: 'EXT:repeatable_form_elements/Resources/Private/Language/Database.xlf'
56 |       translationFiles:
57 |         1595333290: 'EXT:repeatable_form_elements/Resources/Private/Language/Database.xlf'
58 |       dynamicJavaScriptModules:
59 |         additionalViewModelModules:
60 |           1595333290: '@tritum/repeatable-form-elements/backend/form-editor/view-model.js'
61 |       formEditorPartials:
62 |         FormElement-RepeatableContainer: 'Stage/Fieldset'
63 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 2, June 1991
  3 | 
  4 |  Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
  5 |  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  6 |  Everyone is permitted to copy and distribute verbatim copies
  7 |  of this license document, but changing it is not allowed.
  8 | 
  9 |                             Preamble
 10 | 
 11 |   The licenses for most software are designed to take away your
 12 | freedom to share and change it.  By contrast, the GNU General Public
 13 | License is intended to guarantee your freedom to share and change free
 14 | software--to make sure the software is free for all its users.  This
 15 | General Public License applies to most of the Free Software
 16 | Foundation's software and to any other program whose authors commit to
 17 | using it.  (Some other Free Software Foundation software is covered by
 18 | the GNU Lesser General Public License instead.)  You can apply it to
 19 | your programs, too.
 20 | 
 21 |   When we speak of free software, we are referring to freedom, not
 22 | price.  Our General Public Licenses are designed to make sure that you
 23 | have the freedom to distribute copies of free software (and charge for
 24 | this service if you wish), that you receive source code or can get it
 25 | if you want it, that you can change the software or use pieces of it
 26 | in new free programs; and that you know you can do these things.
 27 | 
 28 |   To protect your rights, we need to make restrictions that forbid
 29 | anyone to deny you these rights or to ask you to surrender the rights.
 30 | These restrictions translate to certain responsibilities for you if you
 31 | distribute copies of the software, or if you modify it.
 32 | 
 33 |   For example, if you distribute copies of such a program, whether
 34 | gratis or for a fee, you must give the recipients all the rights that
 35 | you have.  You must make sure that they, too, receive or can get the
 36 | source code.  And you must show them these terms so they know their
 37 | rights.
 38 | 
 39 |   We protect your rights with two steps: (1) copyright the software, and
 40 | (2) offer you this license which gives you legal permission to copy,
 41 | distribute and/or modify the software.
 42 | 
 43 |   Also, for each author's protection and ours, we want to make certain
 44 | that everyone understands that there is no warranty for this free
 45 | software.  If the software is modified by someone else and passed on, we
 46 | want its recipients to know that what they have is not the original, so
 47 | that any problems introduced by others will not reflect on the original
 48 | authors' reputations.
 49 | 
 50 |   Finally, any free program is threatened constantly by software
 51 | patents.  We wish to avoid the danger that redistributors of a free
 52 | program will individually obtain patent licenses, in effect making the
 53 | program proprietary.  To prevent this, we have made it clear that any
 54 | patent must be licensed for everyone's free use or not licensed at all.
 55 | 
 56 |   The precise terms and conditions for copying, distribution and
 57 | modification follow.
 58 | 
 59 |                     GNU GENERAL PUBLIC LICENSE
 60 |    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 61 | 
 62 |   0. This License applies to any program or other work which contains
 63 | a notice placed by the copyright holder saying it may be distributed
 64 | under the terms of this General Public License.  The "Program", below,
 65 | refers to any such program or work, and a "work based on the Program"
 66 | means either the Program or any derivative work under copyright law:
 67 | that is to say, a work containing the Program or a portion of it,
 68 | either verbatim or with modifications and/or translated into another
 69 | language.  (Hereinafter, translation is included without limitation in
 70 | the term "modification".)  Each licensee is addressed as "you".
 71 | 
 72 | Activities other than copying, distribution and modification are not
 73 | covered by this License; they are outside its scope.  The act of
 74 | running the Program is not restricted, and the output from the Program
 75 | is covered only if its contents constitute a work based on the
 76 | Program (independent of having been made by running the Program).
 77 | Whether that is true depends on what the Program does.
 78 | 
 79 |   1. You may copy and distribute verbatim copies of the Program's
 80 | source code as you receive it, in any medium, provided that you
 81 | conspicuously and appropriately publish on each copy an appropriate
 82 | copyright notice and disclaimer of warranty; keep intact all the
 83 | notices that refer to this License and to the absence of any warranty;
 84 | and give any other recipients of the Program a copy of this License
 85 | along with the Program.
 86 | 
 87 | You may charge a fee for the physical act of transferring a copy, and
 88 | you may at your option offer warranty protection in exchange for a fee.
 89 | 
 90 |   2. You may modify your copy or copies of the Program or any portion
 91 | of it, thus forming a work based on the Program, and copy and
 92 | distribute such modifications or work under the terms of Section 1
 93 | above, provided that you also meet all of these conditions:
 94 | 
 95 |     a) You must cause the modified files to carry prominent notices
 96 |     stating that you changed the files and the date of any change.
 97 | 
 98 |     b) You must cause any work that you distribute or publish, that in
 99 |     whole or in part contains or is derived from the Program or any
100 |     part thereof, to be licensed as a whole at no charge to all third
101 |     parties under the terms of this License.
102 | 
103 |     c) If the modified program normally reads commands interactively
104 |     when run, you must cause it, when started running for such
105 |     interactive use in the most ordinary way, to print or display an
106 |     announcement including an appropriate copyright notice and a
107 |     notice that there is no warranty (or else, saying that you provide
108 |     a warranty) and that users may redistribute the program under
109 |     these conditions, and telling the user how to view a copy of this
110 |     License.  (Exception: if the Program itself is interactive but
111 |     does not normally print such an announcement, your work based on
112 |     the Program is not required to print an announcement.)
113 | 
114 | These requirements apply to the modified work as a whole.  If
115 | identifiable sections of that work are not derived from the Program,
116 | and can be reasonably considered independent and separate works in
117 | themselves, then this License, and its terms, do not apply to those
118 | sections when you distribute them as separate works.  But when you
119 | distribute the same sections as part of a whole which is a work based
120 | on the Program, the distribution of the whole must be on the terms of
121 | this License, whose permissions for other licensees extend to the
122 | entire whole, and thus to each and every part regardless of who wrote it.
123 | 
124 | Thus, it is not the intent of this section to claim rights or contest
125 | your rights to work written entirely by you; rather, the intent is to
126 | exercise the right to control the distribution of derivative or
127 | collective works based on the Program.
128 | 
129 | In addition, mere aggregation of another work not based on the Program
130 | with the Program (or with a work based on the Program) on a volume of
131 | a storage or distribution medium does not bring the other work under
132 | the scope of this License.
133 | 
134 |   3. You may copy and distribute the Program (or a work based on it,
135 | under Section 2) in object code or executable form under the terms of
136 | Sections 1 and 2 above provided that you also do one of the following:
137 | 
138 |     a) Accompany it with the complete corresponding machine-readable
139 |     source code, which must be distributed under the terms of Sections
140 |     1 and 2 above on a medium customarily used for software interchange; or,
141 | 
142 |     b) Accompany it with a written offer, valid for at least three
143 |     years, to give any third party, for a charge no more than your
144 |     cost of physically performing source distribution, a complete
145 |     machine-readable copy of the corresponding source code, to be
146 |     distributed under the terms of Sections 1 and 2 above on a medium
147 |     customarily used for software interchange; or,
148 | 
149 |     c) Accompany it with the information you received as to the offer
150 |     to distribute corresponding source code.  (This alternative is
151 |     allowed only for noncommercial distribution and only if you
152 |     received the program in object code or executable form with such
153 |     an offer, in accord with Subsection b above.)
154 | 
155 | The source code for a work means the preferred form of the work for
156 | making modifications to it.  For an executable work, complete source
157 | code means all the source code for all modules it contains, plus any
158 | associated interface definition files, plus the scripts used to
159 | control compilation and installation of the executable.  However, as a
160 | special exception, the source code distributed need not include
161 | anything that is normally distributed (in either source or binary
162 | form) with the major components (compiler, kernel, and so on) of the
163 | operating system on which the executable runs, unless that component
164 | itself accompanies the executable.
165 | 
166 | If distribution of executable or object code is made by offering
167 | access to copy from a designated place, then offering equivalent
168 | access to copy the source code from the same place counts as
169 | distribution of the source code, even though third parties are not
170 | compelled to copy the source along with the object code.
171 | 
172 |   4. You may not copy, modify, sublicense, or distribute the Program
173 | except as expressly provided under this License.  Any attempt
174 | otherwise to copy, modify, sublicense or distribute the Program is
175 | void, and will automatically terminate your rights under this License.
176 | However, parties who have received copies, or rights, from you under
177 | this License will not have their licenses terminated so long as such
178 | parties remain in full compliance.
179 | 
180 |   5. You are not required to accept this License, since you have not
181 | signed it.  However, nothing else grants you permission to modify or
182 | distribute the Program or its derivative works.  These actions are
183 | prohibited by law if you do not accept this License.  Therefore, by
184 | modifying or distributing the Program (or any work based on the
185 | Program), you indicate your acceptance of this License to do so, and
186 | all its terms and conditions for copying, distributing or modifying
187 | the Program or works based on it.
188 | 
189 |   6. Each time you redistribute the Program (or any work based on the
190 | Program), the recipient automatically receives a license from the
191 | original licensor to copy, distribute or modify the Program subject to
192 | these terms and conditions.  You may not impose any further
193 | restrictions on the recipients' exercise of the rights granted herein.
194 | You are not responsible for enforcing compliance by third parties to
195 | this License.
196 | 
197 |   7. If, as a consequence of a court judgment or allegation of patent
198 | infringement or for any other reason (not limited to patent issues),
199 | conditions are imposed on you (whether by court order, agreement or
200 | otherwise) that contradict the conditions of this License, they do not
201 | excuse you from the conditions of this License.  If you cannot
202 | distribute so as to satisfy simultaneously your obligations under this
203 | License and any other pertinent obligations, then as a consequence you
204 | may not distribute the Program at all.  For example, if a patent
205 | license would not permit royalty-free redistribution of the Program by
206 | all those who receive copies directly or indirectly through you, then
207 | the only way you could satisfy both it and this License would be to
208 | refrain entirely from distribution of the Program.
209 | 
210 | If any portion of this section is held invalid or unenforceable under
211 | any particular circumstance, the balance of the section is intended to
212 | apply and the section as a whole is intended to apply in other
213 | circumstances.
214 | 
215 | It is not the purpose of this section to induce you to infringe any
216 | patents or other property right claims or to contest validity of any
217 | such claims; this section has the sole purpose of protecting the
218 | integrity of the free software distribution system, which is
219 | implemented by public license practices.  Many people have made
220 | generous contributions to the wide range of software distributed
221 | through that system in reliance on consistent application of that
222 | system; it is up to the author/donor to decide if he or she is willing
223 | to distribute software through any other system and a licensee cannot
224 | impose that choice.
225 | 
226 | This section is intended to make thoroughly clear what is believed to
227 | be a consequence of the rest of this License.
228 | 
229 |   8. If the distribution and/or use of the Program is restricted in
230 | certain countries either by patents or by copyrighted interfaces, the
231 | original copyright holder who places the Program under this License
232 | may add an explicit geographical distribution limitation excluding
233 | those countries, so that distribution is permitted only in or among
234 | countries not thus excluded.  In such case, this License incorporates
235 | the limitation as if written in the body of this License.
236 | 
237 |   9. The Free Software Foundation may publish revised and/or new versions
238 | of the General Public License from time to time.  Such new versions will
239 | be similar in spirit to the present version, but may differ in detail to
240 | address new problems or concerns.
241 | 
242 | Each version is given a distinguishing version number.  If the Program
243 | specifies a version number of this License which applies to it and "any
244 | later version", you have the option of following the terms and conditions
245 | either of that version or of any later version published by the Free
246 | Software Foundation.  If the Program does not specify a version number of
247 | this License, you may choose any version ever published by the Free Software
248 | Foundation.
249 | 
250 |   10. If you wish to incorporate parts of the Program into other free
251 | programs whose distribution conditions are different, write to the author
252 | to ask for permission.  For software which is copyrighted by the Free
253 | Software Foundation, write to the Free Software Foundation; we sometimes
254 | make exceptions for this.  Our decision will be guided by the two goals
255 | of preserving the free status of all derivatives of our free software and
256 | of promoting the sharing and reuse of software generally.
257 | 
258 |                             NO WARRANTY
259 | 
260 |   11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
261 | FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
262 | OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
263 | PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
264 | OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
265 | MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
266 | TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
267 | PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
268 | REPAIR OR CORRECTION.
269 | 
270 |   12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
271 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
272 | REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
273 | INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
274 | OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
275 | TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
276 | YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
277 | PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
278 | POSSIBILITY OF SUCH DAMAGES.
279 | 
280 |                      END OF TERMS AND CONDITIONS
281 | 
282 |             How to Apply These Terms to Your New Programs
283 | 
284 |   If you develop a new program, and you want it to be of the greatest
285 | possible use to the public, the best way to achieve this is to make it
286 | free software which everyone can redistribute and change under these terms.
287 | 
288 |   To do so, attach the following notices to the program.  It is safest
289 | to attach them to the start of each source file to most effectively
290 | convey the exclusion of warranty; and each file should have at least
291 | the "copyright" line and a pointer to where the full notice is found.
292 | 
293 |     <one line to give the program's name and a brief idea of what it does.>
294 |     Copyright (C) <year>  <name of author>
295 | 
296 |     This program is free software; you can redistribute it and/or modify
297 |     it under the terms of the GNU General Public License as published by
298 |     the Free Software Foundation; either version 2 of the License, or
299 |     (at your option) any later version.
300 | 
301 |     This program is distributed in the hope that it will be useful,
302 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
303 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
304 |     GNU General Public License for more details.
305 | 
306 |     You should have received a copy of the GNU General Public License along
307 |     with this program; if not, write to the Free Software Foundation, Inc.,
308 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
309 | 
310 | Also add information on how to contact you by electronic and paper mail.
311 | 
312 | If the program is interactive, make it output a short notice like this
313 | when it starts in an interactive mode:
314 | 
315 |     Gnomovision version 69, Copyright (C) year name of author
316 |     Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
317 |     This is free software, and you are welcome to redistribute it
318 |     under certain conditions; type `show c' for details.
319 | 
320 | The hypothetical commands `show w' and `show c' should show the appropriate
321 | parts of the General Public License.  Of course, the commands you use may
322 | be called something other than `show w' and `show c'; they could even be
323 | mouse-clicks or menu items--whatever suits your program.
324 | 
325 | You should also get your employer (if you work as a programmer) or your
326 | school, if any, to sign a "copyright disclaimer" for the program, if
327 | necessary.  Here is a sample; alter the names:
328 | 
329 |   Yoyodyne, Inc., hereby disclaims all copyright interest in the program
330 |   `Gnomovision' (which makes passes at compilers) written by James Hacker.
331 | 
332 |   <signature of Ty Coon>, 1 April 1989
333 |   Ty Coon, President of Vice
334 | 
335 | This General Public License does not permit incorporating your program into
336 | proprietary programs.  If your program is a subroutine library, you may
337 | consider it more useful to permit linking proprietary applications with the
338 | library.  If this is what you want to do, use the GNU Lesser General
339 | Public License instead of this License.
340 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | <!-- Generated with 🧡 at typo3-badges.dev -->
 2 | ![TYPO3 extension](https://typo3-badges.dev/badge/repeatable_form_elements/extension/shields.svg)
 3 | ![Total downloads](https://typo3-badges.dev/badge/repeatable_form_elements/downloads/shields.svg)
 4 | ![Stability](https://typo3-badges.dev/badge/repeatable_form_elements/stability/shields.svg)
 5 | ![TYPO3 versions](https://typo3-badges.dev/badge/repeatable_form_elements/typo3/shields.svg)
 6 | ![Latest version](https://typo3-badges.dev/badge/repeatable_form_elements/version/shields.svg)
 7 | 
 8 | # Custom form element "Repeatable container"
 9 | 
10 | This TYPO3 extension adds a custom form element "Repeatable container" to the
11 | TYPO3 form framework. It displays one/ a set of fields which can be duplicated
12 | and removed if desired. Any existing validation is copied as well. All form
13 | finishers will be aware of the copied field(s).
14 | 
15 | ## Preferred installation
16 | 
17 | 1. Require the extension via composer.
18 | 2. Add the site set tritum/form-element-linked-checkbox to the dependencies of 
19 |    your site packages site set (TYPO3 v13). Or add the static TypoScript 
20 |    configuration to your TypoScript template (TYPO3 v12 and TYPO3 v13).
21 | 
22 | ## Usage
23 | 
24 | Open the TYPO3 form editor and create a new form/ open an existing one. Add a
25 | new element to your form. The modal will list the new custom form element
26 | "Repeatable container".
27 | 
28 | Add the desired fields with the favored validators to the "Repeatable container".
29 | 
30 | The frontend will render the "Repeatable container" as fieldset. In addition to the
31 | included form elements it will display buttons for copying/ removing new sets of fields.
32 | 
33 | The newly implemented extended version of SaveToDatabaseFinisher can be used as seen [here](Resources/Private/ExampleFormDefinitions/extended-save-to-database-finisher.form.yaml).
34 | 
35 | ## Configuration
36 | 
37 | To deactivate the copying of variants, the feature `repeatableFormElements.copyVariants` can be used
38 | 
39 | ## Extendability
40 | 
41 | The following options can be used to extend the behavior when copying.
42 | 
43 | | Name             | Description                                                      |
44 | |------------------|------------------------------------------------------------------|
45 | | CopyVariantEvent | Extend manipulation of copied variants or disable specific ones. |
46 | 
47 | ## Credits
48 | 
49 | This TYPO3 extension was created by Ralf Zimmermann (https://dreistrom.land).
50 | 
51 | ## Thank you
52 | 
53 | Nora Winter - "Faktenkopf" at www.faktenhaus.de - sponsored this great extension.
54 | The fine people at www.b13.de connected all the people involved.
55 | 
56 | Elias Häußler - haeussler.dev - for helping with TYPO3v11 compatability and providing
57 | the beautiful [TYPO3 badges](https://typo3-badges.dev). Use them. Give him some kudos!
58 | 
59 | Uwe - Hawkeye1909 - for removing jQuery as dependency.
60 | 
61 | Alexander Opitz @ extrameile-gehen.de - for his work on saving repeatable elements to database.
62 | 
63 | 
64 | especially to all others who have contributed to the improvement of the extension.
65 | 


--------------------------------------------------------------------------------
/Resources/Private/ExampleFormDefinitions/extended-save-to-database-finisher.form.yaml:
--------------------------------------------------------------------------------
 1 | 
 2 | renderingOptions:
 3 |   submitButtonLabel: Submit
 4 | type: Form
 5 | identifier: extended-save-to-database-finisher
 6 | label: extended-save-to-database-finisher
 7 | prototypeName: standard
 8 | finishers:
 9 |   -
10 |     options:
11 |       0:
12 |         table: tt_content
13 |         mode: insert
14 |         elements:
15 |           Example:
16 |             mapOnDatabaseColumn: bodytext
17 |         databaseColumnMappings:
18 |           CType:
19 |             value: textmedia
20 |       1:
21 |         table: sys_file_reference
22 |         mode: insert
23 |         container: RepeatableContainer-1
24 |         elements:
25 |           'imageupload-1':
26 |             mapOnDatabaseColumn: uid_local
27 |           'Person':
28 |             mapOnDatabaseColumn: description
29 |         databaseColumnMappings:
30 |           uid_foreign:
31 |             value: '{ExtendedSaveToDatabase.insertedUids.0}'
32 |           tablenames:
33 |             value: tt_content
34 |           fieldname:
35 |             value: assets
36 |       2:
37 |         table: tt_content
38 |         mode: update
39 |         whereClause:
40 |           uid: '{ExtendedSaveToDatabase.insertedUids.0}'
41 |         databaseColumnMappings:
42 |           assets:
43 |             value: '{ExtendedSaveToDatabase.countInserts.1}'
44 |     identifier: ExtendedSaveToDatabase
45 | renderables:
46 |   -
47 |     renderingOptions:
48 |       previousButtonLabel: 'Previous step'
49 |       nextButtonLabel: 'Next step'
50 |     type: Page
51 |     identifier: page-1
52 |     label: Step
53 |     renderables:
54 |       -
55 |         defaultValue: ''
56 |         type: Text
57 |         identifier: Example
58 |         label: ExampleTest
59 |       -
60 |         properties:
61 |           minimumCopies: '1'
62 |           maximumCopies: 10
63 |           showRemoveButton: true
64 |           copyButtonLabel: Copy
65 |           removeButtonLabel: Remove
66 |         type: RepeatableContainer
67 |         identifier: RepeatableContainer-1
68 |         label: RepeatableContainerTest
69 |         renderables:
70 |           -
71 |             defaultValue: ''
72 |             type: Text
73 |             identifier: Person
74 |             label: PersonTest
75 |           -
76 |             properties:
77 |               saveToFileMount: '1:/user_upload/'
78 |               allowedMimeTypes:
79 |                 - image/jpeg
80 |                 - image/png
81 |                 - image/bmp
82 |             type: ImageUpload
83 |             identifier: imageupload-1
84 |             label: 'Image upload'
85 |   -
86 |     renderingOptions:
87 |       previousButtonLabel: 'Previous step'
88 |       nextButtonLabel: 'Next step'
89 |     type: SummaryPage
90 |     identifier: summarypage-1
91 |     label: 'Summary step'
92 | 


--------------------------------------------------------------------------------
/Resources/Private/Frontend/Partials/RepeatableContainer.html:
--------------------------------------------------------------------------------
 1 | <html xmlns:f="http://typo3.org/ns/TYPO3/CMS/Fluid/ViewHelpers" xmlns:formvh="http://typo3.org/ns/TYPO3/CMS/Form/ViewHelpers" xmlns:rfe="http://typo3.org/ns/TRITUM/RepeatableFormElements/ViewHelpers" data-namespace-typo3-fluid="true">
 2 | <formvh:renderRenderable renderable="{element}">
 3 |     <fieldset data-repeatable-container data-identifier="{element.identifier}"{f:if(condition: '{element.renderingOptions._isRootRepeatableContainer}', then: ' data-is-root data-min-copies="{element.properties.minimumCopies}" data-max-copies="{element.properties.maximumCopies}"', else: ' data-is-copy data-copy-reference="{element.renderingOptions._copyReference}" data-copy-mother="{element.renderingOptions._copyMother}"')}{f:if(condition: '{element.renderingOptions._isReferenceContainer}', then: ' data-min-copies="{element.properties.minimumCopies}" data-max-copies="{element.properties.maximumCopies}"')}>
 4 |         <f:render partial="Field/Field" arguments="{element: element, doNotShowLabel: 1}" contentAs="elementContent">
 5 |             <div class="row">
 6 |                 <legend class="control-label" for="{element.uniqueIdentifier}">
 7 |                     {formvh:translateElementProperty(element: element, property: 'label')}
 8 |                         <div class="btn-group" role="group">
 9 |                             <f:if condition="{element.renderingOptions._isReferenceContainer}">
10 |                                 <button class="btn btn-default btn-sm" type="button" title="{formvh:translateElementProperty(element: element, property: 'copyButtonLabel')}" data-repeatable-container data-copy-button data-copy-button-for="{element.identifier}">
11 |                                     {formvh:translateElementProperty(element: element, property: 'copyButtonLabel')} <span class="glyphicon glyphicon-plus" aria-hidden="true"></span>
12 |                                 </button>
13 |                             </f:if>
14 |                             <f:if condition="{element.properties.showRemoveButton}">
15 |                                 <button class="btn btn-default btn-sm" type="button" title="{formvh:translateElementProperty(element: element, property: 'removeButtonLabel')}" data-repeatable-container data-remove-button data-remove-button-for="{element.identifier}" disabled>
16 |                                     {formvh:translateElementProperty(element: element, property: 'removeButtonLabel')} <span class="glyphicon glyphicon-minus" aria-hidden="true"></span>
17 |                                 </button>
18 |                             </f:if>
19 |                         </div>
20 |                 </legend>
21 |             </div>
22 | 
23 |             <div class="{element.properties.elementClassAttribute}">
24 |                 <f:for each="{element.elements}" as="childElement">
25 |                     <f:render partial="{childElement.templateName}" arguments="{element: childElement}" />
26 |                 </f:for>
27 |             </div>
28 |         </f:render>
29 |     </fieldset>
30 | </formvh:renderRenderable>
31 | </html>
32 | 


--------------------------------------------------------------------------------
/Resources/Private/Language/Database.xlf:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <xliff version="1.0" xmlns:t3="http://typo3.org/schemas/xliff">
 3 |     <file t3:id="1511194481" source-language="en" datatype="plaintext" original="messages" date="2017-11-20T11:32:45Z" product-name="repeatable_form_elements">
 4 |         <header/>
 5 |         <body>
 6 |             <trans-unit id="formEditor.elements.RepeatableContainer.label">
 7 |                 <source>Repeatable container</source>
 8 |             </trans-unit>
 9 |             <trans-unit id="formEditor.elements.RepeatableContainer.editor.label.label">
10 |                 <source>Repeatable container</source>
11 |             </trans-unit>
12 |             <trans-unit id="formEditor.elements.RepeatableContainer.editor.copyButtonLabel.label">
13 |                 <source>Copy button label</source>
14 |             </trans-unit>
15 |             <trans-unit id="formEditor.elements.RepeatableContainer.editor.copyButtonLabel.value">
16 |                 <source>Copy</source>
17 |             </trans-unit>
18 |             <trans-unit id="formEditor.elements.RepeatableContainer.editor.removeButtonLabel.label">
19 |                 <source>Remove button label</source>
20 |             </trans-unit>
21 |             <trans-unit id="formEditor.elements.RepeatableContainer.editor.removeButtonLabel.value">
22 |                 <source>Remove</source>
23 |             </trans-unit>
24 |             <trans-unit id="formEditor.elements.RepeatableContainer.editor.minimumCopies.label">
25 |                 <source>Minimum number of copies</source>
26 |             </trans-unit>
27 |             <trans-unit id="formEditor.elements.RepeatableContainer.editor.maximumCopies.label">
28 |                 <source>Maximum number of copies</source>
29 |             </trans-unit>
30 |             <trans-unit id="formEditor.elements.RepeatableContainer.editor.showRemoveButton.label">
31 |                 <source>Show remove button</source>
32 |             </trans-unit>
33 |         </body>
34 |     </file>
35 | </xliff>
36 | 


--------------------------------------------------------------------------------
/Resources/Private/Language/de.Database.xlf:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <xliff version="1.0" xmlns:t3="http://typo3.org/schemas/xliff">
 3 |     <file t3:id="1511194482" source-language="en" target-language="de" datatype="plaintext" original="messages" date="2017-11-20T11:32:45Z" product-name="repeatable_form_elements">
 4 |         <header/>
 5 |         <body>
 6 |             <trans-unit id="formEditor.elements.RepeatableContainer.label">
 7 |                 <source>Repeatable container</source>
 8 |                 <target>Repeatable Container</target>
 9 |             </trans-unit>
10 |             <trans-unit id="formEditor.elements.RepeatableContainer.editor.label.label">
11 |                 <source>Repeatable container</source>
12 |                 <target>Repeatable Container</target>
13 |             </trans-unit>
14 |             <trans-unit id="formEditor.elements.RepeatableContainer.editor.copyButtonLabel.label">
15 |                 <source>Copy button label</source>
16 |                 <target>Label Kopier-Button</target>
17 |             </trans-unit>
18 |             <trans-unit id="formEditor.elements.RepeatableContainer.editor.copyButtonLabel.value">
19 |                 <source>Copy</source>
20 |                 <target>Kopieren</target>
21 |             </trans-unit>
22 |             <trans-unit id="formEditor.elements.RepeatableContainer.editor.removeButtonLabel.label">
23 |                 <source>Remove button label</source>
24 |                 <target>Label Lösch-Button</target>
25 |             </trans-unit>
26 |             <trans-unit id="formEditor.elements.RepeatableContainer.editor.removeButtonLabel.value">
27 |                 <source>Remove</source>
28 |                 <target>Entfernen</target>
29 |             </trans-unit>
30 |             <trans-unit id="formEditor.elements.RepeatableContainer.editor.minimumCopies.label">
31 |                 <source>Minimum number of copies</source>
32 |                 <target>Minimale Anzahl an Kopien</target>
33 |             </trans-unit>
34 |             <trans-unit id="formEditor.elements.RepeatableContainer.editor.maximumCopies.label">
35 |                 <source>Maximum number of copies</source>
36 |                 <target>Maximale Anzahl an Kopien</target>
37 |             </trans-unit>
38 |             <trans-unit id="formEditor.elements.RepeatableContainer.editor.showRemoveButton.label">
39 |                 <source>Show remove button</source>
40 |                 <target>Zeige Lösch-Button</target>
41 |             </trans-unit>
42 |         </body>
43 |     </file>
44 | </xliff>
45 | 


--------------------------------------------------------------------------------
/Resources/Private/Language/de.locallang.xlf:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <xliff version="1.0" xmlns:t3="http://typo3.org/schemas/xliff">
 3 |     <file t3:id="1511194483" source-language="en" target-language="de" datatype="plaintext" original="messages" date="2017-11-20T11:32:45Z" product-name="repeatable_form_elements">
 4 |         <header/>
 5 |         <body>
 6 |             <trans-unit id="validation.error.1518701681">
 7 |                 <source>The maximum number of copies has been reached.</source>
 8 |                 <target>Die maximale Anzahl an Kopien wurde erreicht.</target>
 9 |             </trans-unit>
10 |             <trans-unit id="validation.error.1518701682">
11 |                 <source>The minimum number of copies has not yet been reached.</source>
12 |                 <target>Die minimale Anzahl an Kopien wurde noch nicht erreicht.</target>
13 |             </trans-unit>
14 |         </body>
15 |     </file>
16 | </xliff>
17 | 


--------------------------------------------------------------------------------
/Resources/Private/Language/locallang.xlf:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <xliff version="1.0" xmlns:t3="http://typo3.org/schemas/xliff">
 3 |     <file t3:id="1511194484" source-language="en" datatype="plaintext" original="messages" date="2017-11-20T11:32:45Z" product-name="repeatable_form_elements">
 4 |         <header/>
 5 |         <body>
 6 |             <trans-unit id="validation.error.1518701681">
 7 |                 <source>The maximum number of copies has been reached.</source>
 8 |             </trans-unit>
 9 |             <trans-unit id="validation.error.1518701682">
10 |                 <source>The minimum number of copies has not yet been reached.</source>
11 |             </trans-unit>
12 |         </body>
13 |     </file>
14 | </xliff>
15 | 


--------------------------------------------------------------------------------
/Resources/Public/Icons/Extension.svg:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- Generator: Adobe Illustrator 22.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
 3 | <svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
 4 | 	 viewBox="0 0 64 64" style="enable-background:new 0 0 64 64;" xml:space="preserve">
 5 | <path style="fill:#54A7D7;" d="M0,0h64v64H0V0z"/>
 6 | <g>
 7 | 	<rect x="34.625" y="43.8125" style="fill:#FFFFFF;" width="13.125" height="2.625"/>
 8 | 	<polygon style="fill:#FFFFFF;" points="29.375,43.8125 24.125,43.8125 24.125,38.5625 21.5,38.5625 21.5,43.8125 16.25,43.8125 
 9 | 		16.25,46.4375 21.5,46.4375 21.5,51.6875 24.125,51.6875 24.125,46.4375 29.375,46.4375 	"/>
10 | 	<g>
11 | 		<rect x="16.25" y="17.5625" style="fill:#FFFFFF;" width="13.125" height="2.625"/>
12 | 		<rect x="34.625" y="17.5625" style="fill:#FFFFFF;" width="13.125" height="2.625"/>
13 | 		<path style="fill:#FFFFFF;" d="M39.875,12.3125h-21H11v10.5v2.625v10.5h42v-10.5v-2.625v-10.5H39.875z M50.375,33.3125h-36.75
14 | 			v-7.875h5.25H21.5h15.75h2.625h10.5V33.3125z M50.375,22.8125h-10.5H37.25H21.5h-2.625h-5.25v-7.875h5.25h21h10.5V22.8125z"/>
15 | 		<rect x="16.25" y="28.0625" style="fill:#FFFFFF;" width="13.125" height="2.625"/>
16 | 		<rect x="34.625" y="28.0625" style="fill:#FFFFFF;" width="13.125" height="2.625"/>
17 | 	</g>
18 | </g>
19 | </svg>
20 | 


--------------------------------------------------------------------------------
/Resources/Public/Icons/t3-form-icon-repeatable-container.svg:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- Generator: Adobe Illustrator 22.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
 3 | <svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
 4 | 	 viewBox="0 0 16 16" style="enable-background:new 0 0 16 16;" xml:space="preserve">
 5 | <rect x="9" y="12" style="fill:#676767;" width="5" height="1"/>
 6 | <polygon style="fill:#676767;" points="7,12 5,12 5,10 4,10 4,12 2,12 2,13 4,13 4,15 5,15 5,13 7,13 "/>
 7 | <g>
 8 | 	<rect x="2" y="2" style="fill:#9A9999;" width="5" height="1"/>
 9 | 	<rect x="9" y="2" style="fill:#9A9999;" width="5" height="1"/>
10 | 	<path style="fill:#9A9999;" d="M11,0H3H0v4v1v4h16V5V4V0H11z M15,8H1V5h2h1h6h1h4V8z M15,4h-4h-1H4H3H1V1h2h8h4V4z"/>
11 | 	<rect x="2" y="6" style="fill:#9A9999;" width="5" height="1"/>
12 | 	<rect x="9" y="6" style="fill:#9A9999;" width="5" height="1"/>
13 | </g>
14 | <g>
15 | 	<path style="fill:#FFFFFF;" d="M15,5h-4h-1H4H3H1v3h14V5z M7,7H2V6h5V7z M14,7H9V6h5V7z"/>
16 | 	<path style="fill:#FFFFFF;" d="M3,1H1v3h2h1h6h1h4V1h-4H3z M7,3H2V2h5V3z M14,3H9V2h5V3z"/>
17 | </g>
18 | </svg>
19 | 


--------------------------------------------------------------------------------
/Resources/Public/JavaScript/backend/form-editor/view-model.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Module: @vendor/form-element-linked-checkbox/Backend/FormEditor/ViewModel.js
  3 |  */
  4 | 
  5 | import $ from 'jquery';
  6 | import * as Helper from '@typo3/form/backend/form-editor/helper.js'
  7 | import {renderCheckboxTemplate} from '@typo3/form/backend/form-editor/stage-component.js'
  8 | 
  9 | /**
 10 |  * @private
 11 |  *
 12 |  * @var object
 13 |  */
 14 | let _formEditorApp = null;
 15 | 
 16 | /**
 17 |  * @private
 18 |  *
 19 |  * @return object
 20 |  */
 21 | function getFormEditorApp() {
 22 |     return _formEditorApp;
 23 | };
 24 | 
 25 | /**
 26 |  * @private
 27 |  *
 28 |  * @return object
 29 |  */
 30 | function getPublisherSubscriber() {
 31 |     return getFormEditorApp().getPublisherSubscriber();
 32 | };
 33 | 
 34 | /**
 35 |  * @private
 36 |  *
 37 |  * @return object
 38 |  */
 39 | function getUtility() {
 40 |     return getFormEditorApp().getUtility();
 41 | };
 42 | 
 43 | /**
 44 |  * @private
 45 |  *
 46 |  * @param object
 47 |  * @return object
 48 |  */
 49 | function getHelper() {
 50 |     return Helper;
 51 | };
 52 | 
 53 | /**
 54 |  * @private
 55 |  *
 56 |  * @return object
 57 |  */
 58 | function getCurrentlySelectedFormElement() {
 59 |     return getFormEditorApp().getCurrentlySelectedFormElement();
 60 | };
 61 | 
 62 | /**
 63 |  * @private
 64 |  *
 65 |  * @param mixed test
 66 |  * @param string message
 67 |  * @param int messageCode
 68 |  * @return void
 69 |  */
 70 | function assert(test, message, messageCode) {
 71 |     return getFormEditorApp().assert(test, message, messageCode);
 72 | };
 73 | 
 74 | /**
 75 |  * @private
 76 |  *
 77 |  * @return void
 78 |  * @throws 1491643380
 79 |  */
 80 | function _helperSetup() {
 81 |     assert('function' === $.type(Helper.bootstrap),
 82 |         'The view model helper does not implement the method "bootstrap"',
 83 |         1491643380
 84 |     );
 85 |     Helper.bootstrap(getFormEditorApp());
 86 | };
 87 | 
 88 | /**
 89 |  * @private
 90 |  *
 91 |  * @return void
 92 |  */
 93 | function _subscribeEvents() {
 94 |     getPublisherSubscriber().subscribe('view/stage/abstract/render/template/perform', function(topic, args) {
 95 |         if (args[0].get('type') === 'RepeatableContainer') {
 96 |             renderCheckboxTemplate(args[0], args[1]);
 97 |         }
 98 |     });
 99 | };
100 | 
101 | /**
102 |  * @public
103 |  *
104 |  * @param object formEditorApp
105 |  * @return void
106 |  */
107 | export function bootstrap(formEditorApp) {
108 |     _formEditorApp = formEditorApp;
109 |     _helperSetup();
110 |     _subscribeEvents();
111 | };
112 | 


--------------------------------------------------------------------------------
/Resources/Public/JavaScript/frontend/repeatable-container.js:
--------------------------------------------------------------------------------
  1 | var ready = (callback) => {
  2 |   if (document.readyState != "loading") callback();
  3 |   else document.addEventListener("DOMContentLoaded", callback);
  4 | }
  5 | ready(() => {
  6 |     var containerClones = {};
  7 | 
  8 |     document.querySelectorAll('[data-repeatable-container][data-is-root]').forEach((rootElement) => {
  9 |         let containerClone = rootElement.cloneNode(true),
 10 |             containerIdentifier = rootElement.dataset['identifier'],
 11 |             formIdentifier = rootElement.closest('form').getAttribute('id'),
 12 |             copyButton = containerClone.querySelector('[data-repeatable-container][data-copy-button]');
 13 | 
 14 |         containerClones[formIdentifier] = containerClones[formIdentifier] || {};
 15 | 
 16 |         for (const copyElement of containerClone.querySelectorAll('[data-repeatable-container][data-is-copy]')) {
 17 |             copyElement.remove();
 18 |         }
 19 |         if (copyButton !== null) {
 20 |             copyButton.remove();
 21 |         }
 22 |         for (const alertElement of containerClone.querySelectorAll('[role="alert"]')) {
 23 |             alertElement.remove();
 24 |         }
 25 | 
 26 |         containerClone.querySelectorAll('[data-repeatable-container][data-is-root]').forEach((cloneElement) => {
 27 |             delete cloneElement.dataset.isRoot;
 28 |             cloneElement.dataset.isCopy = '';
 29 |             cloneElement.dataset.copyMother = cloneElement.dataset['identifier'];
 30 |         });
 31 |         delete containerClone.dataset.isRoot;
 32 |         containerClone.dataset.isCopy = '';
 33 |         containerClone.querySelectorAll('*').forEach((cloneChildElement) => {
 34 |             cloneChildElement.classList.remove('has-error');
 35 |         });
 36 | 
 37 |         let inputs = [...containerClone.querySelectorAll('input')];
 38 |         inputs.filter((input) => ['checkbox', 'radio', 'hidden'].indexOf(input.getAttribute('type')) == -1).forEach((inputElement) => {
 39 |             inputElement.setAttribute('value', '');
 40 |         });
 41 |         inputs.filter((input) => ['file'].indexOf(input.getAttribute('type')) >= 0).forEach((inputElement) => {
 42 |             [...inputElement.parentNode.children].filter((child) => child !== inputElement).forEach((siblingElement) => {
 43 |                 siblingElement.remove();
 44 |             });
 45 |         });
 46 |         inputs.filter((input) => ['checkbox', 'radio'].indexOf(input.getAttribute('type')) >= 0).forEach((inputElement) => {
 47 |             inputElement.checked = false;
 48 |         });
 49 |         containerClone.querySelectorAll('textarea').forEach((textareaElement) => {
 50 |             textareaElement.setAttribute('value', '');
 51 |         });
 52 |         containerClone.querySelectorAll('select').forEach((selectElement) => {
 53 |             let selected = selectElement.selectedOptions;
 54 |             for (let i = 0; i < selected.length; i++) {
 55 |                 selected[i].removeAttribute('selected');
 56 |             }
 57 |             selectElement.selectedIndex = -1;
 58 |         });
 59 | 
 60 |         containerClones[formIdentifier][containerIdentifier] = containerClone;
 61 |     });
 62 | 
 63 |     document.dispatchEvent(new CustomEvent('initialize-repeatable-container-copy-buttons', { 'detail': { 'containerClones': containerClones } }));
 64 |     document.dispatchEvent(new CustomEvent('initialize-repeatable-container-remove-buttons'));
 65 | });
 66 | 
 67 | document.addEventListener('initialize-repeatable-container-copy-buttons', (copyEvent) => {
 68 |     let containerClones = copyEvent.detail.containerClones,
 69 |         getNextCopyNumber = (referenceElement, formElement) => {
 70 |             let highestCopyNumber = 0;
 71 | 
 72 |             formElement.querySelectorAll('[data-repeatable-container][data-copy-reference="' + referenceElement.dataset['identifier'] + '"]').forEach((copyElement) => {
 73 |                 let copyNumber = parseInt(copyElement.dataset['identifier'].split('.').pop());
 74 | 
 75 |                 if (copyNumber > highestCopyNumber) {
 76 |                     highestCopyNumber = copyNumber;
 77 |                 }
 78 |             });
 79 | 
 80 |             return ++highestCopyNumber;
 81 |         },
 82 |         setRandomIds = (subject) => {
 83 |             let idReplacements = {};
 84 | 
 85 |             subject.querySelectorAll('[id]').forEach((subjectIdElement) => {
 86 |                 let id = subjectIdElement.getAttribute('id'),
 87 |                     newId = Math.floor(Math.random() * 99999999) + Date.now();
 88 | 
 89 |                 subjectIdElement.setAttribute('id', newId);
 90 |                 idReplacements[id] = newId;
 91 |             });
 92 | 
 93 |             subject.querySelectorAll('*').forEach((subjectChildElement) => {
 94 |                 for (let i = 0, len = subjectChildElement.attributes.length; i < len; i++) {
 95 |                     let attributeValue = subjectChildElement.attributes[i].nodeValue;
 96 | 
 97 |                     if (attributeValue in idReplacements) {
 98 |                         subjectChildElement.attributes[i].nodeValue = idReplacements[attributeValue];
 99 |                     }
100 |                 }
101 |             });
102 |         },
103 |         escapeRegExp = (subject) => {
104 |             return subject.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
105 |         };
106 | 
107 |     document.querySelectorAll('[data-repeatable-container][data-copy-button]').forEach((copyBtnElement) => {
108 |         let formElement = copyBtnElement.closest('form'),
109 |             referenceElementIdentifier = copyBtnElement.dataset['copyButtonFor'],
110 |             referenceElement = formElement.querySelector('[data-repeatable-container][data-identifier="' + referenceElementIdentifier + '"]'),
111 |             elementCopies = formElement.querySelectorAll('[data-repeatable-container][data-copy-reference="' + referenceElementIdentifier + '"]'),
112 |             maxCopies = referenceElement.dataset['maxCopies'] || false;
113 | 
114 |         if (maxCopies && elementCopies.length >= maxCopies) {
115 |             copyBtnElement.disabled = true;
116 |         } else {
117 |             copyBtnElement.disabled = false;
118 |             /* clone element to remove all event listeners */
119 |             let copyBtnElementClone = copyBtnElement.cloneNode(true);
120 |             copyBtnElement.replaceWith(copyBtnElementClone);
121 |             copyBtnElementClone.addEventListener('click', (clickEvent) => {
122 |                 clickEvent.preventDefault();
123 |                 let clickElement = clickEvent.currentTarget,
124 |                     clickFormElement = clickElement.closest('form'),
125 |                     referenceElementIdentifier = clickElement.dataset['copyButtonFor'],
126 |                     formIdentifier = clickFormElement.getAttribute('id'),
127 |                     referenceElement = clickFormElement.querySelector('[data-repeatable-container][data-identifier="' + referenceElementIdentifier + '"]'),
128 |                     referenceElementIsRoot = 'isRoot' in referenceElement.dataset,
129 |                     elementCopies = clickFormElement.querySelectorAll('[data-repeatable-container][data-copy-reference="' + referenceElementIdentifier + '"]'),
130 |                     containerCloneIdentifier = referenceElementIsRoot ? referenceElementIdentifier : referenceElement.dataset['copyMother'],
131 |                     copyMotherIdentifier = containerClones[formIdentifier][containerCloneIdentifier].dataset['identifier'],
132 |                     newIdentifierParts = referenceElement.dataset['identifier'].split('.'),
133 |                     oldIdentifierNameRegex = escapeRegExp('[' + copyMotherIdentifier.split('.').join('][') + ']'),
134 |                     copyMotherIdentifierRegex = '(' + escapeRegExp('data-copy-mother="') + ')?' + escapeRegExp(copyMotherIdentifier),
135 |                     newIdentifier = undefined,
136 |                     newIdentifierNameRegex = undefined,
137 |                     containerClone = undefined,
138 |                     containerCloneHtml = undefined;
139 | 
140 |                 newIdentifierParts.pop();
141 |                 newIdentifierParts.push(getNextCopyNumber(referenceElement, clickFormElement));
142 |                 newIdentifier = newIdentifierParts.join('.');
143 | 
144 |                 containerCloneHtml = containerClones[formIdentifier][containerCloneIdentifier].outerHTML;
145 |                 // leading, negative lookbehind ("?<!")
146 |                 containerCloneHtml = containerCloneHtml.replace(new RegExp(copyMotherIdentifierRegex, 'g'), ($0, $1) => {
147 |                     return $1 ? $0 : newIdentifier;
148 |                 });
149 | 
150 |                 newIdentifierNameRegex = '[' + newIdentifierParts.join('][') + ']';
151 |                 containerCloneHtml = containerCloneHtml.replace(new RegExp(oldIdentifierNameRegex, 'g'), newIdentifierNameRegex);
152 | 
153 |                 let containerCloneWrap = document.createElement('div');
154 |                 containerCloneWrap.innerHTML = containerCloneHtml;
155 |                 containerClone = containerCloneWrap.firstChild;
156 |                 containerClone.dataset.copyReference = referenceElementIdentifier;
157 | 
158 |                 setRandomIds(containerClone);
159 | 
160 |                 if (elementCopies.length === 0) {
161 |                     referenceElement.after(containerClone);
162 |                 } else {
163 |                     [...elementCopies].at(-1).after(containerClone);
164 |                 }
165 | 
166 |                 // document.dispatchEvent(new CustomEvent('after-element-copy', { 'detail': { 'containerClone': containerClone } }));
167 |                 document.dispatchEvent(new CustomEvent('initialize-repeatable-container-copy-buttons', { 'detail': { 'containerClones': containerClones } }));
168 |                 document.dispatchEvent(new CustomEvent('initialize-repeatable-container-remove-buttons'));
169 |             });
170 |         }
171 |     });
172 | });
173 | 
174 | document.addEventListener('initialize-repeatable-container-remove-buttons', (removeEvent) => {
175 |     document.querySelectorAll('[data-repeatable-container][data-remove-button]').forEach((removeBtnElement) => {
176 |         let formElement = removeBtnElement.closest('form'),
177 |             referenceElementIdentifier = removeBtnElement.dataset['removeButtonFor'],
178 |             referenceElement = formElement.querySelector('[data-repeatable-container][data-identifier="' + referenceElementIdentifier + '"]'),
179 |             referenceElementIsRoot = 'isRoot' in referenceElement.dataset,
180 |             referenceReferenceElementIdentifier = referenceElementIsRoot ? referenceElementIdentifier : referenceElement.dataset['copyReference'],
181 |             referenceReferenceElement = formElement.querySelector('[data-repeatable-container][data-identifier="' + referenceReferenceElementIdentifier + '"]'),
182 |             elementCopies = formElement.querySelectorAll('[data-repeatable-container][data-copy-reference="' + referenceReferenceElementIdentifier + '"]'),
183 |             minCopies = referenceReferenceElement?.dataset['minCopies'] || false;
184 | 
185 |         if ((referenceElement.dataset['copyReference'] || false) && referenceElement.dataset['copyReference'] !== '') {
186 |             if (minCopies && elementCopies.length <= minCopies) {
187 |                 // removeBtnElement.classList.remove('d-none');
188 |                 removeBtnElement.disabled = true;
189 |             } else {
190 |                 // removeBtnElement.classList.remove('d-none');
191 |                 removeBtnElement.disabled = false;
192 |             }
193 |         } else {
194 |             removeBtnElement.remove();
195 |         }
196 | 
197 |         if (removeBtnElement.disabled) {
198 |             /* clone element to remove all event listeners */
199 |             removeBtnElement.replaceWith(removeBtnElement.cloneNode(true));
200 |         } else {
201 |             /* clone element to remove all event listeners */
202 |             let removeBtnElementClone = removeBtnElement.cloneNode(true);
203 |             removeBtnElement.replaceWith(removeBtnElementClone);
204 |             removeBtnElementClone.addEventListener('click', (clickEvent) => {
205 |                 clickEvent.preventDefault();
206 | 
207 |                 let clickElement = clickEvent.currentTarget,
208 |                     clickFormElement = clickElement.closest('form'),
209 |                     referenceElementIdentifier = clickElement.dataset['removeButtonFor'],
210 |                     referenceElement = clickFormElement.querySelector('[data-repeatable-container][data-identifier="' + referenceElementIdentifier + '"]'),
211 |                     referenceElementIsRoot = 'isRoot' in referenceElement.dataset,
212 |                     referenceReferenceElementIdentifier = referenceElementIsRoot ? referenceElementIdentifier : referenceElement.dataset['copyReference'],
213 |                     referenceReferenceElement = clickFormElement.querySelector('[data-repeatable-container][data-identifier="' + referenceReferenceElementIdentifier + '"]'),
214 |                     elementCopies = clickFormElement.querySelectorAll('[data-repeatable-container][data-copy-reference="' + referenceReferenceElementIdentifier + '"]'),
215 |                     maxCopies = referenceReferenceElement?.dataset['maxCopies'] || false,
216 |                     copyButton = clickFormElement.querySelector('[data-repeatable-container][data-copy-button-for="' + referenceReferenceElementIdentifier + '"]');
217 | 
218 |                 if (maxCopies && elementCopies.length - 1 < maxCopies) {
219 |                     copyButton.disabled = false;
220 |                 }
221 | 
222 |                 referenceElement.remove();
223 |                 document.dispatchEvent(new CustomEvent('initialize-repeatable-container-remove-buttons'));
224 |             });
225 |         }
226 |     });
227 | });
228 | 
229 | /* DatePicker is a jQuery UI function and we want to get rid of jQuery... */
230 | /* document.addEventListener('after-element-copy', (afterCopyEvent) => {
231 |     let containerClone = afterCopyEvent.detail.containerClone;
232 |     document.querySelectorAll('[data-element-type="DatePicker"]').forEach((datePickerElement) => {
233 |         var dateFormat;
234 | 
235 |         // if (!datePickerElement.classList.contains('hasDatepicker') && parseInt(datePickerElement.getAttribute('data-element-datepicker-enabled')) === 1) {
236 |         if (!datePickerElement.classList.contains('hasDatepicker') && parseInt(datePickerElement.dataset['elementDatepickerEnabled']) === 1) {
237 |             // dateFormat = datePickerElement.getAttribute('data-element-datepicker-date-format');
238 |             dateFormat = datePickerElement.dataset['elementDatepickerDateFormat'];
239 | 
240 |             dateFormat = dateFormat.replace('d', 'dd');
241 |             dateFormat = dateFormat.replace('j', 'o');
242 |             dateFormat = dateFormat.replace('l', 'DD');
243 |             dateFormat = dateFormat.replace('F', 'MM');
244 |             dateFormat = dateFormat.replace('m', 'mm');
245 |             dateFormat = dateFormat.replace('n', 'm');
246 |             dateFormat = dateFormat.replace('Y', 'yy');
247 | 
248 |             $('#' + datePickerElement.attr('id')).datepicker({
249 |                 dateFormat: dateFormat
250 |             }).on('keydown', function(e) {
251 |                 if(e.keyCode == 8 || e.keyCode == 46) {
252 |                     e.preventDefault();
253 |                     $.datepicker._clearDate(this);
254 |                 }
255 |             });
256 |         }
257 |     });
258 | }); */
259 | 


--------------------------------------------------------------------------------
/Resources/Public/StyleSheets/app.css:
--------------------------------------------------------------------------------
1 | .repeatable-container {
2 |     padding: 0 20px;
3 | }
4 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "tritum/repeatable-form-elements",
 3 |     "description": "Adds a new form element which allows the editor to create new container elements with any type fields in them. In the frontend, a user can create any number of new containers. This is an extension for TYPO3 CMS.",
 4 |     "license": "GPL-2.0-or-later",
 5 |     "type": "typo3-cms-extension",
 6 |     "authors": [
 7 |         {
 8 |             "name": "Ralf Zimmermann",
 9 |             "email": "r.zimmermann@dreistrom.land",
10 |             "homepage": "https://dreistrom.land",
11 |             "role": "Developer"
12 |         },
13 |         {
14 |             "name": "Falko Linke",
15 |             "email": "f.linke@dreistrom.land",
16 |             "homepage": "https://dreistrom.land",
17 |             "role": "Developer"
18 |         },
19 |         {
20 |             "name": "Elias Häußler",
21 |             "email": "elias@haeussler.dev",
22 |             "homepage": "https://haeussler.dev",
23 |             "role": "Developer"
24 |         },
25 |         {
26 |             "name": "Christian Seyfferth",
27 |             "email": "c.seyfferth@dreistrom.land",
28 |             "homepage": "https://dreistrom.land",
29 |             "role": "Developer"
30 |         }
31 |     ],
32 |     "require": {
33 |         "typo3/cms-core": "^12.4 || ^13.4",
34 |         "typo3/cms-extbase": "^12.4 || ^13.4",
35 |         "typo3/cms-form": "^12.4 || ^13.4"
36 |     },
37 |     "autoload": {
38 |         "psr-4": {
39 |             "TRITUM\\RepeatableFormElements\\": "Classes/"
40 |         }
41 |     },
42 |     "config": {
43 |         "allow-plugins": {
44 |             "typo3/class-alias-loader": true,
45 |             "typo3/cms-composer-installers": true
46 |         },
47 |         "sort-packages": true
48 |     },
49 |     "extra": {
50 |         "typo3/cms": {
51 |             "extension-key": "repeatable_form_elements"
52 |         }
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/ext_emconf.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $EM_CONF['repeatable_form_elements'] = [
 4 |     'title' => 'Repeatable form elements',
 5 |     'description' => 'Adds a new form element which allows the editor to create new container elements with any type fields in them. In the frontend, a user can create any number of new containers. This is an extension for TYPO3 CMS.',
 6 |     'category' => 'fe',
 7 |     'state' => 'stable',
 8 |     'author' => 'Ralf Zimmermann, Elias Häußler, Christian Seyfferth',
 9 |     'author_email' => 'r.zimmermann@dreistrom.land, elias@haeussler.dev, c.seyfferth@dreistrom.land',
10 |     'version' => '5.0.0',
11 |     'constraints' => [
12 |         'depends' => [
13 |             'typo3' => '12.4.0-13.4.99',
14 |         ],
15 |         'conflicts' => [],
16 |         'suggests' => [],
17 |     ],
18 | ];
19 | 


--------------------------------------------------------------------------------
/ext_localconf.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use TRITUM\RepeatableFormElements\Configuration\Extension;
 4 | 
 5 | defined('TYPO3') or die();
 6 | 
 7 | call_user_func(function () {
 8 |     Extension::addTypoScriptSetup();
 9 |     Extension::registerHooks();
10 | 
11 |     $GLOBALS['TYPO3_CONF_VARS']['SYS']['features']['repeatableFormElements.copyVariants'] ??= true;
12 | });
13 | 


--------------------------------------------------------------------------------