@valtimo/form-view-model 12.1.0

package/esm2022/lib/components/form-view-model/form-view-model.component.mjs

@@ -0,0 +1,282 @@
+/*
+ * 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 { Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import moment from 'moment';
+import { BehaviorSubject, catchError, combineLatest, debounceTime, EMPTY, filter, of, pairwise, switchMap, take, tap, } from 'rxjs';
+import { FormioModule, } from '@formio/angular';
+import { distinctUntilChanged, map } from 'rxjs/operators';
+import { deepmerge } from 'deepmerge-ts';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services";
+import * as i2 from "@ngx-translate/core";
+import * as i3 from "@valtimo/components";
+import * as i4 from "@angular/common";
+import * as i5 from "@formio/angular";
+moment.defaultFormat = 'DD MMM YYYY HH:mm';
+export class FormViewModelComponent {
+    set options(optionsValue) {
+        this.options$.next(optionsValue);
+    }
+    set submission(submissionValue) {
+        this.submission$.next(submissionValue);
+    }
+    set form(formValue) {
+        const instance = this;
+        const form = {
+            loadInitialViewModel: () => instance.loadInitialViewModel(),
+            updateViewModel: () => instance.updateViewModel(),
+            ...formValue,
+        };
+        this.form$.next(form);
+    }
+    set formName(formName) {
+        this.formName$.next(formName);
+    }
+    set taskInstanceId(taskInstanceId) {
+        this.taskInstanceId$.next(taskInstanceId);
+    }
+    set readOnly(readOnlyValue) {
+        this.readOnly$.next(readOnlyValue);
+    }
+    set isStartForm(isStartFormValue) {
+        this.isStartForm$.next(isStartFormValue);
+    }
+    set processDefinitionKey(processDefinitionKeyValue) {
+        this.processDefinitionKey$.next(processDefinitionKeyValue);
+    }
+    set documentDefinitionName(documentDefinitionNameValue) {
+        this.documentDefinitionName$.next(documentDefinitionNameValue);
+    }
+    constructor(viewModelService, translateService, stateService) {
+        this.viewModelService = viewModelService;
+        this.translateService = translateService;
+        this.stateService = stateService;
+        this.formSubmit = new EventEmitter();
+        this.refreshForm = new EventEmitter();
+        this.submission$ = new BehaviorSubject({});
+        this.form$ = new BehaviorSubject(undefined);
+        this.formName$ = new BehaviorSubject(undefined);
+        this.options$ = new BehaviorSubject(undefined);
+        this.taskInstanceId$ = new BehaviorSubject(undefined);
+        this.readOnly$ = new BehaviorSubject(false);
+        this.tokenSetInLocalStorage$ = new BehaviorSubject(false);
+        this.change$ = new BehaviorSubject(null);
+        this.errors$ = new BehaviorSubject([]);
+        this.loading$ = new BehaviorSubject(true);
+        this.isStartForm$ = new BehaviorSubject(false);
+        this.processDefinitionKey$ = new BehaviorSubject(undefined);
+        this.documentDefinitionName$ = new BehaviorSubject(undefined);
+        this.currentLanguage$ = this.translateService.stream('key').pipe(map(() => this.translateService.currentLang), distinctUntilChanged());
+        this._overrideOptions$ = new BehaviorSubject({
+            hooks: {
+                beforeSubmit: this.beforeSubmitHook(this),
+            },
+        });
+        this.formioOptions$ = combineLatest([
+            this.currentLanguage$,
+            this.options$,
+            this._overrideOptions$,
+        ]).pipe(map(([language, options, overrideOptions]) => {
+            const formioTranslations = this.translateService.instant('formioTranslations');
+            const defaultOptions = {
+                ...options,
+                language,
+                ...(formioTranslations === 'object' && {
+                    i18n: {
+                        [language]: this.stateService.flattenTranslationsObject(formioTranslations),
+                    },
+                }),
+            };
+            return deepmerge(defaultOptions, overrideOptions);
+        }));
+    }
+    ngOnInit() {
+        if (this.isStartForm$.value) {
+            this.loadInitialViewModelForStartForm();
+        }
+        else {
+            this.loadInitialViewModel();
+        }
+    }
+    beforeSubmitHook(instance) {
+        return (submission, callback) => instance.beforeSubmit(submission, callback);
+    }
+    beforeSubmit(submission, callback) {
+        combineLatest([
+            this.formName$,
+            this.taskInstanceId$,
+            this.processDefinitionKey$,
+            this.documentDefinitionName$,
+            this.isStartForm$,
+        ])
+            .pipe(take(1), switchMap(([formName, taskInstanceId, processDefinitionKey, documentDefinitionName, isStartForm,]) => isStartForm
+            ? this.viewModelService
+                .submitViewModelForStartForm(formName, processDefinitionKey, documentDefinitionName, submission.data)
+                .pipe(take(1), switchMap(response => {
+                callback(null, submission);
+                return of(response);
+            }), catchError(error => {
+                this.handleFormError(error);
+                callback({ message: error.error.error, component: null }, null);
+                return EMPTY; // return an empty observable to complete the stream
+            }))
+            : this.viewModelService
+                .submitViewModel(formName, taskInstanceId, submission.data)
+                .pipe(take(1), switchMap(response => {
+                callback(null, submission);
+                return of(response);
+            }), catchError(error => {
+                this.handleFormError(error);
+                callback({ message: error.error.error, component: null }, null);
+                return EMPTY; // return an empty observable to complete the stream
+            }))))
+            .subscribe();
+    }
+    handleFormError(error) {
+        const formInstance = this.formio.formio;
+        const component = formInstance.getComponent(error.error?.component);
+        const submitComponent = formInstance.getComponent('submit');
+        if (component == null) {
+            this.errors$.next([error.error.error]);
+        }
+        else {
+            component?.setCustomValidity(error.error.error);
+            submitComponent.disabled = true;
+        }
+    }
+    onSubmit(submission) {
+        this.formSubmit.next(submission);
+    }
+    onChange(object) {
+        if (object.data) {
+            this.change$.next(object);
+        }
+        if (object.changed) {
+            this.handleChanges();
+        }
+    }
+    loadInitialViewModel() {
+        combineLatest([this.formName$, this.taskInstanceId$])
+            .pipe(take(1), switchMap(([formName, taskInstanceId]) => this.viewModelService.getViewModel(formName, taskInstanceId).pipe(tap(viewModel => {
+            this.submission$.next({ data: viewModel });
+            this.change$.pipe(take(1)).subscribe(() => {
+                this.loading$.next(false);
+            });
+        }))))
+            .subscribe();
+    }
+    updateViewModel() {
+        this.loading$
+            .pipe(take(1), switchMap(updating => {
+            if (!updating) {
+                this.loading$.next(true);
+                return combineLatest([this.formName$, this.taskInstanceId$, this.change$]).pipe(take(1), switchMap(([formName, taskInstanceId, change]) => this.viewModelService.updateViewModel(formName, taskInstanceId, change.data).pipe(tap({
+                    next: viewModel => {
+                        this.submission$.next({ data: viewModel });
+                        this.loading$.next(false);
+                        this.errors$.next([]);
+                    },
+                    error: error => {
+                        this.loading$.next(false);
+                        this.handleFormError(error);
+                    },
+                }))));
+            }
+            return of(null); // Fallback to return an observable if updating is true
+        }))
+            .subscribe();
+    }
+    loadInitialViewModelForStartForm() {
+        combineLatest([this.formName$, this.processDefinitionKey$])
+            .pipe(take(1), switchMap(([formName, processDefinitionKey]) => this.viewModelService.getViewModelForStartForm(formName, processDefinitionKey).pipe(tap(viewModel => {
+            this.submission$.next({ data: viewModel });
+            this.change$.pipe(take(1)).subscribe(() => {
+                this.loading$.next(false);
+            });
+        }))))
+            .subscribe();
+    }
+    updateViewModelForStartForm() {
+        this.loading$
+            .pipe(take(1), switchMap(updating => {
+            if (!updating) {
+                this.loading$.next(true);
+                return combineLatest([this.formName$, this.processDefinitionKey$, this.change$]).pipe(take(1), switchMap(([formName, processDefinitionKey, change]) => this.viewModelService
+                    .updateViewModelForStartForm(formName, processDefinitionKey, change.data)
+                    .pipe(tap({
+                    next: viewModel => {
+                        this.submission$.next({ data: viewModel });
+                        this.loading$.next(false);
+                        this.errors$.next([]);
+                    },
+                    error: error => {
+                        this.loading$.next(false);
+                        this.handleFormError(error);
+                    },
+                }))));
+            }
+            return of(null); // Fallback to return an observable if updating is true
+        }))
+            .subscribe();
+    }
+    handleChanges() {
+        this.change$
+            .pipe(pairwise(), debounceTime(500), filter(([prevChange, currentChange]) => prevChange?.changed?.value !== undefined &&
+            currentChange?.changed?.value !== undefined &&
+            prevChange.changed.value !== currentChange.changed.value))
+            .subscribe(() => {
+            if (this.isStartForm$.value) {
+                this.updateViewModelForStartForm();
+            }
+            else {
+                this.updateViewModel();
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: FormViewModelComponent, deps: [{ token: i1.ViewModelService }, { token: i2.TranslateService }, { token: i3.FormIoStateService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.3", type: FormViewModelComponent, isStandalone: true, selector: "valtimo-form-view-model", inputs: { options: "options", submission: "submission", form: "form", formName: "formName", taskInstanceId: "taskInstanceId", readOnly: "readOnly", isStartForm: "isStartForm", processDefinitionKey: "processDefinitionKey", documentDefinitionName: "documentDefinitionName", formRefresh$: "formRefresh$" }, outputs: { formSubmit: "formSubmit" }, viewQueries: [{ propertyName: "formio", first: true, predicate: ["formio"], descendants: true }], ngImport: i0, template: "<!--\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\n<div\n  class=\"form-container\"\n  *ngIf=\"{\n    submission: submission$ | async,\n    readOnly: readOnly$ | async,\n    form: form$ | async,\n    tokenSetInLocalStorage: tokenSetInLocalStorage$ | async,\n    formioOptions: formioOptions$ | async,\n    loading: loading$ | async,\n    errors: errors$ | async\n  } as obs\"\n>\n  <div *ngIf=\"obs.loading\" class=\"loading-icon\">\n    <i class=\"fa fa-spinner fa-spin\"></i>\n  </div>\n  <div *ngIf=\"obs.errors.length > 0\" class=\"alert alert-danger pt-5 pb-5 mb-2\">\n    <ol>\n      @for (error of obs.errors; track error) {\n        <li class=\"pl-2\">\n          {{ error }}\n        </li>\n      }\n    </ol>\n  </div>\n  <formio\n    #formio\n    [submission]=\"obs.submission\"\n    [form]=\"obs.form\"\n    [refresh]=\"refreshForm\"\n    [readOnly]=\"obs.readOnly\"\n    [options]=\"obs.formioOptions\"\n    (submit)=\"onSubmit($event)\"\n    (change)=\"onChange($event)\"\n  ></formio>\n</div>\n", styles: [".form-container{position:relative}.loading-icon{position:absolute;top:10px;right:10px;font-size:1.5em;color:#000}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }, { kind: "ngmodule", type: FormioModule }, { kind: "component", type: i5.FormioComponent, selector: "formio" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: FormViewModelComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'valtimo-form-view-model', standalone: true, imports: [CommonModule, FormioModule], template: "<!--\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\n<div\n  class=\"form-container\"\n  *ngIf=\"{\n    submission: submission$ | async,\n    readOnly: readOnly$ | async,\n    form: form$ | async,\n    tokenSetInLocalStorage: tokenSetInLocalStorage$ | async,\n    formioOptions: formioOptions$ | async,\n    loading: loading$ | async,\n    errors: errors$ | async\n  } as obs\"\n>\n  <div *ngIf=\"obs.loading\" class=\"loading-icon\">\n    <i class=\"fa fa-spinner fa-spin\"></i>\n  </div>\n  <div *ngIf=\"obs.errors.length > 0\" class=\"alert alert-danger pt-5 pb-5 mb-2\">\n    <ol>\n      @for (error of obs.errors; track error) {\n        <li class=\"pl-2\">\n          {{ error }}\n        </li>\n      }\n    </ol>\n  </div>\n  <formio\n    #formio\n    [submission]=\"obs.submission\"\n    [form]=\"obs.form\"\n    [refresh]=\"refreshForm\"\n    [readOnly]=\"obs.readOnly\"\n    [options]=\"obs.formioOptions\"\n    (submit)=\"onSubmit($event)\"\n    (change)=\"onChange($event)\"\n  ></formio>\n</div>\n", styles: [".form-container{position:relative}.loading-icon{position:absolute;top:10px;right:10px;font-size:1.5em;color:#000}\n"] }]
+        }], ctorParameters: () => [{ type: i1.ViewModelService }, { type: i2.TranslateService }, { type: i3.FormIoStateService }], propDecorators: { formio: [{
+                type: ViewChild,
+                args: ['formio']
+            }], options: [{
+                type: Input
+            }], submission: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }], formName: [{
+                type: Input
+            }], taskInstanceId: [{
+                type: Input
+            }], readOnly: [{
+                type: Input
+            }], isStartForm: [{
+                type: Input
+            }], processDefinitionKey: [{
+                type: Input
+            }], documentDefinitionName: [{
+                type: Input
+            }], formRefresh$: [{
+                type: Input
+            }], formSubmit: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-view-model.component.js","sourceRoot":"","sources":["../../../../../../../projects/valtimo/form-view-model/src/lib/components/form-view-model/form-view-model.component.ts","../../../../../../../projects/valtimo/form-view-model/src/lib/components/form-view-model/form-view-model.component.html"],"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 */\nimport {Component, EventEmitter, Input, OnInit, Output, ViewChild} from '@angular/core';\nimport moment from 'moment';\nimport {\n  BehaviorSubject,\n  catchError,\n  combineLatest,\n  debounceTime,\n  EMPTY,\n  filter,\n  Observable,\n  of,\n  pairwise,\n  Subject,\n  switchMap,\n  take,\n  tap,\n} from 'rxjs';\nimport {\n  FormioComponent,\n  FormioModule,\n  FormioOptions,\n  FormioSubmission,\n  FormioSubmissionCallback,\n} from '@formio/angular';\nimport {FormioRefreshValue} from '@formio/angular/formio.common';\nimport {ViewModelService} from '../../services';\nimport {distinctUntilChanged, map} from 'rxjs/operators';\nimport {deepmerge} from 'deepmerge-ts';\nimport {FormIoStateService, ValtimoFormioOptions} from '@valtimo/components';\nimport {TranslateService} from '@ngx-translate/core';\nimport {HttpErrorResponse} from '@angular/common/http';\nimport {CommonModule} from '@angular/common';\n\nmoment.defaultFormat = 'DD MMM YYYY HH:mm';\n\n@Component({\n  selector: 'valtimo-form-view-model',\n  templateUrl: './form-view-model.component.html',\n  styleUrls: ['./form-view-model.component.css'],\n  standalone: true,\n  imports: [CommonModule, FormioModule],\n})\nexport class FormViewModelComponent implements OnInit {\n  @ViewChild('formio') formio: FormioComponent;\n\n  @Input() set options(optionsValue: any) {\n    this.options$.next(optionsValue);\n  }\n\n  @Input() set submission(submissionValue: FormioSubmission) {\n    this.submission$.next(submissionValue);\n  }\n\n  @Input() set form(formValue: object) {\n    const instance = this;\n    const form = {\n      loadInitialViewModel: () => instance.loadInitialViewModel(),\n      updateViewModel: () => instance.updateViewModel(),\n      ...formValue,\n    };\n    this.form$.next(form);\n  }\n\n  @Input() set formName(formName: string) {\n    this.formName$.next(formName);\n  }\n\n  @Input() set taskInstanceId(taskInstanceId: string) {\n    this.taskInstanceId$.next(taskInstanceId);\n  }\n\n  @Input() set readOnly(readOnlyValue: boolean) {\n    this.readOnly$.next(readOnlyValue);\n  }\n\n  @Input() set isStartForm(isStartFormValue: boolean) {\n    this.isStartForm$.next(isStartFormValue);\n  }\n\n  @Input() set processDefinitionKey(processDefinitionKeyValue: string) {\n    this.processDefinitionKey$.next(processDefinitionKeyValue);\n  }\n\n  @Input() set documentDefinitionName(documentDefinitionNameValue: string) {\n    this.documentDefinitionName$.next(documentDefinitionNameValue);\n  }\n\n  @Input() formRefresh$!: Subject<FormioRefreshValue>;\n  @Output() formSubmit = new EventEmitter<any>();\n\n  public refreshForm = new EventEmitter<FormioRefreshValue>();\n\n  public readonly submission$ = new BehaviorSubject<any>({});\n  public readonly form$ = new BehaviorSubject<object>(undefined);\n  public readonly formName$ = new BehaviorSubject<string>(undefined);\n  public readonly options$ = new BehaviorSubject<ValtimoFormioOptions>(undefined);\n  public readonly taskInstanceId$ = new BehaviorSubject<string>(undefined);\n  public readonly readOnly$ = new BehaviorSubject<boolean>(false);\n  public readonly tokenSetInLocalStorage$ = new BehaviorSubject<boolean>(false);\n  public readonly change$ = new BehaviorSubject<any>(null);\n  public readonly errors$ = new BehaviorSubject<Array<string>>([]);\n  public readonly loading$ = new BehaviorSubject<boolean>(true);\n  public readonly isStartForm$ = new BehaviorSubject<boolean>(false);\n  public readonly processDefinitionKey$ = new BehaviorSubject<string>(undefined);\n  public readonly documentDefinitionName$ = new BehaviorSubject<string>(undefined);\n\n  public readonly currentLanguage$ = this.translateService.stream('key').pipe(\n    map(() => this.translateService.currentLang),\n    distinctUntilChanged()\n  );\n\n  private readonly _overrideOptions$ = new BehaviorSubject<FormioOptions>({\n    hooks: {\n      beforeSubmit: this.beforeSubmitHook(this),\n    },\n  });\n\n  public readonly formioOptions$: Observable<ValtimoFormioOptions | FormioOptions> = combineLatest([\n    this.currentLanguage$,\n    this.options$,\n    this._overrideOptions$,\n  ]).pipe(\n    map(([language, options, overrideOptions]) => {\n      const formioTranslations = this.translateService.instant('formioTranslations');\n\n      const defaultOptions = {\n        ...options,\n        language,\n        ...(formioTranslations === 'object' && {\n          i18n: {\n            [language]: this.stateService.flattenTranslationsObject(formioTranslations),\n          },\n        }),\n      };\n\n      return deepmerge(defaultOptions, overrideOptions);\n    })\n  );\n\n  constructor(\n    private readonly viewModelService: ViewModelService,\n    private readonly translateService: TranslateService,\n    private readonly stateService: FormIoStateService\n  ) {}\n\n  public ngOnInit(): void {\n    if (this.isStartForm$.value) {\n      this.loadInitialViewModelForStartForm();\n    } else {\n      this.loadInitialViewModel();\n    }\n  }\n\n  public beforeSubmitHook(instance: FormViewModelComponent): (submission, callback) => void {\n    return (submission, callback) => instance.beforeSubmit(submission, callback);\n  }\n\n  public beforeSubmit(submission: any, callback: FormioSubmissionCallback): void {\n    combineLatest([\n      this.formName$,\n      this.taskInstanceId$,\n      this.processDefinitionKey$,\n      this.documentDefinitionName$,\n      this.isStartForm$,\n    ])\n      .pipe(\n        take(1),\n        switchMap(\n          ([\n            formName,\n            taskInstanceId,\n            processDefinitionKey,\n            documentDefinitionName,\n            isStartForm,\n          ]) =>\n            isStartForm\n              ? this.viewModelService\n                  .submitViewModelForStartForm(\n                    formName,\n                    processDefinitionKey,\n                    documentDefinitionName,\n                    submission.data\n                  )\n                  .pipe(\n                    take(1),\n                    switchMap(response => {\n                      callback(null, submission);\n                      return of(response);\n                    }),\n                    catchError(error => {\n                      this.handleFormError(error);\n                      callback({message: error.error.error, component: null}, null);\n                      return EMPTY; // return an empty observable to complete the stream\n                    })\n                  )\n              : this.viewModelService\n                  .submitViewModel(formName, taskInstanceId, submission.data)\n                  .pipe(\n                    take(1),\n                    switchMap(response => {\n                      callback(null, submission);\n                      return of(response);\n                    }),\n                    catchError(error => {\n                      this.handleFormError(error);\n                      callback({message: error.error.error, component: null}, null);\n                      return EMPTY; // return an empty observable to complete the stream\n                    })\n                  )\n        )\n      )\n      .subscribe();\n  }\n\n  private handleFormError(error: HttpErrorResponse): void {\n    const formInstance = this.formio.formio;\n    const component = formInstance.getComponent(error.error?.component);\n    const submitComponent = formInstance.getComponent('submit');\n    if (component == null) {\n      this.errors$.next([error.error.error]);\n    } else {\n      component?.setCustomValidity(error.error.error);\n      submitComponent.disabled = true;\n    }\n  }\n\n  public onSubmit(submission: FormioSubmission): void {\n    this.formSubmit.next(submission);\n  }\n\n  public onChange(object: any): void {\n    if (object.data) {\n      this.change$.next(object);\n    }\n\n    if (object.changed) {\n      this.handleChanges();\n    }\n  }\n\n  public loadInitialViewModel(): void {\n    combineLatest([this.formName$, this.taskInstanceId$])\n      .pipe(\n        take(1),\n        switchMap(([formName, taskInstanceId]) =>\n          this.viewModelService.getViewModel(formName, taskInstanceId).pipe(\n            tap(viewModel => {\n              this.submission$.next({data: viewModel});\n              this.change$.pipe(take(1)).subscribe(() => {\n                this.loading$.next(false);\n              });\n            })\n          )\n        )\n      )\n      .subscribe();\n  }\n\n  public updateViewModel(): void {\n    this.loading$\n      .pipe(\n        take(1),\n        switchMap(updating => {\n          if (!updating) {\n            this.loading$.next(true);\n            return combineLatest([this.formName$, this.taskInstanceId$, this.change$]).pipe(\n              take(1),\n              switchMap(([formName, taskInstanceId, change]) =>\n                this.viewModelService.updateViewModel(formName, taskInstanceId, change.data).pipe(\n                  tap({\n                    next: viewModel => {\n                      this.submission$.next({data: viewModel});\n                      this.loading$.next(false);\n                      this.errors$.next([]);\n                    },\n                    error: error => {\n                      this.loading$.next(false);\n                      this.handleFormError(error);\n                    },\n                  })\n                )\n              )\n            );\n          }\n          return of(null); // Fallback to return an observable if updating is true\n        })\n      )\n      .subscribe();\n  }\n\n  public loadInitialViewModelForStartForm(): void {\n    combineLatest([this.formName$, this.processDefinitionKey$])\n      .pipe(\n        take(1),\n        switchMap(([formName, processDefinitionKey]) =>\n          this.viewModelService.getViewModelForStartForm(formName, processDefinitionKey).pipe(\n            tap(viewModel => {\n              this.submission$.next({data: viewModel});\n              this.change$.pipe(take(1)).subscribe(() => {\n                this.loading$.next(false);\n              });\n            })\n          )\n        )\n      )\n      .subscribe();\n  }\n\n  public updateViewModelForStartForm(): void {\n    this.loading$\n      .pipe(\n        take(1),\n        switchMap(updating => {\n          if (!updating) {\n            this.loading$.next(true);\n            return combineLatest([this.formName$, this.processDefinitionKey$, this.change$]).pipe(\n              take(1),\n              switchMap(([formName, processDefinitionKey, change]) =>\n                this.viewModelService\n                  .updateViewModelForStartForm(formName, processDefinitionKey, change.data)\n                  .pipe(\n                    tap({\n                      next: viewModel => {\n                        this.submission$.next({data: viewModel});\n                        this.loading$.next(false);\n                        this.errors$.next([]);\n                      },\n                      error: error => {\n                        this.loading$.next(false);\n                        this.handleFormError(error);\n                      },\n                    })\n                  )\n              )\n            );\n          }\n          return of(null); // Fallback to return an observable if updating is true\n        })\n      )\n      .subscribe();\n  }\n\n  private handleChanges(): void {\n    this.change$\n      .pipe(\n        pairwise(),\n        debounceTime(500),\n        filter(\n          ([prevChange, currentChange]) =>\n            prevChange?.changed?.value !== undefined &&\n            currentChange?.changed?.value !== undefined &&\n            prevChange.changed.value !== currentChange.changed.value\n        )\n      )\n      .subscribe(() => {\n        if (this.isStartForm$.value) {\n          this.updateViewModelForStartForm();\n        } else {\n          this.updateViewModel();\n        }\n      });\n  }\n}\n","<!--\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\n<div\n  class=\"form-container\"\n  *ngIf=\"{\n    submission: submission$ | async,\n    readOnly: readOnly$ | async,\n    form: form$ | async,\n    tokenSetInLocalStorage: tokenSetInLocalStorage$ | async,\n    formioOptions: formioOptions$ | async,\n    loading: loading$ | async,\n    errors: errors$ | async\n  } as obs\"\n>\n  <div *ngIf=\"obs.loading\" class=\"loading-icon\">\n    <i class=\"fa fa-spinner fa-spin\"></i>\n  </div>\n  <div *ngIf=\"obs.errors.length > 0\" class=\"alert alert-danger pt-5 pb-5 mb-2\">\n    <ol>\n      @for (error of obs.errors; track error) {\n        <li class=\"pl-2\">\n          {{ error }}\n        </li>\n      }\n    </ol>\n  </div>\n  <formio\n    #formio\n    [submission]=\"obs.submission\"\n    [form]=\"obs.form\"\n    [refresh]=\"refreshForm\"\n    [readOnly]=\"obs.readOnly\"\n    [options]=\"obs.formioOptions\"\n    (submit)=\"onSubmit($event)\"\n    (change)=\"onChange($event)\"\n  ></formio>\n</div>\n"]}

package/esm2022/lib/components/form-view-model/index.mjs

@@ -0,0 +1,17 @@
+/*
+ * 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-view-model.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL2Zvcm0tdmlldy1tb2RlbC9zcmMvbGliL2NvbXBvbmVudHMvZm9ybS12aWV3LW1vZGVsL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBRUgsY0FBYyw2QkFBNkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgMjAxNS0yMDI0IFJpdGVuc2UgQlYsIHRoZSBOZXRoZXJsYW5kcy5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciBFVVBMLCBWZXJzaW9uIDEuMiAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqIGh0dHBzOi8vam9pbnVwLmVjLmV1cm9wYS5ldS9jb2xsZWN0aW9uL2V1cGwvZXVwbC10ZXh0LWV1cGwtMTJcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgYmFzaXMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vZm9ybS12aWV3LW1vZGVsLmNvbXBvbmVudCc7XG4iXX0=

package/esm2022/lib/form-view-model.module.mjs

@@ -0,0 +1,41 @@
+/*
+ * 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 { FORM_VIEW_MODEL_TOKEN } from '@valtimo/config';
+import { FormViewModelComponent } from './components/form-view-model';
+import * as i0 from "@angular/core";
+export class FormViewModelModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: FormViewModelModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.3", ngImport: i0, type: FormViewModelModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: FormViewModelModule, providers: [
+            {
+                provide: FORM_VIEW_MODEL_TOKEN,
+                useValue: { component: FormViewModelComponent },
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: FormViewModelModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        {
+                            provide: FORM_VIEW_MODEL_TOKEN,
+                            useValue: { component: FormViewModelComponent },
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/index.mjs

@@ -0,0 +1,17 @@
+/*
+ * 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 './view-model.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL2Zvcm0tdmlldy1tb2RlbC9zcmMvbGliL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBRUgsY0FBYyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgMjAxNS0yMDI0IFJpdGVuc2UgQlYsIHRoZSBOZXRoZXJsYW5kcy5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciBFVVBMLCBWZXJzaW9uIDEuMiAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqIGh0dHBzOi8vam9pbnVwLmVjLmV1cm9wYS5ldS9jb2xsZWN0aW9uL2V1cGwvZXVwbC10ZXh0LWV1cGwtMTJcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgYmFzaXMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vdmlldy1tb2RlbC5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/lib/services/view-model.service.mjs

@@ -0,0 +1,91 @@
+/*
+ * 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 { HttpHeaders } from '@angular/common/http';
+import { BaseApiService } from '@valtimo/config';
+import { InterceptorSkip } from '@valtimo/security';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@valtimo/config";
+export class ViewModelService extends BaseApiService {
+    constructor(httpClient, configService) {
+        super(httpClient, configService);
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    getViewModel(formName, taskInstanceId) {
+        return this.httpClient.get(this.getApiUrl('/v1/form/view-model/user-task'), {
+            params: {
+                formName,
+                taskInstanceId,
+            },
+            headers: new HttpHeaders().set(InterceptorSkip, '400'),
+        });
+    }
+    updateViewModel(formName, taskInstanceId, viewModel) {
+        return this.httpClient.post(this.getApiUrl(`/v1/form/view-model/user-task`), viewModel, {
+            params: {
+                formName,
+                taskInstanceId,
+            },
+            headers: new HttpHeaders().set(InterceptorSkip, '400'),
+        });
+    }
+    submitViewModel(formName, taskInstanceId, viewModel) {
+        return this.httpClient.post(this.getApiUrl(`/v1/form/view-model/submit/user-task`), viewModel, {
+            params: {
+                formName,
+                taskInstanceId,
+            },
+            headers: new HttpHeaders().set(InterceptorSkip, '400'),
+        });
+    }
+    getViewModelForStartForm(formName, processDefinitionKey) {
+        return this.httpClient.get(this.getApiUrl('/v1/form/view-model/start-form'), {
+            params: {
+                formName,
+                processDefinitionKey,
+            },
+            headers: new HttpHeaders().set(InterceptorSkip, '400'),
+        });
+    }
+    updateViewModelForStartForm(formName, processDefinitionKey, viewModel) {
+        return this.httpClient.post(this.getApiUrl(`/v1/form/view-model/start-form`), viewModel, {
+            params: {
+                formName,
+                processDefinitionKey,
+            },
+            headers: new HttpHeaders().set(InterceptorSkip, '400'),
+        });
+    }
+    submitViewModelForStartForm(formName, processDefinitionKey, documentDefinitionName, viewModel) {
+        return this.httpClient.post(this.getApiUrl(`/v1/form/view-model/submit/start-form`), viewModel, {
+            params: {
+                formName,
+                processDefinitionKey,
+                documentDefinitionName,
+            },
+            headers: new HttpHeaders().set(InterceptorSkip, '400'),
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ViewModelService, 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: ViewModelService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ViewModelService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.ConfigService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/public_api.mjs

@@ -0,0 +1,22 @@
+/*
+ * 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.
+ */
+/*
+ * Public API Surface of form view model
+ */
+export * from './lib/components/form-view-model/form-view-model.component';
+export * from './lib/services';
+export * from './lib/form-view-model.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRpbW8vZm9ybS12aWV3LW1vZGVsL3NyYy9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBRUg7O0dBRUc7QUFFSCxjQUFjLDREQUE0RCxDQUFDO0FBQzNFLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyw4QkFBOEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgMjAxNS0yMDI0IFJpdGVuc2UgQlYsIHRoZSBOZXRoZXJsYW5kcy5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciBFVVBMLCBWZXJzaW9uIDEuMiAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqIGh0dHBzOi8vam9pbnVwLmVjLmV1cm9wYS5ldS9jb2xsZWN0aW9uL2V1cGwvZXVwbC10ZXh0LWV1cGwtMTJcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgYmFzaXMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2YgZm9ybSB2aWV3IG1vZGVsXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9mb3JtLXZpZXctbW9kZWwvZm9ybS12aWV3LW1vZGVsLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlcyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9mb3JtLXZpZXctbW9kZWwubW9kdWxlJztcbiJdfQ==

package/esm2022/valtimo-form-view-model.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsdGltby1mb3JtLXZpZXctbW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL2Zvcm0tdmlldy1tb2RlbC9zcmMvdmFsdGltby1mb3JtLXZpZXctbW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWNfYXBpJztcbiJdfQ==