@yuuvis/client-framework 0.6.5

package/esm2022/object-form/lib/form-scripting.service.mjs

@@ -0,0 +1,160 @@
+import { inject, Injectable, NgZone, signal } from '@angular/core';
+import { Router } from '@angular/router';
+import { ApiBase, AppCacheService, BackendService, DmsObject, DmsService, EventService, NotificationService, Operator, SearchService, SystemService, TranslateService, UserService, Utils, YuvEventType } from '@yuuvis/client-core';
+import { firstValueFrom, map } from 'rxjs';
+import * as i0 from "@angular/core";
+export class FormScriptingApiService {
+    constructor() {
+        this.#ngZone = inject(NgZone);
+        this.#router = inject(Router);
+        this.#eventService = inject(EventService);
+        this.#userService = inject(UserService);
+        this.#dmsService = inject(DmsService);
+        this.#systemService = inject(SystemService);
+        this.#searchService = inject(SearchService);
+        this.#backend = inject(BackendService);
+        this.#translate = inject(TranslateService);
+        this.#notifications = inject(NotificationService);
+        this.#appCache = inject(AppCacheService);
+        this.#activeFormComponents = new Map();
+        this.elementExtensions = signal({});
+    }
+    #ngZone;
+    #router;
+    #eventService;
+    #userService;
+    #dmsService;
+    #systemService;
+    #searchService;
+    #backend;
+    #translate;
+    #notifications;
+    #appCache;
+    static { this.EVENT_MODEL_CHANGED = 'yuv.event.object-form.model.changed'; }
+    #activeFormComponents;
+    get api() {
+        return this.getApi();
+    }
+    registerActiveForm(component) {
+        const id = component.formOptions()?.formModel?.name || component?.id;
+        return id && this.#activeFormComponents.set(id, component);
+    }
+    unregisterActiveForm(component) {
+        const id = component.formOptions()?.formModel?.name || component?.id;
+        return id && this.#activeFormComponents.delete(id);
+    }
+    getApi() {
+        const formId = this.formId;
+        return {
+            elementExtensions: {
+                register: (extensions) => {
+                    extensions.forEach((ext) => {
+                        if (ext.id)
+                            this.elementExtensions.set({ ...this.elementExtensions(), [ext.id]: ext });
+                    });
+                }
+            },
+            events: {
+                yuuvisEventType: YuvEventType,
+                on: (type) => this.#ngZone.run(() => this.#eventService.on(type)),
+                trigger: (type, data) => this.#ngZone.run(() => this.#eventService.trigger(type, data))
+            },
+            session: {
+                getUser: () => this.getCurrentUser(),
+                user: {
+                    get: () => this.getCurrentUser(),
+                    hasRole: (role) => this.getCurrentUser().authorities?.includes(role) || false
+                }
+            },
+            http: {
+                get: (uri, base, options) => this.get(uri, base, options),
+                post: (uri, data, base, options) => this.post(uri, data, base, options),
+                del: (uri, base, options) => this.del(uri, base, options),
+                put: (uri, data, base, options) => this.put(uri, data, base, options)
+            },
+            form: {
+                activeForms: this.#activeFormComponents,
+                getValue: (formControlName) => Array.from(this.#activeFormComponents.values()).reduce((prev, cur) => ({ ...prev, ...(cur.formData || {}) }), {})[formControlName],
+                setValue: (formControlName, newValue) => this.api.form.modelChange(formControlName, { name: 'value', newValue }),
+                modelChange: (formControlName, change) => this.#ngZone.run(() => this.#eventService.trigger(FormScriptingApiService.EVENT_MODEL_CHANGED, {
+                    formId,
+                    formControlName,
+                    change
+                }))
+            },
+            storage: {
+                getItem: (key) => firstValueFrom(this.#appCache.getItem(key)),
+                setItem: (key, value) => firstValueFrom(this.#appCache.setItem(key, value))
+            },
+            notifier: {
+                success: (text, title) => this.#notifications.success(title, text),
+                error: (text, title) => this.#notifications.error(title, text),
+                info: (text, title) => this.#notifications.info(title, text),
+                warning: (text, title) => this.#notifications.warning(title, text)
+            },
+            util: {
+                translate: (key, data) => this.#translate.instant(key, data)
+            }
+        };
+    }
+    get(uri, base, options) {
+        return firstValueFrom(this.#backend.get(uri, base || ApiBase.none, options || { observe: 'response' }).pipe(map((res) => {
+            return options ? res : { status: res.status, data: res.body };
+        })));
+    }
+    put(uri, data, base, options) {
+        return firstValueFrom(this.#backend.put(uri, data, base || ApiBase.none, options));
+    }
+    post(uri, data, base, options) {
+        return firstValueFrom(this.#backend.post(uri, data, base || ApiBase.none, options));
+    }
+    del(uri, base, options) {
+        return firstValueFrom(this.#backend.delete(uri, base || ApiBase.none, options));
+    }
+    getCurrentUser() {
+        return this.#userService.getCurrentUser();
+    }
+    getDmsObject(id, version) {
+        return firstValueFrom(this.#dmsService.getDmsObject(id, version))
+            .then((response) => {
+            return Promise.resolve(response);
+        })
+            .catch(this.#handleError);
+    }
+    /**
+     * fetches dms objects from the server that match the given params
+     *
+     * @param fields - the fields to match. example: {name: 'max', plz: '47111}
+     * @param type - the target object type
+     */
+    getResult(fields, type) {
+        const searchQuery = {
+            filters: Object.keys(fields).map((f) => ({
+                f,
+                o: Operator.EQUAL,
+                v1: fields[f]
+            }))
+        };
+        if (type)
+            searchQuery.types = [type];
+        return firstValueFrom(this.#searchService.search(searchQuery))
+            .then((res) => {
+            return Promise.resolve(res.items.map((resItem) => {
+                new DmsObject(resItem);
+            }));
+        })
+            .catch(this.#handleError);
+    }
+    encodeFileName(filename) {
+        return Utils.encodeFileName(filename);
+    }
+    #handleError(error) {
+        return Promise.reject(error.message || error);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormScriptingApiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormScriptingApiService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormScriptingApiService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-scripting.service.js","sourceRoot":"","sources":["../../../../../../../libs/yuuvis/client-framework/object-form/src/lib/form-scripting.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable, NgZone, signal } from '@angular/core';\nimport { Router } from '@angular/router';\nimport {\n  ApiBase,\n  AppCacheService,\n  BackendService,\n  DmsObject,\n  DmsService,\n  EventService,\n  HttpOptions,\n  NotificationService,\n  Operator,\n  SearchQuery,\n  SearchResult,\n  SearchResultItem,\n  SearchService,\n  SystemService,\n  TranslateService,\n  UserService,\n  Utils,\n  YuvEventType,\n  YuvUser\n} from '@yuuvis/client-core';\nimport { firstValueFrom, map } from 'rxjs';\nimport { FormScriptingAPI, FormScriptingElementExtension } from './form-scripting.api.interface';\nimport { ObjectFormComponent } from './object-form.component';\n\n@Injectable()\nexport class FormScriptingApiService {\n  #ngZone = inject(NgZone);\n  #router = inject(Router);\n  #eventService = inject(EventService);\n  #userService = inject(UserService);\n  #dmsService = inject(DmsService);\n  #systemService = inject(SystemService);\n  #searchService = inject(SearchService);\n  #backend = inject(BackendService);\n  #translate = inject(TranslateService);\n  #notifications = inject(NotificationService);\n  #appCache = inject(AppCacheService);\n\n  static EVENT_MODEL_CHANGED = 'yuv.event.object-form.model.changed';\n  #activeFormComponents = new Map<string, ObjectFormComponent>();\n  elementExtensions = signal<Record<string, FormScriptingElementExtension>>({});\n  formId?: string;\n\n  get api() {\n    return this.getApi();\n  }\n\n  registerActiveForm(component: ObjectFormComponent) {\n    const id = component.formOptions()?.formModel?.name || component?.id;\n    return id && this.#activeFormComponents.set(id, component);\n  }\n\n  unregisterActiveForm(component: ObjectFormComponent) {\n    const id = component.formOptions()?.formModel?.name || component?.id;\n    return id && this.#activeFormComponents.delete(id);\n  }\n\n  getApi(): FormScriptingAPI {\n    const formId = this.formId;\n    return {\n      elementExtensions: {\n        register: (extensions: FormScriptingElementExtension[]) => {\n          extensions.forEach((ext) => {\n            if (ext.id) this.elementExtensions.set({ ...this.elementExtensions(), [ext.id]: ext });\n          });\n        }\n      },\n      events: {\n        yuuvisEventType: YuvEventType,\n        on: (type: string) => this.#ngZone.run(() => this.#eventService.on(type)),\n        trigger: (type: string, data?: any) => this.#ngZone.run(() => this.#eventService.trigger(type, data))\n      },\n      session: {\n        getUser: () => this.getCurrentUser(),\n        user: {\n          get: () => this.getCurrentUser(),\n          hasRole: (role: string) => this.getCurrentUser().authorities?.includes(role) || false\n        }\n      },\n      http: {\n        get: (uri, base, options) => this.get(uri, base, options),\n        post: (uri, data, base, options) => this.post(uri, data, base, options),\n        del: (uri, base, options) => this.del(uri, base, options),\n        put: (uri, data, base, options) => this.put(uri, data, base, options)\n      },\n      form: {\n        activeForms: this.#activeFormComponents,\n        getValue: (formControlName) =>\n          Array.from(this.#activeFormComponents.values()).reduce(\n            (prev: Record<string, unknown>, cur: ObjectFormComponent) => ({ ...prev, ...(cur.formData || {}) }),\n            {}\n          )[formControlName],\n        setValue: (formControlName, newValue) => this.api.form.modelChange(formControlName, { name: 'value', newValue }),\n        modelChange: (formControlName, change) =>\n          this.#ngZone.run(() =>\n            this.#eventService.trigger(FormScriptingApiService.EVENT_MODEL_CHANGED, {\n              formId,\n              formControlName,\n              change\n            })\n          )\n      },\n      storage: {\n        getItem: (key) => firstValueFrom(this.#appCache.getItem(key)),\n        setItem: (key, value) => firstValueFrom(this.#appCache.setItem(key, value))\n      },\n      notifier: {\n        success: (text, title) => this.#notifications.success(title, text),\n        error: (text, title) => this.#notifications.error(title, text),\n        info: (text, title) => this.#notifications.info(title, text),\n        warning: (text, title) => this.#notifications.warning(title, text)\n      },\n      util: {\n        translate: (key, data) => this.#translate.instant(key, data)\n      }\n    };\n  }\n\n  get(uri: string, base?: string, options?: HttpOptions) {\n    return firstValueFrom(\n      this.#backend.get(uri, base || ApiBase.none, options || { observe: 'response' }).pipe(\n        map((res: any) => {\n          return options ? res : { status: res.status, data: res.body };\n        })\n      )\n    );\n  }\n\n  put(uri: string, data: Record<string, unknown>, base?: string, options?: HttpOptions) {\n    return firstValueFrom(this.#backend.put(uri, data, base || ApiBase.none, options));\n  }\n\n  post(uri: string, data: Record<string, unknown>, base?: string, options?: HttpOptions) {\n    return firstValueFrom(this.#backend.post(uri, data, base || ApiBase.none, options));\n  }\n\n  del(uri: string, base?: string, options?: HttpOptions) {\n    return firstValueFrom(this.#backend.delete(uri, base || ApiBase.none, options));\n  }\n\n  getCurrentUser(): YuvUser {\n    return this.#userService.getCurrentUser();\n  }\n\n  getDmsObject(id: string, version: number): Promise<DmsObject> {\n    return firstValueFrom(this.#dmsService.getDmsObject(id, version))\n      .then((response) => {\n        return Promise.resolve(response);\n      })\n      .catch(this.#handleError);\n  }\n\n  /**\n   * fetches dms objects from the server that match the given params\n   *\n   * @param fields - the fields to match. example: {name: 'max', plz: '47111}\n   * @param type - the target object type\n   */\n  getResult(fields: Record<string, unknown>, type?: string): Promise<DmsObject[]> {\n    const searchQuery: SearchQuery = {\n      filters: Object.keys(fields).map((f) => ({\n        f,\n        o: Operator.EQUAL,\n        v1: fields[f]\n      }))\n    };\n    if (type) searchQuery.types = [type];\n    return firstValueFrom(this.#searchService.search(searchQuery))\n      .then((res: SearchResult) => {\n        return Promise.resolve(\n          res.items.map((resItem: SearchResultItem) => {\n            new DmsObject(resItem);\n          })\n        );\n      })\n      .catch(this.#handleError);\n  }\n\n  encodeFileName(filename: string) {\n    return Utils.encodeFileName(filename);\n  }\n\n  #handleError(error: any): Promise<any> {\n    return Promise.reject(error.message || error);\n  }\n}\n"]}

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

@@ -0,0 +1,87 @@
+import { CommonModule, NgComponentOutlet } from '@angular/common';
+import { Component, computed, DestroyRef, effect, inject, input, signal, untracked, ViewEncapsulation } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { ReactiveFormsModule } from '@angular/forms';
+import { Classification, Situation } from '@yuuvis/client-core';
+import { MetadataFormFieldComponent } from '@yuuvis/client-framework/metadata-form';
+import { ObjectFormTranslateService } from '../object-form-translate.service';
+import { ObjectFormService } from '../object-form.service';
+import { FormScriptingApiService } from '../form-scripting.service';
+import { FormScriptingElementExtensionComponent } from '../object-form-script/form-scripting-element-extension/form-scripting-element-extension.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+export class ObjectFormElementComponent {
+    constructor() {
+        this.#destroyRef = inject(DestroyRef);
+        this.#formTranslateService = inject(ObjectFormTranslateService);
+        this.#objectFormService = inject(ObjectFormService);
+        this.#scriptingApi = inject(FormScriptingApiService);
+        this.createForm = signal(false);
+        this.extensionComponents = [];
+        this.#scriptingExtensions = this.#scriptingApi.elementExtensions;
+        this.scriptingExtensions = computed(() => Object.values(this.#scriptingExtensions()).filter((ext) => ext.propertyName === this.formControlName));
+        this.scriptExtensionCmp = FormScriptingElementExtensionComponent;
+        this.situation = input();
+        this.element = input();
+        this.#elementEffect = effect(() => {
+            const element = this.element();
+            untracked(() => {
+                this.createForm.set(true);
+                element && this.#setElement(this.element());
+            });
+        });
+    }
+    #destroyRef;
+    #formTranslateService;
+    #objectFormService;
+    #scriptingApi;
+    #scriptingExtensions;
+    #elementEffect;
+    get extensionComponentInput() {
+        const xti = {
+            formControlName: this.formControlName || ''
+        };
+        return xti;
+    }
+    #setElement(el) {
+        if (el && el._eoFormControlWrapper) {
+            this.formControlName = el._eoFormControlWrapper.controlName;
+            this.formElementRef = el.controls[this.formControlName];
+            this.formElementRef._eoFormElement = this.#setGrouping(this.formElementRef?._eoFormElement);
+            this.formElementRef?.valueChanges.pipe(takeUntilDestroyed(this.#destroyRef)).subscribe(() => this.#setupErrors());
+            this.extensionComponents = this.#objectFormService.getElementExtensions(this.formControlName);
+            this.createForm.set(false);
+        }
+    }
+    /**
+     * formating rules...
+     * https://wiki.optimal-systems.de/display/PM/Status+yuuvis+Momentum+-+Flex+client
+     */
+    #setGrouping(formElement) {
+        return { ...formElement, grouping: !!formElement?.classifications?.includes(Classification.NUMBER_DIGIT) };
+    }
+    onDataMetaChange(data) {
+        this.formElementRef._eoFormElement.dataMeta = data;
+    }
+    #setupErrors() {
+        this.errors = undefined;
+        if ((this.situation() !== Situation.SEARCH && this.situation() !== Situation.CREATE && this.formElementRef.errors) ||
+            ((this.situation() === Situation.SEARCH || this.situation() === Situation.CREATE) &&
+                this.formElementRef.errors &&
+                (this.formElementRef.dirty || this.formElementRef.touched))) {
+            this.errors = Object.keys(this.formElementRef.errors).map((key) => {
+                return key === 'eoformScript'
+                    ? this.formElementRef._eoFormElement.error.msg
+                    : this.#formTranslateService.getErrorLabel(key, this.formElementRef.errors[key].params);
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectFormElementComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: ObjectFormElementComponent, isStandalone: true, selector: "yuv-object-form-element", inputs: { situation: { classPropertyName: "situation", publicName: "situation", isSignal: true, isRequired: false, transformFunction: null }, element: { classPropertyName: "element", publicName: "element", isSignal: true, isRequired: false, transformFunction: null } }, host: { classAttribute: "yuv-object-form-element" }, ngImport: i0, template: "@let el = element();\n\n@if (!createForm()) {\n  @if (el && formElementRef) {\n    <div class=\"form-element input\" [formGroup]=\"el\">\n      <yuv-metadata-form-field\n        [field]=\"formElementRef._eoFormElement\"\n        [formControlName]=\"el._eoFormControlWrapper!.controlName\"\n        [situation]=\"situation()\"\n      ></yuv-metadata-form-field>\n\n      <div class=\"ext\">\n        @for (cmp of extensionComponents; track $index) {\n          <ng-container *ngComponentOutlet=\"cmp; inputs: { input: extensionComponentInput }\"></ng-container>\n        }\n        @for (scmp of scriptingExtensions(); track $index) {\n          <ng-container *ngComponentOutlet=\"scriptExtensionCmp; inputs: { ext: scmp }\"></ng-container>\n        }\n      </div>\n    </div>\n  }\n}\n", styles: [":host{flex:1 1 auto}.yuv-object-form-element .form-element{box-sizing:border-box;display:flex;flex-flow:row nowrap}.yuv-object-form-element .form-element .ext{display:flex;flex-flow:row nowrap;gap:2px;align-items:center}.yuv-object-form-element .form-element yuv-metadata-form-field{width:100%}.yuv-object-form-element .form-element .form-field{padding:calc(var(--app-pane-padding) / 4) calc(var(--app-pane-padding) / 2)}.yuv-object-form-element .form-element .form-field .description{border:0;font-size:var(--font-hint);color:var(--text-color-caption);font-style:italic;padding:calc(var(--app-pane-padding) / 8) calc(var(--app-pane-padding) / 8) 0 calc(var(--app-pane-padding) / 8)}.yuv-object-form-element .form-element .form-field .err-msg{font-size:var(--font-hint);color:var(--color-error);padding:calc(var(--app-pane-padding) / 4) 0;border:0}.yuv-object-form-element .form-element .form-field .table{flex-flow:column;align-items:flex-start;border:1px solid var(--panel-divider-color)}.yuv-object-form-element .form-element .form-field .table .label{padding-bottom:calc(var(--app-pane-padding) / 4)}.yuv-object-form-element .form-element .form-field .table.invalid{border:1px solid var(--color-error)}.yuv-object-form-element .form-element .form-field.inlineError .err-msg{display:none}.yuv-object-form-element .form-element.ng-dirty:not(.ng-invalid)>.form-field:not(.focused)::ng-deep .fe-wrapper>label{background-color:var(--color-dirty-background);color:var(--color-dirty-font)!important}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }, { kind: "component", type: MetadataFormFieldComponent, selector: "yuv-metadata-form-field", inputs: ["field", "situation"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i2.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i2.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectFormElementComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'yuv-object-form-element', standalone: true, imports: [CommonModule, MetadataFormFieldComponent, NgComponentOutlet, ReactiveFormsModule], encapsulation: ViewEncapsulation.None, host: { class: 'yuv-object-form-element' }, template: "@let el = element();\n\n@if (!createForm()) {\n  @if (el && formElementRef) {\n    <div class=\"form-element input\" [formGroup]=\"el\">\n      <yuv-metadata-form-field\n        [field]=\"formElementRef._eoFormElement\"\n        [formControlName]=\"el._eoFormControlWrapper!.controlName\"\n        [situation]=\"situation()\"\n      ></yuv-metadata-form-field>\n\n      <div class=\"ext\">\n        @for (cmp of extensionComponents; track $index) {\n          <ng-container *ngComponentOutlet=\"cmp; inputs: { input: extensionComponentInput }\"></ng-container>\n        }\n        @for (scmp of scriptingExtensions(); track $index) {\n          <ng-container *ngComponentOutlet=\"scriptExtensionCmp; inputs: { ext: scmp }\"></ng-container>\n        }\n      </div>\n    </div>\n  }\n}\n", styles: [":host{flex:1 1 auto}.yuv-object-form-element .form-element{box-sizing:border-box;display:flex;flex-flow:row nowrap}.yuv-object-form-element .form-element .ext{display:flex;flex-flow:row nowrap;gap:2px;align-items:center}.yuv-object-form-element .form-element yuv-metadata-form-field{width:100%}.yuv-object-form-element .form-element .form-field{padding:calc(var(--app-pane-padding) / 4) calc(var(--app-pane-padding) / 2)}.yuv-object-form-element .form-element .form-field .description{border:0;font-size:var(--font-hint);color:var(--text-color-caption);font-style:italic;padding:calc(var(--app-pane-padding) / 8) calc(var(--app-pane-padding) / 8) 0 calc(var(--app-pane-padding) / 8)}.yuv-object-form-element .form-element .form-field .err-msg{font-size:var(--font-hint);color:var(--color-error);padding:calc(var(--app-pane-padding) / 4) 0;border:0}.yuv-object-form-element .form-element .form-field .table{flex-flow:column;align-items:flex-start;border:1px solid var(--panel-divider-color)}.yuv-object-form-element .form-element .form-field .table .label{padding-bottom:calc(var(--app-pane-padding) / 4)}.yuv-object-form-element .form-element .form-field .table.invalid{border:1px solid var(--color-error)}.yuv-object-form-element .form-element .form-field.inlineError .err-msg{display:none}.yuv-object-form-element .form-element.ng-dirty:not(.ng-invalid)>.form-field:not(.focused)::ng-deep .fe-wrapper>label{background-color:var(--color-dirty-background);color:var(--color-dirty-font)!important}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object-form-element.component.js","sourceRoot":"","sources":["../../../../../../../../libs/yuuvis/client-framework/object-form/src/lib/object-form-element/object-form-element.component.ts","../../../../../../../../libs/yuuvis/client-framework/object-form/src/lib/object-form-element/object-form-element.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule, NgComponentOutlet } from '@angular/common';\nimport { Component, computed, DestroyRef, effect, inject, input, signal, Type, untracked, ViewEncapsulation } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { ReactiveFormsModule } from '@angular/forms';\nimport { Classification, Situation } from '@yuuvis/client-core';\nimport { MetadataFormFieldComponent } from '@yuuvis/client-framework/metadata-form';\nimport { ObjectFormTranslateService } from '../object-form-translate.service';\nimport { ObjectFormControlWrapper } from '../object-form.interface';\nimport { ObjectFormService } from '../object-form.service';\nimport { IObjectFormElementExtensionComponentInput, ObjectFormElementExtension } from '../object-form-extension.interface';\nimport { FormScriptingApiService } from '../form-scripting.service';\nimport { FormScriptingElementExtensionComponent } from '../object-form-script/form-scripting-element-extension/form-scripting-element-extension.component';\nimport { FormScriptingElementExtension } from '../form-scripting.api.interface';\n\n@Component({\n  selector: 'yuv-object-form-element',\n  standalone: true,\n  imports: [CommonModule, MetadataFormFieldComponent, NgComponentOutlet, ReactiveFormsModule],\n  templateUrl: './object-form-element.component.html',\n  styleUrls: ['./object-form-element.component.scss'],\n  encapsulation: ViewEncapsulation.None,\n  host: { class: 'yuv-object-form-element' }\n})\nexport class ObjectFormElementComponent {\n  #destroyRef = inject(DestroyRef);\n  #formTranslateService = inject(ObjectFormTranslateService);\n  #objectFormService = inject(ObjectFormService);\n  #scriptingApi = inject(FormScriptingApiService);\n\n  createForm = signal(false);\n\n  formControlName?: string;\n  formElementRef: any;\n  errors?: string[];\n  extensionComponents: Type<ObjectFormElementExtension>[] = [];\n  #scriptingExtensions = this.#scriptingApi.elementExtensions;\n  scriptingExtensions = computed(() =>\n    Object.values(this.#scriptingExtensions()).filter((ext: FormScriptingElementExtension) => ext.propertyName === this.formControlName)\n  );\n\n  scriptExtensionCmp = FormScriptingElementExtensionComponent;\n  situation = input<string>();\n\n  element = input<ObjectFormControlWrapper>();\n  #elementEffect = effect(() => {\n    const element = this.element();\n\n    untracked(() => {\n      this.createForm.set(true);\n      element && this.#setElement(this.element());\n    });\n  });\n\n  get extensionComponentInput(): Record<string, unknown> {\n    const xti: IObjectFormElementExtensionComponentInput = {\n      formControlName: this.formControlName || ''\n    };\n    return xti as Record<string, any>;\n  }\n\n  #setElement(el: ObjectFormControlWrapper | undefined) {\n    if (el && el._eoFormControlWrapper) {\n      this.formControlName = el._eoFormControlWrapper.controlName;\n      this.formElementRef = el.controls[this.formControlName];\n      this.formElementRef._eoFormElement = this.#setGrouping(this.formElementRef?._eoFormElement);\n      this.formElementRef?.valueChanges.pipe(takeUntilDestroyed(this.#destroyRef)).subscribe(() => this.#setupErrors());\n      this.extensionComponents = this.#objectFormService.getElementExtensions(this.formControlName);\n\n      this.createForm.set(false);\n    }\n  }\n\n  /**\n   * formating rules...\n   * https://wiki.optimal-systems.de/display/PM/Status+yuuvis+Momentum+-+Flex+client\n   */\n  #setGrouping(formElement: any) {\n    return { ...formElement, grouping: !!formElement?.classifications?.includes(Classification.NUMBER_DIGIT) };\n  }\n\n  onDataMetaChange(data: any) {\n    this.formElementRef._eoFormElement.dataMeta = data;\n  }\n\n  #setupErrors() {\n    this.errors = undefined;\n    if (\n      (this.situation() !== Situation.SEARCH && this.situation() !== Situation.CREATE && this.formElementRef.errors) ||\n      ((this.situation() === Situation.SEARCH || this.situation() === Situation.CREATE) &&\n        this.formElementRef.errors &&\n        (this.formElementRef.dirty || this.formElementRef.touched))\n    ) {\n      this.errors = Object.keys(this.formElementRef.errors).map((key) => {\n        return key === 'eoformScript'\n          ? this.formElementRef._eoFormElement.error.msg\n          : this.#formTranslateService.getErrorLabel(key, this.formElementRef.errors[key].params);\n      });\n    }\n  }\n}\n","@let el = element();\n\n@if (!createForm()) {\n  @if (el && formElementRef) {\n    <div class=\"form-element input\" [formGroup]=\"el\">\n      <yuv-metadata-form-field\n        [field]=\"formElementRef._eoFormElement\"\n        [formControlName]=\"el._eoFormControlWrapper!.controlName\"\n        [situation]=\"situation()\"\n      ></yuv-metadata-form-field>\n\n      <div class=\"ext\">\n        @for (cmp of extensionComponents; track $index) {\n          <ng-container *ngComponentOutlet=\"cmp; inputs: { input: extensionComponentInput }\"></ng-container>\n        }\n        @for (scmp of scriptingExtensions(); track $index) {\n          <ng-container *ngComponentOutlet=\"scriptExtensionCmp; inputs: { ext: scmp }\"></ng-container>\n        }\n      </div>\n    </div>\n  }\n}\n"]}

package/esm2022/object-form/lib/object-form-extension.interface.mjs

@@ -0,0 +1,36 @@
+import { Component, inject, input } from '@angular/core';
+import { FormScriptingApiService } from './form-scripting.service';
+import * as i0 from "@angular/core";
+/**
+ * Class to extend by form element extensions.
+ */
+// eslint-disable-next-line @angular-eslint/component-class-suffix
+export class ObjectFormElementExtension {
+    constructor() {
+        this.#formScriptingApiService = inject(FormScriptingApiService);
+        this.input = input.required();
+    }
+    #formScriptingApiService;
+    getApi() {
+        return this.#formScriptingApiService.getApi();
+    }
+    getCurrentValue() {
+        return this.getApi().form.getValue(this.input().formControlName);
+    }
+    setValue(value) {
+        // only set the value if the value is different. Otherwise the form
+        // will end up in an infinite loop
+        if (value !== this.getCurrentValue())
+            this.getApi().form.setValue(this.input().formControlName, value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectFormElementExtension, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.13", type: ObjectFormElementExtension, isStandalone: true, selector: "ng-component", inputs: { input: { classPropertyName: "input", publicName: "input", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectFormElementExtension, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                    standalone: true
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,85 @@
+import { CommonModule } from '@angular/common';
+import { Component, effect, input, Input, ViewEncapsulation } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { KeysPipe, Situation } from '@yuuvis/client-core';
+import { YvcTabsModule } from '@yuuvis/components/tabs';
+import { ObjectFormElementComponent } from '../object-form-element/object-form-element.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@yuuvis/components/tabs";
+import * as i3 from "@angular/forms";
+export class ObjectFormGroupComponent {
+    constructor() {
+        this.types = {
+            STACK: 'stack',
+            GROUP: 'group',
+            FIELDSET: 'fieldset'
+        };
+        this.isCore = false;
+        this.isData = false;
+        // @ViewChild('tabView') tabView: TabView;
+        // form situation, if not set default will be 'EDIT'
+        this.situation = Situation.EDIT;
+        this.group = input();
+        this.#groupEffect = effect(() => {
+            const g = this.group();
+            if (g) {
+                this.isCore = !!g._eoFormGroup && g._eoFormGroup.label === 'core';
+                this.isData = !!g._eoFormGroup && g._eoFormGroup.label === 'data';
+                this.groupType = this.#getGroupType();
+            }
+        });
+        this.noGroupLabels = input();
+    }
+    #groupEffect;
+    getHeaderStyleClass(ctrl) {
+        return `dirty-${ctrl.dirty} invalid-${ctrl.invalid}`;
+    }
+    getChildControl(ctrl) {
+        return ctrl;
+    }
+    getObjectFormGroup(control) {
+        return control._eoFormGroup;
+    }
+    getObjectFormControlWrapper(control) {
+        return control?._eoFormControlWrapper;
+    }
+    getElement(control) {
+        return control;
+    }
+    #getGroupType() {
+        // may as well be an ObjectFormControlWrapper so check first
+        // if we got a real group
+        const group = this.group();
+        if (group?._eoFormGroup) {
+            if (group._eoFormGroup.type === 'o2mGroupStack') {
+                // for data section only render as stack (tabs) if we have more than one child
+                if (this.isData && Object.keys(group.controls).length === 1) {
+                    return this.types.GROUP;
+                }
+                return this.types.STACK;
+            }
+            if (group._eoFormGroup.type === 'o2mGroup') {
+                return group._eoFormGroup.label && !(this.isCore || this.isData) && !this.noGroupLabels && !this.#parentIsStack(group)
+                    ? this.types.FIELDSET
+                    : this.types.GROUP;
+            }
+            return this.types.GROUP;
+        }
+        else
+            return undefined;
+    }
+    #parentIsStack(group) {
+        const parentFormElement = group.parent && group.parent['_eoFormGroup'];
+        return parentFormElement && parentFormElement.type === 'o2mGroupStack';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectFormGroupComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: ObjectFormGroupComponent, isStandalone: true, selector: "yuv-object-form-group", inputs: { situation: { classPropertyName: "situation", publicName: "situation", isSignal: false, isRequired: false, transformFunction: null }, group: { classPropertyName: "group", publicName: "group", isSignal: true, isRequired: false, transformFunction: null }, noGroupLabels: { classPropertyName: "noGroupLabels", publicName: "noGroupLabels", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: "@let grp = group();\n@if (grp) {\n  <div\n    class=\"form-element {{ grp._eoFormGroup ? grp._eoFormGroup.type : 'o2mControlWrap' }} align-{{\n      grp._eoFormGroup && grp._eoFormGroup.layout ? grp._eoFormGroup.layout.align : ''\n    }}\"\n    [formGroup]=\"grp\"\n  >\n    @switch (groupType) {\n      <!-- group stacks (tabs) -->\n      @case ('stack') {\n        <yvc-tabs>\n          @for (key of grp.controls | keys; track key) {\n            <ng-template\n              [yvcTab]=\"{\n                id: key,\n                headerStyleClass: getHeaderStyleClass(grp.controls[key]),\n                label: getObjectFormGroup(grp.controls[key])?.label || ''\n              }\"\n            >\n              <div class=\"stack\" [ngClass]=\"{ stackBase: grp._eoFormGroup?.label === 'data' }\">\n                @if (getObjectFormControlWrapper(grp.controls[key])) {\n                  <yuv-object-form-element [element]=\"getElement(grp.controls[key])\" [situation]=\"situation\"></yuv-object-form-element>\n                } @else {\n                  <yuv-object-form-group [group]=\"getChildControl(grp.controls[key])\" [noGroupLabels]=\"true\" [situation]=\"situation\"></yuv-object-form-group>\n                }\n              </div>\n            </ng-template>\n          }\n        </yvc-tabs>\n      }\n\n      <!-- group with legend -->\n      @case ('fieldset') {\n        <div class=\"om-group fieldset\">\n          <div class=\"legend\">\n            <span>{{ grp._eoFormGroup?.label }}</span>\n          </div>\n\n          <div>\n            @for (key of grp.controls | keys; track key) {\n              @if (getObjectFormControlWrapper(grp.controls[key])) {\n                <yuv-object-form-element [element]=\"getElement(grp.controls[key])\" [situation]=\"situation\"></yuv-object-form-element>\n              } @else {\n                <yuv-object-form-group [group]=\"getChildControl(grp.controls[key])\" [noGroupLabels]=\"true\" [situation]=\"situation\"></yuv-object-form-group>\n              }\n            }\n          </div>\n        </div>\n      }\n      <!-- group -->\n      @case ('group') {\n        @for (key of grp.controls | keys; track key) {\n          @if (getObjectFormControlWrapper(grp.controls[key])) {\n            <yuv-object-form-element [element]=\"getElement(grp.controls[key])\" [situation]=\"situation\"></yuv-object-form-element>\n          } @else {\n            <yuv-object-form-group [group]=\"getChildControl(grp.controls[key])\" [noGroupLabels]=\"true\" [situation]=\"situation\"></yuv-object-form-group>\n          }\n        }\n      }\n    }\n  </div>\n}\n", styles: [".form-element{box-sizing:border-box}.form-element .fieldset{margin:calc(var(--app-pane-padding) / 4) calc(var(--app-pane-padding) / 2);padding:calc(var(--app-pane-padding) / 4);background:#00000006;border:1px solid rgba(0,0,0,.1)}.dark .form-element .fieldset{background:#ffffff06;border-color:#ffffff1a}.contrast .form-element .fieldset{background-color:transparent;border-color:var(--panel-divider-color)}.form-element .fieldset .legend{margin-bottom:calc(var(--app-pane-padding) / 2)}.form-element .fieldset .legend>span{display:inline-block;font-size:var(--font-hint);border-radius:2px;color:#fff;background-color:#00000038;padding:calc(var(--app-pane-padding) / 8) calc(var(--app-pane-padding) / 4)}.dark .form-element .fieldset .legend>span{background-color:#ffffff38}.contrast .form-element .fieldset .legend>span{background-color:var(--panel-divider-color);color:var(--panel-background)}.form-element.o2mGroupStack{background:#00000005;border:1px solid rgba(0,0,0,.1)}.dark .form-element.o2mGroupStack{background:#ffffff05;border:1px solid rgba(255,255,255,.1)}.contrast .form-element.o2mGroupStack{background-color:transparent;border-color:var(--panel-divider-color)}.form-element.o2mGroupStack .p-tabview.p-component .p-tabview-panels{background:#fff;overflow:initial}.dark .form-element.o2mGroupStack .p-tabview.p-component .p-tabview-panels{background:#ffffff0a}.form-element.o2mGroupStack .p-tabview.p-component>.p-tabview-nav li.p-highlight{border-color:#00000042}.dark .form-element.o2mGroupStack .p-tabview.p-component>.p-tabview-nav li.p-highlight{border-color:#ffffff42}.form-element.o2mGroupStack .p-tabview.p-component>.p-tabview-nav>li:not(.p-highlight):not(.p-disabled):hover{border-color:#00000029}.dark .form-element.o2mGroupStack .p-tabview.p-component>.p-tabview-nav>li:not(.p-highlight):not(.p-disabled):hover{border-color:#ffffff29}.form-element.o2mGroupStack .p-tabview.p-component>.p-tabview-nav-container>.p-tabview-nav-content>.p-tabview-nav li.dirty-true:not(.invalid-true) a .p-tabview-title{background-color:var(--color-dirty-background);color:var(--color-dirty-font)}.form-element.o2mGroupStack .p-tabview.p-component>.p-tabview-nav-container>.p-tabview-nav-content>.p-tabview-nav li.invalid-true a .p-tabview-title{background-color:var(--color-error);color:#fff}.form-element.o2mGroupStack .p-tabview.p-component>.p-tabview-nav-container>.p-tabview-nav-content>.p-tabview-nav li.invalid-true a .p-tabview-title:after{content:\"!\";margin-left:calc(var(--app-pane-padding) / 2)}.form-element.align-column{display:flex;flex-flow:column nowrap;justify-content:flex-start;align-content:stretch;align-items:stretch}.form-element.align-column>*{flex:1 1 auto}.form-element.align-row{display:flex;flex-flow:row wrap;justify-content:flex-start;align-content:flex-start;align-items:flex-start}.form-element.align-row>*{flex:1 0 200px;max-width:100%}.form-element.align-row>.fieldset>:not(.legend){display:flex;flex-flow:row wrap;justify-content:flex-start;align-content:flex-start;align-items:flex-start}.form-element .stackBase{padding:var(--app-pane-padding);background:var(--panel-background-lightgrey)}.form-element .stackBase>yuv-form-group>.form-element>.fieldset{margin:0;padding:0;border:0;background-color:transparent}.form-element .stackBase>yuv-form-group>.form-element>.fieldset>.legend{display:none}\n"], dependencies: [{ kind: "component", type: ObjectFormGroupComponent, selector: "yuv-object-form-group", inputs: ["situation", "group", "noGroupLabels"] }, { kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "ngmodule", type: YvcTabsModule }, { kind: "component", type: i2.Tabs, selector: "yvc-tabs", inputs: ["tabs", "layoutSettingsID", "panelOrder", "panelOrderIncludeUnmentioned", "cacheViews", "tabSplitEnabled", "tabRemoveEnabled"], outputs: ["tabSplit", "tabRemove", "tabChange"] }, { kind: "directive", type: i2.YvcTabDirective, selector: "[yvcTab]", inputs: ["yvcTab"] }, { kind: "pipe", type: KeysPipe, name: "keys" }, { kind: "component", type: ObjectFormElementComponent, selector: "yuv-object-form-element", inputs: ["situation", "element"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectFormGroupComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'yuv-object-form-group', standalone: true, imports: [CommonModule, YvcTabsModule, KeysPipe, ObjectFormElementComponent, ReactiveFormsModule], encapsulation: ViewEncapsulation.None, template: "@let grp = group();\n@if (grp) {\n  <div\n    class=\"form-element {{ grp._eoFormGroup ? grp._eoFormGroup.type : 'o2mControlWrap' }} align-{{\n      grp._eoFormGroup && grp._eoFormGroup.layout ? grp._eoFormGroup.layout.align : ''\n    }}\"\n    [formGroup]=\"grp\"\n  >\n    @switch (groupType) {\n      <!-- group stacks (tabs) -->\n      @case ('stack') {\n        <yvc-tabs>\n          @for (key of grp.controls | keys; track key) {\n            <ng-template\n              [yvcTab]=\"{\n                id: key,\n                headerStyleClass: getHeaderStyleClass(grp.controls[key]),\n                label: getObjectFormGroup(grp.controls[key])?.label || ''\n              }\"\n            >\n              <div class=\"stack\" [ngClass]=\"{ stackBase: grp._eoFormGroup?.label === 'data' }\">\n                @if (getObjectFormControlWrapper(grp.controls[key])) {\n                  <yuv-object-form-element [element]=\"getElement(grp.controls[key])\" [situation]=\"situation\"></yuv-object-form-element>\n                } @else {\n                  <yuv-object-form-group [group]=\"getChildControl(grp.controls[key])\" [noGroupLabels]=\"true\" [situation]=\"situation\"></yuv-object-form-group>\n                }\n              </div>\n            </ng-template>\n          }\n        </yvc-tabs>\n      }\n\n      <!-- group with legend -->\n      @case ('fieldset') {\n        <div class=\"om-group fieldset\">\n          <div class=\"legend\">\n            <span>{{ grp._eoFormGroup?.label }}</span>\n          </div>\n\n          <div>\n            @for (key of grp.controls | keys; track key) {\n              @if (getObjectFormControlWrapper(grp.controls[key])) {\n                <yuv-object-form-element [element]=\"getElement(grp.controls[key])\" [situation]=\"situation\"></yuv-object-form-element>\n              } @else {\n                <yuv-object-form-group [group]=\"getChildControl(grp.controls[key])\" [noGroupLabels]=\"true\" [situation]=\"situation\"></yuv-object-form-group>\n              }\n            }\n          </div>\n        </div>\n      }\n      <!-- group -->\n      @case ('group') {\n        @for (key of grp.controls | keys; track key) {\n          @if (getObjectFormControlWrapper(grp.controls[key])) {\n            <yuv-object-form-element [element]=\"getElement(grp.controls[key])\" [situation]=\"situation\"></yuv-object-form-element>\n          } @else {\n            <yuv-object-form-group [group]=\"getChildControl(grp.controls[key])\" [noGroupLabels]=\"true\" [situation]=\"situation\"></yuv-object-form-group>\n          }\n        }\n      }\n    }\n  </div>\n}\n", styles: [".form-element{box-sizing:border-box}.form-element .fieldset{margin:calc(var(--app-pane-padding) / 4) calc(var(--app-pane-padding) / 2);padding:calc(var(--app-pane-padding) / 4);background:#00000006;border:1px solid rgba(0,0,0,.1)}.dark .form-element .fieldset{background:#ffffff06;border-color:#ffffff1a}.contrast .form-element .fieldset{background-color:transparent;border-color:var(--panel-divider-color)}.form-element .fieldset .legend{margin-bottom:calc(var(--app-pane-padding) / 2)}.form-element .fieldset .legend>span{display:inline-block;font-size:var(--font-hint);border-radius:2px;color:#fff;background-color:#00000038;padding:calc(var(--app-pane-padding) / 8) calc(var(--app-pane-padding) / 4)}.dark .form-element .fieldset .legend>span{background-color:#ffffff38}.contrast .form-element .fieldset .legend>span{background-color:var(--panel-divider-color);color:var(--panel-background)}.form-element.o2mGroupStack{background:#00000005;border:1px solid rgba(0,0,0,.1)}.dark .form-element.o2mGroupStack{background:#ffffff05;border:1px solid rgba(255,255,255,.1)}.contrast .form-element.o2mGroupStack{background-color:transparent;border-color:var(--panel-divider-color)}.form-element.o2mGroupStack .p-tabview.p-component .p-tabview-panels{background:#fff;overflow:initial}.dark .form-element.o2mGroupStack .p-tabview.p-component .p-tabview-panels{background:#ffffff0a}.form-element.o2mGroupStack .p-tabview.p-component>.p-tabview-nav li.p-highlight{border-color:#00000042}.dark .form-element.o2mGroupStack .p-tabview.p-component>.p-tabview-nav li.p-highlight{border-color:#ffffff42}.form-element.o2mGroupStack .p-tabview.p-component>.p-tabview-nav>li:not(.p-highlight):not(.p-disabled):hover{border-color:#00000029}.dark .form-element.o2mGroupStack .p-tabview.p-component>.p-tabview-nav>li:not(.p-highlight):not(.p-disabled):hover{border-color:#ffffff29}.form-element.o2mGroupStack .p-tabview.p-component>.p-tabview-nav-container>.p-tabview-nav-content>.p-tabview-nav li.dirty-true:not(.invalid-true) a .p-tabview-title{background-color:var(--color-dirty-background);color:var(--color-dirty-font)}.form-element.o2mGroupStack .p-tabview.p-component>.p-tabview-nav-container>.p-tabview-nav-content>.p-tabview-nav li.invalid-true a .p-tabview-title{background-color:var(--color-error);color:#fff}.form-element.o2mGroupStack .p-tabview.p-component>.p-tabview-nav-container>.p-tabview-nav-content>.p-tabview-nav li.invalid-true a .p-tabview-title:after{content:\"!\";margin-left:calc(var(--app-pane-padding) / 2)}.form-element.align-column{display:flex;flex-flow:column nowrap;justify-content:flex-start;align-content:stretch;align-items:stretch}.form-element.align-column>*{flex:1 1 auto}.form-element.align-row{display:flex;flex-flow:row wrap;justify-content:flex-start;align-content:flex-start;align-items:flex-start}.form-element.align-row>*{flex:1 0 200px;max-width:100%}.form-element.align-row>.fieldset>:not(.legend){display:flex;flex-flow:row wrap;justify-content:flex-start;align-content:flex-start;align-items:flex-start}.form-element .stackBase{padding:var(--app-pane-padding);background:var(--panel-background-lightgrey)}.form-element .stackBase>yuv-form-group>.form-element>.fieldset{margin:0;padding:0;border:0;background-color:transparent}.form-element .stackBase>yuv-form-group>.form-element>.fieldset>.legend{display:none}\n"] }]
+        }], propDecorators: { situation: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object-form-group.component.js","sourceRoot":"","sources":["../../../../../../../../libs/yuuvis/client-framework/object-form/src/lib/object-form-group/object-form-group.component.ts","../../../../../../../../libs/yuuvis/client-framework/object-form/src/lib/object-form-group/object-form-group.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, effect, input, Input, ViewEncapsulation } from '@angular/core';\nimport { AbstractControl, ReactiveFormsModule } from '@angular/forms';\nimport { KeysPipe, Situation } from '@yuuvis/client-core';\nimport { YvcTabsModule } from '@yuuvis/components/tabs';\nimport { ObjectFormElementComponent } from '../object-form-element/object-form-element.component';\nimport { ObjectFormControlWrapper, YuvFormGroup, YuvFormGroupWrapper } from '../object-form.interface';\nimport { ObjectFormGroup } from '../object-form.model';\n\n@Component({\n  selector: 'yuv-object-form-group',\n  standalone: true,\n  imports: [CommonModule, YvcTabsModule, KeysPipe, ObjectFormElementComponent, ReactiveFormsModule],\n  templateUrl: './object-form-group.component.html',\n  styleUrls: ['./object-form-group.component.scss'],\n  encapsulation: ViewEncapsulation.None\n})\nexport class ObjectFormGroupComponent {\n  private types = {\n    STACK: 'stack',\n    GROUP: 'group',\n    FIELDSET: 'fieldset'\n  };\n\n  groupType?: string;\n  isCore = false;\n  isData = false;\n\n  // @ViewChild('tabView') tabView: TabView;\n\n  // form situation, if not set default will be 'EDIT'\n  @Input() situation = Situation.EDIT;\n\n  group = input<ObjectFormGroup>();\n  #groupEffect = effect(() => {\n    const g = this.group();\n\n    if (g) {\n      this.isCore = !!g._eoFormGroup && g._eoFormGroup.label === 'core';\n      this.isData = !!g._eoFormGroup && g._eoFormGroup.label === 'data';\n      this.groupType = this.#getGroupType();\n    }\n  });\n\n  noGroupLabels = input<boolean>();\n\n  getHeaderStyleClass(ctrl: AbstractControl): string {\n    return `dirty-${ctrl.dirty} invalid-${ctrl.invalid}`;\n  }\n\n  getChildControl(ctrl: AbstractControl): ObjectFormGroup {\n    return ctrl as ObjectFormGroup;\n  }\n\n  getObjectFormGroup(control: any): YuvFormGroup | undefined {\n    return (control as ObjectFormGroup)._eoFormGroup;\n  }\n\n  getObjectFormControlWrapper(control: any): YuvFormGroupWrapper | undefined {\n    return (control as ObjectFormControlWrapper)?._eoFormControlWrapper;\n  }\n\n  getElement(control: any): ObjectFormControlWrapper {\n    return control as ObjectFormControlWrapper;\n  }\n\n  #getGroupType(): string | undefined {\n    // may as well be an ObjectFormControlWrapper so check first\n    // if we got a real group\n    const group = this.group() as ObjectFormGroup;\n    if (group?._eoFormGroup) {\n      if (group._eoFormGroup.type === 'o2mGroupStack') {\n        // for data section only render as stack (tabs) if we have more than one child\n        if (this.isData && Object.keys(group.controls).length === 1) {\n          return this.types.GROUP;\n        }\n        return this.types.STACK;\n      }\n      if (group._eoFormGroup.type === 'o2mGroup') {\n        return group._eoFormGroup.label && !(this.isCore || this.isData) && !this.noGroupLabels && !this.#parentIsStack(group)\n          ? this.types.FIELDSET\n          : this.types.GROUP;\n      }\n      return this.types.GROUP;\n    } else return undefined;\n  }\n\n  #parentIsStack(group: ObjectFormGroup): boolean {\n    const parentFormElement = group.parent && (group.parent as any)['_eoFormGroup'];\n    return parentFormElement && parentFormElement.type === 'o2mGroupStack';\n  }\n}\n","@let grp = group();\n@if (grp) {\n  <div\n    class=\"form-element {{ grp._eoFormGroup ? grp._eoFormGroup.type : 'o2mControlWrap' }} align-{{\n      grp._eoFormGroup && grp._eoFormGroup.layout ? grp._eoFormGroup.layout.align : ''\n    }}\"\n    [formGroup]=\"grp\"\n  >\n    @switch (groupType) {\n      <!-- group stacks (tabs) -->\n      @case ('stack') {\n        <yvc-tabs>\n          @for (key of grp.controls | keys; track key) {\n            <ng-template\n              [yvcTab]=\"{\n                id: key,\n                headerStyleClass: getHeaderStyleClass(grp.controls[key]),\n                label: getObjectFormGroup(grp.controls[key])?.label || ''\n              }\"\n            >\n              <div class=\"stack\" [ngClass]=\"{ stackBase: grp._eoFormGroup?.label === 'data' }\">\n                @if (getObjectFormControlWrapper(grp.controls[key])) {\n                  <yuv-object-form-element [element]=\"getElement(grp.controls[key])\" [situation]=\"situation\"></yuv-object-form-element>\n                } @else {\n                  <yuv-object-form-group [group]=\"getChildControl(grp.controls[key])\" [noGroupLabels]=\"true\" [situation]=\"situation\"></yuv-object-form-group>\n                }\n              </div>\n            </ng-template>\n          }\n        </yvc-tabs>\n      }\n\n      <!-- group with legend -->\n      @case ('fieldset') {\n        <div class=\"om-group fieldset\">\n          <div class=\"legend\">\n            <span>{{ grp._eoFormGroup?.label }}</span>\n          </div>\n\n          <div>\n            @for (key of grp.controls | keys; track key) {\n              @if (getObjectFormControlWrapper(grp.controls[key])) {\n                <yuv-object-form-element [element]=\"getElement(grp.controls[key])\" [situation]=\"situation\"></yuv-object-form-element>\n              } @else {\n                <yuv-object-form-group [group]=\"getChildControl(grp.controls[key])\" [noGroupLabels]=\"true\" [situation]=\"situation\"></yuv-object-form-group>\n              }\n            }\n          </div>\n        </div>\n      }\n      <!-- group -->\n      @case ('group') {\n        @for (key of grp.controls | keys; track key) {\n          @if (getObjectFormControlWrapper(grp.controls[key])) {\n            <yuv-object-form-element [element]=\"getElement(grp.controls[key])\" [situation]=\"situation\"></yuv-object-form-element>\n          } @else {\n            <yuv-object-form-group [group]=\"getChildControl(grp.controls[key])\" [noGroupLabels]=\"true\" [situation]=\"situation\"></yuv-object-form-group>\n          }\n        }\n      }\n    }\n  </div>\n}\n"]}

package/esm2022/object-form/lib/object-form-script/form-scripting-element-extension/form-scripting-element-extension.component.mjs

@@ -0,0 +1,23 @@
+import { CommonModule } from '@angular/common';
+import { Component, input } from '@angular/core';
+import { ObjectFormElementExtension } from '../../object-form-extension.interface';
+import { YvcIconModule } from '@yuuvis/components/icon';
+import * as i0 from "@angular/core";
+import * as i1 from "@yuuvis/components/icon";
+export class FormScriptingElementExtensionComponent extends ObjectFormElementExtension {
+    constructor() {
+        super(...arguments);
+        this.ext = input();
+        this.defaultIcon = '<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e8eaed"><path d="M160-120q-33 0-56.5-23.5T80-200v-560q0-33 23.5-56.5T160-840h560q33 0 56.5 23.5T800-760v80h80v80h-80v80h80v80h-80v80h80v80h-80v80q0 33-23.5 56.5T720-120H160Zm0-80h560v-560H160v560Zm80-80h200v-160H240v160Zm240-280h160v-120H480v120Zm-240 80h200v-200H240v200Zm240 200h160v-240H480v240ZM160-760v560-560Z"/></svg>';
+    }
+    run() {
+        this.ext()?.callback();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormScriptingElementExtensionComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: FormScriptingElementExtensionComponent, isStandalone: true, selector: "yuv-form-scripting-element-extension", inputs: { ext: { classPropertyName: "ext", publicName: "ext", isSignal: true, isRequired: false, transformFunction: null } }, usesInheritance: true, ngImport: i0, template: "@let x = ext();\n@if (x) {\n  @if (x.icon) {\n    <button class=\"secondary\" (click)=\"run()\" [title]=\"x.label\">\n      <yvc-icon [svg]=\"x.icon\"></yvc-icon>\n    </button>\n  } @else if (x.label) {\n    <button class=\"secondary\" (click)=\"run()\">{{ x.label }}</button>\n  } @else {\n    <button class=\"secondary\" (click)=\"run()\">\n      <yvc-icon [svg]=\"defaultIcon\"></yvc-icon>\n    </button>\n  }\n}\n", styles: [":host button{--icon-size: 18px;color:var(--text-color-caption);padding:2px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: YvcIconModule }, { kind: "component", type: i1.Icon, selector: "yvc-icon", inputs: ["label", "svg", "svgSrc"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormScriptingElementExtensionComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'yuv-form-scripting-element-extension', standalone: true, imports: [CommonModule, YvcIconModule], template: "@let x = ext();\n@if (x) {\n  @if (x.icon) {\n    <button class=\"secondary\" (click)=\"run()\" [title]=\"x.label\">\n      <yvc-icon [svg]=\"x.icon\"></yvc-icon>\n    </button>\n  } @else if (x.label) {\n    <button class=\"secondary\" (click)=\"run()\">{{ x.label }}</button>\n  } @else {\n    <button class=\"secondary\" (click)=\"run()\">\n      <yvc-icon [svg]=\"defaultIcon\"></yvc-icon>\n    </button>\n  }\n}\n", styles: [":host button{--icon-size: 18px;color:var(--text-color-caption);padding:2px}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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