@mediusinc/mng-commons 0.0.1-rc.2

package/esm2020/lib/components/action/route/action-route.component.mjs

@@ -0,0 +1,144 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { ConfirmationService, MessageService } from 'primeng/api';
+import { first } from 'rxjs/operators';
+import { ActionActivationTriggerEnum } from '../../../models/descriptors';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "primeng/api";
+import * as i3 from "../../../services";
+import * as i4 from "../../tableview/tableview.component.service";
+import * as i5 from "primeng/confirmdialog";
+export class ActionRouteComponent {
+    constructor(router, route, confirmationService, navigationService, actionService, tableviewService) {
+        this.router = router;
+        this.route = route;
+        this.confirmationService = confirmationService;
+        this.navigationService = navigationService;
+        this.actionService = actionService;
+        this.tableviewService = tableviewService;
+        this.actions = [];
+        this.subscriptions = [];
+        this.cmpId = Math.random().toString(36).substring(2);
+    }
+    ngOnInit() {
+        this.actions = this.tableviewService?.actions.filter(a => a.activationTrigger === ActionActivationTriggerEnum.OnRoute) ?? [];
+        const subscription = this.route.params.subscribe(p => {
+            const action = this.findActiveAction(p);
+            if (action) {
+                this.activateAction(action, p, this.route.snapshot.queryParams);
+            }
+        });
+        this.subscriptions.push(subscription);
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach(s => s.unsubscribe());
+        if (this.dialogRef) {
+            this.dialogRef.close();
+        }
+    }
+    getConfirmationService() {
+        return this.confirmationService;
+    }
+    getConfirmationServiceInstanceKey(action) {
+        return `actionRoute_${this.cmpId}`;
+    }
+    activateAction(action, p, qp) {
+        this.activeAction = action;
+        const itemId = p['itemId'];
+        const actionData = {};
+        for (let key in p) {
+            if (key === 'itemId') {
+                continue;
+            }
+            actionData[key] = p[key];
+        }
+        for (let key in qp) {
+            actionData[key] = p[key];
+        }
+        this.actionService.activateAction(action, itemId, undefined, actionData, this.tableviewService, this)
+            .pipe(first())
+            .subscribe(res => {
+            if (res.dialogRef) {
+                this.dialogRef = res.dialogRef;
+                this.dialogCloseSubscription = this.dialogRef.onClose.subscribe(e => {
+                    const actionEv = e;
+                    if (!actionEv?.error || !actionEv?.error?.dismissed) {
+                        this.tableviewService.reloadTable(); // reload only if no error in action and
+                    }
+                    this.deactivateAction();
+                });
+            }
+        });
+    }
+    deactivateAction() {
+        if (this.dialogCloseSubscription) {
+            this.dialogCloseSubscription.unsubscribe();
+            this.dialogCloseSubscription = undefined;
+        }
+        if (this.navigationService.getPreviousLocation()) {
+            // there are internal history records, so back can be normally called
+            this.navigationService.back();
+        }
+        else {
+            // there is no internal history records, figure out the base url by eliminating action specific url
+            let url = this.navigationService.getCurrentLocation();
+            if (!url) {
+                this.navigationService.back();
+            }
+            else {
+                if (url.startsWith('/')) {
+                    url = url.substring(1);
+                }
+                const urlPathSegments = url.split('?')[0].split('#')[0].split('/');
+                let actionUrl = this.activeAction?.routeUrl ?? '';
+                if (actionUrl.startsWith('/')) {
+                    actionUrl = actionUrl.substring(1);
+                }
+                const actionUrlSegments = actionUrl.split('/');
+                const redirectUrl = urlPathSegments.slice(0, urlPathSegments.length - actionUrlSegments.length).join('/');
+                this.router.navigateByUrl(`/${redirectUrl}`, { replaceUrl: true });
+            }
+        }
+        this.activeAction = undefined;
+        this.dialogRef = undefined;
+    }
+    findActiveAction(params) {
+        const urlSegments = this.route.snapshot.url;
+        for (const action of this.actions) {
+            let actionUrl = action.routeUrl ?? '';
+            // TODO: dont strip '/', but use it accordingly with Angular's router patterns (/, ./, ../)
+            if (actionUrl.startsWith('/')) {
+                actionUrl = actionUrl.substring(1);
+            }
+            const actionUrlSegments = actionUrl.split('/');
+            if (actionUrlSegments.length !== urlSegments.length) {
+                continue;
+            }
+            let isMatch = true;
+            for (let i = 0; i < actionUrlSegments.length; i++) {
+                if (actionUrlSegments[i].startsWith(':')) {
+                    const paramName = actionUrlSegments[i].substring(1);
+                    if (!params[paramName]) {
+                        isMatch = false;
+                        break;
+                    }
+                }
+                else if (actionUrlSegments[i] !== urlSegments[i].path) {
+                    isMatch = false;
+                    break;
+                }
+            }
+            if (isMatch) {
+                return action;
+            }
+        }
+        return null;
+    }
+}
+ActionRouteComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ActionRouteComponent, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }, { token: i2.ConfirmationService }, { token: i3.NavigationService }, { token: i3.ActionService }, { token: i4.TableviewComponentService }], target: i0.ɵɵFactoryTarget.Component });
+ActionRouteComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: ActionRouteComponent, selector: "mng-action-route", providers: [MessageService, ConfirmationService], ngImport: i0, template: "<p-confirmDialog [key]=\"'actionRoute_' + cmpId\" [baseZIndex]=\"50\" appendTo=\"body\"></p-confirmDialog>\n", components: [{ type: i5.ConfirmDialog, selector: "p-confirmDialog", inputs: ["header", "icon", "message", "style", "styleClass", "maskStyleClass", "acceptIcon", "acceptLabel", "acceptAriaLabel", "acceptVisible", "rejectIcon", "rejectLabel", "rejectAriaLabel", "rejectVisible", "acceptButtonStyleClass", "rejectButtonStyleClass", "closeOnEscape", "dismissableMask", "blockScroll", "rtl", "closable", "appendTo", "key", "autoZIndex", "baseZIndex", "transitionOptions", "focusTrap", "defaultFocus", "breakpoints", "visible", "position"], outputs: ["onHide"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ActionRouteComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mng-action-route', changeDetection: ChangeDetectionStrategy.OnPush, providers: [MessageService, ConfirmationService], template: "<p-confirmDialog [key]=\"'actionRoute_' + cmpId\" [baseZIndex]=\"50\" appendTo=\"body\"></p-confirmDialog>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }, { type: i2.ConfirmationService }, { type: i3.NavigationService }, { type: i3.ActionService }, { type: i4.TableviewComponentService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action-route.component.js","sourceRoot":"","sources":["../../../../../../../projects/mng-commons/src/lib/components/action/route/action-route.component.ts","../../../../../../../projects/mng-commons/src/lib/components/action/route/action-route.component.html"],"names":[],"mappings":"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","sourcesContent":["import {ChangeDetectionStrategy, Component, OnDestroy, OnInit} from '@angular/core';\nimport {ActivatedRoute, Params, Router} from '@angular/router';\n\nimport {ConfirmationService, MessageService} from 'primeng/api';\nimport {DynamicDialogRef} from 'primeng/dynamicdialog';\nimport {Subscription} from 'rxjs';\nimport {first} from 'rxjs/operators';\n\nimport {ActionData, ActionRunResult} from '../../../models/action';\nimport {ActionDescriptor, ActionActivationTriggerEnum} from '../../../models/descriptors';\nimport {IConfirmationService} from '../../../models/interfaces';\nimport {ActionService, NavigationService} from '../../../services';\nimport {TableviewComponentService} from '../../tableview/tableview.component.service';\n\n@Component({\n    selector: 'mng-action-route',\n    templateUrl: './action-route.component.html',\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    providers: [MessageService, ConfirmationService]\n})\nexport class ActionRouteComponent<T, S> implements OnInit, OnDestroy, IConfirmationService {\n\n    private actions: Array<ActionDescriptor<T>> = [];\n    private activeAction?: ActionDescriptor<T>;\n\n    private dialogRef?: DynamicDialogRef;\n    private dialogCloseSubscription?: Subscription;\n\n    private subscriptions: Array<Subscription> = [];\n\n    public cmpId: string = Math.random().toString(36).substring(2);\n\n    constructor(\n        private router: Router,\n        private route: ActivatedRoute,\n        private confirmationService: ConfirmationService,\n        private navigationService: NavigationService,\n        private actionService: ActionService,\n        private tableviewService: TableviewComponentService<T, S>\n    ) {}\n\n    public ngOnInit() {\n\n        this.actions = this.tableviewService?.actions.filter(a => a.activationTrigger === ActionActivationTriggerEnum.OnRoute) ?? [];\n        const subscription = this.route.params.subscribe(p => {\n            const action = this.findActiveAction(p);\n            if (action) {\n                this.activateAction(action, p, this.route.snapshot.queryParams);\n            }\n        });\n        this.subscriptions.push(subscription);\n    }\n\n    public ngOnDestroy() {\n        this.subscriptions.forEach(s => s.unsubscribe());\n        if (this.dialogRef) {\n            this.dialogRef.close();\n        }\n    }\n\n    public getConfirmationService() {\n        return this.confirmationService;\n    }\n\n    public getConfirmationServiceInstanceKey(action: ActionDescriptor<any>) {\n        return `actionRoute_${this.cmpId}`;\n    }\n\n    private activateAction(action: ActionDescriptor<T>, p: Params, qp: Params) {\n        this.activeAction = action;\n        const itemId = p['itemId'];\n        const actionData: ActionData = {};\n        for (let key in p) {\n            if (key === 'itemId') {\n                continue;\n            }\n            actionData[key] = p[key];\n        }\n        for (let key in qp) {\n            actionData[key] = p[key];\n        }\n        this.actionService.activateAction(action, itemId, undefined, actionData, this.tableviewService, this)\n            .pipe(first())\n            .subscribe(res => {\n                if (res.dialogRef) {\n                    this.dialogRef = res.dialogRef;\n                    this.dialogCloseSubscription = this.dialogRef.onClose.subscribe(e => {\n                        const actionEv = e as ActionRunResult<T, S, any>;\n                        if (!actionEv?.error || !actionEv?.error?.dismissed) {\n                            this.tableviewService.reloadTable(); // reload only if no error in action and\n                        }\n                        this.deactivateAction();\n                    });\n                }\n            });\n    }\n\n    private deactivateAction() {\n        if (this.dialogCloseSubscription) {\n            this.dialogCloseSubscription.unsubscribe();\n            this.dialogCloseSubscription = undefined;\n        }\n        if (this.navigationService.getPreviousLocation()) {\n            // there are internal history records, so back can be normally called\n            this.navigationService.back();\n        } else {\n            // there is no internal history records, figure out the base url by eliminating action specific url\n            let url = this.navigationService.getCurrentLocation();\n            if (!url) {\n                this.navigationService.back();\n            } else {\n                if (url.startsWith('/')) {\n                    url = url.substring(1);\n                }\n                const urlPathSegments = url.split('?')[0].split('#')[0].split('/');\n                let actionUrl = this.activeAction?.routeUrl ?? '';\n                if (actionUrl.startsWith('/')) {\n                    actionUrl = actionUrl.substring(1);\n                }\n                const actionUrlSegments = actionUrl.split('/');\n                const redirectUrl = urlPathSegments.slice(0, urlPathSegments.length - actionUrlSegments.length).join('/');\n                this.router.navigateByUrl(`/${redirectUrl}`, { replaceUrl: true });\n            }\n        }\n        this.activeAction = undefined;\n        this.dialogRef = undefined;\n    }\n\n    private findActiveAction(params: Params): ActionDescriptor<T>|null {\n        const urlSegments = this.route.snapshot.url;\n        for (const action of this.actions) {\n            let actionUrl = action.routeUrl ?? '';\n            // TODO: dont strip '/', but use it accordingly with Angular's router patterns (/, ./, ../)\n            if (actionUrl.startsWith('/')) {\n                actionUrl = actionUrl.substring(1);\n            }\n            const actionUrlSegments = actionUrl.split('/');\n            if (actionUrlSegments.length !== urlSegments.length) {\n                continue;\n            }\n            let isMatch = true;\n            for (let i = 0; i < actionUrlSegments.length; i++) {\n                if (actionUrlSegments[i].startsWith(':')) {\n                    const paramName = actionUrlSegments[i].substring(1);\n                    if (!params[paramName]) {\n                        isMatch = false;\n                        break;\n                    }\n                } else if (actionUrlSegments[i] !== urlSegments[i].path) {\n                    isMatch = false;\n                    break;\n                }\n            }\n            if (isMatch) {\n                return action;\n            }\n        }\n        return null;\n    }\n}\n","<p-confirmDialog [key]=\"'actionRoute_' + cmpId\" [baseZIndex]=\"50\" appendTo=\"body\"></p-confirmDialog>\n"]}

package/esm2020/lib/components/form/editor/form-editor.component.mjs

@@ -0,0 +1,140 @@
+import { ChangeDetectionStrategy, Component, ContentChildren, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { Observable, of } from 'rxjs';
+import { MngEditorSubmitEvent } from '../../../models/events';
+import { TemplateDirective } from '../../../directives';
+import { EditorFormlyUtil } from '../../../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-formly/core";
+import * as i2 from "primeng/messages";
+import * as i3 from "@angular/forms";
+import * as i4 from "primeng/button";
+import * as i5 from "@angular/common";
+export class FormEditorComponent {
+    constructor() {
+        this.submitLoading = false;
+        // extra features input
+        this.isSubmitButtonVisible = false;
+        this.isFormDisabled = null;
+        // event outputs
+        this.submitEventEmitter = new EventEmitter();
+        this.form = new FormGroup({});
+        this.formOptions = {
+            formState: {
+                add: false,
+                edit: false,
+                disabled: false
+            }
+        };
+        this.formModel = {};
+        this.formMessages = [];
+        this.subscriptions = [];
+    }
+    ngOnInit() {
+        this.updateFormModel(this.item);
+        this.submitLoading$ = this.submitLoading instanceof Observable ? this.submitLoading : of(this.submitLoading);
+        // init fields for formly
+        this.formFields = EditorFormlyUtil.createFormlyConfigFromDescriptor(this.descriptor);
+        this.updateFormState();
+    }
+    ngAfterContentInit() {
+        this.templates.forEach(template => {
+            switch (template.getType()) {
+                // case 'caption':
+                //     this.captionTemplate = template.template;
+                //     break;
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach(s => s.unsubscribe());
+    }
+    submit() {
+        this.submitButtonElementRef?.nativeElement.click();
+    }
+    onSubmit(event) {
+        this.formOptions.formState.submittedOn = Date.now();
+        this.formMessages = [];
+        const formSubmitItem = this.form.value;
+        if (this.form.valid) {
+            this.descriptor.fields.forEach(field => {
+                if (field && field.setter) {
+                    // TODO: resolve ts ignore
+                    // @ts-ignore
+                    field.setter(formSubmitItem, formSubmitItem[field.property]);
+                }
+            });
+            this.submitEventEmitter.next(new MngEditorSubmitEvent(formSubmitItem));
+        }
+        else {
+            // find and mark invalid tabs
+            if (this.formFields[0].type === 'tabs' && this.formFields[0].fieldGroup) {
+                for (const tab of this.formFields[0].fieldGroup) {
+                    const isInvalid = this.isAnyFieldInvalid(tab.fieldGroup);
+                    this.formOptions.formState['tab_' + (tab.id ? tab.id : tab.templateOptions?.label) + '_invalid'] = isInvalid;
+                }
+            }
+            const event = new MngEditorSubmitEvent(formSubmitItem);
+            event.success = false;
+            this.submitEventEmitter.next(event);
+        }
+    }
+    isAnyFieldInvalid(fields = []) {
+        for (const field of fields) {
+            let fieldInvalid = false;
+            if (Array.isArray(field.fieldGroup)) {
+                fieldInvalid = this.isAnyFieldInvalid(field.fieldGroup);
+            }
+            else if (typeof field.type !== 'undefined') {
+                fieldInvalid = !field.formControl?.valid;
+            }
+            if (fieldInvalid) {
+                return true;
+            }
+        }
+        return false;
+    }
+    updateFormModel(item) {
+        this.formOrigItem = item;
+        // TODO: to check if this is ok, could be problems with dates, if so, try lodash
+        const formModel = JSON.parse(JSON.stringify(item ?? {}));
+        this.descriptor.fields.forEach(field => {
+            if (field.getter && item) {
+                formModel[field.property] = field.getter(item);
+            }
+        });
+        if (typeof this.formOptions.resetModel === 'function') { // could not be initiated yet
+            this.formOptions.resetModel(this.formModel);
+        }
+        this.formModel = formModel;
+    }
+    updateFormState() {
+        this.formOptions.formState.disabled = this.isFormDisabled !== null ? this.isFormDisabled === true : this.descriptor.disabled;
+    }
+}
+FormEditorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FormEditorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+FormEditorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: FormEditorComponent, selector: "mng-form-editor", inputs: { descriptor: "descriptor", submitLoading: "submitLoading", item: "item", isSubmitButtonVisible: "isSubmitButtonVisible", isFormDisabled: "isFormDisabled" }, outputs: { submitEventEmitter: "onSubmit" }, queries: [{ propertyName: "templates", predicate: TemplateDirective }], viewQueries: [{ propertyName: "submitButtonElementRef", first: true, predicate: ["submitButton"], descendants: true }], ngImport: i0, template: "<form [formGroup]=\"form\" (ngSubmit)=\"onSubmit($event)\">\n    <formly-form [form]=\"form\" [fields]=\"formFields\" [options]=\"formOptions\" [model]=\"formModel\"></formly-form>\n    <button #submitButton pButton type=\"submit\" [class.hidden]=\"!isSubmitButtonVisible\" [disabled]=\"form.disabled\" [loading]=\"(submitLoading$ | async) ?? false\"></button>\n</form>\n<p-messages [value]=\"formMessages\"></p-messages>\n", components: [{ type: i1.FormlyForm, selector: "formly-form", inputs: ["form", "model", "fields", "options"], outputs: ["modelChange"] }, { type: i2.Messages, selector: "p-messages", inputs: ["value", "closable", "style", "styleClass", "enableService", "key", "escape", "severity", "showTransitionOptions", "hideTransitionOptions"], outputs: ["valueChange"] }], directives: [{ type: i3.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i4.ButtonDirective, selector: "[pButton]", inputs: ["iconPos", "loadingIcon", "label", "icon", "loading"] }], pipes: { "async": i5.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FormEditorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mng-form-editor', changeDetection: ChangeDetectionStrategy.OnPush, template: "<form [formGroup]=\"form\" (ngSubmit)=\"onSubmit($event)\">\n    <formly-form [form]=\"form\" [fields]=\"formFields\" [options]=\"formOptions\" [model]=\"formModel\"></formly-form>\n    <button #submitButton pButton type=\"submit\" [class.hidden]=\"!isSubmitButtonVisible\" [disabled]=\"form.disabled\" [loading]=\"(submitLoading$ | async) ?? false\"></button>\n</form>\n<p-messages [value]=\"formMessages\"></p-messages>\n" }]
+        }], ctorParameters: function () { return []; }, propDecorators: { descriptor: [{
+                type: Input
+            }], submitLoading: [{
+                type: Input
+            }], item: [{
+                type: Input
+            }], isSubmitButtonVisible: [{
+                type: Input
+            }], isFormDisabled: [{
+                type: Input
+            }], submitEventEmitter: [{
+                type: Output,
+                args: ['onSubmit']
+            }], templates: [{
+                type: ContentChildren,
+                args: [TemplateDirective]
+            }], submitButtonElementRef: [{
+                type: ViewChild,
+                args: ['submitButton']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-editor.component.js","sourceRoot":"","sources":["../../../../../../../projects/mng-commons/src/lib/components/form/editor/form-editor.component.ts","../../../../../../../projects/mng-commons/src/lib/components/form/editor/form-editor.component.html"],"names":[],"mappings":"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","sourcesContent":["import {AfterContentInit, ChangeDetectionStrategy, Component, ContentChildren, ElementRef, EventEmitter, Input, OnDestroy, OnInit, Output, QueryList, ViewChild} from '@angular/core';\nimport {FormGroup} from '@angular/forms';\n\nimport {FormlyFieldConfig, FormlyFormOptions} from '@ngx-formly/core';\nimport {Message} from 'primeng/api';\nimport {Observable, of, Subscription} from 'rxjs';\n\nimport {EditorDescriptor} from '../../../models/descriptors';\nimport {MngEditorSubmitEvent} from '../../../models/events';\nimport {TemplateDirective} from '../../../directives';\nimport {EditorFormlyUtil} from '../../../utils';\n\n@Component({\n    selector: 'mng-form-editor',\n    templateUrl: './form-editor.component.html',\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class FormEditorComponent<T> implements OnInit, AfterContentInit, OnDestroy {\n\n    // metadata and editor mode input\n    @Input() public descriptor!: EditorDescriptor<T>;\n    @Input() public submitLoading: Observable<boolean>|boolean = false;\n\n    // data source inputs;\n    @Input() public item?: T;\n\n    // extra features input\n    @Input() public isSubmitButtonVisible = false;\n    @Input() public isFormDisabled = null;\n\n    // event outputs\n    @Output('onSubmit') private submitEventEmitter = new EventEmitter<MngEditorSubmitEvent<T>>();\n\n    // content and view queries\n    @ContentChildren(TemplateDirective) templates!: QueryList<TemplateDirective>;\n\n    @ViewChild('submitButton')\n    public submitButtonElementRef?: ElementRef;\n\n    public form: FormGroup = new FormGroup({});\n    public formOptions: FormlyFormOptions = {\n        formState: {\n            add: false,\n            edit: false,\n            disabled: false\n        }\n    };\n    public formFields!: FormlyFieldConfig[];\n    public formOrigItem?: T;\n    public formModel: any = {};\n    public formMessages: Message[] = [];\n    public submitLoading$!: Observable<boolean>;\n\n    private subscriptions: Subscription[] = [];\n\n    constructor() { }\n\n    public ngOnInit() {\n\n        this.updateFormModel(this.item);\n        this.submitLoading$ = this.submitLoading instanceof Observable ? this.submitLoading : of(this.submitLoading);\n\n        // init fields for formly\n        this.formFields = EditorFormlyUtil.createFormlyConfigFromDescriptor(this.descriptor);\n        this.updateFormState();\n    }\n\n    public ngAfterContentInit() {\n        this.templates.forEach(template => {\n            switch(template.getType()) {\n                // case 'caption':\n                //     this.captionTemplate = template.template;\n                //     break;\n            }\n        });\n    }\n\n    public ngOnDestroy() {\n        this.subscriptions.forEach(s => s.unsubscribe());\n    }\n\n    public submit() {\n        this.submitButtonElementRef?.nativeElement.click();\n    }\n\n    public onSubmit(event: Event) {\n        this.formOptions.formState.submittedOn = Date.now();\n        this.formMessages = [];\n\n        const formSubmitItem = this.form.value as T;\n        if (this.form.valid) {\n            this.descriptor.fields.forEach(field => {\n                if (field && field.setter) {\n                    // TODO: resolve ts ignore\n                    // @ts-ignore\n                    field.setter(formSubmitItem, formSubmitItem[field.property]);\n                }\n            });\n\n            this.submitEventEmitter.next(new MngEditorSubmitEvent(formSubmitItem));\n        } else {\n            // find and mark invalid tabs\n            if (this.formFields[0].type === 'tabs' && this.formFields[0].fieldGroup) {\n                for (const tab of this.formFields[0].fieldGroup) {\n                    const isInvalid = this.isAnyFieldInvalid(tab.fieldGroup);\n                    this.formOptions.formState['tab_' + (tab.id ? tab.id : tab.templateOptions?.label) + '_invalid'] = isInvalid;\n                }\n            }\n            const event = new MngEditorSubmitEvent(formSubmitItem);\n            event.success = false;\n            this.submitEventEmitter.next(event);\n        }\n    }\n\n    private isAnyFieldInvalid(fields: FormlyFieldConfig[] = []): boolean {\n        for (const field of fields) {\n            let fieldInvalid = false;\n            if (Array.isArray(field.fieldGroup)) {\n                fieldInvalid = this.isAnyFieldInvalid(field.fieldGroup);\n            } else if (typeof field.type !== 'undefined') {\n                fieldInvalid = !field.formControl?.valid;\n            }\n            if (fieldInvalid) {\n                return true;\n            }\n        }\n        return false;\n    }\n\n    private updateFormModel(item?: T) {\n        this.formOrigItem = item;\n        // TODO: to check if this is ok, could be problems with dates, if so, try lodash\n        const formModel =  JSON.parse(JSON.stringify(item ?? {}));\n\n        this.descriptor.fields.forEach(field => {\n            if (field.getter && item) {\n                formModel[field.property] = field.getter(item);\n            }\n        });\n        if (typeof this.formOptions.resetModel === 'function') { // could not be initiated yet\n            this.formOptions.resetModel(this.formModel);\n        }\n        this.formModel = formModel;\n    }\n\n    private updateFormState() {\n        this.formOptions.formState.disabled = this.isFormDisabled !== null ? this.isFormDisabled === true : this.descriptor.disabled;\n    }\n}\n","<form [formGroup]=\"form\" (ngSubmit)=\"onSubmit($event)\">\n    <formly-form [form]=\"form\" [fields]=\"formFields\" [options]=\"formOptions\" [model]=\"formModel\"></formly-form>\n    <button #submitButton pButton type=\"submit\" [class.hidden]=\"!isSubmitButtonVisible\" [disabled]=\"form.disabled\" [loading]=\"(submitLoading$ | async) ?? false\"></button>\n</form>\n<p-messages [value]=\"formMessages\"></p-messages>\n"]}

package/esm2020/lib/components/form/formly/fields/formly-field-autocomplete/formly-field-autocomplete.component.mjs

@@ -0,0 +1,58 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { FieldType } from '@ngx-formly/core';
+import { Subject } from 'rxjs';
+import { finalize, first } from 'rxjs/operators';
+import { FilterMatchType, QueryParamBuilder } from '../../../../../api/models';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/autocomplete";
+import * as i2 from "@angular/forms";
+import * as i3 from "@angular/common";
+import * as i4 from "@ngx-translate/core";
+export class FormlyFieldAutocompleteComponent extends FieldType {
+    constructor(injector) {
+        super();
+        this.injector = injector;
+        this.suggestionsSubject = new Subject();
+        this.suggestionsAsync = this.suggestionsSubject.asObservable();
+        this.searchSubscription = null;
+        this.isLoading = false;
+        this.dataProviderService = null;
+    }
+    ngOnInit() {
+        this.aFormControl = this.formControl;
+        this.descriptor = this.to['descriptor'];
+        if (this.descriptor.dataProvider) {
+            this.dataProviderService = this.descriptor.dataProvider.serviceType
+                ? this.injector.get(this.descriptor.dataProvider.serviceType)
+                : null;
+        }
+    }
+    onSearch(event) {
+        if (this.searchSubscription) {
+            // try to cancel existing HTTP request subscription
+            this.searchSubscription.unsubscribe();
+        }
+        if (this.descriptor.dataProvider) {
+            this.isLoading = true;
+            const queryParamBuilder = QueryParamBuilder.create(10);
+            if (this.descriptor.itemsLabelProperty) {
+                queryParamBuilder.withSort(this.descriptor.itemsLabelProperty);
+            }
+            if (event.query && event.query.length > 0 && this.descriptor.itemsLabelProperty) {
+                queryParamBuilder.withFilter(this.descriptor.itemsLabelProperty, event.query, undefined, FilterMatchType.StartsWith);
+            }
+            this.searchSubscription = this.descriptor.dataProvider.lookup(queryParamBuilder.build(), this.dataProviderService, event.query)
+                .pipe(first(), finalize(() => this.isLoading = false))
+                .subscribe(res => {
+                this.suggestionsSubject.next(res);
+            });
+        }
+    }
+}
+FormlyFieldAutocompleteComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FormlyFieldAutocompleteComponent, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+FormlyFieldAutocompleteComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: FormlyFieldAutocompleteComponent, selector: "mng-formly-field-autocomplete", usesInheritance: true, ngImport: i0, template: "<p-autoComplete [id]=\"key\"\n                [formControl]=\"aFormControl\"\n                [suggestions]=\"(suggestionsAsync | async) ?? []\"\n                (completeMethod)=\"onSearch($event)\"\n                [field]=\"$any(descriptor.itemsLabelProperty)\"\n                [dropdown]=\"true\"\n                [showEmptyMessage]=\"true\" [emptyMessage]=\"'fields.noMatches' | translate \"\n                dropdownMode=\"current\">\n</p-autoComplete>\n", components: [{ type: i1.AutoComplete, selector: "p-autoComplete", inputs: ["minLength", "delay", "style", "panelStyle", "styleClass", "panelStyleClass", "inputStyle", "inputId", "inputStyleClass", "placeholder", "readonly", "disabled", "virtualScroll", "itemSize", "maxlength", "name", "required", "size", "appendTo", "autoHighlight", "forceSelection", "type", "autoZIndex", "baseZIndex", "ariaLabel", "dropdownAriaLabel", "ariaLabelledBy", "dropdownIcon", "unique", "group", "completeOnFocus", "field", "scrollHeight", "dropdown", "showEmptyMessage", "dropdownMode", "multiple", "tabindex", "dataKey", "emptyMessage", "showTransitionOptions", "hideTransitionOptions", "autofocus", "autocomplete", "optionGroupChildren", "optionGroupLabel", "suggestions"], outputs: ["completeMethod", "onSelect", "onUnselect", "onFocus", "onBlur", "onDropdownClick", "onClear", "onKeyUp", "onShow", "onHide"] }], directives: [{ type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }], pipes: { "async": i3.AsyncPipe, "translate": i4.TranslatePipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FormlyFieldAutocompleteComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mng-formly-field-autocomplete', changeDetection: ChangeDetectionStrategy.OnPush, template: "<p-autoComplete [id]=\"key\"\n                [formControl]=\"aFormControl\"\n                [suggestions]=\"(suggestionsAsync | async) ?? []\"\n                (completeMethod)=\"onSearch($event)\"\n                [field]=\"$any(descriptor.itemsLabelProperty)\"\n                [dropdown]=\"true\"\n                [showEmptyMessage]=\"true\" [emptyMessage]=\"'fields.noMatches' | translate \"\n                dropdownMode=\"current\">\n</p-autoComplete>\n" }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/form/formly/fields/formly-field-dropdown/formly-field-dropdown.component.mjs

@@ -0,0 +1,51 @@
+import { Component, ChangeDetectionStrategy } from '@angular/core';
+import { FieldType } from '@ngx-formly/core';
+import { ReplaySubject } from 'rxjs';
+import { first } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/dropdown";
+import * as i2 from "@angular/forms";
+import * as i3 from "@ngx-formly/core";
+import * as i4 from "@angular/common";
+export class FormlyFieldDropdownComponent extends FieldType {
+    constructor(injector) {
+        super();
+        this.injector = injector;
+        this.itemsSubject = new ReplaySubject(1);
+        this.itemsAsync = this.itemsSubject.asObservable();
+        this.useDataProvider = false;
+        this.dataProviderService = null;
+    }
+    ngOnInit() {
+        this.dFormControl = this.formControl;
+        this.descriptor = this.to['descriptor'];
+        if (this.descriptor.dataProvider) {
+            this.useDataProvider = true;
+            if (this.descriptor.dataProvider.serviceType) {
+                this.dataProviderService = this.injector.get(this.descriptor.dataProvider.serviceType);
+            }
+            this.descriptor.dataProvider.lookup(undefined, this.dataProviderService)
+                .pipe(first())
+                .subscribe(res => {
+                this.itemsSubject.next(res);
+            });
+        }
+        if (!this.formControl.value) {
+            this.itemsAsync.pipe(first()).subscribe(res => {
+                // TODO: check if really only way
+                if (res.length === 1) {
+                    const value = this.descriptor.itemsValueProperty ? res[0][this.descriptor.itemsValueProperty] : res[0];
+                    this.formControl.patchValue(value);
+                    console.log('patched dropdown form value with', value);
+                }
+            });
+        }
+    }
+}
+FormlyFieldDropdownComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FormlyFieldDropdownComponent, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+FormlyFieldDropdownComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: FormlyFieldDropdownComponent, selector: "mng-formly-field-dropdown", usesInheritance: true, ngImport: i0, template: "<p-dropdown [id]=\"$any(key)\"\n        [placeholder]=\"$any(descriptor.placeholder)\"\n        [options]=\"(itemsAsync | async) ?? []\"\n        [optionLabel]=\"$any(descriptor.itemsLabelProperty)\"\n        [optionLabel]=\"$any(descriptor.itemsValueProperty)\"\n        [formControl]=\"dFormControl\"\n        [formlyAttributes]=\"field\"\n        [showClear]=\"!this.to.required\"\n        [dataKey]=\"$any(descriptor.dataKeyProperty)\">\n</p-dropdown>\n", components: [{ type: i1.Dropdown, selector: "p-dropdown", inputs: ["scrollHeight", "filter", "name", "style", "panelStyle", "styleClass", "panelStyleClass", "readonly", "required", "editable", "appendTo", "tabindex", "placeholder", "filterPlaceholder", "filterLocale", "inputId", "selectId", "dataKey", "filterBy", "autofocus", "resetFilterOnHide", "dropdownIcon", "optionLabel", "optionValue", "optionDisabled", "optionGroupLabel", "optionGroupChildren", "autoDisplayFirst", "group", "showClear", "emptyFilterMessage", "emptyMessage", "virtualScroll", "itemSize", "autoZIndex", "baseZIndex", "showTransitionOptions", "hideTransitionOptions", "ariaFilterLabel", "ariaLabelledBy", "filterMatchMode", "maxlength", "tooltip", "tooltipPosition", "tooltipPositionStyle", "tooltipStyleClass", "autofocusFilter", "disabled", "options", "filterValue"], outputs: ["onChange", "onFilter", "onFocus", "onBlur", "onClick", "onShow", "onHide", "onClear"] }], directives: [{ type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { type: i3.ɵFormlyAttributes, selector: "[formlyAttributes]", inputs: ["formlyAttributes", "id"] }], pipes: { "async": i4.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FormlyFieldDropdownComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mng-formly-field-dropdown', changeDetection: ChangeDetectionStrategy.OnPush, template: "<p-dropdown [id]=\"$any(key)\"\n        [placeholder]=\"$any(descriptor.placeholder)\"\n        [options]=\"(itemsAsync | async) ?? []\"\n        [optionLabel]=\"$any(descriptor.itemsLabelProperty)\"\n        [optionLabel]=\"$any(descriptor.itemsValueProperty)\"\n        [formControl]=\"dFormControl\"\n        [formlyAttributes]=\"field\"\n        [showClear]=\"!this.to.required\"\n        [dataKey]=\"$any(descriptor.dataKeyProperty)\">\n</p-dropdown>\n" }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/form/formly/fields/formly-field-fieldset/formly-field-fieldset.component.mjs

@@ -0,0 +1,16 @@
+import { Component, ChangeDetectionStrategy } from '@angular/core';
+import { FieldType } from '@ngx-formly/core';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/fieldset";
+import * as i2 from "@ngx-formly/core";
+import * as i3 from "@angular/common";
+import * as i4 from "@ngx-translate/core";
+export class FormlyFieldFieldsetComponent extends FieldType {
+}
+FormlyFieldFieldsetComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FormlyFieldFieldsetComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+FormlyFieldFieldsetComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: FormlyFieldFieldsetComponent, selector: "mng-formly-field-fieldset", usesInheritance: true, ngImport: i0, template: "<ng-container *ngFor=\"let group of field.fieldGroup; let i = index; let last = last;\">\n    <p-fieldset *ngIf=\"!group.templateOptions?.['descriptor']?.default; else defaultSet\" [legend]=\"group.templateOptions?.label! | translate\">\n        <formly-field [field]=\"group\"></formly-field>\n    </p-fieldset>\n    <ng-template #defaultSet>\n        <formly-field [field]=\"group\"></formly-field>\n    </ng-template>\n</ng-container>\n", components: [{ type: i1.Fieldset, selector: "p-fieldset", inputs: ["legend", "toggleable", "collapsed", "style", "styleClass", "transitionOptions"], outputs: ["collapsedChange", "onBeforeToggle", "onAfterToggle"] }, { type: i2.FormlyField, selector: "formly-field", inputs: ["field"] }], directives: [{ type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "translate": i4.TranslatePipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FormlyFieldFieldsetComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mng-formly-field-fieldset', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngFor=\"let group of field.fieldGroup; let i = index; let last = last;\">\n    <p-fieldset *ngIf=\"!group.templateOptions?.['descriptor']?.default; else defaultSet\" [legend]=\"group.templateOptions?.label! | translate\">\n        <formly-field [field]=\"group\"></formly-field>\n    </p-fieldset>\n    <ng-template #defaultSet>\n        <formly-field [field]=\"group\"></formly-field>\n    </ng-template>\n</ng-container>\n" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybWx5LWZpZWxkLWZpZWxkc2V0LmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21uZy1jb21tb25zL3NyYy9saWIvY29tcG9uZW50cy9mb3JtL2Zvcm1seS9maWVsZHMvZm9ybWx5LWZpZWxkLWZpZWxkc2V0L2Zvcm1seS1maWVsZC1maWVsZHNldC5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tbmctY29tbW9ucy9zcmMvbGliL2NvbXBvbmVudHMvZm9ybS9mb3JtbHkvZmllbGRzL2Zvcm1seS1maWVsZC1maWVsZHNldC9mb3JtbHktZmllbGQtZmllbGRzZXQuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFNBQVMsRUFBRSx1QkFBdUIsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUNqRSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7Ozs7OztBQU83QyxNQUFNLE9BQU8sNEJBQTZCLFNBQVEsU0FBUzs7eUhBQTlDLDRCQUE0Qjs2R0FBNUIsNEJBQTRCLHdGQ1J6Qyx5YkFRQTsyRkRBYSw0QkFBNEI7a0JBTHhDLFNBQVM7K0JBQ0ksMkJBQTJCLG1CQUVwQix1QkFBdUIsQ0FBQyxNQUFNIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtDb21wb25lbnQsIENoYW5nZURldGVjdGlvblN0cmF0ZWd5fSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEZpZWxkVHlwZSB9IGZyb20gJ0BuZ3gtZm9ybWx5L2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgICBzZWxlY3RvcjogJ21uZy1mb3JtbHktZmllbGQtZmllbGRzZXQnLFxuICAgIHRlbXBsYXRlVXJsOiAnLi9mb3JtbHktZmllbGQtZmllbGRzZXQuY29tcG9uZW50Lmh0bWwnLFxuICAgIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxufSlcbmV4cG9ydCBjbGFzcyBGb3JtbHlGaWVsZEZpZWxkc2V0Q29tcG9uZW50IGV4dGVuZHMgRmllbGRUeXBlIHtcbn1cbiIsIjxuZy1jb250YWluZXIgKm5nRm9yPVwibGV0IGdyb3VwIG9mIGZpZWxkLmZpZWxkR3JvdXA7IGxldCBpID0gaW5kZXg7IGxldCBsYXN0ID0gbGFzdDtcIj5cbiAgICA8cC1maWVsZHNldCAqbmdJZj1cIiFncm91cC50ZW1wbGF0ZU9wdGlvbnM/LlsnZGVzY3JpcHRvciddPy5kZWZhdWx0OyBlbHNlIGRlZmF1bHRTZXRcIiBbbGVnZW5kXT1cImdyb3VwLnRlbXBsYXRlT3B0aW9ucz8ubGFiZWwhIHwgdHJhbnNsYXRlXCI+XG4gICAgICAgIDxmb3JtbHktZmllbGQgW2ZpZWxkXT1cImdyb3VwXCI+PC9mb3JtbHktZmllbGQ+XG4gICAgPC9wLWZpZWxkc2V0PlxuICAgIDxuZy10ZW1wbGF0ZSAjZGVmYXVsdFNldD5cbiAgICAgICAgPGZvcm1seS1maWVsZCBbZmllbGRdPVwiZ3JvdXBcIj48L2Zvcm1seS1maWVsZD5cbiAgICA8L25nLXRlbXBsYXRlPlxuPC9uZy1jb250YWluZXI+XG4iXX0=

package/esm2020/lib/components/form/formly/fields/formly-field-input/formly-field-input.component.mjs

@@ -0,0 +1,26 @@
+import { Component, ChangeDetectionStrategy } from '@angular/core';
+import { FieldType } from '@ngx-formly/core';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/inputnumber";
+import * as i2 from "primeng/inputswitch";
+import * as i3 from "@ngx-formly/core";
+import * as i4 from "primeng/radiobutton";
+import * as i5 from "primeng/calendar";
+import * as i6 from "@angular/common";
+import * as i7 from "@angular/forms";
+import * as i8 from "primeng/inputtextarea";
+import * as i9 from "primeng/inputtext";
+import * as i10 from "@ngx-translate/core";
+export class FormlyFieldInputComponent extends FieldType {
+    ngOnInit() {
+        this.iFormControl = this.formControl;
+        this.descriptor = this.to['descriptor'];
+    }
+}
+FormlyFieldInputComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FormlyFieldInputComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+FormlyFieldInputComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: FormlyFieldInputComponent, selector: "mng-formly-field-input", usesInheritance: true, ngImport: i0, template: "<ng-container [ngSwitch]=\"to.type\">\n    <p-inputNumber *ngSwitchCase=\"'number'\"\n                   [id]=\"$any(key)\"\n                   [formControl]=\"iFormControl\"\n                   [formlyAttributes]=\"field\"\n                   [min]=\"$any(descriptor.numberMin)\"\n                   [max]=\"$any(descriptor.numberMax)\"\n                   [step]=\"$any(descriptor.numberStep)\"\n                   [minFractionDigits]=\"descriptor.numberMinFractionDigits || 0\"\n                   [maxFractionDigits]=\"descriptor.numberMaxFractionDigits || 0\">\n    </p-inputNumber>\n\n    <div *ngSwitchCase=\"'switch'\" class=\"flex flex-column\">\n        <label [for]=\"key\">{{ to?.label! | translate }} <span *ngIf=\"to.required && to['hideRequiredMarker'] !== true\">*</span></label>\n        <p-inputSwitch [id]=\"$any(key)\"\n                       [formControl]=\"iFormControl\"\n                       [formlyAttributes]=\"field\">\n        </p-inputSwitch>\n        <small *ngIf=\"showError\" class=\"p-error\">\n            <formly-validation-message [field]=\"field\"></formly-validation-message>\n        </small>\n    </div>\n\n    <ng-container *ngSwitchCase=\"'radio'\">\n        <div *ngFor=\"let category of descriptor.radioOptions\" [id]=\"$any(key)\" class=\"p-field-radiobutton\">\n            <p-radioButton [value]=\"category\" [formControl]=\"iFormControl\" [formlyAttributes]=\"field\"></p-radioButton>\n            <label [for]=\"category\" class=\"mng-radio-button-label\">{{category}}</label>\n        </div>\n    </ng-container>\n\n    <textarea *ngSwitchCase=\"'textarea'\"\n              [id]=\"$any(key)\"\n              [formControl]=\"iFormControl\"\n              [formlyAttributes]=\"field\"\n              [rows]=\"descriptor.rows ?? 3\"\n              pInputTextarea>\n    </textarea>\n\n    <p-calendar *ngSwitchCase=\"'datepicker'\"\n                [formControl]=\"iFormControl\"\n                [formlyAttributes]=\"field\"\n                [dateFormat]=\"$any(descriptor.datePickerFormat)\"\n                [minDate]=\"$any(descriptor.datePickerMin)\"\n                [maxDate]=\"$any(descriptor.datePickerMax)\"\n                [showTime]=\"descriptor.datePickerShowTime\"\n                [showIcon]=\"true\">\n    </p-calendar>\n\n    <input *ngSwitchDefault\n           pInputText\n           [id]=\"$any(key)\"\n           [type]=\"to.type || 'text'\"\n           [formControl]=\"iFormControl\"\n           [formlyAttributes]=\"field\"\n    />\n</ng-container>\n", components: [{ type: i1.InputNumber, selector: "p-inputNumber", inputs: ["showButtons", "format", "buttonLayout", "inputId", "styleClass", "style", "placeholder", "size", "maxlength", "tabindex", "title", "ariaLabel", "ariaRequired", "name", "required", "autocomplete", "min", "max", "incrementButtonClass", "decrementButtonClass", "incrementButtonIcon", "decrementButtonIcon", "readonly", "step", "allowEmpty", "locale", "localeMatcher", "mode", "currency", "currencyDisplay", "useGrouping", "minFractionDigits", "maxFractionDigits", "prefix", "suffix", "inputStyle", "inputStyleClass", "disabled"], outputs: ["onInput", "onFocus", "onBlur", "onKeyDown"] }, { type: i2.InputSwitch, selector: "p-inputSwitch", inputs: ["style", "styleClass", "tabindex", "inputId", "name", "disabled", "readonly", "trueValue", "falseValue", "ariaLabelledBy"], outputs: ["onChange"] }, { type: i3.ɵFormlyValidationMessage, selector: "formly-validation-message", inputs: ["field"] }, { type: i4.RadioButton, selector: "p-radioButton", inputs: ["value", "formControlName", "name", "disabled", "label", "tabindex", "inputId", "ariaLabelledBy", "ariaLabel", "style", "styleClass", "labelStyleClass"], outputs: ["onClick", "onFocus", "onBlur"] }, { type: i5.Calendar, selector: "p-calendar", inputs: ["style", "styleClass", "inputStyle", "inputId", "name", "inputStyleClass", "placeholder", "ariaLabelledBy", "iconAriaLabel", "disabled", "dateFormat", "multipleSeparator", "rangeSeparator", "inline", "showOtherMonths", "selectOtherMonths", "showIcon", "icon", "appendTo", "readonlyInput", "shortYearCutoff", "monthNavigator", "yearNavigator", "hourFormat", "timeOnly", "stepHour", "stepMinute", "stepSecond", "showSeconds", "required", "showOnFocus", "showWeek", "dataType", "selectionMode", "maxDateCount", "showButtonBar", "todayButtonStyleClass", "clearButtonStyleClass", "autoZIndex", "baseZIndex", "panelStyleClass", "panelStyle", "keepInvalid", "hideOnDateTimeSelect", "touchUI", "timeSeparator", "focusTrap", "showTransitionOptions", "hideTransitionOptions", "tabindex", "view", "defaultDate", "minDate", "maxDate", "disabledDates", "disabledDays", "yearRange", "showTime", "responsiveOptions", "numberOfMonths", "firstDayOfWeek", "locale"], outputs: ["onFocus", "onBlur", "onClose", "onSelect", "onInput", "onTodayClick", "onClearClick", "onMonthChange", "onYearChange", "onClickOutside", "onShow"] }], directives: [{ type: i6.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { type: i6.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { type: i7.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i7.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { type: i3.ɵFormlyAttributes, selector: "[formlyAttributes]", inputs: ["formlyAttributes", "id"] }, { type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i6.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i7.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i8.InputTextarea, selector: "[pInputTextarea]", inputs: ["autoResize"], outputs: ["onResize"] }, { type: i6.NgSwitchDefault, selector: "[ngSwitchDefault]" }, { type: i9.InputText, selector: "[pInputText]" }], pipes: { "translate": i10.TranslatePipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FormlyFieldInputComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mng-formly-field-input', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container [ngSwitch]=\"to.type\">\n    <p-inputNumber *ngSwitchCase=\"'number'\"\n                   [id]=\"$any(key)\"\n                   [formControl]=\"iFormControl\"\n                   [formlyAttributes]=\"field\"\n                   [min]=\"$any(descriptor.numberMin)\"\n                   [max]=\"$any(descriptor.numberMax)\"\n                   [step]=\"$any(descriptor.numberStep)\"\n                   [minFractionDigits]=\"descriptor.numberMinFractionDigits || 0\"\n                   [maxFractionDigits]=\"descriptor.numberMaxFractionDigits || 0\">\n    </p-inputNumber>\n\n    <div *ngSwitchCase=\"'switch'\" class=\"flex flex-column\">\n        <label [for]=\"key\">{{ to?.label! | translate }} <span *ngIf=\"to.required && to['hideRequiredMarker'] !== true\">*</span></label>\n        <p-inputSwitch [id]=\"$any(key)\"\n                       [formControl]=\"iFormControl\"\n                       [formlyAttributes]=\"field\">\n        </p-inputSwitch>\n        <small *ngIf=\"showError\" class=\"p-error\">\n            <formly-validation-message [field]=\"field\"></formly-validation-message>\n        </small>\n    </div>\n\n    <ng-container *ngSwitchCase=\"'radio'\">\n        <div *ngFor=\"let category of descriptor.radioOptions\" [id]=\"$any(key)\" class=\"p-field-radiobutton\">\n            <p-radioButton [value]=\"category\" [formControl]=\"iFormControl\" [formlyAttributes]=\"field\"></p-radioButton>\n            <label [for]=\"category\" class=\"mng-radio-button-label\">{{category}}</label>\n        </div>\n    </ng-container>\n\n    <textarea *ngSwitchCase=\"'textarea'\"\n              [id]=\"$any(key)\"\n              [formControl]=\"iFormControl\"\n              [formlyAttributes]=\"field\"\n              [rows]=\"descriptor.rows ?? 3\"\n              pInputTextarea>\n    </textarea>\n\n    <p-calendar *ngSwitchCase=\"'datepicker'\"\n                [formControl]=\"iFormControl\"\n                [formlyAttributes]=\"field\"\n                [dateFormat]=\"$any(descriptor.datePickerFormat)\"\n                [minDate]=\"$any(descriptor.datePickerMin)\"\n                [maxDate]=\"$any(descriptor.datePickerMax)\"\n                [showTime]=\"descriptor.datePickerShowTime\"\n                [showIcon]=\"true\">\n    </p-calendar>\n\n    <input *ngSwitchDefault\n           pInputText\n           [id]=\"$any(key)\"\n           [type]=\"to.type || 'text'\"\n           [formControl]=\"iFormControl\"\n           [formlyAttributes]=\"field\"\n    />\n</ng-container>\n" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybWx5LWZpZWxkLWlucHV0LmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21uZy1jb21tb25zL3NyYy9saWIvY29tcG9uZW50cy9mb3JtL2Zvcm1seS9maWVsZHMvZm9ybWx5LWZpZWxkLWlucHV0L2Zvcm1seS1maWVsZC1pbnB1dC5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tbmctY29tbW9ucy9zcmMvbGliL2NvbXBvbmVudHMvZm9ybS9mb3JtbHkvZmllbGRzL2Zvcm1seS1maWVsZC1pbnB1dC9mb3JtbHktZmllbGQtaW5wdXQuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFNBQVMsRUFBRSx1QkFBdUIsRUFBUyxNQUFNLGVBQWUsQ0FBQztBQUd6RSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7Ozs7Ozs7Ozs7OztBQVM3QyxNQUFNLE9BQU8seUJBQTBCLFNBQVEsU0FBUztJQUtwRCxRQUFRO1FBQ0osSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLENBQUMsV0FBMEIsQ0FBQztRQUNwRCxJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksQ0FBQyxFQUFFLENBQUMsWUFBWSxDQUFDLENBQUM7SUFDNUMsQ0FBQzs7c0hBUlEseUJBQXlCOzBHQUF6Qix5QkFBeUIscUZDWnRDLDI5RUF3REE7MkZENUNhLHlCQUF5QjtrQkFMckMsU0FBUzsrQkFDSSx3QkFBd0IsbUJBRWpCLHVCQUF1QixDQUFDLE1BQU0iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0NvbXBvbmVudCwgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksIE9uSW5pdH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0Zvcm1Db250cm9sfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5cbmltcG9ydCB7IEZpZWxkVHlwZSB9IGZyb20gJ0BuZ3gtZm9ybWx5L2NvcmUnO1xuXG5pbXBvcnQge0ZpZWxkSW5wdXREZXNjcmlwdG9yfSBmcm9tICcuLi8uLi8uLi8uLi8uLi9tb2RlbHMvZGVzY3JpcHRvcnMnO1xuXG5AQ29tcG9uZW50KHtcbiAgICBzZWxlY3RvcjogJ21uZy1mb3JtbHktZmllbGQtaW5wdXQnLFxuICAgIHRlbXBsYXRlVXJsOiAnLi9mb3JtbHktZmllbGQtaW5wdXQuY29tcG9uZW50Lmh0bWwnLFxuICAgIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxufSlcbmV4cG9ydCBjbGFzcyBGb3JtbHlGaWVsZElucHV0Q29tcG9uZW50IGV4dGVuZHMgRmllbGRUeXBlIGltcGxlbWVudHMgT25Jbml0IHtcblxuICAgIHB1YmxpYyBpRm9ybUNvbnRyb2whOiBGb3JtQ29udHJvbDtcbiAgICBwdWJsaWMgZGVzY3JpcHRvciE6IEZpZWxkSW5wdXREZXNjcmlwdG9yPGFueT47XG5cbiAgICBuZ09uSW5pdCgpOiB2b2lkIHtcbiAgICAgICAgdGhpcy5pRm9ybUNvbnRyb2wgPSB0aGlzLmZvcm1Db250cm9sIGFzIEZvcm1Db250cm9sO1xuICAgICAgICB0aGlzLmRlc2NyaXB0b3IgPSB0aGlzLnRvWydkZXNjcmlwdG9yJ107XG4gICAgfVxufVxuIiwiPG5nLWNvbnRhaW5lciBbbmdTd2l0Y2hdPVwidG8udHlwZVwiPlxuICAgIDxwLWlucHV0TnVtYmVyICpuZ1N3aXRjaENhc2U9XCInbnVtYmVyJ1wiXG4gICAgICAgICAgICAgICAgICAgW2lkXT1cIiRhbnkoa2V5KVwiXG4gICAgICAgICAgICAgICAgICAgW2Zvcm1Db250cm9sXT1cImlGb3JtQ29udHJvbFwiXG4gICAgICAgICAgICAgICAgICAgW2Zvcm1seUF0dHJpYnV0ZXNdPVwiZmllbGRcIlxuICAgICAgICAgICAgICAgICAgIFttaW5dPVwiJGFueShkZXNjcmlwdG9yLm51bWJlck1pbilcIlxuICAgICAgICAgICAgICAgICAgIFttYXhdPVwiJGFueShkZXNjcmlwdG9yLm51bWJlck1heClcIlxuICAgICAgICAgICAgICAgICAgIFtzdGVwXT1cIiRhbnkoZGVzY3JpcHRvci5udW1iZXJTdGVwKVwiXG4gICAgICAgICAgICAgICAgICAgW21pbkZyYWN0aW9uRGlnaXRzXT1cImRlc2NyaXB0b3IubnVtYmVyTWluRnJhY3Rpb25EaWdpdHMgfHwgMFwiXG4gICAgICAgICAgICAgICAgICAgW21heEZyYWN0aW9uRGlnaXRzXT1cImRlc2NyaXB0b3IubnVtYmVyTWF4RnJhY3Rpb25EaWdpdHMgfHwgMFwiPlxuICAgIDwvcC1pbnB1dE51bWJlcj5cblxuICAgIDxkaXYgKm5nU3dpdGNoQ2FzZT1cIidzd2l0Y2gnXCIgY2xhc3M9XCJmbGV4IGZsZXgtY29sdW1uXCI+XG4gICAgICAgIDxsYWJlbCBbZm9yXT1cImtleVwiPnt7IHRvPy5sYWJlbCEgfCB0cmFuc2xhdGUgfX0gPHNwYW4gKm5nSWY9XCJ0by5yZXF1aXJlZCAmJiB0b1snaGlkZVJlcXVpcmVkTWFya2VyJ10gIT09IHRydWVcIj4qPC9zcGFuPjwvbGFiZWw+XG4gICAgICAgIDxwLWlucHV0U3dpdGNoIFtpZF09XCIkYW55KGtleSlcIlxuICAgICAgICAgICAgICAgICAgICAgICBbZm9ybUNvbnRyb2xdPVwiaUZvcm1Db250cm9sXCJcbiAgICAgICAgICAgICAgICAgICAgICAgW2Zvcm1seUF0dHJpYnV0ZXNdPVwiZmllbGRcIj5cbiAgICAgICAgPC9wLWlucHV0U3dpdGNoPlxuICAgICAgICA8c21hbGwgKm5nSWY9XCJzaG93RXJyb3JcIiBjbGFzcz1cInAtZXJyb3JcIj5cbiAgICAgICAgICAgIDxmb3JtbHktdmFsaWRhdGlvbi1tZXNzYWdlIFtmaWVsZF09XCJmaWVsZFwiPjwvZm9ybWx5LXZhbGlkYXRpb24tbWVzc2FnZT5cbiAgICAgICAgPC9zbWFsbD5cbiAgICA8L2Rpdj5cblxuICAgIDxuZy1jb250YWluZXIgKm5nU3dpdGNoQ2FzZT1cIidyYWRpbydcIj5cbiAgICAgICAgPGRpdiAqbmdGb3I9XCJsZXQgY2F0ZWdvcnkgb2YgZGVzY3JpcHRvci5yYWRpb09wdGlvbnNcIiBbaWRdPVwiJGFueShrZXkpXCIgY2xhc3M9XCJwLWZpZWxkLXJhZGlvYnV0dG9uXCI+XG4gICAgICAgICAgICA8cC1yYWRpb0J1dHRvbiBbdmFsdWVdPVwiY2F0ZWdvcnlcIiBbZm9ybUNvbnRyb2xdPVwiaUZvcm1Db250cm9sXCIgW2Zvcm1seUF0dHJpYnV0ZXNdPVwiZmllbGRcIj48L3AtcmFkaW9CdXR0b24+XG4gICAgICAgICAgICA8bGFiZWwgW2Zvcl09XCJjYXRlZ29yeVwiIGNsYXNzPVwibW5nLXJhZGlvLWJ1dHRvbi1sYWJlbFwiPnt7Y2F0ZWdvcnl9fTwvbGFiZWw+XG4gICAgICAgIDwvZGl2PlxuICAgIDwvbmctY29udGFpbmVyPlxuXG4gICAgPHRleHRhcmVhICpuZ1N3aXRjaENhc2U9XCIndGV4dGFyZWEnXCJcbiAgICAgICAgICAgICAgW2lkXT1cIiRhbnkoa2V5KVwiXG4gICAgICAgICAgICAgIFtmb3JtQ29udHJvbF09XCJpRm9ybUNvbnRyb2xcIlxuICAgICAgICAgICAgICBbZm9ybWx5QXR0cmlidXRlc109XCJmaWVsZFwiXG4gICAgICAgICAgICAgIFtyb3dzXT1cImRlc2NyaXB0b3Iucm93cyA/PyAzXCJcbiAgICAgICAgICAgICAgcElucHV0VGV4dGFyZWE+XG4gICAgPC90ZXh0YXJlYT5cblxuICAgIDxwLWNhbGVuZGFyICpuZ1N3aXRjaENhc2U9XCInZGF0ZXBpY2tlcidcIlxuICAgICAgICAgICAgICAgIFtmb3JtQ29udHJvbF09XCJpRm9ybUNvbnRyb2xcIlxuICAgICAgICAgICAgICAgIFtmb3JtbHlBdHRyaWJ1dGVzXT1cImZpZWxkXCJcbiAgICAgICAgICAgICAgICBbZGF0ZUZvcm1hdF09XCIkYW55KGRlc2NyaXB0b3IuZGF0ZVBpY2tlckZvcm1hdClcIlxuICAgICAgICAgICAgICAgIFttaW5EYXRlXT1cIiRhbnkoZGVzY3JpcHRvci5kYXRlUGlja2VyTWluKVwiXG4gICAgICAgICAgICAgICAgW21heERhdGVdPVwiJGFueShkZXNjcmlwdG9yLmRhdGVQaWNrZXJNYXgpXCJcbiAgICAgICAgICAgICAgICBbc2hvd1RpbWVdPVwiZGVzY3JpcHRvci5kYXRlUGlja2VyU2hvd1RpbWVcIlxuICAgICAgICAgICAgICAgIFtzaG93SWNvbl09XCJ0cnVlXCI+XG4gICAgPC9wLWNhbGVuZGFyPlxuXG4gICAgPGlucHV0ICpuZ1N3aXRjaERlZmF1bHRcbiAgICAgICAgICAgcElucHV0VGV4dFxuICAgICAgICAgICBbaWRdPVwiJGFueShrZXkpXCJcbiAgICAgICAgICAgW3R5cGVdPVwidG8udHlwZSB8fCAndGV4dCdcIlxuICAgICAgICAgICBbZm9ybUNvbnRyb2xdPVwiaUZvcm1Db250cm9sXCJcbiAgICAgICAgICAgW2Zvcm1seUF0dHJpYnV0ZXNdPVwiZmllbGRcIlxuICAgIC8+XG48L25nLWNvbnRhaW5lcj5cbiJdfQ==