@eo-sdk/client 10.7.0-rc.5 → 11.0.0-beta.1

package/esm2022/app/eo-framework/object-form/object-form/object-form-script/object-form-scripting-scope.mjs

@@ -0,0 +1,267 @@
+import * as _ from 'lodash';
+// This class will be injected as scope into form scripts
+export class ObjectFormScriptingScope {
+    /**
+     * Constructor
+     * @param situation - Current form model situation (could be CREATE, SEARCH or EDIT)
+     * @param onScriptingModelChange - callback function to be called when the scripting model changed
+     * Be aware to provide an instance method as callback for the scripting scope.
+     * @see: https://blog.johnnyreilly.com/2014/04/typescript-instance-methods.html
+     *
+     * @param api - Plugin API reference
+     * @param isTableRowScope - set this to true if the current scripting scope is created for a
+     * row editing form from a table element. It will then provide the right parameters for the scripting functions
+     */
+    constructor(situation, onScriptingModelChange, api, isTableRowScope) {
+        this.situation = situation;
+        this.onScriptingModelChange = onScriptingModelChange;
+        this.api = api;
+        this.isTableRowScope = isTableRowScope;
+        // List of all form fields (elements)
+        this.model = {};
+        // all data values including invisible elements (READONLY)
+        this.data = {};
+        // actions passed by BPM forms
+        this.actions = {};
+        // additional objects provided by the object form
+        // used for example to pass dms objects attached to a work item
+        // to the script (READONLY)
+        // may contain: FormScriptDmsObject, FileEntry
+        this.objects = [];
+        this.context = { id: '', title: '', typeName: '' };
+    }
+    /**
+     * Sets the internal model and wraps every model element with an observer to be
+     * able to track their changes from within a form script
+     * @param model
+     */
+    setModel(model) {
+        this.model = {};
+        for (let k of Object.keys(model)) {
+            this.model[k] = new ScopeElement(model[k], this.onScriptingModelChange);
+        }
+    }
+    /**
+     * Returns the observed model. Used for row editing forms of table elements that
+     * create their own scripting scope in context of their parent form.
+     * @returns the observed scripting scope model
+     */
+    getModel() {
+        return this.model;
+    }
+    /**
+     * Called by the object form when the form model changes.
+     * @param change - object with key equals name of the element
+     * that changes and value of the new value
+     */
+    modelChanged(change) {
+        // find the changed element in the scopes model
+        let propertyName = Object.keys(change)[0];
+        if (change[propertyName] === undefined) {
+            return;
+        }
+        if (this.model[propertyName]) {
+            let el = this.model[propertyName];
+            el.update(change[propertyName], this.model);
+        }
+    }
+}
+class ScopeElement {
+    constructor(originalElement, onScriptingModelChange) {
+        this.originalElement = originalElement;
+        this.onScriptingModelChange = onScriptingModelChange;
+        this.element = _.cloneDeep(originalElement);
+        if (this.element.value === undefined) {
+            this.element.value = null;
+        }
+        if (this.isProxyable(this.element.value)) {
+            this.element.value = this.createProxy(this.element.value);
+        }
+    }
+    isProxyable(value, key) {
+        return (typeof value === 'object' || Array.isArray(value))
+            && value !== null
+            && !(value instanceof Date)
+            && !value.isProxy
+            && (key ? !key.includes('_meta') : true);
+    }
+    createProxy(value) {
+        const handler = {
+            set: (target, key, val) => {
+                const previousValue = _.cloneDeep(this.element.value);
+                target[key] = val;
+                if (this.hasValueChanged(this.element.value, previousValue) && !key.includes('_meta')) {
+                    this.onScriptingModelChange(this.element.name, { newValue: _.cloneDeep(this.element.value), name: 'value' });
+                }
+                return true;
+            },
+            // This get trap is only used to find out, if an object is a proxy or not.
+            get: (target, key) => {
+                if (key === 'isProxy') {
+                    return true;
+                }
+                return target[key];
+            }
+        };
+        return new Proxy(value, handler);
+    }
+    hasValueChanged(value1, value2) {
+        let v1 = value1;
+        let v2 = value2;
+        if (Array.isArray(value1) && typeof value1[0] === 'object' && Array.isArray(value2) && typeof value2[0] === 'object') { // this is only the case in tables
+            v1 = value1.map(entry => this.createEntryWithoutMetadata(entry)); // removing metadata from every row, because it's insignificant for change detection
+            v2 = value2.map(entry => this.createEntryWithoutMetadata(entry)); // and can cause false "true"-results
+        }
+        return JSON.stringify(v1) !== JSON.stringify(v2);
+    }
+    createEntryWithoutMetadata(entry) {
+        let entryWithoutMetadata = { ...entry };
+        Object.keys(entryWithoutMetadata).forEach(key => {
+            delete entryWithoutMetadata[key + '_meta'];
+        });
+        return entryWithoutMetadata;
+    }
+    update(value, model) {
+        const newValue = _.cloneDeep(value);
+        if (this.hasValueChanged(this.element.value, value)) {
+            if (this.isProxyable(newValue)) {
+                this.element.value = this.createProxy(newValue);
+            }
+            else {
+                this.element.value = newValue;
+            }
+            if (this.element.onchange) {
+                this.element.onchange(this, model);
+            }
+        }
+    }
+    set value(value) {
+        if (this.isProxyable(value)) {
+            this.element.value = this.createProxy(value);
+        }
+        else {
+            this.element.value = value;
+        }
+        this.onScriptingModelChange(this.element.name, { newValue: _.cloneDeep(this.element.value), name: 'value' });
+    }
+    get value() {
+        return this.element.value;
+    }
+    set onchange(onchange) {
+        this.element.onchange = onchange;
+        this.onScriptingModelChange(this.element.name, { newValue: onchange, name: 'onchange' });
+    }
+    get onchange() {
+        return this.element.onchange;
+    }
+    set required(required) {
+        if (this.hasValueChanged(this.element.required, required)) {
+            this.element.required = required;
+            this.onScriptingModelChange(this.element.name, { newValue: required, name: 'required' });
+        }
+    }
+    get required() {
+        return this.element.required;
+    }
+    set readonly(readonly) {
+        this.element.readonly = readonly;
+        this.onScriptingModelChange(this.element.name, { newValue: readonly, name: 'readonly' });
+    }
+    get readonly() {
+        return this.element.readonly;
+    }
+    set error(error) {
+        if (this.hasValueChanged(this.element.error, error)) {
+            this.element.error = error;
+            this.onScriptingModelChange(this.element.name, { newValue: error, name: 'error' });
+        }
+    }
+    get error() {
+        return this.element.error;
+    }
+    set onrowedit(onrowedit) {
+        this.element.onrowedit = onrowedit;
+        this.onScriptingModelChange(this.element.name, { newValue: onrowedit, name: 'onrowedit' });
+    }
+    get onrowedit() {
+        return this.element.onrowedit;
+    }
+    set contextId(contextId) {
+        this.element.contextId = contextId;
+        this.onScriptingModelChange(this.element.name, { newValue: contextId, name: 'contextId' });
+    }
+    get contextId() {
+        return this.element.contextId;
+    }
+    setList(obj) {
+        if (this.originalElement.setList) {
+            this.originalElement.setList(obj);
+        }
+    }
+    applyFilter(func) {
+        if (this.originalElement.applyFilter) {
+            this.originalElement.applyFilter(func);
+        }
+    }
+    applyDisablingFilter(func) {
+        if (this.originalElement.applyDisablingFilter) {
+            this.originalElement.applyDisablingFilter(func);
+        }
+    }
+    setFilter(obj) {
+        if (this.originalElement.setFilter) {
+            this.originalElement.setFilter(obj);
+        }
+    }
+    setQueryFilters(queryFiltersObject, objectTypes) {
+        if (this.originalElement.setQueryFilters) {
+            this.originalElement.setQueryFilters(queryFiltersObject, objectTypes);
+        }
+    }
+    get name() {
+        return this.element.name;
+    }
+    get qname() {
+        return this.element.qname;
+    }
+    get label() {
+        return this.element.label;
+    }
+    get description() {
+        return this.element.description;
+    }
+    get type() {
+        return this.element.type;
+    }
+    get multiselect() {
+        return this.element.multiselect;
+    }
+    get codesystem() {
+        return this.element.codesystem;
+    }
+    get minlen() {
+        return this.element.minlen;
+    }
+    get maxlen() {
+        return this.element.maxlen;
+    }
+    get classification() {
+        return this.element.classification;
+    }
+    get scale() {
+        return this.element.scale;
+    }
+    get precision() {
+        return this.element.precision;
+    }
+    get withtime() {
+        return this.element.withtime;
+    }
+    get elements() {
+        return this.element.elements;
+    }
+    get aliases() {
+        return this.element.aliases;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object-form-scripting-scope.js","sourceRoot":"","sources":["../../../../../../../../../src/app/eo-framework/object-form/object-form/object-form-script/object-form-scripting-scope.ts"],"names":[],"mappings":"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","sourcesContent":["import * as _ from 'lodash';\n\n// This class will be injected as scope into form scripts\nexport class ObjectFormScriptingScope {\n\n  // List of all form fields (elements)\n  public model: any = {};\n\n  // all data values including invisible elements (READONLY)\n  public data: any = {};\n\n  // The id of the current DMS-Object (READONLY)\n  public objectId: string;\n\n  // actions passed by BPM forms\n  public actions: any = {};\n  // additional objects provided by the object form\n  // used for example to pass dms objects attached to a work item\n  // to the script (READONLY)\n  // may contain: FormScriptDmsObject, FileEntry\n  public objects: any[] = [];\n  public context: { id: string, title: string, typeName: string } = {id: '', title: '', typeName: ''};\n\n\n  /**\n   * Constructor\n   * @param situation - Current form model situation (could be CREATE, SEARCH or EDIT)\n   * @param onScriptingModelChange - callback function to be called when the scripting model changed\n   * Be aware to provide an instance method as callback for the scripting scope.\n   * @see: https://blog.johnnyreilly.com/2014/04/typescript-instance-methods.html\n   *\n   * @param api - Plugin API reference\n   * @param isTableRowScope - set this to true if the current scripting scope is created for a\n   * row editing form from a table element. It will then provide the right parameters for the scripting functions\n   */\n  constructor(public situation: string,\n              private onScriptingModelChange,\n              public api: any,\n              private isTableRowScope?: boolean) {\n  }\n\n  /**\n   * Sets the internal model and wraps every model element with an observer to be\n   * able to track their changes from within a form script\n   * @param model\n   */\n  public setModel(model: any) {\n    this.model = {};\n    for (let k of Object.keys(model)) {\n      this.model[k] = new ScopeElement(model[k], this.onScriptingModelChange);\n    }\n  }\n\n  /**\n   * Returns the observed model. Used for row editing forms of table elements that\n   * create their own scripting scope in context of their parent form.\n   * @returns the observed scripting scope model\n   */\n  public getModel() {\n    return this.model;\n  }\n\n  /**\n   * Called by the object form when the form model changes.\n   * @param change - object with key equals name of the element\n   * that changes and value of the new value\n   */\n  public modelChanged(change: any) {\n\n    // find the changed element in the scopes model\n    let propertyName = Object.keys(change)[0];\n    if (change[propertyName] === undefined) {\n      return;\n    }\n\n    if (this.model[propertyName]) {\n      let el = this.model[propertyName];\n      el.update(change[propertyName], this.model);\n    }\n  }\n}\n\nclass ScopeElement {\n  private element;\n\n  constructor(private originalElement: any, private onScriptingModelChange: Function) {\n    this.element = _.cloneDeep(originalElement);\n    if (this.element.value === undefined) {\n      this.element.value = null;\n    }\n    if (this.isProxyable(this.element.value)) {\n      this.element.value = this.createProxy(this.element.value);\n    }\n  }\n\n  private isProxyable(value, key?: string) {\n    return (typeof value === 'object' || Array.isArray(value))\n      && value !== null\n      && !(value instanceof Date)\n      && !value.isProxy\n      && (key ? !key.includes('_meta') : true);\n  }\n\n  private createProxy(value) {\n    const handler = {\n      set: (target, key, val) => {\n        const previousValue = _.cloneDeep(this.element.value);\n        target[key] = val;\n        if (this.hasValueChanged(this.element.value, previousValue) && !key.includes('_meta')) {\n          this.onScriptingModelChange(this.element.name, {newValue: _.cloneDeep(this.element.value), name: 'value'});\n        }\n        return true;\n      },\n      // This get trap is only used to find out, if an object is a proxy or not.\n      get: (target, key) => {\n        if (key === 'isProxy') {\n          return true;\n        }\n        return target[key];\n      }\n    };\n\n    return new Proxy(value, handler);\n  }\n\n  private hasValueChanged(value1, value2) {\n    let v1 = value1;\n    let v2 = value2;\n    if(Array.isArray(value1) && typeof value1[0] === 'object' && Array.isArray(value2) && typeof value2[0] === 'object'){// this is only the case in tables\n      v1 = value1.map(entry => this.createEntryWithoutMetadata(entry));// removing metadata from every row, because it's insignificant for change detection\n      v2 = value2.map(entry => this.createEntryWithoutMetadata(entry));// and can cause false \"true\"-results\n    }\n    return JSON.stringify(v1) !== JSON.stringify(v2);\n  }\n\n  private createEntryWithoutMetadata(entry){\n    let entryWithoutMetadata = {...entry};\n    Object.keys(entryWithoutMetadata).forEach(key => {\n      delete entryWithoutMetadata[key + '_meta'];\n    });\n    return entryWithoutMetadata;\n  }\n\n  update(value, model) {\n    const newValue = _.cloneDeep(value);\n    if (this.hasValueChanged(this.element.value, value)) {\n      if (this.isProxyable(newValue)) {\n        this.element.value = this.createProxy(newValue);\n      } else {\n        this.element.value = newValue;\n      }\n      if (this.element.onchange) {\n        this.element.onchange(this, model);\n      }\n    }\n  }\n\n  set value(value) {\n    if (this.isProxyable(value)) {\n      this.element.value = this.createProxy(value);\n    } else {\n      this.element.value = value;\n    }\n    this.onScriptingModelChange(this.element.name, {newValue: _.cloneDeep(this.element.value), name: 'value'});\n  }\n\n  get value() {\n    return this.element.value;\n  }\n\n  set onchange(onchange) {\n    this.element.onchange = onchange;\n    this.onScriptingModelChange(this.element.name, {newValue: onchange, name: 'onchange'});\n  }\n\n  get onchange() {\n    return this.element.onchange;\n  }\n\n  set required(required) {\n    if(this.hasValueChanged(this.element.required, required)){\n      this.element.required = required;\n      this.onScriptingModelChange(this.element.name, {newValue: required, name: 'required'});\n    }\n  }\n\n  get required() {\n    return this.element.required;\n  }\n\n  set readonly(readonly) {\n    this.element.readonly = readonly;\n    this.onScriptingModelChange(this.element.name, {newValue: readonly, name: 'readonly'});\n  }\n\n  get readonly() {\n    return this.element.readonly;\n  }\n\n  set error(error) {\n    if(this.hasValueChanged(this.element.error, error)){\n      this.element.error = error;\n      this.onScriptingModelChange(this.element.name, {newValue: error, name: 'error'});\n    }\n  }\n\n  get error() {\n    return this.element.error;\n  }\n\n  set onrowedit(onrowedit) {\n    this.element.onrowedit = onrowedit;\n    this.onScriptingModelChange(this.element.name, {newValue: onrowedit, name: 'onrowedit'});\n  }\n\n  get onrowedit() {\n    return this.element.onrowedit;\n  }\n\n  set contextId(contextId) {\n    this.element.contextId = contextId;\n    this.onScriptingModelChange(this.element.name, {newValue: contextId, name: 'contextId'});\n  }\n\n  get contextId() {\n    return this.element.contextId;\n  }\n\n  setList(obj) {\n    if (this.originalElement.setList) {\n      this.originalElement.setList(obj);\n    }\n  }\n\n  applyFilter(func) {\n    if (this.originalElement.applyFilter) {\n      this.originalElement.applyFilter(func);\n    }\n  }\n\n  applyDisablingFilter(func) {\n    if (this.originalElement.applyDisablingFilter) {\n      this.originalElement.applyDisablingFilter(func);\n    }\n  }\n\n  setFilter(obj) {\n    if (this.originalElement.setFilter) {\n      this.originalElement.setFilter(obj);\n    }\n  }\n\n  setQueryFilters(queryFiltersObject: {[fieldQname: string]: {o: string, v1: any, v2: any}}, objectTypes?: string[]) {\n    if (this.originalElement.setQueryFilters) {\n      this.originalElement.setQueryFilters(queryFiltersObject, objectTypes);\n    }\n  }\n\n  get name() {\n    return this.element.name;\n  }\n\n  get qname() {\n    return this.element.qname;\n  }\n\n  get label() {\n    return this.element.label;\n  }\n\n  get description() {\n    return this.element.description;\n  }\n\n  get type() {\n    return this.element.type;\n  }\n\n  get multiselect() {\n    return this.element.multiselect;\n  }\n\n  get codesystem() {\n    return this.element.codesystem;\n  }\n\n  get minlen() {\n    return this.element.minlen;\n  }\n\n  get maxlen() {\n    return this.element.maxlen;\n  }\n\n  get classification() {\n    return this.element.classification;\n  }\n\n  get scale() {\n    return this.element.scale;\n  }\n\n  get precision() {\n    return this.element.precision;\n  }\n\n  get withtime() {\n    return this.element.withtime;\n  }\n\n  get elements() {\n    return this.element.elements;\n  }\n\n  get aliases() {\n    return this.element.aliases;\n  }\n}\n"]}

package/esm2022/app/eo-framework/object-form/object-form/object-form.component.mjs

@@ -0,0 +1,148 @@
+import { Component, EventEmitter, Input, Output, } from '@angular/core';
+import { Utils } from '@eo-sdk/core';
+import * as _ from 'lodash';
+import { debounceTime } from 'rxjs/operators';
+import { ObjectFormScriptService } from './object-form-script/object-form-script.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@eo-sdk/core";
+import * as i2 from "./object-form-script/object-form-script.service";
+import * as i3 from "../object-form-helper.service";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/forms";
+import * as i6 from "../../ui/rtl-aware/rtl-aware.directive";
+import * as i7 from "./object-form-group/object-form-group.component";
+export class ObjectFormComponent {
+    set options(formOptions) {
+        this.defaultFormOptions = formOptions;
+        this.formOptions = _.cloneDeep(formOptions);
+        this.init();
+    }
+    constructor(logger, elementRef, formScriptService, formHelperService, cdRef) {
+        this.logger = logger;
+        this.elementRef = elementRef;
+        this.formScriptService = formScriptService;
+        this.formHelperService = formHelperService;
+        this.cdRef = cdRef;
+        // triggered when the forms state has been changed
+        this.statusChanged = new EventEmitter();
+        // handler to be executed after the form has been set up
+        this.onFormReady = new EventEmitter();
+        this.subscriptions = [];
+    }
+    // initialize the form based on the provided form options
+    init() {
+        this.form = null;
+        setTimeout(() => {
+            this.unsubscribeAll();
+            this.buildReactiveForm(this.formOptions || {});
+        }, 0);
+    }
+    initOptions() {
+        this.options = this.defaultFormOptions;
+    }
+    focusForm() {
+        this.elementRef.nativeElement.querySelector('input').focus();
+    }
+    setFormData(data) {
+        this.formOptions.data = data;
+        setTimeout(() => {
+            this.init();
+        }, 0);
+    }
+    /**
+     * 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 (in SEARCH situation the `qname` field is used).
+     *
+     * How values are extracted is influenced by the forms situation.
+     *
+     * @return object of key value pairs
+     */
+    getFormData() {
+        return this.formToData();
+    }
+    setFormPristine() {
+        this.form.markAsPristine();
+    }
+    // reset the form to its initial state
+    resetForm() {
+        this.initOptions();
+        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) {
+        const formGenRes = this.formHelperService.buildReactiveForm(formOptions, this.formScriptService, this.isInnerTableForm);
+        this.form = formGenRes.form;
+        this.scriptingScope = formGenRes.scriptingScope;
+        this.subscriptions = formGenRes.controlValueSubscriptions;
+        setTimeout(() => {
+            if (!this.form)
+                return;
+            let formWatch = this.form.valueChanges.pipe(debounceTime(500))
+                .subscribe(() => !formWatch.closed && this.emitFormChangedEvent());
+            this.subscriptions.push(formWatch);
+            this.onFormReady.emit();
+            this.emitFormChangedEvent(false);
+        }, 300);
+    }
+    emitFormChangedEvent(compare = true) {
+        // check if indexdata has been changed
+        let currentFormData = this.getFormData();
+        let idxChange = compare ? JSON.stringify(this.formData) !== JSON.stringify(currentFormData) : false;
+        this.formData = Utils.formDataParse(Utils.formDataStringify(currentFormData));
+        if (this.form) {
+            this.statusChanged.emit({
+                invalid: this.form.invalid,
+                dirty: this.form.dirty,
+                data: this.formData,
+                indexdataChanged: idxChange
+            });
+        }
+    }
+    /**
+     * Extract the values from the form
+     */
+    formToData() {
+        return this.formHelperService.extractFormData(this.form, this.formOptions.formModel.situation, this.formOptions.data, this.isInnerTableForm);
+    }
+    ngOnDestroy() {
+        this.unsubscribeAll();
+    }
+    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) {
+            this.logger.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: "17.1.2", ngImport: i0, type: ObjectFormComponent, deps: [{ token: i1.Logger }, { token: i0.ElementRef }, { token: i2.ObjectFormScriptService }, { token: i3.ObjectFormHelperService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.2", type: ObjectFormComponent, selector: "eo-object-form", inputs: { isInnerTableForm: "isInnerTableForm", options: ["formOptions", "options"] }, outputs: { statusChanged: "statusChanged", onFormReady: "onFormReady" }, providers: [ObjectFormScriptService], ngImport: i0, template: "<div class=\"eo-object-form\" *ngIf=\"form && formOptions\" [formGroup]=\"form\" eoRtlAware>\n  <div class=\"form-element-wrap core\">\n    <eo-form-group [group]=\"form.get('core')\" [situation]=\"formOptions.formModel.situation\"></eo-form-group>\n  </div>\n  <div class=\"form-element-wrap data\">\n    <eo-form-group [group]=\"form.get('data')\" [situation]=\"formOptions.formModel.situation\"></eo-form-group>\n  </div>\n</div>\n\n\n\n\n", styles: [":host{display:block}:host .eo-object-form .core{padding:var(--app-pane-padding) var(--app-pane-padding) calc(var(--app-pane-padding) * 2) var(--app-pane-padding)}:host .eo-object-form .ui-tabview{padding:0}:host::ng-deep .eo-object-form>.data>eo-form-group>.form-element.o2mGroupStack{background:transparent;border:0}:host::ng-deep .eo-object-form>.data>eo-form-group>.form-element.o2mGroupStack>eo-form-group>.o2mGroup{background-color:var(--panel-background-lightgrey);border-top:1px solid rgba(var(--color-black-rgb),.1);padding:var(--app-pane-padding)}:host::ng-deep .eo-object-form>.data>eo-form-group>.form-element.o2mGroupStack>p-tabview>.ui-tabview>.ui-tabview-panels{background-color:var(--panel-background-lightgrey)}:host-context(.dark)::ng-deep .eo-object-form>.data>eo-form-group>.form-element.o2mGroupStack>eo-form-group>.o2mGroup{background-color:rgba(var(--color-white-rgb),.1);border-top:1px solid rgba(var(--color-white-rgb),.1)}:host-context(.dark)::ng-deep .eo-object-form>.data>eo-form-group>.form-element.o2mGroupStack>p-tabview>.ui-tabview>.ui-tabview-panels{background-color:rgba(var(--color-white-rgb),.1)}\n"], dependencies: [{ kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i5.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i5.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i6.RtlAwareDirective, selector: "[eoRtlAware]", inputs: ["eoRtlAware"] }, { kind: "component", type: i7.ObjectFormGroupComponent, selector: "eo-form-group", inputs: ["situation", "skipToggle", "group", "noGroupLabels"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ObjectFormComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'eo-object-form', providers: [ObjectFormScriptService], template: "<div class=\"eo-object-form\" *ngIf=\"form && formOptions\" [formGroup]=\"form\" eoRtlAware>\n  <div class=\"form-element-wrap core\">\n    <eo-form-group [group]=\"form.get('core')\" [situation]=\"formOptions.formModel.situation\"></eo-form-group>\n  </div>\n  <div class=\"form-element-wrap data\">\n    <eo-form-group [group]=\"form.get('data')\" [situation]=\"formOptions.formModel.situation\"></eo-form-group>\n  </div>\n</div>\n\n\n\n\n", styles: [":host{display:block}:host .eo-object-form .core{padding:var(--app-pane-padding) var(--app-pane-padding) calc(var(--app-pane-padding) * 2) var(--app-pane-padding)}:host .eo-object-form .ui-tabview{padding:0}:host::ng-deep .eo-object-form>.data>eo-form-group>.form-element.o2mGroupStack{background:transparent;border:0}:host::ng-deep .eo-object-form>.data>eo-form-group>.form-element.o2mGroupStack>eo-form-group>.o2mGroup{background-color:var(--panel-background-lightgrey);border-top:1px solid rgba(var(--color-black-rgb),.1);padding:var(--app-pane-padding)}:host::ng-deep .eo-object-form>.data>eo-form-group>.form-element.o2mGroupStack>p-tabview>.ui-tabview>.ui-tabview-panels{background-color:var(--panel-background-lightgrey)}:host-context(.dark)::ng-deep .eo-object-form>.data>eo-form-group>.form-element.o2mGroupStack>eo-form-group>.o2mGroup{background-color:rgba(var(--color-white-rgb),.1);border-top:1px solid rgba(var(--color-white-rgb),.1)}:host-context(.dark)::ng-deep .eo-object-form>.data>eo-form-group>.form-element.o2mGroupStack>p-tabview>.ui-tabview>.ui-tabview-panels{background-color:rgba(var(--color-white-rgb),.1)}\n"] }]
+        }], ctorParameters: () => [{ type: i1.Logger }, { type: i0.ElementRef }, { type: i2.ObjectFormScriptService }, { type: i3.ObjectFormHelperService }, { type: i0.ChangeDetectorRef }], propDecorators: { isInnerTableForm: [{
+                type: Input
+            }], statusChanged: [{
+                type: Output
+            }], onFormReady: [{
+                type: Output
+            }], options: [{
+                type: Input,
+                args: ['formOptions']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object-form.component.js","sourceRoot":"","sources":["../../../../../../../../src/app/eo-framework/object-form/object-form/object-form.component.ts","../../../../../../../../src/app/eo-framework/object-form/object-form/object-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  Output,\n} from '@angular/core';\nimport {Logger, Utils} from '@eo-sdk/core';\nimport * as _ from 'lodash';\nimport {Subscription} from 'rxjs';\nimport {debounceTime} from 'rxjs/operators';\n\nimport {FormStatusChangedEvent} from '../form-status-changed-event.interface';\nimport {FormGenResult, ObjectFormHelperService} from '../object-form-helper.service';\nimport {ObjectFormOptions} from '../object-form-options.interface';\nimport {ObjectFormScriptService} from './object-form-script/object-form-script.service';\nimport {ObjectFormScriptingScope} from './object-form-script/object-form-scripting-scope';\n\n\n@Component({\n  selector: 'eo-object-form',\n  templateUrl: './object-form.component.html',\n  styleUrls: ['./object-form.component.scss'],\n  // define 'child only' services for the form without setting it up on the module\n  // which would cause them to be propagated to the whole application\n  providers: [ObjectFormScriptService],\n})\nexport class ObjectFormComponent implements OnDestroy, AfterViewInit {\n\n  @Input() isInnerTableForm: boolean;\n  // triggered when the forms state has been changed\n  @Output() statusChanged = new EventEmitter<FormStatusChangedEvent>();\n  // handler to be executed after the form has been set up\n  @Output() onFormReady = new EventEmitter();\n\n  public formOptions: ObjectFormOptions;\n  public defaultFormOptions: ObjectFormOptions;\n  // the actual form instance\n  public form;\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  private formData: any;\n  private scriptingScope: ObjectFormScriptingScope;\n  private subscriptions: Subscription[] = [];\n\n  @Input('formOptions')\n  set options(formOptions: ObjectFormOptions) {\n    this.defaultFormOptions = formOptions;\n    this.formOptions = _.cloneDeep(formOptions);\n    this.init();\n  }\n\n  constructor(private logger: Logger,\n    private elementRef: ElementRef,\n    private formScriptService: ObjectFormScriptService,\n    private formHelperService: ObjectFormHelperService,\n    private cdRef: ChangeDetectorRef) {\n  }\n\n  // initialize the form based on the provided form options\n  private init() {\n    this.form = null;\n    setTimeout(() => {\n      this.unsubscribeAll();\n      this.buildReactiveForm(this.formOptions || {});\n    }, 0);\n  }\n\n  private initOptions() {\n    this.options = this.defaultFormOptions;\n  }\n\n  public focusForm() {\n    this.elementRef.nativeElement.querySelector('input').focus();\n  }\n\n  public setFormData(data) {\n    this.formOptions.data = data;\n    setTimeout(() => {\n      this.init();\n    }, 0);\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 (in SEARCH situation the `qname` field is used).\n   *\n   * How values are extracted is influenced by the forms situation.\n   *\n   * @return object of key value pairs\n   */\n  public getFormData() {\n    return this.formToData();\n  }\n\n  public setFormPristine() {\n    this.form.markAsPristine();\n  }\n\n  // reset the form to its initial state\n  public resetForm() {\n    this.initOptions();\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  public getObservedScriptModel() {\n    return this.scriptingScope ? this.scriptingScope.getModel() : null;\n  }\n\n  // Create a reactive form from the enaio form model\n  private buildReactiveForm(formOptions) {\n    const formGenRes: FormGenResult = this.formHelperService.buildReactiveForm(\n      formOptions, this.formScriptService, this.isInnerTableForm\n    );\n    this.form = formGenRes.form;\n    this.scriptingScope = formGenRes.scriptingScope;\n    this.subscriptions = formGenRes.controlValueSubscriptions;\n\n    setTimeout(() => {\n      if (!this.form) return;\n      let formWatch = this.form.valueChanges.pipe(debounceTime(500))\n        .subscribe(() => !formWatch.closed && this.emitFormChangedEvent());\n      this.subscriptions.push(formWatch);\n      this.onFormReady.emit();\n      this.emitFormChangedEvent(false);\n    }, 300);\n  }\n\n  private emitFormChangedEvent(compare = true) {\n    // check if indexdata has been changed\n    let currentFormData = this.getFormData();\n    let idxChange = compare ? JSON.stringify(this.formData) !== JSON.stringify(currentFormData) : false;\n\n    this.formData = Utils.formDataParse(Utils.formDataStringify(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   * Extract the values from the form\n   */\n  private formToData() {\n\n    return this.formHelperService.extractFormData(\n      this.form,\n      this.formOptions.formModel.situation,\n      this.formOptions.data,\n      this.isInnerTableForm\n    );\n  }\n\n  ngOnDestroy() {\n    this.unsubscribeAll();\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      this.logger.debug('unsubscribed from ' + this.subscriptions.length + ' value change listeners.');\n      this.subscriptions.forEach(s => s.unsubscribe());\n      this.subscriptions = [];\n    }\n  }\n}\n","<div class=\"eo-object-form\" *ngIf=\"form && formOptions\" [formGroup]=\"form\" eoRtlAware>\n  <div class=\"form-element-wrap core\">\n    <eo-form-group [group]=\"form.get('core')\" [situation]=\"formOptions.formModel.situation\"></eo-form-group>\n  </div>\n  <div class=\"form-element-wrap data\">\n    <eo-form-group [group]=\"form.get('data')\" [situation]=\"formOptions.formModel.situation\"></eo-form-group>\n  </div>\n</div>\n\n\n\n\n"]}