@yuuvis/client-framework 0.6.5

package/esm2022/object-form/lib/object-form.component.mjs

@@ -0,0 +1,627 @@
+import { CommonModule } from '@angular/common';
+import { ChangeDetectorRef, Component, effect, ElementRef, inject, input, output, ViewEncapsulation } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { ReactiveFormsModule, Validators } from '@angular/forms';
+import { Situation, SystemService, UserService, Utils } from '@yuuvis/client-core';
+import { debounceTime, of } from 'rxjs';
+import { FormScriptingApiService } from './form-scripting.service';
+import { ObjectFormGroupComponent } from './object-form-group/object-form-group.component';
+import { ObjectFormScriptService } from './object-form-script/object-form-script.service';
+import { ObjectFormScriptingScope } from './object-form-script/object-form-scripting-scope';
+import { ObjectFormControlWrapper } from './object-form.interface';
+import { ObjectFormControl, ObjectFormGroup } from './object-form.model';
+import { ObjectFormService } from './object-form.service';
+import { ObjectFormUtils } from './object-form.utils';
+import { FormValidation } from './object-form.validation';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class ObjectFormComponent {
+    #elementRef;
+    #systemService;
+    #formScriptService;
+    #formHelperService;
+    #userService;
+    #cdRef;
+    #formScriptingApiService;
+    #skipTranslationsFor;
+    #namePrefix;
+    #formOptionsEffect;
+    #elementExtensionsEffect;
+    #scriptModel;
+    #scriptingScope;
+    #subscriptions;
+    // local store for all the form control references
+    #formControls;
+    #initialValidators;
+    constructor() {
+        this.#elementRef = inject(ElementRef);
+        this.#systemService = inject(SystemService);
+        this.#formScriptService = inject(ObjectFormScriptService);
+        this.#formHelperService = inject(ObjectFormService);
+        this.#userService = inject(UserService);
+        this.#cdRef = inject(ChangeDetectorRef);
+        this.#formScriptingApiService = inject(FormScriptingApiService);
+        this.#skipTranslationsFor = ['core', 'data'];
+        this.#namePrefix = 'fg_';
+        this.gCount = 0;
+        this.id = Utils.uuid();
+        this.formOptions = input();
+        this.#formOptionsEffect = effect(() => {
+            this.#init(this.formOptions());
+        });
+        this.inert = input();
+        this.elementExtensions = input([]);
+        this.#elementExtensionsEffect = effect(() => {
+            this.#formHelperService.setElementExtensions(this.elementExtensions());
+        });
+        /**
+         * There are special scenarios where forms are within a form themselves.
+         * Setting this property to true, will handle the current form in a
+         * slightly different way when it comes to form scripting.
+         */
+        this.isInnerTableForm = input();
+        /**
+         * triggered when the forms state has been changed
+         */
+        this.statusChanged = output();
+        /**
+         * handler to be executed after the form has been set up
+         */
+        this.onFormReady = output();
+        this.#scriptModel = {};
+        this.#subscriptions = [];
+        // local store for all the form control references
+        this.#formControls = {};
+        this.#initialValidators = {};
+        /**
+         * This method will be called each time the script changes its internal model.
+         * It is used to transfer the script changes to the actual form model.
+         *
+         * To ensure the right context, we define an instance method as callback for the scripting scope
+         * @see: https://blog.johnnyreilly.com/2014/04/typescript-instance-methods.html
+         *
+         * @param formControlName
+         * @param change
+         */
+        this.#onScriptingModelChanged = (formControlName, change, formId) => {
+            if (!this.form || (formId && this.id !== formId))
+                return;
+            // find the target control
+            const fc = this.#formControls[formControlName];
+            if (fc) {
+                // change only allowed properties
+                switch (change.name) {
+                    case 'value': {
+                        if (Array.isArray(change.newValue)) {
+                            this.#processArrayValueChange(fc, change);
+                        }
+                        else {
+                            fc._eoFormElement.value = change.newValue;
+                            if (fc.value !== change.newValue) {
+                                fc.patchValue(change.newValue);
+                                fc.updateValueAndValidity();
+                                fc.markAsDirty();
+                            }
+                        }
+                        this.form.markAsDirty();
+                        break;
+                    }
+                    case 'required': {
+                        fc._eoFormElement.required = change.newValue;
+                        // apply new validators
+                        // @see: https://scotch.io/tutorials/how-to-implement-conditional-validation-in-angular-2-model-driven-forms
+                        fc.setValidators(Validators.compose(this.#getValidators(fc._eoFormElement).concat([this.#initialValidators[fc._eoFormElement.name]])));
+                        // need to mark form control as touched because otherwise form validation will not show
+                        // error messages
+                        fc.markAsTouched();
+                        fc.updateValueAndValidity();
+                        break;
+                    }
+                    case 'readonly': {
+                        fc._eoFormElement.readonly = change.newValue;
+                        if (change.newValue === true) {
+                            fc.disable();
+                        }
+                        else {
+                            fc.enable();
+                        }
+                        break;
+                    }
+                    case 'error': {
+                        fc._eoFormElement.error = change.newValue;
+                        fc.markAsTouched();
+                        fc.updateValueAndValidity();
+                        break;
+                    }
+                    // new onrowedit function was applied by the script
+                    case 'onrowedit': {
+                        fc._eoFormElement.onrowedit = change.newValue;
+                        break;
+                    }
+                    // new onchange function was applied by the script
+                    case 'onchange': {
+                        fc._eoFormElement.onchange = change.newValue;
+                        break;
+                    }
+                }
+                this.#cdRef.detectChanges();
+            }
+        };
+        this.#formScriptingApiService.formId = this.id;
+        this.#formScriptingApiService.api.events
+            .on(FormScriptingApiService.EVENT_MODEL_CHANGED)
+            .pipe(takeUntilDestroyed())
+            .subscribe((event) => event.data && this.#onScriptingModelChanged(event.data.formControlName, event.data.change, event.data.formId));
+        this.#formScriptingApiService.formId = this.id;
+    }
+    // initialize the form based on the provided form options
+    #init(fo) {
+        this.form = undefined;
+        if (!fo)
+            return;
+        setTimeout(() => {
+            this.#initialValidators = {};
+            this.unsubscribeAll();
+            this.#buildReactiveForm(fo);
+        }, 0);
+    }
+    #initScriptingScope(formOptions, dataFormModel) {
+        const { data, actions, objects, context } = (formOptions || {});
+        if (this.#scriptingScope) {
+            this.#scriptingScope.setModel(this.#scriptModel);
+            /** provide access to actions (used inside of BPM-Forms) */
+            this.#scriptingScope.actions = actions;
+            /** provide access to additional objects (used for example in BPM-Start-Forms to
+             * add data of DMS-Objects to start the process for)
+             */
+            this.#scriptingScope.objects = objects || [];
+            this.#scriptingScope.context = context || { id: '', title: '', objectTypeId: '' };
+            /** provide readonly access to initial form data (which may also contain values that
+             * are not rendered as form elements (invisible values))
+             */
+            this.#scriptingScope.data = data;
+            /** by default, scripting scopes are applied to forms. But table elements create their own scope
+             * for editing rows. Being one of those inner forms should not run the form script again, but
+             * instead just provide the observing abilities of the scripting scope.
+             */
+            if (!this.isInnerTableForm() && dataFormModel) {
+                const scriptName = dataFormModel.name + '_' + dataFormModel.situation;
+                console.debug('executing form script ' + scriptName);
+                this.#formScriptService.runFormScript(this.#scriptingScope, dataFormModel.script, scriptName);
+            }
+        }
+    }
+    focusForm() {
+        this.#elementRef.nativeElement.querySelector('input').focus();
+    }
+    getGroup(id) {
+        return this.form?.get(id);
+    }
+    setFormData(data) {
+        const fo = this.formOptions();
+        if (!fo)
+            return;
+        fo.data = data;
+        setTimeout(() => this.#init(fo), 0);
+    }
+    patchValue(data) {
+        Object.keys(data).forEach((key) => {
+            this.#onScriptingModelChanged(key, {
+                name: 'value',
+                newValue: data[key]
+            });
+        });
+    }
+    /**
+     * Extracts the values from the form model. Each form value is represented by one
+     * property on the result object holding the fields value. The keys (properties) are the `name`
+     * properties of the form element.
+     *
+     * How values are extracted is influenced by the forms situation.
+     *
+     * @return object of key value pairs
+     */
+    getFormData() {
+        return this.#formToData();
+    }
+    getFormElements() {
+        const formElements = {};
+        Object.keys(this.#formControls).forEach((k) => {
+            formElements[k] = this.#formControls[k].__eoFormElement;
+        });
+        return formElements;
+    }
+    setFormPristine() {
+        if (!this.form)
+            return;
+        this.form.markAsPristine();
+    }
+    // reset the form to its initial state
+    resetForm() {
+        const fo = this.formOptions();
+        if (!fo)
+            return;
+        this.setFormData(fo.data);
+        this.#emitFormChangedEvent();
+    }
+    /**
+     * Returns the observed model that was passed to the current form script running. If there is
+     * no form script, this method will return NULL.
+     * @returns
+     */
+    getObservedScriptModel() {
+        return this.#scriptingScope ? this.#scriptingScope.getModel() : null;
+    }
+    // Create a reactive form from the enaio form model
+    #buildReactiveForm(formOptions) {
+        this.#scriptingScope = undefined;
+        this.#scriptModel = {};
+        this.#formControls = {};
+        const formModel = this.#dataToForm(formOptions.formModel, formOptions.data);
+        if (!formModel) {
+            return;
+        }
+        // if a script is available, we'll init the form scripting for the
+        // current form
+        if (this.isInnerTableForm() || (formModel.script && formModel.script.length > 0)) {
+            console.debug('adding form scripting scope');
+            this.#scriptingScope = new ObjectFormScriptingScope(formModel.situation, this.#onScriptingModelChanged, this.#formScriptingApiService.getApi(), this.isInnerTableForm());
+            this.#scriptingScope.objectId = this.formOptions().objectId;
+        }
+        const form = new ObjectFormGroup({});
+        if (formModel?.elements[0]?.elements) {
+            this.#addFormControl(form, formModel.elements[0], 'core');
+        }
+        if (formModel?.elements[1]?.elements) {
+            this.#addFormControl(form, formModel.elements[1], 'data');
+        }
+        this.form = form;
+        this.#formScriptingApiService.registerActiveForm(this);
+        setTimeout(() => {
+            if (!this.form)
+                return;
+            this.initValidators(this.form);
+            this.#subscriptions.push(this.form.valueChanges.pipe(debounceTime(500)).subscribe(() => this.#emitFormChangedEvent()));
+            this.#initScriptingScope(formOptions, formModel);
+            this.onFormReady.emit();
+            this.#emitFormChangedEvent(false);
+        }, 300);
+    }
+    initValidators(form) {
+        if (this.form) {
+            for (const key of Object.keys(form.controls)) {
+                const control = form.controls[key];
+                if (control.controls) {
+                    this.initValidators(control);
+                }
+                else {
+                    this.#initialValidators[control._eoFormElement.name] = control.validator;
+                    control.setValidators(Validators.compose(this.#getValidators(control._eoFormElement).concat([this.#initialValidators[control._eoFormElement.name]])));
+                    control.updateValueAndValidity();
+                }
+            }
+        }
+    }
+    #emitFormChangedEvent(compare = true) {
+        // check if indexdata has been changed
+        const currentFormData = this.getFormData();
+        const idxChange = compare ? JSON.stringify(this.formData) !== JSON.stringify(currentFormData) : false;
+        this.formData = currentFormData;
+        if (this.form) {
+            this.statusChanged.emit({
+                invalid: this.form.invalid,
+                dirty: this.form.dirty,
+                data: this.formData,
+                indexdataChanged: idxChange
+            });
+        }
+    }
+    /**
+     * This method will be called each time the script changes its internal model.
+     * It is used to transfer the script changes to the actual form model.
+     *
+     * To ensure the right context, we define an instance method as callback for the scripting scope
+     * @see: https://blog.johnnyreilly.com/2014/04/typescript-instance-methods.html
+     *
+     * @param formControlName
+     * @param change
+     */
+    #onScriptingModelChanged;
+    #processArrayValueChange(fc, change) {
+        const newVal = change.newValue;
+        const targetType = fc._eoFormElement.type;
+        // for some types we have to ensure that meta data are provided as well
+        switch (targetType) {
+            case 'ORGANIZATION': {
+                this.#getDataMeta(fc._eoFormElement, newVal).subscribe((m) => {
+                    fc._eoFormElement.dataMeta = m;
+                });
+                break;
+            }
+            case 'TABLE': {
+                const dataToBeProcessed = {};
+                fc._eoFormElement.elements.forEach((e) => {
+                    if (e.type === 'ORGANIZATION' || e.type === 'CODESYSTEM') {
+                        dataToBeProcessed[e.name] = e;
+                    }
+                });
+                if (Object.keys(dataToBeProcessed).length) {
+                    newVal.forEach((rowData) => {
+                        Object.keys(rowData).forEach((key) => {
+                            if (dataToBeProcessed[key]) {
+                                this.#getDataMeta(dataToBeProcessed[key], rowData[key]).subscribe((m) => {
+                                    if (m) {
+                                        rowData[key + '_meta'] = m;
+                                    }
+                                    else {
+                                        delete rowData[key + '_meta'];
+                                    }
+                                    this.#updateArrayValue(fc, newVal);
+                                });
+                            }
+                        });
+                    });
+                }
+                break;
+            }
+        }
+        this.#updateArrayValue(fc, newVal);
+    }
+    #updateArrayValue(fc, newValue) {
+        fc._eoFormElement.value = [].concat(newValue);
+        fc.patchValue([].concat(newValue));
+        fc.updateValueAndValidity();
+        fc.markAsDirty();
+    }
+    #getDataMeta(formElement, newValue) {
+        if (newValue) {
+            switch (formElement.type) {
+                case 'ORGANIZATION': {
+                    return this.#userService.getUserById(newValue);
+                }
+            }
+        }
+        return of(null);
+    }
+    #patchFormValue(formValue) {
+        let value;
+        if (Array.isArray(formValue)) {
+            value = [];
+            // copy by value for arrays of objects (e.g. table data)
+            formValue.forEach((o) => value.push(JSON.parse(JSON.stringify(o))));
+        }
+        else {
+            value = formValue;
+        }
+        return value;
+    }
+    /**
+     * Recursive method adding a new FormControl (group or control) to a parent form group
+     *
+     * @param parentGroup - the parent group to add the control to
+     * @param formElement - the enaio form model element to create the child control from
+     * @param [useName] - use this name instead of the one from the model
+     */
+    #addFormControl(parentGroup, formElement, useName) {
+        const fo = this.formOptions();
+        if (!fo)
+            return;
+        let ctrl;
+        let name;
+        // add a form group
+        if (formElement.type === 'o2mGroup' || formElement.type === 'o2mGroupStack') {
+            // do not add groups that are empty
+            const isRootGroup = formElement.name && (formElement.name !== 'data' || formElement.name !== 'core');
+            if (!isRootGroup && (!formElement.elements || formElement.elements.length === 0)) {
+                console.error('Found empty form group', formElement);
+                return;
+            }
+            ctrl = new ObjectFormGroup({});
+            ctrl._eoFormGroup = {
+                layout: formElement.layout,
+                type: formElement.type
+            };
+            if (formElement.name) {
+                if (this.#skipTranslationsFor.includes(formElement.name)) {
+                    ctrl._eoFormGroup.label = formElement.name;
+                }
+                else if (!formElement.label) {
+                    // no label, so try to translate the technical name
+                    ctrl._eoFormGroup.label = this.#systemService.getLocalizedResource(`${formElement.name}_label`) || formElement.name;
+                }
+                else {
+                    // there is a label so we take this one
+                    ctrl._eoFormGroup.label = formElement.label;
+                }
+            }
+            if (useName === 'core' || useName === 'data') {
+                ctrl._eoFormGroup.label = useName;
+            }
+            for (const e of formElement.elements) {
+                this.#addFormControl(ctrl, e);
+            }
+            name = useName || 'fg' + this.gCount++;
+        }
+        else {
+            // add form control
+            // To be able to integrate recursive form controls into the main form,
+            // we have to wrap them in a form group
+            ctrl = new ObjectFormControlWrapper({});
+            ctrl._eoFormControlWrapper = {
+                // the name of the wrapped FormControl
+                controlName: formElement.name,
+                situation: fo.formModel.situation
+            };
+            // do not set a reference as the form controls value
+            // otherwise we could not reset the form
+            const value = formElement?.value
+                ? this.#patchFormValue(formElement?.value)
+                : !Utils.isEmpty(formElement?.defaultvalue) && fo.formModel.situation === Situation.CREATE
+                    ? this.#patchFormValue(formElement?.defaultvalue)
+                    : formElement?.value;
+            // create the actual form control
+            const controlDisabled = fo.disabled || !!formElement.readonly;
+            const formControl = new ObjectFormControl({
+                value,
+                disabled: controlDisabled
+            });
+            // if form element has a 'label' property it will be shown as is ...
+            if (!formElement.label) {
+                // ... if there is no label but a 'labelKey' property we are going to localize that key ...
+                if (formElement.labelkey) {
+                    formElement.label = this.#systemService.getLocalizedResource(`${formElement.labelkey}_label`) || formElement.labelkey;
+                    formElement.description = this.#systemService.getLocalizedResource(`${formElement.labelkey}_description`);
+                }
+                else {
+                    // ... no 'label' and also no 'labelKey' means that we are showing technical name instead
+                    formElement.label = formElement.name;
+                }
+            }
+            formElement.readonly = controlDisabled;
+            // we are using an internal type to distinguish between the components
+            // to be used to render certain form elements
+            formElement._internalType = this.#systemService.getInternalFormElementType(formElement.type, formElement.classifications);
+            formControl._eoFormElement = formElement;
+            this.#formControls[formElement.name] = formControl;
+            if (formElement.type === 'TABLE') {
+                // Add 'onrowedit' property even if it's not set.
+                // This is required because otherwise mobX-Observer would not recognize
+                // changes to this property applied by the form script
+                if (!Object.keys(formControl._eoFormElement).includes('onrowedit')) {
+                    formControl._eoFormElement.onrowedit = null;
+                }
+                if (this.#scriptingScope && formControl._eoFormElement.value) {
+                    // having a scripting scope and table rows means that we need to set empty
+                    // columns to NULL, because otherwise mobX won't be able to track those values
+                    const valueFields = formControl._eoFormElement.elements.map((e) => e.name);
+                    formControl._eoFormElement.value.forEach((rowValue) => {
+                        valueFields.forEach((valueField) => {
+                            if (!Object.keys(rowValue).includes(valueField)) {
+                                rowValue[valueField] = null;
+                            }
+                        });
+                    });
+                    // update form controls value as well to reflect the observed value
+                    formControl.patchValue(formControl._eoFormElement.value, {
+                        onlySelf: true,
+                        emitEvent: false,
+                        emitModelToViewChange: false,
+                        emitViewToModelChange: false
+                    });
+                }
+            }
+            if (formElement._internalType === 'string:organization') {
+                formControl._eoFormElement.setFilter = (filterObject) => {
+                    formControl._eoFormElement.filter = filterObject;
+                };
+            }
+            ObjectFormUtils.updateFormElement(formElement);
+            // remove empty descriptions
+            const desc = formControl._eoFormElement.description;
+            if (desc && desc.trim().length === 0) {
+                formControl._eoFormElement.description = null;
+            }
+            // add the form element to the script model that will be injected into
+            // the forms scripting scope later on
+            this.#scriptModel[formElement.name] = formControl._eoFormElement;
+            // apply change listener to the form control, that will trigger
+            // the form elements onChange listener
+            const controlWatch = ctrl.valueChanges.pipe(debounceTime(500));
+            this.#subscriptions.push(controlWatch.subscribe((v) => {
+                if (this.#scriptingScope) {
+                    this.#scriptingScope.modelChanged(v);
+                }
+            }));
+            ctrl.addControl(formElement.name, formControl);
+            name = this.#namePrefix + formElement.name;
+        }
+        parentGroup.addControl(name, ctrl);
+    }
+    /**
+     * Build validators for the given form element to be attached to
+     * a reactive formControl.
+     *
+     * @param formElement - form element object
+     */
+    #getValidators(formElement) {
+        const fo = this.formOptions();
+        const elmValidators = FormValidation.getValidators(formElement, fo?.formModel.situation);
+        // add custom validator for script enabled forms
+        if (this.#scriptingScope) {
+            elmValidators.push(FormValidation.customScriptingValidation);
+        }
+        return elmValidators;
+    }
+    /**
+     * Extract the values from the form
+     */
+    #formToData() {
+        const fo = this.formOptions();
+        return fo && this.form ? this.#formHelperService.extractFormData(this.form, fo.formModel.situation, fo.data, this.isInnerTableForm()) : {};
+    }
+    /**
+     * Merge data into a form model.
+     *
+     * @param model - form model
+     * @param data - data object or array of SearchFilter objects in case of a search form
+     */
+    #dataToForm(model, data) {
+        if (model && data) {
+            this.#setElementValues(model.elements, data);
+        }
+        return model;
+    }
+    // recursive method for adding values to model elements
+    #setElementValues(elements, data) {
+        elements?.forEach((element) => {
+            if (this.#hasValue(data, element)) {
+                element.value = this.#getValue(data, element);
+            }
+            else {
+                delete element.value;
+            }
+            if (element.type !== 'TABLE' && element.elements && element.elements.length > 0) {
+                this.#setElementValues(element.elements, data);
+            }
+        });
+    }
+    #hasValue(data, element) {
+        // differ between array of SearchFilters and a form data object
+        if (Array.isArray(data)) {
+            return !!data.find((filter) => filter.property === element.id);
+        }
+        else {
+            return Object.keys(data).includes(element.name);
+        }
+    }
+    #getValue(data, element) {
+        return data[element.name];
+    }
+    ngOnDestroy() {
+        this.unsubscribeAll();
+        this.#formScriptingApiService.unregisterActiveForm(this);
+    }
+    ngAfterViewInit() {
+        this.#cdRef.detectChanges();
+    }
+    // unsubscribe from all value change listeners for the current form
+    // to avoid memory leaks. This method will also be called every time
+    // a new form is rendered to get rid of the old form element subscriptions
+    unsubscribeAll() {
+        if (this.#subscriptions.length) {
+            console.debug('unsubscribed from ' + this.#subscriptions.length + ' value change listeners.');
+            this.#subscriptions.forEach((s) => s.unsubscribe());
+            this.#subscriptions = [];
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectFormComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: ObjectFormComponent, isStandalone: true, selector: "yuv-object-form", inputs: { formOptions: { classPropertyName: "formOptions", publicName: "formOptions", isSignal: true, isRequired: false, transformFunction: null }, inert: { classPropertyName: "inert", publicName: "inert", isSignal: true, isRequired: false, transformFunction: null }, elementExtensions: { classPropertyName: "elementExtensions", publicName: "elementExtensions", isSignal: true, isRequired: false, transformFunction: null }, isInnerTableForm: { classPropertyName: "isInnerTableForm", publicName: "isInnerTableForm", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { statusChanged: "statusChanged", onFormReady: "onFormReady" }, host: { properties: { "attr.inert": "inert() ? true : null" }, classAttribute: "yuv-object-form" }, providers: [ObjectFormService, ObjectFormScriptService, FormScriptingApiService], ngImport: i0, template: "@let fo = formOptions();\n@if (fo && form) {\n  <div class=\"yuv-object-form\" [formGroup]=\"form\">\n    <div class=\"form-element-wrap core\">\n      <yuv-object-form-group [group]=\"getGroup('core')\" [situation]=\"fo.formModel.situation\"></yuv-object-form-group>\n    </div>\n    <div class=\"form-element-wrap data\">\n      <yuv-object-form-group [group]=\"getGroup('data')\" [situation]=\"fo.formModel.situation\"></yuv-object-form-group>\n    </div>\n  </div>\n}\n", styles: [".yuv-object-form>.core{padding:calc(var(--app-pane-padding) / 2)}.yuv-object-form>.data>yuv-object-form-group>.form-element.o2mGroupStack{background:transparent;border:0}.yuv-object-form>.data>yuv-object-form-group>.form-element.o2mGroupStack>yuv-object-form-group>.o2mGroup{background-color:var(--panel-background-lightgrey);border-top:1px solid rgba(0,0,0,.1);padding:var(--app-pane-padding)}.yuv-object-form>.data>yuv-object-form-group>.form-element.o2mGroupStack>p-tabview>.p-tabview>.p-tabview-panels{background-color:var(--panel-background-lightgrey)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: ObjectFormGroupComponent, selector: "yuv-object-form-group", inputs: ["situation", "group", "noGroupLabels"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectFormComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'yuv-object-form', standalone: true, imports: [CommonModule, ReactiveFormsModule, ObjectFormGroupComponent], providers: [ObjectFormService, ObjectFormScriptService, FormScriptingApiService], encapsulation: ViewEncapsulation.None, host: {
+                        class: 'yuv-object-form',
+                        '[attr.inert]': 'inert() ? true : null'
+                    }, template: "@let fo = formOptions();\n@if (fo && form) {\n  <div class=\"yuv-object-form\" [formGroup]=\"form\">\n    <div class=\"form-element-wrap core\">\n      <yuv-object-form-group [group]=\"getGroup('core')\" [situation]=\"fo.formModel.situation\"></yuv-object-form-group>\n    </div>\n    <div class=\"form-element-wrap data\">\n      <yuv-object-form-group [group]=\"getGroup('data')\" [situation]=\"fo.formModel.situation\"></yuv-object-form-group>\n    </div>\n  </div>\n}\n", styles: [".yuv-object-form>.core{padding:calc(var(--app-pane-padding) / 2)}.yuv-object-form>.data>yuv-object-form-group>.form-element.o2mGroupStack{background:transparent;border:0}.yuv-object-form>.data>yuv-object-form-group>.form-element.o2mGroupStack>yuv-object-form-group>.o2mGroup{background-color:var(--panel-background-lightgrey);border-top:1px solid rgba(0,0,0,.1);padding:var(--app-pane-padding)}.yuv-object-form>.data>yuv-object-form-group>.form-element.o2mGroupStack>p-tabview>.p-tabview>.p-tabview-panels{background-color:var(--panel-background-lightgrey)}\n"] }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object-form.component.js","sourceRoot":"","sources":["../../../../../../../libs/yuuvis/client-framework/object-form/src/lib/object-form.component.ts","../../../../../../../libs/yuuvis/client-framework/object-form/src/lib/object-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { AfterViewInit, ChangeDetectorRef, Component, effect, ElementRef, inject, input, OnDestroy, output, ViewEncapsulation } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { ReactiveFormsModule, ValidatorFn, Validators } from '@angular/forms';\nimport { Situation, SystemService, UserService, Utils } from '@yuuvis/client-core';\nimport { debounceTime, Observable, of, Subscription } from 'rxjs';\nimport { FormScriptingApiService } from './form-scripting.service';\nimport { IObjectFormElementExtension } from './object-form-extension.interface';\nimport { ObjectFormGroupComponent } from './object-form-group/object-form-group.component';\nimport { ObjectFormScriptService } from './object-form-script/object-form-script.service';\nimport { ObjectFormScriptingScope } from './object-form-script/object-form-scripting-scope';\nimport { FormStatusChangedEvent, ObjectFormControlWrapper, ObjectFormModelChange, ObjectFormOptions } from './object-form.interface';\nimport { ObjectFormControl, ObjectFormGroup } from './object-form.model';\nimport { ObjectFormService } from './object-form.service';\nimport { ObjectFormUtils } from './object-form.utils';\nimport { FormValidation } from './object-form.validation';\n\n@Component({\n  selector: 'yuv-object-form',\n  standalone: true,\n  imports: [CommonModule, ReactiveFormsModule, ObjectFormGroupComponent],\n  providers: [ObjectFormService, ObjectFormScriptService, FormScriptingApiService],\n  templateUrl: './object-form.component.html',\n  styleUrl: './object-form.component.scss',\n  encapsulation: ViewEncapsulation.None,\n  host: {\n    class: 'yuv-object-form',\n    '[attr.inert]': 'inert() ? true : null'\n  }\n})\nexport class ObjectFormComponent implements OnDestroy, AfterViewInit {\n  #elementRef = inject(ElementRef);\n  #systemService = inject(SystemService);\n  #formScriptService = inject(ObjectFormScriptService);\n  #formHelperService = inject(ObjectFormService);\n  #userService = inject(UserService);\n  #cdRef = inject(ChangeDetectorRef);\n  #formScriptingApiService = inject(FormScriptingApiService);\n\n  #skipTranslationsFor = ['core', 'data'];\n  #namePrefix = 'fg_';\n  gCount = 0;\n\n  id = Utils.uuid();\n\n  fo?: ObjectFormOptions;\n  formOptions = input<ObjectFormOptions>();\n  #formOptionsEffect = effect(() => {\n    this.#init(this.formOptions());\n  });\n\n  inert = input<boolean>();\n  elementExtensions = input<IObjectFormElementExtension[]>([]);\n  #elementExtensionsEffect = effect(() => {\n    this.#formHelperService.setElementExtensions(this.elementExtensions());\n  });\n\n  /**\n   * There are special scenarios where forms are within a form themselves.\n   * Setting this property to true, will handle the current form in a\n   * slightly different way when it comes to form scripting.\n   */\n  isInnerTableForm = input<boolean>();\n\n  /**\n   * triggered when the forms state has been changed\n   */\n  statusChanged = output<FormStatusChangedEvent>();\n\n  /**\n   * handler to be executed after the form has been set up\n   */\n  onFormReady = output();\n\n  // the actual form instance\n  form?: ObjectFormGroup;\n  // property for holding the forms data used for comparison when a form-changed-event\n  // is fetched to indicate wher or not the indexdata were changed or just the properties\n  // of the form elements (eg. form script setting fields to readonly)\n  formData: any;\n  #scriptModel: any = {};\n  #scriptingScope?: ObjectFormScriptingScope;\n  #subscriptions: Subscription[] = [];\n\n  // local store for all the form control references\n  #formControls: any = {};\n  #initialValidators: any = {};\n\n  constructor() {\n    this.#formScriptingApiService.formId = this.id;\n    this.#formScriptingApiService.api.events\n      .on(FormScriptingApiService.EVENT_MODEL_CHANGED)\n      .pipe(takeUntilDestroyed())\n      .subscribe((event) => event.data && this.#onScriptingModelChanged(event.data.formControlName, event.data.change, event.data.formId));\n\n    this.#formScriptingApiService.formId = this.id;    \n  }\n\n  // initialize the form based on the provided form options\n  #init(fo: ObjectFormOptions | undefined) {\n    this.form = undefined;\n    if (!fo) return;\n    setTimeout(() => {\n      this.#initialValidators = {};\n      this.unsubscribeAll();\n      this.#buildReactiveForm(fo);\n    }, 0);\n  }\n\n  #initScriptingScope(formOptions: ObjectFormOptions, dataFormModel: any) {\n    const { data, actions, objects, context } = (formOptions || {}) as ObjectFormOptions;\n\n    if (this.#scriptingScope) {\n      this.#scriptingScope.setModel(this.#scriptModel);\n      /** provide access to actions (used inside of BPM-Forms) */\n      this.#scriptingScope.actions = actions;\n      /** provide access to additional objects (used for example in BPM-Start-Forms to\n       * add data of DMS-Objects to start the process for)\n       */\n      this.#scriptingScope.objects = objects || [];\n      this.#scriptingScope.context = context || { id: '', title: '', objectTypeId: '' };\n      /** provide readonly access to initial form data (which may also contain values that\n       * are not rendered as form elements (invisible values))\n       */\n      this.#scriptingScope.data = data;\n\n      /** by default, scripting scopes are applied to forms. But table elements create their own scope\n       * for editing rows. Being one of those inner forms should not run the form script again, but\n       * instead just provide the observing abilities of the scripting scope.\n       */\n      if (!this.isInnerTableForm() && dataFormModel) {\n        const scriptName = dataFormModel.name + '_' + dataFormModel.situation;\n        console.debug('executing form script ' + scriptName);\n        this.#formScriptService.runFormScript(this.#scriptingScope, dataFormModel.script, scriptName);\n      }\n    }\n  }\n\n  focusForm() {\n    this.#elementRef.nativeElement.querySelector('input').focus();\n  }\n\n  getGroup(id: string): ObjectFormGroup {\n    return this.form?.get(id) as ObjectFormGroup;\n  }\n\n  setFormData(data: Record<string, unknown>) {\n    const fo = this.formOptions();\n    if (!fo) return;\n    fo.data = data;\n    setTimeout(() => this.#init(fo), 0);\n  }\n\n  patchValue(data: Record<string, unknown>) {\n    Object.keys(data).forEach((key) => {\n      this.#onScriptingModelChanged(key, {\n        name: 'value',\n        newValue: data[key]\n      });\n    });\n  }\n\n  /**\n   * Extracts the values from the form model. Each form value is represented by one\n   * property on the result object holding the fields value. The keys (properties) are the `name`\n   * properties of the form element.\n   *\n   * How values are extracted is influenced by the forms situation.\n   *\n   * @return object of key value pairs\n   */\n  getFormData() {\n    return this.#formToData();\n  }\n\n  getFormElements() {\n    const formElements: any = {};\n    Object.keys(this.#formControls).forEach((k) => {\n      formElements[k] = this.#formControls[k].__eoFormElement;\n    });\n    return formElements;\n  }\n\n  setFormPristine() {\n    if (!this.form) return;\n    this.form.markAsPristine();\n  }\n\n  // reset the form to its initial state\n  resetForm() {\n    const fo = this.formOptions();\n    if (!fo) return;\n    this.setFormData(fo.data);\n    this.#emitFormChangedEvent();\n  }\n\n  /**\n   * Returns the observed model that was passed to the current form script running. If there is\n   * no form script, this method will return NULL.\n   * @returns\n   */\n  getObservedScriptModel() {\n    return this.#scriptingScope ? this.#scriptingScope.getModel() : null;\n  }\n\n  // Create a reactive form from the enaio form model\n  #buildReactiveForm(formOptions: ObjectFormOptions) {\n    this.#scriptingScope = undefined;\n    this.#scriptModel = {};\n    this.#formControls = {};\n    const formModel = this.#dataToForm(formOptions.formModel, formOptions.data);\n\n    if (!formModel) {\n      return;\n    }\n    // if a script is available, we'll init the form scripting for the\n    // current form\n    if (this.isInnerTableForm() || (formModel.script && formModel.script.length > 0)) {\n      console.debug('adding form scripting scope');\n      this.#scriptingScope = new ObjectFormScriptingScope(\n        formModel.situation,\n        this.#onScriptingModelChanged,\n        this.#formScriptingApiService.getApi(),\n        this.isInnerTableForm()\n      );\n      this.#scriptingScope.objectId = this.formOptions()!.objectId;\n    }\n\n    const form = new ObjectFormGroup({});\n    if (formModel?.elements[0]?.elements) {\n      this.#addFormControl(form, formModel.elements[0], 'core');\n    }\n    if (formModel?.elements[1]?.elements) {\n      this.#addFormControl(form, formModel.elements[1], 'data');\n    }\n    this.form = form;\n    this.#formScriptingApiService.registerActiveForm(this);\n\n    setTimeout(() => {\n      if (!this.form) return;\n      this.initValidators(this.form);\n      this.#subscriptions.push(this.form.valueChanges.pipe(debounceTime(500)).subscribe(() => this.#emitFormChangedEvent()));\n\n      this.#initScriptingScope(formOptions, formModel);\n\n      this.onFormReady.emit();\n      this.#emitFormChangedEvent(false);\n    }, 300);\n  }\n\n  initValidators(form: any) {\n    if (this.form) {\n      for (const key of Object.keys(form.controls)) {\n        const control = form.controls[key];\n        if (control.controls) {\n          this.initValidators(control);\n        } else {\n          this.#initialValidators[control._eoFormElement.name] = control.validator;\n          control.setValidators(Validators.compose(this.#getValidators(control._eoFormElement).concat([this.#initialValidators[control._eoFormElement.name]])));\n          control.updateValueAndValidity();\n        }\n      }\n    }\n  }\n\n  #emitFormChangedEvent(compare = true) {\n    // check if indexdata has been changed\n    const currentFormData = this.getFormData();\n    const idxChange = compare ? JSON.stringify(this.formData) !== JSON.stringify(currentFormData) : false;\n    this.formData = currentFormData;\n    if (this.form) {\n      this.statusChanged.emit({\n        invalid: this.form.invalid,\n        dirty: this.form.dirty,\n        data: this.formData,\n        indexdataChanged: idxChange\n      });\n    }\n  }\n\n  /**\n   * This method will be called each time the script changes its internal model.\n   * It is used to transfer the script changes to the actual form model.\n   *\n   * To ensure the right context, we define an instance method as callback for the scripting scope\n   * @see: https://blog.johnnyreilly.com/2014/04/typescript-instance-methods.html\n   *\n   * @param formControlName\n   * @param change\n   */\n  #onScriptingModelChanged = (formControlName: string, change: ObjectFormModelChange, formId?: string) => {\n    if (!this.form || (formId && this.id !== formId)) return;\n    // find the target control\n    const fc: ObjectFormControl = this.#formControls[formControlName] as ObjectFormControl;\n    if (fc) {\n      // change only allowed properties\n      switch (change.name) {\n        case 'value': {\n          if (Array.isArray(change.newValue)) {\n            this.#processArrayValueChange(fc, change);\n          } else {\n            fc._eoFormElement.value = change.newValue;\n            if (fc.value !== change.newValue) {\n              fc.patchValue(change.newValue);\n              fc.updateValueAndValidity();\n              fc.markAsDirty();\n            }\n          }\n          this.form.markAsDirty();\n          break;\n        }\n        case 'required': {\n          fc._eoFormElement.required = change.newValue;\n          // apply new validators\n          // @see: https://scotch.io/tutorials/how-to-implement-conditional-validation-in-angular-2-model-driven-forms\n          fc.setValidators(Validators.compose(this.#getValidators(fc._eoFormElement).concat([this.#initialValidators[fc._eoFormElement.name]])));\n          // need to mark form control as touched because otherwise form validation will not show\n          // error messages\n          fc.markAsTouched();\n          fc.updateValueAndValidity();\n          break;\n        }\n        case 'readonly': {\n          fc._eoFormElement.readonly = change.newValue;\n          if (change.newValue === true) {\n            fc.disable();\n          } else {\n            fc.enable();\n          }\n          break;\n        }\n        case 'error': {\n          fc._eoFormElement.error = change.newValue;\n          fc.markAsTouched();\n          fc.updateValueAndValidity();\n          break;\n        }\n        // new onrowedit function was applied by the script\n        case 'onrowedit': {\n          fc._eoFormElement.onrowedit = change.newValue;\n          break;\n        }\n        // new onchange function was applied by the script\n        case 'onchange': {\n          fc._eoFormElement.onchange = change.newValue;\n          break;\n        }\n      }\n      this.#cdRef.detectChanges();\n    }\n  };\n\n  #processArrayValueChange(fc: any, change: any) {\n    const newVal = change.newValue;\n    const targetType = fc._eoFormElement.type;\n    // for some types we have to ensure that meta data are provided as well\n    switch (targetType) {\n      case 'ORGANIZATION': {\n        this.#getDataMeta(fc._eoFormElement, newVal).subscribe((m) => {\n          fc._eoFormElement.dataMeta = m;\n        });\n        break;\n      }\n      case 'TABLE': {\n        const dataToBeProcessed: Record<string, unknown> = {};\n        fc._eoFormElement.elements.forEach((e: any) => {\n          if (e.type === 'ORGANIZATION' || e.type === 'CODESYSTEM') {\n            dataToBeProcessed[e.name] = e;\n          }\n        });\n        if (Object.keys(dataToBeProcessed).length) {\n          newVal.forEach((rowData: any) => {\n            Object.keys(rowData).forEach((key) => {\n              if (dataToBeProcessed[key]) {\n                this.#getDataMeta(dataToBeProcessed[key], rowData[key]).subscribe((m) => {\n                  if (m) {\n                    rowData[key + '_meta'] = m;\n                  } else {\n                    delete rowData[key + '_meta'];\n                  }\n                  this.#updateArrayValue(fc, newVal);\n                });\n              }\n            });\n          });\n        }\n        break;\n      }\n    }\n    this.#updateArrayValue(fc, newVal);\n  }\n\n  #updateArrayValue(fc: any, newValue: any) {\n    fc._eoFormElement.value = [].concat(newValue);\n    fc.patchValue([].concat(newValue));\n    fc.updateValueAndValidity();\n    fc.markAsDirty();\n  }\n\n  #getDataMeta(formElement: any, newValue: any): Observable<any> {\n    if (newValue) {\n      switch (formElement.type) {\n        case 'ORGANIZATION': {\n          return this.#userService.getUserById(newValue);\n        }\n      }\n    }\n    return of(null);\n  }\n\n  #patchFormValue(formValue: string[] | string) {\n    let value: any;\n    if (Array.isArray(formValue)) {\n      value = [];\n      // copy by value for arrays of objects (e.g. table data)\n      formValue.forEach((o) => value.push(JSON.parse(JSON.stringify(o))));\n    } else {\n      value = formValue;\n    }\n    return value;\n  }\n\n  /**\n   * Recursive method adding a new FormControl (group or control) to a parent form group\n   *\n   * @param parentGroup - the parent group to add the control to\n   * @param formElement - the enaio form model element to create the child control from\n   * @param [useName] - use this name instead of the one from the model\n   */\n  #addFormControl(parentGroup: ObjectFormGroup, formElement: any, useName?: string) {\n    const fo = this.formOptions();\n    if (!fo) return;\n\n    let ctrl;\n    let name;\n\n    // add a form group\n    if (formElement.type === 'o2mGroup' || formElement.type === 'o2mGroupStack') {\n      // do not add groups that are empty\n      const isRootGroup = formElement.name && (formElement.name !== 'data' || formElement.name !== 'core');\n      if (!isRootGroup && (!formElement.elements || formElement.elements.length === 0)) {\n        console.error('Found empty form group', formElement);\n        return;\n      }\n\n      ctrl = new ObjectFormGroup({});\n      ctrl._eoFormGroup = {\n        layout: formElement.layout,\n        type: formElement.type\n      };\n\n      if (formElement.name) {\n        if (this.#skipTranslationsFor.includes(formElement.name)) {\n          ctrl._eoFormGroup.label = formElement.name;\n        } else if (!formElement.label) {\n          // no label, so try to translate the technical name\n          ctrl._eoFormGroup.label = this.#systemService.getLocalizedResource(`${formElement.name}_label`) || formElement.name;\n        } else {\n          // there is a label so we take this one\n          ctrl._eoFormGroup.label = formElement.label;\n        }\n      }\n\n      if (useName === 'core' || useName === 'data') {\n        ctrl._eoFormGroup.label = useName;\n      }\n\n      for (const e of formElement.elements) {\n        this.#addFormControl(ctrl, e);\n      }\n      name = useName || 'fg' + this.gCount++;\n    } else {\n      // add form control\n      // To be able to integrate recursive form controls into the main form,\n      // we have to wrap them in a form group\n      ctrl = new ObjectFormControlWrapper({});\n      ctrl._eoFormControlWrapper = {\n        // the name of the wrapped FormControl\n        controlName: formElement.name,\n        situation: fo.formModel.situation\n      };\n\n      // do not set a reference as the form controls value\n      // otherwise we could not reset the form\n      const value = formElement?.value\n        ? this.#patchFormValue(formElement?.value)\n        : !Utils.isEmpty(formElement?.defaultvalue) && fo.formModel.situation === Situation.CREATE\n          ? this.#patchFormValue(formElement?.defaultvalue)\n          : formElement?.value;\n\n      // create the actual form control\n      const controlDisabled = fo.disabled || !!formElement.readonly;\n      const formControl = new ObjectFormControl({\n        value,\n        disabled: controlDisabled\n      });\n\n      // if form element has a 'label' property it will be shown as is ...\n      if (!formElement.label) {\n        // ... if there is no label but a 'labelKey' property we are going to localize that key ...\n        if (formElement.labelkey) {\n          formElement.label = this.#systemService.getLocalizedResource(`${formElement.labelkey}_label`) || formElement.labelkey;\n          formElement.description = this.#systemService.getLocalizedResource(`${formElement.labelkey}_description`);\n        } else {\n          // ... no 'label' and also no 'labelKey' means that we are showing technical name instead\n          formElement.label = formElement.name;\n        }\n      }\n      formElement.readonly = controlDisabled;\n      // we are using an internal type to distinguish between the components\n      // to be used to render certain form elements\n      formElement._internalType = this.#systemService.getInternalFormElementType(formElement.type, formElement.classifications);\n\n      formControl._eoFormElement = formElement;\n      this.#formControls[formElement.name] = formControl;\n\n      if (formElement.type === 'TABLE') {\n        // Add 'onrowedit' property even if it's not set.\n        // This is required because otherwise mobX-Observer would not recognize\n        // changes to this property applied by the form script\n        if (!Object.keys(formControl._eoFormElement).includes('onrowedit')) {\n          formControl._eoFormElement.onrowedit = null;\n        }\n\n        if (this.#scriptingScope && formControl._eoFormElement.value) {\n          // having a scripting scope and table rows means that we need to set empty\n          // columns to NULL, because otherwise mobX won't be able to track those values\n          const valueFields = formControl._eoFormElement.elements.map((e: any) => e.name);\n          formControl._eoFormElement.value.forEach((rowValue: any) => {\n            valueFields.forEach((valueField: string) => {\n              if (!Object.keys(rowValue).includes(valueField)) {\n                rowValue[valueField] = null;\n              }\n            });\n          });\n          // update form controls value as well to reflect the observed value\n          formControl.patchValue(formControl._eoFormElement.value, {\n            onlySelf: true,\n            emitEvent: false,\n            emitModelToViewChange: false,\n            emitViewToModelChange: false\n          });\n        }\n      }\n\n      if (formElement._internalType === 'string:organization') {\n        formControl._eoFormElement.setFilter = (filterObject: any) => {\n          formControl._eoFormElement.filter = filterObject;\n        };\n      }\n\n      ObjectFormUtils.updateFormElement(formElement);\n\n      // remove empty descriptions\n      const desc = formControl._eoFormElement.description;\n      if (desc && desc.trim().length === 0) {\n        formControl._eoFormElement.description = null;\n      }\n\n      // add the form element to the script model that will be injected into\n      // the forms scripting scope later on\n      this.#scriptModel[formElement.name] = formControl._eoFormElement;\n\n      // apply change listener to the form control, that will trigger\n      // the form elements onChange listener\n      const controlWatch = ctrl.valueChanges.pipe(debounceTime(500));\n      this.#subscriptions.push(\n        controlWatch.subscribe((v) => {\n          if (this.#scriptingScope) {\n            this.#scriptingScope.modelChanged(v);\n          }\n        })\n      );\n\n      ctrl.addControl(formElement.name, formControl);\n      name = this.#namePrefix + formElement.name;\n    }\n    parentGroup.addControl(name, ctrl);\n  }\n\n  /**\n   * Build validators for the given form element to be attached to\n   * a reactive formControl.\n   *\n   * @param formElement - form element object\n   */\n  #getValidators(formElement: any): ValidatorFn[] {\n    const fo = this.formOptions();\n    const elmValidators = FormValidation.getValidators(formElement, fo?.formModel.situation);\n\n    // add custom validator for script enabled forms\n    if (this.#scriptingScope) {\n      elmValidators.push(FormValidation.customScriptingValidation);\n    }\n\n    return elmValidators;\n  }\n\n  /**\n   * Extract the values from the form\n   */\n  #formToData() {\n    const fo = this.formOptions();\n    return fo && this.form ? this.#formHelperService.extractFormData(this.form, fo.formModel.situation, fo.data, this.isInnerTableForm()) : {};\n  }\n\n  /**\n   * Merge data into a form model.\n   *\n   * @param model - form model\n   * @param data - data object or array of SearchFilter objects in case of a search form\n   */\n  #dataToForm(model: any, data: any) {\n    if (model && data) {\n      this.#setElementValues(model.elements, data);\n    }\n    return model;\n  }\n\n  // recursive method for adding values to model elements\n  #setElementValues(elements: any[], data: Record<string, unknown>) {\n    elements?.forEach((element) => {\n      if (this.#hasValue(data, element)) {\n        element.value = this.#getValue(data, element);\n      } else {\n        delete element.value;\n      }\n      if (element.type !== 'TABLE' && element.elements && element.elements.length > 0) {\n        this.#setElementValues(element.elements, data);\n      }\n    });\n  }\n\n  #hasValue(data: Record<string, unknown>, element: any) {\n    // differ between array of SearchFilters and a form data object\n    if (Array.isArray(data)) {\n      return !!data.find((filter) => filter.property === element.id);\n    } else {\n      return Object.keys(data).includes(element.name);\n    }\n  }\n\n  #getValue(data: Record<string, unknown>, element: any) {\n    return data[element.name];\n  }\n\n  ngOnDestroy() {\n    this.unsubscribeAll();\n    this.#formScriptingApiService.unregisterActiveForm(this);\n  }\n\n  ngAfterViewInit() {\n    this.#cdRef.detectChanges();\n  }\n\n  // unsubscribe from all value change listeners for the current form\n  // to avoid memory leaks. This method will also be called every time\n  // a new form is rendered to get rid of the old form element subscriptions\n  private unsubscribeAll() {\n    if (this.#subscriptions.length) {\n      console.debug('unsubscribed from ' + this.#subscriptions.length + ' value change listeners.');\n      this.#subscriptions.forEach((s) => s.unsubscribe());\n      this.#subscriptions = [];\n    }\n  }\n}\n","@let fo = formOptions();\n@if (fo && form) {\n  <div class=\"yuv-object-form\" [formGroup]=\"form\">\n    <div class=\"form-element-wrap core\">\n      <yuv-object-form-group [group]=\"getGroup('core')\" [situation]=\"fo.formModel.situation\"></yuv-object-form-group>\n    </div>\n    <div class=\"form-element-wrap data\">\n      <yuv-object-form-group [group]=\"getGroup('data')\" [situation]=\"fo.formModel.situation\"></yuv-object-form-group>\n    </div>\n  </div>\n}\n"]}