@valtimo-plugins/freemarker 8.0.0 → 8.1.1-V12

package/esm2022/lib/plugins/mail-template/mail-template-plugin-module.mjs

@@ -0,0 +1,154 @@
+/*
+ * Copyright 2015-2022 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { NgModule } from '@angular/core';
+import { MailTemplateConfigurationComponent } from './components/mail-template-configuration/mail-template-configuration.component';
+import { CommonModule } from '@angular/common';
+import { PluginTranslatePipeModule } from '@valtimo/plugin';
+import { CarbonListModule, ConfirmationModalModule, EditorModule, FormModule, InputModule as ValtimoInputModule, ParagraphModule, RenderInPageHeaderDirectiveModule, SelectModule, } from '@valtimo/components';
+import { GenerateMailContentComponent } from './components/generate-mail-content/generate-mail-content.component';
+import { GenerateMailFileComponent } from './components/generate-mail-file/generate-mail-file.component';
+import { ButtonModule, DialogModule, DropdownModule, IconModule, InputModule, LoadingModule, ModalModule, NotificationModule, TabsModule, } from 'carbon-components-angular';
+import { CASE_MANAGEMENT_TAB_TOKEN } from '@valtimo/config';
+import { MailTemplateListComponent } from './components/mail-template-list/mail-template-list.component';
+import { MailTemplateAddEditModalComponent } from './components/mail-template-add-edit-modal/mail-template-add-edit-modal.component';
+import { MailTemplateEditorComponent } from './components/mail-template-editor/mail-template-editor.component';
+import { MailTemplateDeleteModalComponent } from './components/mail-template-delete-modal/mail-template-delete-modal.component';
+import { TranslateModule } from '@ngx-translate/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { TemplateManagementRoutingModule } from './mail-template-management-routing.module';
+import * as i0 from "@angular/core";
+export class MailTemplatePluginModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MailTemplatePluginModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: MailTemplatePluginModule, declarations: [MailTemplateConfigurationComponent,
+            GenerateMailFileComponent,
+            GenerateMailContentComponent], imports: [CommonModule,
+            PluginTranslatePipeModule,
+            TemplateManagementRoutingModule,
+            FormModule,
+            ParagraphModule,
+            SelectModule,
+            ConfirmationModalModule,
+            TranslateModule,
+            ReactiveFormsModule,
+            CarbonListModule,
+            EditorModule,
+            ValtimoInputModule,
+            ButtonModule,
+            DialogModule,
+            DropdownModule,
+            IconModule,
+            InputModule,
+            LoadingModule,
+            ModalModule,
+            NotificationModule,
+            RenderInPageHeaderDirectiveModule,
+            TabsModule,
+            MailTemplateAddEditModalComponent,
+            MailTemplateEditorComponent,
+            MailTemplateDeleteModalComponent,
+            MailTemplateListComponent], exports: [MailTemplateConfigurationComponent,
+            GenerateMailFileComponent,
+            GenerateMailContentComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MailTemplatePluginModule, providers: [
+            {
+                provide: CASE_MANAGEMENT_TAB_TOKEN,
+                useValue: {
+                    translationKey: 'Mail templates',
+                    component: MailTemplateListComponent,
+                },
+                multi: true,
+            }
+        ], imports: [CommonModule,
+            PluginTranslatePipeModule,
+            TemplateManagementRoutingModule,
+            FormModule,
+            ParagraphModule,
+            SelectModule,
+            ConfirmationModalModule,
+            TranslateModule,
+            ReactiveFormsModule,
+            CarbonListModule,
+            EditorModule,
+            ValtimoInputModule,
+            ButtonModule,
+            DialogModule,
+            DropdownModule,
+            IconModule,
+            InputModule,
+            LoadingModule,
+            ModalModule,
+            NotificationModule,
+            RenderInPageHeaderDirectiveModule,
+            TabsModule,
+            MailTemplateAddEditModalComponent,
+            MailTemplateEditorComponent,
+            MailTemplateDeleteModalComponent,
+            MailTemplateListComponent] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MailTemplatePluginModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        MailTemplateConfigurationComponent,
+                        GenerateMailFileComponent,
+                        GenerateMailContentComponent,
+                    ],
+                    imports: [
+                        CommonModule,
+                        PluginTranslatePipeModule,
+                        TemplateManagementRoutingModule,
+                        FormModule,
+                        ParagraphModule,
+                        SelectModule,
+                        ConfirmationModalModule,
+                        TranslateModule,
+                        ReactiveFormsModule,
+                        CarbonListModule,
+                        EditorModule,
+                        ValtimoInputModule,
+                        ButtonModule,
+                        DialogModule,
+                        DropdownModule,
+                        IconModule,
+                        InputModule,
+                        LoadingModule,
+                        ModalModule,
+                        NotificationModule,
+                        RenderInPageHeaderDirectiveModule,
+                        TabsModule,
+                        MailTemplateAddEditModalComponent,
+                        MailTemplateEditorComponent,
+                        MailTemplateDeleteModalComponent,
+                        MailTemplateListComponent,
+                    ],
+                    exports: [
+                        MailTemplateConfigurationComponent,
+                        GenerateMailFileComponent,
+                        GenerateMailContentComponent,
+                    ],
+                    providers: [
+                        {
+                            provide: CASE_MANAGEMENT_TAB_TOKEN,
+                            useValue: {
+                                translationKey: 'Mail templates',
+                                component: MailTemplateListComponent,
+                            },
+                            multi: true,
+                        }
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mail-template-plugin-module.js","sourceRoot":"","sources":["../../../../../../../projects/valtimo-plugins/freemarker/src/lib/plugins/mail-template/mail-template-plugin-module.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2022 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {NgModule} from '@angular/core';\nimport {\n    MailTemplateConfigurationComponent\n} from './components/mail-template-configuration/mail-template-configuration.component';\nimport {CommonModule} from '@angular/common';\nimport {PluginTranslatePipeModule} from '@valtimo/plugin';\nimport {\n    CarbonListModule,\n    ConfirmationModalModule,\n    EditorModule,\n    FormModule,\n    InputModule as ValtimoInputModule,\n    ParagraphModule, RenderInPageHeaderDirectiveModule,\n    SelectModule,\n} from '@valtimo/components';\nimport {GenerateMailContentComponent} from './components/generate-mail-content/generate-mail-content.component';\nimport {GenerateMailFileComponent} from './components/generate-mail-file/generate-mail-file.component';\nimport {\n    ButtonModule,\n    DialogModule,\n    DropdownModule,\n    IconModule,\n    InputModule,\n    LoadingModule,\n    ModalModule,\n    NotificationModule, TabsModule,\n} from 'carbon-components-angular';\nimport {CASE_MANAGEMENT_TAB_TOKEN} from '@valtimo/config';\nimport {MailTemplateListComponent} from './components/mail-template-list/mail-template-list.component';\nimport {\n    MailTemplateAddEditModalComponent\n} from './components/mail-template-add-edit-modal/mail-template-add-edit-modal.component';\nimport {MailTemplateEditorComponent} from './components/mail-template-editor/mail-template-editor.component';\nimport {\n    MailTemplateDeleteModalComponent\n} from './components/mail-template-delete-modal/mail-template-delete-modal.component';\nimport {TranslateModule} from '@ngx-translate/core';\nimport {ReactiveFormsModule} from '@angular/forms';\nimport {TemplateManagementRoutingModule} from './mail-template-management-routing.module';\n\n@NgModule({\n    declarations: [\n        MailTemplateConfigurationComponent,\n        GenerateMailFileComponent,\n        GenerateMailContentComponent,\n    ],\n    imports: [\n        CommonModule,\n        PluginTranslatePipeModule,\n        TemplateManagementRoutingModule,\n        FormModule,\n        ParagraphModule,\n        SelectModule,\n        ConfirmationModalModule,\n        TranslateModule,\n        ReactiveFormsModule,\n        CarbonListModule,\n        EditorModule,\n        ValtimoInputModule,\n        ButtonModule,\n        DialogModule,\n        DropdownModule,\n        IconModule,\n        InputModule,\n        LoadingModule,\n        ModalModule,\n        NotificationModule,\n        RenderInPageHeaderDirectiveModule,\n        TabsModule,\n        MailTemplateAddEditModalComponent,\n        MailTemplateEditorComponent,\n        MailTemplateDeleteModalComponent,\n        MailTemplateListComponent,\n    ],\n    exports: [\n        MailTemplateConfigurationComponent,\n        GenerateMailFileComponent,\n        GenerateMailContentComponent,\n    ],\n    providers: [\n        {\n            provide: CASE_MANAGEMENT_TAB_TOKEN,\n            useValue: {\n                translationKey: 'Mail templates',\n                component: MailTemplateListComponent,\n            },\n            multi: true,\n        }\n    ]\n})\nexport class MailTemplatePluginModule {\n}\n"]}

package/esm2022/lib/plugins/mail-template/mail-template-plugin.specification.mjs

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2015-2022 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { MailTemplateConfigurationComponent } from './components/mail-template-configuration/mail-template-configuration.component';
+import { MAIL_TEMPLATE_PLUGIN_LOGO_BASE64 } from './assets';
+import { GenerateMailContentComponent } from './components/generate-mail-content/generate-mail-content.component';
+import { GenerateMailFileComponent } from './components/generate-mail-file/generate-mail-file.component';
+const mailTemplatePluginSpecification = {
+    pluginId: 'mail-template',
+    pluginConfigurationComponent: MailTemplateConfigurationComponent,
+    pluginLogoBase64: MAIL_TEMPLATE_PLUGIN_LOGO_BASE64,
+    functionConfigurationComponents: {
+        'generate-mail-file': GenerateMailFileComponent,
+        'generate-mail-content': GenerateMailContentComponent,
+    },
+    pluginTranslations: {
+        nl: {
+            title: 'Mail sjablonen',
+            'generate-mail-file': 'Genereer Mailbestand',
+            'generate-mail-content': 'Genereer Mailinhoud',
+            description: 'Maak Mail sjablonen met Freemarker.',
+            configurationTitle: 'Configuratienaam',
+            configurationTitleTooltip: 'De naam van de huidige plug-in configuratie. Onder deze naam kan de configuratie worden gevonden in de rest van de applicatie.',
+            generateMailContentDescription: 'Deze actie genereert de inhoud van een mail op basis van een sjabloon. De mail tekst wordt opgeslagen in een Proces Variabele.',
+            generateMailFileDescription: 'Deze actie genereert de inhoud van een mail en slaat het resultaat op in een tijdelijk bestand. Het ID van het bestand wordt opgeslagen in een Proces Variabele.',
+            mailTemplateKey: 'Mail sjabloon',
+            mailTemplateKeyTooltip: 'Op bases van deze sjabloon wordt de mail gegenereerd',
+            processVariableName: 'Procesvariabelenaam',
+            processVariableNameTooltip: 'Het resultaat wordt opgeslagen in een procesvariabele met deze naam',
+        },
+        en: {
+            title: 'Mail Templates',
+            'generate-mail-file': 'Generate Mail File',
+            'generate-mail-content': 'Generate Mail Content (deprecated)',
+            description: 'Create mail templates with Freemarker.',
+            configurationTitle: 'Configuration Name',
+            configurationTitleTooltip: 'The name of the current plug-in configuration. The configuration can be found under this name in the rest of the application.',
+            generateMailContentDescription: 'This action generates the content of an mail based on a template. The mail text is then stored in a Process Variable. This action is deprecated because the mail text can be bigger than a Process Variable can store. Please use action "Generate Mail File" instead',
+            generateMailFileDescription: 'This action generates the content of an mail and saves the result in a temporary file. The file ID is then stored in a Process Variable.',
+            mailTemplateKey: 'Mail Template',
+            mailTemplateKeyTooltip: 'The mail will be generated based on this template.',
+            processVariableName: 'Process Variable Name',
+            processVariableNameTooltip: 'The result will be stored in a process variable with this name.',
+        },
+        de: {
+            title: 'Mail-Vorlagen',
+            'generate-mail-file': 'Mail-Datei generieren',
+            'generate-mail-content': 'Mail-Inhalt generieren',
+            description: 'Erstellen Sie Mail-Vorlagen mit Freemarker.',
+            configurationTitle: 'Konfigurationsname',
+            configurationTitleTooltip: 'Der Name der aktuellen Plug-in-Konfiguration. Unter diesem Namen kann die Konfiguration im Rest der Anwendung gefunden werden.',
+            generateMailContentDescription: 'Diese Aktion generiert den Inhalt einer Mail basierend auf einer Vorlage. Der Mail-Text wird in einer Prozessvariablen gespeichert.',
+            generateMailFileDescription: 'Diese Aktion generiert den Inhalt einer Mail und speichert das Ergebnis in einer temporären Datei. Die Datei-ID wird in einer Prozessvariablen gespeichert.',
+            mailTemplateKey: 'Mail-Vorlage',
+            mailTemplateKeyTooltip: 'Die Mail wird basierend auf dieser Vorlage generiert.',
+            processVariableName: 'Prozessvariablenname',
+            processVariableNameTooltip: 'Das Ergebnis wird in einer Prozessvariablen mit diesem Namen gespeichert.',
+        },
+    },
+};
+export { mailTemplatePluginSpecification };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mail-template-plugin.specification.js","sourceRoot":"","sources":["../../../../../../../projects/valtimo-plugins/freemarker/src/lib/plugins/mail-template/mail-template-plugin.specification.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAC,kCAAkC,EAAC,MAAM,gFAAgF,CAAC;AAClI,OAAO,EAAC,gCAAgC,EAAC,MAAM,UAAU,CAAC;AAC1D,OAAO,EAAC,4BAA4B,EAAC,MAAM,oEAAoE,CAAC;AAChH,OAAO,EAAC,yBAAyB,EAAC,MAAM,8DAA8D,CAAC;AAEvG,MAAM,+BAA+B,GAAwB;IAC3D,QAAQ,EAAE,eAAe;IACzB,4BAA4B,EAAE,kCAAkC;IAChE,gBAAgB,EAAE,gCAAgC;IAClD,+BAA+B,EAAE;QAC/B,oBAAoB,EAAE,yBAAyB;QAC/C,uBAAuB,EAAE,4BAA4B;KACtD;IACD,kBAAkB,EAAE;QAClB,EAAE,EAAE;YACF,KAAK,EAAE,gBAAgB;YACvB,oBAAoB,EAAE,sBAAsB;YAC5C,uBAAuB,EAAE,qBAAqB;YAC9C,WAAW,EAAE,qCAAqC;YAClD,kBAAkB,EAAE,kBAAkB;YACtC,yBAAyB,EACrB,gIAAgI;YACpI,8BAA8B,EAC1B,gIAAgI;YACpI,2BAA2B,EACvB,kKAAkK;YACtK,eAAe,EAAE,eAAe;YAChC,sBAAsB,EAAE,sDAAsD;YAC9E,mBAAmB,EAAE,qBAAqB;YAC1C,0BAA0B,EAAE,qEAAqE;SAClG;QACD,EAAE,EAAE;YACF,KAAK,EAAE,gBAAgB;YACvB,oBAAoB,EAAE,oBAAoB;YAC1C,uBAAuB,EAAE,oCAAoC;YAC7D,WAAW,EAAE,wCAAwC;YACrD,kBAAkB,EAAE,oBAAoB;YACxC,yBAAyB,EACrB,+HAA+H;YACnI,8BAA8B,EAC1B,uQAAuQ;YAC3Q,2BAA2B,EACvB,0IAA0I;YAC9I,eAAe,EAAE,eAAe;YAChC,sBAAsB,EAAE,oDAAoD;YAC5E,mBAAmB,EAAE,uBAAuB;YAC5C,0BAA0B,EAAE,iEAAiE;SAC9F;QACD,EAAE,EAAE;YACF,KAAK,EAAE,eAAe;YACtB,oBAAoB,EAAE,uBAAuB;YAC7C,uBAAuB,EAAE,wBAAwB;YACjD,WAAW,EAAE,6CAA6C;YAC1D,kBAAkB,EAAE,oBAAoB;YACxC,yBAAyB,EACrB,gIAAgI;YACpI,8BAA8B,EAC1B,qIAAqI;YACzI,2BAA2B,EACvB,6JAA6J;YACjK,eAAe,EAAE,cAAc;YAC/B,sBAAsB,EAAE,uDAAuD;YAC/E,mBAAmB,EAAE,sBAAsB;YAC3C,0BAA0B,EAAE,2EAA2E;SACxG;KACF;CACF,CAAC;AAEF,OAAO,EAAC,+BAA+B,EAAC,CAAC","sourcesContent":["/*\n * Copyright 2015-2022 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {PluginSpecification} from '@valtimo/plugin';\nimport {MailTemplateConfigurationComponent} from './components/mail-template-configuration/mail-template-configuration.component';\nimport {MAIL_TEMPLATE_PLUGIN_LOGO_BASE64} from './assets';\nimport {GenerateMailContentComponent} from './components/generate-mail-content/generate-mail-content.component';\nimport {GenerateMailFileComponent} from './components/generate-mail-file/generate-mail-file.component';\n\nconst mailTemplatePluginSpecification: PluginSpecification = {\n  pluginId: 'mail-template',\n  pluginConfigurationComponent: MailTemplateConfigurationComponent,\n  pluginLogoBase64: MAIL_TEMPLATE_PLUGIN_LOGO_BASE64,\n  functionConfigurationComponents: {\n    'generate-mail-file': GenerateMailFileComponent,\n    'generate-mail-content': GenerateMailContentComponent,\n  },\n  pluginTranslations: {\n    nl: {\n      title: 'Mail sjablonen',\n      'generate-mail-file': 'Genereer Mailbestand',\n      'generate-mail-content': 'Genereer Mailinhoud',\n      description: 'Maak Mail sjablonen met Freemarker.',\n      configurationTitle: 'Configuratienaam',\n      configurationTitleTooltip:\n          'De naam van de huidige plug-in configuratie. Onder deze naam kan de configuratie worden gevonden in de rest van de applicatie.',\n      generateMailContentDescription:\n          'Deze actie genereert de inhoud van een mail op basis van een sjabloon. De mail tekst wordt opgeslagen in een Proces Variabele.',\n      generateMailFileDescription:\n          'Deze actie genereert de inhoud van een mail en slaat het resultaat op in een tijdelijk bestand. Het ID van het bestand wordt opgeslagen in een Proces Variabele.',\n      mailTemplateKey: 'Mail sjabloon',\n      mailTemplateKeyTooltip: 'Op bases van deze sjabloon wordt de mail gegenereerd',\n      processVariableName: 'Procesvariabelenaam',\n      processVariableNameTooltip: 'Het resultaat wordt opgeslagen in een procesvariabele met deze naam',\n    },\n    en: {\n      title: 'Mail Templates',\n      'generate-mail-file': 'Generate Mail File',\n      'generate-mail-content': 'Generate Mail Content (deprecated)',\n      description: 'Create mail templates with Freemarker.',\n      configurationTitle: 'Configuration Name',\n      configurationTitleTooltip:\n          'The name of the current plug-in configuration. The configuration can be found under this name in the rest of the application.',\n      generateMailContentDescription:\n          'This action generates the content of an mail based on a template. The mail text is then stored in a Process Variable. This action is deprecated because the mail text can be bigger than a Process Variable can store. Please use action \"Generate Mail File\" instead',\n      generateMailFileDescription:\n          'This action generates the content of an mail and saves the result in a temporary file. The file ID is then stored in a Process Variable.',\n      mailTemplateKey: 'Mail Template',\n      mailTemplateKeyTooltip: 'The mail will be generated based on this template.',\n      processVariableName: 'Process Variable Name',\n      processVariableNameTooltip: 'The result will be stored in a process variable with this name.',\n    },\n    de: {\n      title: 'Mail-Vorlagen',\n      'generate-mail-file': 'Mail-Datei generieren',\n      'generate-mail-content': 'Mail-Inhalt generieren',\n      description: 'Erstellen Sie Mail-Vorlagen mit Freemarker.',\n      configurationTitle: 'Konfigurationsname',\n      configurationTitleTooltip:\n          'Der Name der aktuellen Plug-in-Konfiguration. Unter diesem Namen kann die Konfiguration im Rest der Anwendung gefunden werden.',\n      generateMailContentDescription:\n          'Diese Aktion generiert den Inhalt einer Mail basierend auf einer Vorlage. Der Mail-Text wird in einer Prozessvariablen gespeichert.',\n      generateMailFileDescription:\n          'Diese Aktion generiert den Inhalt einer Mail und speichert das Ergebnis in einer temporären Datei. Die Datei-ID wird in einer Prozessvariablen gespeichert.',\n      mailTemplateKey: 'Mail-Vorlage',\n      mailTemplateKeyTooltip: 'Die Mail wird basierend auf dieser Vorlage generiert.',\n      processVariableName: 'Prozessvariablenname',\n      processVariableNameTooltip: 'Das Ergebnis wird in einer Prozessvariablen mit diesem Namen gespeichert.',\n    },\n  },\n};\n\nexport {mailTemplatePluginSpecification};\n"]}

package/esm2022/lib/plugins/mail-template/models/config.mjs

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2015-2022 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdmFsdGltby1wbHVnaW5zL2ZyZWVtYXJrZXIvc3JjL2xpYi9wbHVnaW5zL21haWwtdGVtcGxhdGUvbW9kZWxzL2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7R0FjRyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgMjAxNS0yMDIyIFJpdGVuc2UgQlYsIHRoZSBOZXRoZXJsYW5kcy5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciBFVVBMLCBWZXJzaW9uIDEuMiAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqIGh0dHBzOi8vam9pbnVwLmVjLmV1cm9wYS5ldS9jb2xsZWN0aW9uL2V1cGwvZXVwbC10ZXh0LWV1cGwtMTJcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgYmFzaXMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmltcG9ydCB7UGx1Z2luQ29uZmlndXJhdGlvbkRhdGF9IGZyb20gJ0B2YWx0aW1vL3BsdWdpbic7XG5cbmludGVyZmFjZSBNYWlsVGVtcGxhdGVDb25maWcgZXh0ZW5kcyBQbHVnaW5Db25maWd1cmF0aW9uRGF0YSB7XG59XG5cbmludGVyZmFjZSBHZW5lcmF0ZU1haWxDb250ZW50Q29uZmlnIHtcbiAgbWFpbFRlbXBsYXRlS2V5OiBzdHJpbmc7XG4gIHByb2Nlc3NWYXJpYWJsZU5hbWU6IHN0cmluZztcbn1cblxuaW50ZXJmYWNlIEdlbmVyYXRlTWFpbEZpbGVDb25maWcge1xuICBtYWlsVGVtcGxhdGVLZXk6IHN0cmluZztcbiAgcHJvY2Vzc1ZhcmlhYmxlTmFtZTogc3RyaW5nO1xufVxuXG5leHBvcnQge01haWxUZW1wbGF0ZUNvbmZpZywgR2VuZXJhdGVNYWlsQ29udGVudENvbmZpZywgR2VuZXJhdGVNYWlsRmlsZUNvbmZpZ307XG4iXX0=

package/esm2022/lib/plugins/mail-template/models/index.mjs

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2015-2022 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './config';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vLXBsdWdpbnMvZnJlZW1hcmtlci9zcmMvbGliL3BsdWdpbnMvbWFpbC10ZW1wbGF0ZS9tb2RlbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7O0dBY0c7QUFFSCxjQUFjLFVBQVUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgMjAxNS0yMDIyIFJpdGVuc2UgQlYsIHRoZSBOZXRoZXJsYW5kcy5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciBFVVBMLCBWZXJzaW9uIDEuMiAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqIGh0dHBzOi8vam9pbnVwLmVjLmV1cm9wYS5ldS9jb2xsZWN0aW9uL2V1cGwvZXVwbC10ZXh0LWV1cGwtMTJcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgYmFzaXMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vY29uZmlnJztcbiJdfQ==

package/esm2022/lib/plugins/text-template/assets/index.mjs

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2015-2022 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './text-template-plugin-logo';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vLXBsdWdpbnMvZnJlZW1hcmtlci9zcmMvbGliL3BsdWdpbnMvdGV4dC10ZW1wbGF0ZS9hc3NldHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7O0dBY0c7QUFFSCxjQUFjLDZCQUE2QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAyMDE1LTIwMjIgUml0ZW5zZSBCViwgdGhlIE5ldGhlcmxhbmRzLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIEVVUEwsIFZlcnNpb24gMS4yICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogaHR0cHM6Ly9qb2ludXAuZWMuZXVyb3BhLmV1L2NvbGxlY3Rpb24vZXVwbC9ldXBsLXRleHQtZXVwbC0xMlxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBiYXNpcyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi90ZXh0LXRlbXBsYXRlLXBsdWdpbi1sb2dvJztcbiJdfQ==

package/esm2022/lib/plugins/text-template/assets/text-template-plugin-logo.mjs

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2015-2022 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const TEXT_TEMPLATE_PLUGIN_LOGO_BASE64 = 'data:image/svg+xml;base64,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';
+export { TEXT_TEMPLATE_PLUGIN_LOGO_BASE64 };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/plugins/text-template/components/generate-text-file/generate-text-file.component.mjs

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2015-2022 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { BehaviorSubject, combineLatest, map, of, switchMap, take, tap } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@valtimo/components";
+import * as i2 from "@valtimo/document";
+import * as i3 from "../../../../services";
+import * as i4 from "@angular/common";
+import * as i5 from "carbon-components-angular";
+import * as i6 from "@valtimo/plugin";
+export class GenerateTextFileComponent {
+    constructor(modalService, documentService, templateService) {
+        this.modalService = modalService;
+        this.documentService = documentService;
+        this.templateService = templateService;
+        this.valid = new EventEmitter();
+        this.configuration = new EventEmitter();
+        this.formValue$ = new BehaviorSubject(null);
+        this.valid$ = new BehaviorSubject(false);
+        this.loading$ = new BehaviorSubject(true);
+        this.textTemplateItems$ = this.modalService.modalData$.pipe(switchMap(params => this.documentService.findProcessDocumentDefinitionsByProcessDefinitionKey(params?.processDefinitionKey)), switchMap(processDocumentDefinitions => combineLatest([
+            of({ content: [] }),
+            ...processDocumentDefinitions.map(processDocumentDefinition => this.templateService.getAllTextTemplates(processDocumentDefinition.id.documentDefinitionId.name)),
+        ])), map(results => {
+            return results
+                .flatMap(result => result.content)
+                .map(template => ({
+                id: template.key,
+                text: template.key,
+            }));
+        }), tap(() => {
+            this.loading$.next(false);
+        }));
+    }
+    ngOnInit() {
+        this.openSaveSubscription();
+    }
+    ngOnDestroy() {
+        this.saveSubscription?.unsubscribe();
+    }
+    formValueChange(formValue) {
+        this.formValue$.next(formValue);
+        this.handleValid(formValue);
+    }
+    handleValid(formValue) {
+        const valid = !!(formValue.textTemplateKey && formValue.processVariableName);
+        this.valid$.next(valid);
+        this.valid.emit(valid);
+    }
+    openSaveSubscription() {
+        this.saveSubscription = this.save$?.subscribe(save => {
+            combineLatest([this.formValue$, this.valid$])
+                .pipe(take(1))
+                .subscribe(([formValue, valid]) => {
+                if (valid) {
+                    this.configuration.emit(formValue);
+                }
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: GenerateTextFileComponent, deps: [{ token: i1.ModalService }, { token: i2.DocumentService }, { token: i3.FreemarkerTemplateManagementService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: GenerateTextFileComponent, selector: "valtimo-generate-text-file-configuration", inputs: { save$: "save$", disabled$: "disabled$", pluginId: "pluginId", prefillConfiguration$: "prefillConfiguration$" }, outputs: { valid: "valid", configuration: "configuration" }, ngImport: i0, template: "<!--\n  ~ Copyright 2015-2022 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<ng-container *ngIf=\"{\n    disabled: disabled$ | async,\n    prefill: prefillConfiguration$ ? (prefillConfiguration$ | async) : null,\n    textTemplateItems: textTemplateItems$ | async,\n    loading: loading$ | async,\n  } as obs\"\n>\n    <ng-container *ngIf=\"obs.loading === false; else loading\">\n        <v-paragraph [margin]=\"true\" [italic]=\"true\">\n            {{ 'generateTextFileDescription' | pluginTranslate: pluginId | async }}\n        </v-paragraph>\n        <v-form (valueChange)=\"formValueChange($event)\">\n            <v-select\n                    [items]=\"obs.textTemplateItems\"\n                    [margin]=\"true\"\n                    [widthInPx]=\"350\"\n                    name=\"textTemplateKey\"\n                    [title]=\"'textTemplateKey' | pluginTranslate: pluginId | async\"\n                    [disabled]=\"obs.disabled\"\n                    [defaultSelectionId]=\"obs.prefill?.textTemplateKey\"\n                    [required]=\"true\"\n                    [loading]=\"!obs.textTemplateItems\"\n                    [tooltip]=\"'textTemplateKeyTooltip' | pluginTranslate: pluginId | async\"\n            ></v-select>\n            <v-input\n                    name=\"processVariableName\"\n                    [title]=\"'processVariableName' | pluginTranslate: pluginId | async\"\n                    [margin]=\"true\"\n                    [defaultValue]=\"obs.prefill?.processVariableName || 'contentId'\"\n                    [disabled]=\"obs.disabled\"\n                    [tooltip]=\"'processVariableNameTooltip' | pluginTranslate: pluginId | async\"\n            ></v-input>\n        </v-form>\n    </ng-container>\n</ng-container>\n\n<ng-template #loading>\n    <div class=\"loading-container\">\n        <cds-loading></cds-loading>\n    </div>\n</ng-template>\n", dependencies: [{ kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i1.FormComponent, selector: "v-form", inputs: ["className"], outputs: ["valueChange"] }, { kind: "component", type: i1.ParagraphComponent, selector: "v-paragraph", inputs: ["center", "fullWidth", "margin", "italic", "loading", "dataTestId"] }, { kind: "component", type: i1.SelectComponent, selector: "v-select", inputs: ["items", "defaultSelection", "defaultSelectionId", "defaultSelectionIds", "disabled", "dropUp", "multiple", "margin", "widthInPx", "notFoundText", "clearAllText", "clearText", "name", "title", "titleTranslationKey", "clearSelectionSubject$", "tooltip", "required", "loading", "loadingText", "placeholder", "smallMargin", "carbonTheme", "appendInline", "dataTestId"], outputs: ["selectedChange"] }, { kind: "component", type: i1.InputComponent, selector: "v-input", inputs: ["name", "type", "title", "titleTranslationKey", "defaultValue", "widthPx", "fullWidth", "margin", "smallMargin", "disabled", "step", "min", "maxLength", "tooltip", "required", "hideNumberSpinBox", "smallLabel", "rows", "clear$", "carbonTheme", "placeholder", "dataTestId", "trim"], outputs: ["valueChange"] }, { kind: "component", type: i5.Loading, selector: "cds-loading, ibm-loading", inputs: ["title", "isActive", "size", "overlay"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }, { kind: "pipe", type: i6.PluginTranslatePipe, name: "pluginTranslate" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: GenerateTextFileComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'valtimo-generate-text-file-configuration', template: "<!--\n  ~ Copyright 2015-2022 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<ng-container *ngIf=\"{\n    disabled: disabled$ | async,\n    prefill: prefillConfiguration$ ? (prefillConfiguration$ | async) : null,\n    textTemplateItems: textTemplateItems$ | async,\n    loading: loading$ | async,\n  } as obs\"\n>\n    <ng-container *ngIf=\"obs.loading === false; else loading\">\n        <v-paragraph [margin]=\"true\" [italic]=\"true\">\n            {{ 'generateTextFileDescription' | pluginTranslate: pluginId | async }}\n        </v-paragraph>\n        <v-form (valueChange)=\"formValueChange($event)\">\n            <v-select\n                    [items]=\"obs.textTemplateItems\"\n                    [margin]=\"true\"\n                    [widthInPx]=\"350\"\n                    name=\"textTemplateKey\"\n                    [title]=\"'textTemplateKey' | pluginTranslate: pluginId | async\"\n                    [disabled]=\"obs.disabled\"\n                    [defaultSelectionId]=\"obs.prefill?.textTemplateKey\"\n                    [required]=\"true\"\n                    [loading]=\"!obs.textTemplateItems\"\n                    [tooltip]=\"'textTemplateKeyTooltip' | pluginTranslate: pluginId | async\"\n            ></v-select>\n            <v-input\n                    name=\"processVariableName\"\n                    [title]=\"'processVariableName' | pluginTranslate: pluginId | async\"\n                    [margin]=\"true\"\n                    [defaultValue]=\"obs.prefill?.processVariableName || 'contentId'\"\n                    [disabled]=\"obs.disabled\"\n                    [tooltip]=\"'processVariableNameTooltip' | pluginTranslate: pluginId | async\"\n            ></v-input>\n        </v-form>\n    </ng-container>\n</ng-container>\n\n<ng-template #loading>\n    <div class=\"loading-container\">\n        <cds-loading></cds-loading>\n    </div>\n</ng-template>\n" }]
+        }], ctorParameters: () => [{ type: i1.ModalService }, { type: i2.DocumentService }, { type: i3.FreemarkerTemplateManagementService }], propDecorators: { save$: [{
+                type: Input
+            }], disabled$: [{
+                type: Input
+            }], pluginId: [{
+                type: Input
+            }], prefillConfiguration$: [{
+                type: Input
+            }], valid: [{
+                type: Output
+            }], configuration: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generate-text-file.component.js","sourceRoot":"","sources":["../../../../../../../../../projects/valtimo-plugins/freemarker/src/lib/plugins/text-template/components/generate-text-file/generate-text-file.component.ts","../../../../../../../../../projects/valtimo-plugins/freemarker/src/lib/plugins/text-template/components/generate-text-file/generate-text-file.component.html"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2022 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {Component, EventEmitter, Input, OnDestroy, OnInit, Output} from '@angular/core';\nimport {FunctionConfigurationComponent} from '@valtimo/plugin';\nimport {BehaviorSubject, combineLatest, map, Observable, of, Subscription, switchMap, take, tap} from 'rxjs';\nimport {GenerateTextFileConfig} from '../../models';\nimport {FunctionConfigurationData} from '@valtimo/plugin/lib/models/plugin';\nimport {ModalService, SelectItem} from '@valtimo/components';\nimport {DocumentService} from '@valtimo/document';\nimport {FreemarkerTemplateManagementService} from '../../../../services';\n\n@Component({\n    selector: 'valtimo-generate-text-file-configuration',\n    templateUrl: './generate-text-file.component.html',\n})\nexport class GenerateTextFileComponent\n    implements FunctionConfigurationComponent, OnInit, OnDestroy {\n    @Input() save$!: Observable<void>;\n    @Input() disabled$!: Observable<boolean>;\n    @Input() pluginId!: string;\n    @Input() prefillConfiguration$!: Observable<GenerateTextFileConfig>;\n    @Output() valid: EventEmitter<boolean> = new EventEmitter<boolean>();\n    @Output() configuration: EventEmitter<FunctionConfigurationData> = new EventEmitter<FunctionConfigurationData>();\n\n    private saveSubscription!: Subscription;\n    private readonly formValue$ = new BehaviorSubject<GenerateTextFileConfig | null>(null);\n    private readonly valid$ = new BehaviorSubject<boolean>(false);\n\n    readonly loading$ = new BehaviorSubject<boolean>(true);\n\n    readonly textTemplateItems$: Observable<Array<SelectItem>> = this.modalService.modalData$.pipe(\n        switchMap(params =>\n            this.documentService.findProcessDocumentDefinitionsByProcessDefinitionKey(\n                params?.processDefinitionKey\n            )\n        ),\n        switchMap(processDocumentDefinitions =>\n            combineLatest([\n                of({content: []}),\n                ...processDocumentDefinitions.map(processDocumentDefinition =>\n                    this.templateService.getAllTextTemplates(\n                        processDocumentDefinition.id.documentDefinitionId.name\n                    )\n                ),\n            ])\n        ),\n        map(results => {\n            return results\n                .flatMap(result => result.content)\n                .map(template => ({\n                    id: template.key,\n                    text: template.key,\n                }));\n        }),\n        tap(() => {\n            this.loading$.next(false);\n        })\n    );\n\n    constructor(\n        private readonly modalService: ModalService,\n        private readonly documentService: DocumentService,\n        private readonly templateService: FreemarkerTemplateManagementService\n    ) {\n    }\n\n    ngOnInit(): void {\n        this.openSaveSubscription();\n    }\n\n    ngOnDestroy(): void {\n        this.saveSubscription?.unsubscribe();\n    }\n\n    formValueChange(formValue: GenerateTextFileConfig): void {\n        this.formValue$.next(formValue);\n        this.handleValid(formValue);\n    }\n\n    private handleValid(formValue: GenerateTextFileConfig): void {\n        const valid = !!(formValue.textTemplateKey && formValue.processVariableName);\n\n        this.valid$.next(valid);\n        this.valid.emit(valid);\n    }\n\n    private openSaveSubscription(): void {\n        this.saveSubscription = this.save$?.subscribe(save => {\n            combineLatest([this.formValue$, this.valid$])\n                .pipe(take(1))\n                .subscribe(([formValue, valid]) => {\n                    if (valid) {\n                        this.configuration.emit(formValue!);\n                    }\n                });\n        });\n    }\n}\n","<!--\n  ~ Copyright 2015-2022 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<ng-container *ngIf=\"{\n    disabled: disabled$ | async,\n    prefill: prefillConfiguration$ ? (prefillConfiguration$ | async) : null,\n    textTemplateItems: textTemplateItems$ | async,\n    loading: loading$ | async,\n  } as obs\"\n>\n    <ng-container *ngIf=\"obs.loading === false; else loading\">\n        <v-paragraph [margin]=\"true\" [italic]=\"true\">\n            {{ 'generateTextFileDescription' | pluginTranslate: pluginId | async }}\n        </v-paragraph>\n        <v-form (valueChange)=\"formValueChange($event)\">\n            <v-select\n                    [items]=\"obs.textTemplateItems\"\n                    [margin]=\"true\"\n                    [widthInPx]=\"350\"\n                    name=\"textTemplateKey\"\n                    [title]=\"'textTemplateKey' | pluginTranslate: pluginId | async\"\n                    [disabled]=\"obs.disabled\"\n                    [defaultSelectionId]=\"obs.prefill?.textTemplateKey\"\n                    [required]=\"true\"\n                    [loading]=\"!obs.textTemplateItems\"\n                    [tooltip]=\"'textTemplateKeyTooltip' | pluginTranslate: pluginId | async\"\n            ></v-select>\n            <v-input\n                    name=\"processVariableName\"\n                    [title]=\"'processVariableName' | pluginTranslate: pluginId | async\"\n                    [margin]=\"true\"\n                    [defaultValue]=\"obs.prefill?.processVariableName || 'contentId'\"\n                    [disabled]=\"obs.disabled\"\n                    [tooltip]=\"'processVariableNameTooltip' | pluginTranslate: pluginId | async\"\n            ></v-input>\n        </v-form>\n    </ng-container>\n</ng-container>\n\n<ng-template #loading>\n    <div class=\"loading-container\">\n        <cds-loading></cds-loading>\n    </div>\n</ng-template>\n"]}