@valtimo/process-link 12.0.0

package/esm2022/lib/process-link.module.mjs

@@ -0,0 +1,169 @@
+/*
+ * Copyright 2015-2024 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 { FormLinkProcessDiagramComponent } from './components/form-link-process-diagram/form-link-process-diagram.component';
+import { CommonModule } from '@angular/common';
+import { ProcessLinkRoutingModule } from './process-link-routing.module';
+import { FormsModule } from '@angular/forms';
+import { ButtonModule, FormIoModule, ModalModule, ParagraphModule, RenderInPageHeaderDirectiveModule, SearchableDropdownSelectModule, StepperModule, TitleModule, TooltipIconModule, TooltipModule, ValtimoCdsModalDirectiveModule, VCardModule, VModalModule, } from '@valtimo/components';
+import { TranslateModule } from '@ngx-translate/core';
+import { SelectPluginConfigurationComponent } from './components/select-plugin-configuration/select-plugin-configuration.component';
+import { SelectPluginActionComponent } from './components/select-plugin-action/select-plugin-action.component';
+import { PluginConfigurationContainerModule, PluginTranslatePipeModule } from '@valtimo/plugin';
+import { PluginActionConfigurationComponent } from './components/plugin-action-configuration/plugin-action-configuration.component';
+import { ProcessLinkComponent } from './components/process-link/process-link.component';
+import { ProcessLinkModalComponent } from './components/process-link-modal/process-link-modal.component';
+import { ButtonModule as CarbonButtonModule, ComboBoxModule, IconModule, InputModule, LoadingModule, ModalModule as CarbonModalModule, ProgressIndicatorModule, SelectModule, StructuredListModule, TilesModule, } from 'carbon-components-angular';
+import { ChooseProcessLinkTypeComponent } from './components/choose-process-link-type';
+import { SelectFormComponent } from './components/select-form';
+import { FormFlowComponent } from './components/form-flow/form-flow.component';
+import { SelectFormFlowComponent } from './components/select-form-flow';
+import { FormFlowConfigurationContainerComponent } from './components/form-flow-configuration-container';
+import * as i0 from "@angular/core";
+export class ProcessLinkModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ProcessLinkModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.3", ngImport: i0, type: ProcessLinkModule, declarations: [ProcessLinkComponent,
+            FormLinkProcessDiagramComponent,
+            SelectPluginConfigurationComponent,
+            SelectPluginActionComponent,
+            PluginActionConfigurationComponent,
+            ProcessLinkModalComponent,
+            ChooseProcessLinkTypeComponent,
+            SelectFormComponent,
+            FormFlowComponent,
+            SelectFormFlowComponent,
+            FormFlowConfigurationContainerComponent], imports: [CommonModule,
+            ProcessLinkRoutingModule,
+            FormsModule,
+            ModalModule,
+            SearchableDropdownSelectModule,
+            TranslateModule,
+            StepperModule,
+            VModalModule,
+            VCardModule,
+            PluginTranslatePipeModule,
+            ParagraphModule,
+            PluginConfigurationContainerModule,
+            ButtonModule,
+            TitleModule,
+            CarbonModalModule,
+            ProgressIndicatorModule,
+            CarbonButtonModule,
+            IconModule,
+            TooltipModule,
+            ComboBoxModule,
+            InputModule,
+            TooltipIconModule,
+            LoadingModule,
+            FormIoModule,
+            ValtimoCdsModalDirectiveModule,
+            StructuredListModule,
+            TilesModule,
+            RenderInPageHeaderDirectiveModule,
+            SelectModule], exports: [ProcessLinkComponent,
+            SelectPluginConfigurationComponent,
+            SelectPluginActionComponent,
+            PluginActionConfigurationComponent,
+            ProcessLinkModalComponent,
+            FormFlowComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ProcessLinkModule, imports: [CommonModule,
+            ProcessLinkRoutingModule,
+            FormsModule,
+            ModalModule,
+            SearchableDropdownSelectModule,
+            TranslateModule,
+            StepperModule,
+            VModalModule,
+            VCardModule,
+            PluginTranslatePipeModule,
+            ParagraphModule,
+            PluginConfigurationContainerModule,
+            ButtonModule,
+            TitleModule,
+            CarbonModalModule,
+            ProgressIndicatorModule,
+            CarbonButtonModule,
+            IconModule,
+            TooltipModule,
+            ComboBoxModule,
+            InputModule,
+            TooltipIconModule,
+            LoadingModule,
+            FormIoModule,
+            ValtimoCdsModalDirectiveModule,
+            StructuredListModule,
+            TilesModule,
+            RenderInPageHeaderDirectiveModule,
+            SelectModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ProcessLinkModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ProcessLinkComponent,
+                        FormLinkProcessDiagramComponent,
+                        SelectPluginConfigurationComponent,
+                        SelectPluginActionComponent,
+                        PluginActionConfigurationComponent,
+                        ProcessLinkModalComponent,
+                        ChooseProcessLinkTypeComponent,
+                        SelectFormComponent,
+                        FormFlowComponent,
+                        SelectFormFlowComponent,
+                        FormFlowConfigurationContainerComponent,
+                    ],
+                    imports: [
+                        CommonModule,
+                        ProcessLinkRoutingModule,
+                        FormsModule,
+                        ModalModule,
+                        SearchableDropdownSelectModule,
+                        TranslateModule,
+                        StepperModule,
+                        VModalModule,
+                        VCardModule,
+                        PluginTranslatePipeModule,
+                        ParagraphModule,
+                        PluginConfigurationContainerModule,
+                        ButtonModule,
+                        TitleModule,
+                        CarbonModalModule,
+                        ProgressIndicatorModule,
+                        CarbonButtonModule,
+                        IconModule,
+                        TooltipModule,
+                        ComboBoxModule,
+                        InputModule,
+                        TooltipIconModule,
+                        LoadingModule,
+                        FormIoModule,
+                        ValtimoCdsModalDirectiveModule,
+                        StructuredListModule,
+                        TilesModule,
+                        RenderInPageHeaderDirectiveModule,
+                        SelectModule,
+                    ],
+                    exports: [
+                        ProcessLinkComponent,
+                        SelectPluginConfigurationComponent,
+                        SelectPluginActionComponent,
+                        PluginActionConfigurationComponent,
+                        ProcessLinkModalComponent,
+                        FormFlowComponent,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"process-link.module.js","sourceRoot":"","sources":["../../../../../projects/valtimo/process-link/src/lib/process-link.module.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2024 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 {FormLinkProcessDiagramComponent} from './components/form-link-process-diagram/form-link-process-diagram.component';\nimport {CommonModule} from '@angular/common';\nimport {ProcessLinkRoutingModule} from './process-link-routing.module';\nimport {FormsModule} from '@angular/forms';\nimport {\n  ButtonModule,\n  FormIoModule,\n  ModalModule,\n  ParagraphModule,\n  RenderInPageHeaderDirectiveModule,\n  SearchableDropdownSelectModule,\n  StepperModule,\n  TitleModule,\n  TooltipIconModule,\n  TooltipModule,\n  ValtimoCdsModalDirectiveModule,\n  VCardModule,\n  VModalModule,\n} from '@valtimo/components';\nimport {TranslateModule} from '@ngx-translate/core';\nimport {SelectPluginConfigurationComponent} from './components/select-plugin-configuration/select-plugin-configuration.component';\nimport {SelectPluginActionComponent} from './components/select-plugin-action/select-plugin-action.component';\nimport {PluginConfigurationContainerModule, PluginTranslatePipeModule} from '@valtimo/plugin';\nimport {PluginActionConfigurationComponent} from './components/plugin-action-configuration/plugin-action-configuration.component';\nimport {ProcessLinkComponent} from './components/process-link/process-link.component';\nimport {ProcessLinkModalComponent} from './components/process-link-modal/process-link-modal.component';\nimport {\n  ButtonModule as CarbonButtonModule,\n  ComboBoxModule,\n  IconModule,\n  InputModule,\n  LoadingModule,\n  ModalModule as CarbonModalModule,\n  ProgressIndicatorModule,\n  SelectModule,\n  StructuredListModule,\n  TilesModule,\n} from 'carbon-components-angular';\nimport {ChooseProcessLinkTypeComponent} from './components/choose-process-link-type';\nimport {SelectFormComponent} from './components/select-form';\nimport {FormFlowComponent} from './components/form-flow/form-flow.component';\nimport {SelectFormFlowComponent} from './components/select-form-flow';\nimport {FormFlowConfigurationContainerComponent} from './components/form-flow-configuration-container';\n\n@NgModule({\n  declarations: [\n    ProcessLinkComponent,\n    FormLinkProcessDiagramComponent,\n    SelectPluginConfigurationComponent,\n    SelectPluginActionComponent,\n    PluginActionConfigurationComponent,\n    ProcessLinkModalComponent,\n    ChooseProcessLinkTypeComponent,\n    SelectFormComponent,\n    FormFlowComponent,\n    SelectFormFlowComponent,\n    FormFlowConfigurationContainerComponent,\n  ],\n  imports: [\n    CommonModule,\n    ProcessLinkRoutingModule,\n    FormsModule,\n    ModalModule,\n    SearchableDropdownSelectModule,\n    TranslateModule,\n    StepperModule,\n    VModalModule,\n    VCardModule,\n    PluginTranslatePipeModule,\n    ParagraphModule,\n    PluginConfigurationContainerModule,\n    ButtonModule,\n    TitleModule,\n    CarbonModalModule,\n    ProgressIndicatorModule,\n    CarbonButtonModule,\n    IconModule,\n    TooltipModule,\n    ComboBoxModule,\n    InputModule,\n    TooltipIconModule,\n    LoadingModule,\n    FormIoModule,\n    ValtimoCdsModalDirectiveModule,\n    StructuredListModule,\n    TilesModule,\n    RenderInPageHeaderDirectiveModule,\n    SelectModule,\n  ],\n  exports: [\n    ProcessLinkComponent,\n    SelectPluginConfigurationComponent,\n    SelectPluginActionComponent,\n    PluginActionConfigurationComponent,\n    ProcessLinkModalComponent,\n    FormFlowComponent,\n  ],\n})\nexport class ProcessLinkModule {}\n"]}

package/esm2022/lib/services/form-flow-component.service.mjs

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2015-2024 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 { Inject, Injectable } from '@angular/core';
+import { BehaviorSubject, filter } from 'rxjs';
+import { FORM_FLOW_COMPONENT_TOKEN } from '../constants';
+import * as i0 from "@angular/core";
+export class FormFlowComponentService {
+    get supportedComponents$() {
+        return this._supportedComponents$.pipe(filter(components => !!components));
+    }
+    constructor(supportedCustomComponents) {
+        this.supportedCustomComponents = supportedCustomComponents;
+        this._supportedComponents$ = new BehaviorSubject(null);
+        this.setSupportedComponents(supportedCustomComponents);
+    }
+    setSupportedComponents(supportedComponents) {
+        this._supportedComponents$.next(supportedComponents);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: FormFlowComponentService, deps: [{ token: FORM_FLOW_COMPONENT_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: FormFlowComponentService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: FormFlowComponentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: Array, decorators: [{
+                    type: Inject,
+                    args: [FORM_FLOW_COMPONENT_TOKEN]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/form-flow.service.mjs

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2015-2024 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 { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@valtimo/config";
+export class FormFlowService {
+    constructor(http, configService) {
+        this.http = http;
+        this.configService = configService;
+        this.valtimoEndpointUri = configService.config.valtimoApi.endpointUri;
+    }
+    getFormFlowDefinitions() {
+        return this.http.get(`${this.valtimoEndpointUri}v1/form-flow/definition`);
+    }
+    createInstanceForNewProcess(processDefinitionKey, request) {
+        return this.http.post(`${this.valtimoEndpointUri}v1/process-definition/${processDefinitionKey}/form-flow`, request);
+    }
+    getFormFlowStep(formFlowInstanceId) {
+        return this.http.get(`${this.valtimoEndpointUri}v1/form-flow/instance/${formFlowInstanceId}`);
+    }
+    submitStep(formFlowInstanceId, stepInstanceId, submissionData) {
+        return this.http.post(`${this.valtimoEndpointUri}v1/form-flow/instance/${formFlowInstanceId}/step/instance/${stepInstanceId}`, submissionData);
+    }
+    back(formFlowInstanceId, submissionData) {
+        return this.http.post(`${this.valtimoEndpointUri}v1/form-flow/instance/${formFlowInstanceId}/back`, submissionData);
+    }
+    save(formFlowInstanceId, submissionData) {
+        return this.http.post(`${this.valtimoEndpointUri}v1/form-flow/instance/${formFlowInstanceId}/save`, submissionData);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: FormFlowService, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: FormFlowService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: FormFlowService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.ConfigService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/index.mjs

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2015-2024 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 './form-flow.service';
+export * from './plugin-state.service';
+export * from './process-link.service';
+export * from './process-link-state.service';
+export * from './process-link-step.service';
+export * from './process-link-button.service';
+export * from './form-flow-component.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL3Byb2Nlc3MtbGluay9zcmMvbGliL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBRUgsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYywrQkFBK0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgMjAxNS0yMDI0IFJpdGVuc2UgQlYsIHRoZSBOZXRoZXJsYW5kcy5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciBFVVBMLCBWZXJzaW9uIDEuMiAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqIGh0dHBzOi8vam9pbnVwLmVjLmV1cm9wYS5ldS9jb2xsZWN0aW9uL2V1cGwvZXVwbC10ZXh0LWV1cGwtMTJcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgYmFzaXMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vZm9ybS1mbG93LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9wbHVnaW4tc3RhdGUuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3Byb2Nlc3MtbGluay5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvY2Vzcy1saW5rLXN0YXRlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9wcm9jZXNzLWxpbmstc3RlcC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvY2Vzcy1saW5rLWJ1dHRvbi5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybS1mbG93LWNvbXBvbmVudC5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/lib/services/plugin-state.service.mjs

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2015-2024 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 { Injectable } from '@angular/core';
+import { BehaviorSubject, combineLatest, of, Subject, switchMap } from 'rxjs';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@valtimo/plugin";
+export class PluginStateService {
+    constructor(pluginManagementService, pluginService) {
+        this.pluginManagementService = pluginManagementService;
+        this.pluginService = pluginService;
+        this._selectedPluginDefinition$ = new BehaviorSubject(undefined);
+        this._selectedPluginConfiguration$ = new BehaviorSubject(undefined);
+        this._selectedPluginFunction$ = new BehaviorSubject(undefined);
+        this._save$ = new Subject();
+        this._selectedProcessLink$ = new BehaviorSubject(undefined);
+    }
+    get selectedPluginDefinition$() {
+        return this._selectedPluginDefinition$.asObservable();
+    }
+    get selectedPluginConfiguration$() {
+        return this._selectedPluginConfiguration$.asObservable();
+    }
+    get selectedPluginFunction$() {
+        return this._selectedPluginFunction$.asObservable();
+    }
+    get save$() {
+        return this._save$.asObservable();
+    }
+    get functionKey$() {
+        return this._selectedProcessLink$.pipe(switchMap(processLink => !processLink
+            ? this._selectedPluginFunction$.pipe(map(pluginFunction => pluginFunction?.key))
+            : of(processLink?.pluginActionDefinitionKey)));
+    }
+    get pluginDefinitionKey$() {
+        return this._selectedProcessLink$.pipe(switchMap(selectedProcesLink => !selectedProcesLink
+            ? this._selectedPluginConfiguration$.pipe(map(configuration => configuration?.pluginDefinition.key))
+            : combineLatest([
+                this._selectedProcessLink$,
+                this.pluginService.pluginSpecifications$,
+            ]).pipe(map(([processLink, pluginSpecifications]) => {
+                const pluginSpecification = pluginSpecifications.find(specification => {
+                    const functionKeys = specification?.functionConfigurationComponents &&
+                        Object.keys(specification.functionConfigurationComponents);
+                    return functionKeys?.includes(processLink?.pluginActionDefinitionKey);
+                });
+                return pluginSpecification?.pluginId;
+            }))));
+    }
+    selectPluginDefinition(definition) {
+        this._selectedPluginDefinition$.next(definition);
+    }
+    selectPluginConfiguration(configuration) {
+        this._selectedPluginConfiguration$.next(configuration);
+    }
+    selectPluginFunction(pluginFunction) {
+        this._selectedPluginFunction$.next(pluginFunction);
+    }
+    selectProcessLink(processLink) {
+        this._selectedProcessLink$.next(processLink);
+    }
+    deselectProcessLink() {
+        this._selectedProcessLink$.next(undefined);
+    }
+    save() {
+        this._save$.next(null);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PluginStateService, deps: [{ token: i1.PluginManagementService }, { token: i1.PluginService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PluginStateService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PluginStateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.PluginManagementService }, { type: i1.PluginService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-state.service.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/process-link/src/lib/services/plugin-state.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2024 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 {Injectable} from '@angular/core';\nimport {BehaviorSubject, combineLatest, Observable, of, Subject, switchMap} from 'rxjs';\nimport {map} from 'rxjs/operators';\nimport {\n  PluginConfiguration,\n  PluginDefinition,\n  PluginFunction,\n  PluginManagementService,\n  PluginService,\n} from '@valtimo/plugin';\nimport {ProcessLink} from '../models';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class PluginStateService {\n  private readonly _selectedPluginDefinition$ = new BehaviorSubject<PluginDefinition>(undefined);\n  private readonly _selectedPluginConfiguration$ = new BehaviorSubject<PluginConfiguration>(\n    undefined\n  );\n  private readonly _selectedPluginFunction$ = new BehaviorSubject<PluginFunction>(undefined);\n  private readonly _save$ = new Subject<null>();\n  private readonly _selectedProcessLink$ = new BehaviorSubject<ProcessLink>(undefined);\n\n  constructor(\n    private readonly pluginManagementService: PluginManagementService,\n    private readonly pluginService: PluginService\n  ) {}\n\n  get selectedPluginDefinition$(): Observable<PluginDefinition> {\n    return this._selectedPluginDefinition$.asObservable();\n  }\n\n  get selectedPluginConfiguration$(): Observable<PluginConfiguration> {\n    return this._selectedPluginConfiguration$.asObservable();\n  }\n\n  get selectedPluginFunction$(): Observable<PluginFunction> {\n    return this._selectedPluginFunction$.asObservable();\n  }\n\n  get save$(): Observable<any> {\n    return this._save$.asObservable();\n  }\n\n  get functionKey$(): Observable<string> {\n    return this._selectedProcessLink$.pipe(\n      switchMap(processLink =>\n        !processLink\n          ? this._selectedPluginFunction$.pipe(map(pluginFunction => pluginFunction?.key))\n          : of(processLink?.pluginActionDefinitionKey)\n      )\n    );\n  }\n\n  get pluginDefinitionKey$(): Observable<string> {\n    return this._selectedProcessLink$.pipe(\n      switchMap(selectedProcesLink =>\n        !selectedProcesLink\n          ? this._selectedPluginConfiguration$.pipe(\n              map(configuration => configuration?.pluginDefinition.key)\n            )\n          : combineLatest([\n              this._selectedProcessLink$,\n              this.pluginService.pluginSpecifications$,\n            ]).pipe(\n              map(([processLink, pluginSpecifications]) => {\n                const pluginSpecification = pluginSpecifications.find(specification => {\n                  const functionKeys =\n                    specification?.functionConfigurationComponents &&\n                    Object.keys(specification.functionConfigurationComponents);\n                  return functionKeys?.includes(processLink?.pluginActionDefinitionKey);\n                });\n\n                return pluginSpecification?.pluginId;\n              })\n            )\n      )\n    );\n  }\n\n  selectPluginDefinition(definition: PluginDefinition): void {\n    this._selectedPluginDefinition$.next(definition);\n  }\n\n  selectPluginConfiguration(configuration: PluginConfiguration): void {\n    this._selectedPluginConfiguration$.next(configuration);\n  }\n\n  selectPluginFunction(pluginFunction: PluginFunction): void {\n    this._selectedPluginFunction$.next(pluginFunction);\n  }\n\n  selectProcessLink(processLink: ProcessLink): void {\n    this._selectedProcessLink$.next(processLink);\n  }\n\n  deselectProcessLink(): void {\n    this._selectedProcessLink$.next(undefined);\n  }\n\n  save(): void {\n    this._save$.next(null);\n  }\n}\n"]}

package/esm2022/lib/services/process-link-button.service.mjs

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2015-2024 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 { Injectable } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class ProcessLinkButtonService {
+    constructor() {
+        this._showSaveButton$ = new BehaviorSubject(false);
+        this._enableSaveButton$ = new BehaviorSubject(false);
+        this._enableNextButton$ = new BehaviorSubject(false);
+        this._showBackButton$ = new BehaviorSubject(false);
+        this._showNextButton$ = new BehaviorSubject(false);
+        this._backButtonClick$ = new Subject();
+        this._saveButtonClick$ = new Subject();
+        this._nextButtonClick$ = new Subject();
+    }
+    get showSaveButton$() {
+        return this._showSaveButton$.asObservable();
+    }
+    get enableSaveButton$() {
+        return this._enableSaveButton$.asObservable();
+    }
+    get showNextButton$() {
+        return this._showNextButton$.asObservable();
+    }
+    get enableNextButton$() {
+        return this._enableNextButton$.asObservable();
+    }
+    get showBackButton$() {
+        return this._showBackButton$.asObservable();
+    }
+    get backButtonClick$() {
+        return this._backButtonClick$.asObservable();
+    }
+    get saveButtonClick$() {
+        return this._saveButtonClick$.asObservable();
+    }
+    get nextButtonClick$() {
+        return this._nextButtonClick$.asObservable();
+    }
+    showSaveButton() {
+        this._showSaveButton$.next(true);
+    }
+    hideSaveButton() {
+        this._showSaveButton$.next(false);
+    }
+    showNextButton() {
+        this._showNextButton$.next(true);
+    }
+    hideNextButton() {
+        this._showNextButton$.next(false);
+    }
+    enableNextButton() {
+        this._enableNextButton$.next(true);
+    }
+    disableNextButton() {
+        this._enableNextButton$.next(false);
+    }
+    enableSaveButton() {
+        this._enableSaveButton$.next(true);
+    }
+    disableSaveButton() {
+        this._enableSaveButton$.next(false);
+    }
+    showBackButton() {
+        this._showBackButton$.next(true);
+    }
+    hideBackButton() {
+        this._showBackButton$.next(false);
+    }
+    clickBackButton() {
+        this._backButtonClick$.next(null);
+    }
+    clickSaveButton() {
+        this._saveButtonClick$.next(null);
+    }
+    clickNextButton() {
+        this._nextButtonClick$.next(null);
+    }
+    resetButtons() {
+        this.disableSaveButton();
+        this.hideBackButton();
+        this.hideSaveButton();
+        this.hideNextButton();
+        this.disableNextButton();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ProcessLinkButtonService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ProcessLinkButtonService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ProcessLinkButtonService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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