shared-ui-test-2 1.0.0

package/esm2022/modules/dynamic-forms/dynamic-form-UI/dynamic-form-ui.module.mjs

@@ -0,0 +1,117 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { RemoveCancelButtonDirective } from '../../../directives/remove-cancel-button.directive';
+import { UiKitModule } from '../../ui-kit/ui-kit.module';
+import { DynamicFormCoreModule } from '../dynamic-forms-core/dynamic-form-core.module';
+import { DynamicFormControlLabelComponent } from './components/controls/dynamic-form-control-label/dynamic-form-control-label.component';
+import { DynamicFormCounterControlComponent } from './components/controls/dynamic-form-counter-control/dynamic-form-counter-control.component';
+import { DynamicFormDatepickerControlComponent } from './components/controls/dynamic-form-datepicker-control/dynamic-form-datepicker-control.component';
+import { DynamicFormFieldControlComponent } from './components/controls/dynamic-form-field-control/dynamic-form-field-control.component';
+import { DynamicFormInputControlComponent } from './components/controls/dynamic-form-input-control/dynamic-form-input-control.component';
+import { DynamicFormRadioGroupComponent } from './components/controls/dynamic-form-radio-group/dynamic-form-radio-group.component';
+import { DynamicFormSelectControlComponent } from './components/controls/dynamic-form-select-control/dynamic-form-select-control.component';
+import { DynamicFormSwitchControlComponent } from './components/controls/dynamic-form-switch-control/dynamic-form-switch-control.component';
+import { DynamicFormUiControlListComponent } from './components/controls/dynamic-form-ui-control/dynamic-form-ui-control-list/dynamic-form-ui-control-list.component';
+import { DynamicFormUIControlComponent } from './components/controls/dynamic-form-ui-control/dynamic-form-ui-control.component';
+import { DynamicFormUIArrayComponent } from './components/dynamic-form-array/dynamic-form-ui-array.component';
+import { DynamicFormGroupComponent } from './components/dynamic-form-group/dynamic-form-group.component';
+import { DynamicFormLayoutItemComponent } from './components/dynamic-form-layout/dynamic-form-layout-item/dynamic-form-layout-item.component';
+import { DynamicFormLayoutUIComponent } from './components/dynamic-form-layout/dynamic-form-layout.component';
+import { BaseFormActionsComponent } from './components/dynamic-form/base-form-actions/base-form-actions.component';
+import { DynamicFormUIComponent } from './components/dynamic-form/dynamic-form-ui.component';
+import { ErrorsBlockComponent } from './components/errors-block/errors-block.component';
+import { DynamicFormButtonControlComponent } from './components/controls/dynamic-form-button-control/dynamic-form-button-control.component';
+import { DynamicFormTextAreaControlComponent } from './components/controls/dynamic-form-text-area-control/dynamic-form-text-area-control.component';
+import { DynamicFormNgSelectControlComponent } from './components/controls/dynamic-form-ng-select-control/dynamic-form-ng-select-control.component';
+import { DynamicFormCheckboxControlComponent } from './components/controls/dynamic-form-checkbox-control/dynamic-form-checkbox-control.component';
+import { UI_FORM_CONTROL_MAP_PROVIDER } from './providers/ui-form-control-map.provider';
+import * as i0 from "@angular/core";
+const shared = [
+    DynamicFormInputControlComponent,
+    DynamicFormFieldControlComponent,
+    DynamicFormControlLabelComponent,
+    DynamicFormUIComponent,
+    DynamicFormSelectControlComponent,
+    DynamicFormNgSelectControlComponent,
+    DynamicFormGroupComponent,
+    DynamicFormRadioGroupComponent,
+    DynamicFormDatepickerControlComponent,
+    BaseFormActionsComponent,
+    DynamicFormUIArrayComponent,
+    DynamicFormUIControlComponent,
+    DynamicFormButtonControlComponent,
+    DynamicFormTextAreaControlComponent,
+    DynamicFormCheckboxControlComponent,
+];
+export class DynamicFormUIModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFormUIModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: DynamicFormUIModule, declarations: [DynamicFormInputControlComponent,
+            DynamicFormFieldControlComponent,
+            DynamicFormControlLabelComponent,
+            DynamicFormUIComponent,
+            DynamicFormSelectControlComponent,
+            DynamicFormNgSelectControlComponent,
+            DynamicFormGroupComponent,
+            DynamicFormRadioGroupComponent,
+            DynamicFormDatepickerControlComponent,
+            BaseFormActionsComponent,
+            DynamicFormUIArrayComponent,
+            DynamicFormUIControlComponent,
+            DynamicFormButtonControlComponent,
+            DynamicFormTextAreaControlComponent,
+            DynamicFormCheckboxControlComponent, DynamicFormLayoutUIComponent,
+            DynamicFormLayoutItemComponent,
+            DynamicFormUiControlListComponent,
+            DynamicFormCounterControlComponent,
+            DynamicFormSwitchControlComponent,
+            ErrorsBlockComponent,
+            RemoveCancelButtonDirective], imports: [UiKitModule, CommonModule, ReactiveFormsModule, DynamicFormCoreModule], exports: [DynamicFormInputControlComponent,
+            DynamicFormFieldControlComponent,
+            DynamicFormControlLabelComponent,
+            DynamicFormUIComponent,
+            DynamicFormSelectControlComponent,
+            DynamicFormNgSelectControlComponent,
+            DynamicFormGroupComponent,
+            DynamicFormRadioGroupComponent,
+            DynamicFormDatepickerControlComponent,
+            BaseFormActionsComponent,
+            DynamicFormUIArrayComponent,
+            DynamicFormUIControlComponent,
+            DynamicFormButtonControlComponent,
+            DynamicFormTextAreaControlComponent,
+            DynamicFormCheckboxControlComponent, ErrorsBlockComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFormUIModule, providers: [UI_FORM_CONTROL_MAP_PROVIDER], imports: [UiKitModule, CommonModule, ReactiveFormsModule, DynamicFormCoreModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFormUIModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        shared,
+                        DynamicFormLayoutUIComponent,
+                        DynamicFormLayoutItemComponent,
+                        DynamicFormUiControlListComponent,
+                        DynamicFormCounterControlComponent,
+                        DynamicFormSwitchControlComponent,
+                        ErrorsBlockComponent,
+                        RemoveCancelButtonDirective,
+                    ],
+                    imports: [UiKitModule, CommonModule, ReactiveFormsModule, DynamicFormCoreModule],
+                    // entryComponents: [
+                    //   DynamicFormInputControlComponent,
+                    //   DynamicFormSelectControlComponent,
+                    //   DynamicFormNgSelectControlComponent,
+                    //   DynamicFormGroupComponent,
+                    //   DynamicFormDatepickerControlComponent,
+                    //   DynamicFormRadioGroupComponent,
+                    //   DynamicFormUIArrayComponent,
+                    //   DynamicFormCounterControlComponent,
+                    //   DynamicFormSwitchControlComponent,
+                    //   DynamicFormButtonControlComponent,
+                    //   DynamicFormTextAreaControlComponent,
+                    // ],
+                    exports: [shared, ErrorsBlockComponent],
+                    providers: [UI_FORM_CONTROL_MAP_PROVIDER],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-form-ui.module.js","sourceRoot":"","sources":["../../../../../lib/src/modules/dynamic-forms/dynamic-form-UI/dynamic-form-ui.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { NgModule } from '@angular/core';\nimport { ReactiveFormsModule } from '@angular/forms';\nimport { RemoveCancelButtonDirective } from '../../../directives/remove-cancel-button.directive';\nimport { UiKitModule } from '../../ui-kit/ui-kit.module';\nimport { DynamicFormCoreModule } from '../dynamic-forms-core/dynamic-form-core.module';\nimport { DynamicFormControlLabelComponent } from './components/controls/dynamic-form-control-label/dynamic-form-control-label.component';\nimport { DynamicFormCounterControlComponent } from './components/controls/dynamic-form-counter-control/dynamic-form-counter-control.component';\nimport { DynamicFormDatepickerControlComponent } from './components/controls/dynamic-form-datepicker-control/dynamic-form-datepicker-control.component';\nimport { DynamicFormFieldControlComponent } from './components/controls/dynamic-form-field-control/dynamic-form-field-control.component';\nimport { DynamicFormInputControlComponent } from './components/controls/dynamic-form-input-control/dynamic-form-input-control.component';\nimport { DynamicFormRadioGroupComponent } from './components/controls/dynamic-form-radio-group/dynamic-form-radio-group.component';\nimport { DynamicFormSelectControlComponent } from './components/controls/dynamic-form-select-control/dynamic-form-select-control.component';\nimport { DynamicFormSwitchControlComponent } from './components/controls/dynamic-form-switch-control/dynamic-form-switch-control.component';\nimport { DynamicFormUiControlListComponent } from './components/controls/dynamic-form-ui-control/dynamic-form-ui-control-list/dynamic-form-ui-control-list.component';\nimport { DynamicFormUIControlComponent } from './components/controls/dynamic-form-ui-control/dynamic-form-ui-control.component';\nimport { DynamicFormUIArrayComponent } from './components/dynamic-form-array/dynamic-form-ui-array.component';\nimport { DynamicFormGroupComponent } from './components/dynamic-form-group/dynamic-form-group.component';\nimport { DynamicFormLayoutItemComponent } from './components/dynamic-form-layout/dynamic-form-layout-item/dynamic-form-layout-item.component';\nimport { DynamicFormLayoutUIComponent } from './components/dynamic-form-layout/dynamic-form-layout.component';\nimport { BaseFormActionsComponent } from './components/dynamic-form/base-form-actions/base-form-actions.component';\nimport { DynamicFormUIComponent } from './components/dynamic-form/dynamic-form-ui.component';\nimport { ErrorsBlockComponent } from './components/errors-block/errors-block.component';\nimport { DynamicFormButtonControlComponent } from './components/controls/dynamic-form-button-control/dynamic-form-button-control.component';\nimport { DynamicFormTextAreaControlComponent } from './components/controls/dynamic-form-text-area-control/dynamic-form-text-area-control.component';\nimport { DynamicFormNgSelectControlComponent } from './components/controls/dynamic-form-ng-select-control/dynamic-form-ng-select-control.component';\nimport { DynamicFormCheckboxControlComponent } from './components/controls/dynamic-form-checkbox-control/dynamic-form-checkbox-control.component';\nimport { UI_FORM_CONTROL_MAP_PROVIDER } from './providers/ui-form-control-map.provider';\n\nconst shared = [\n  DynamicFormInputControlComponent,\n  DynamicFormFieldControlComponent,\n  DynamicFormControlLabelComponent,\n  DynamicFormUIComponent,\n  DynamicFormSelectControlComponent,\n  DynamicFormNgSelectControlComponent,\n  DynamicFormGroupComponent,\n  DynamicFormRadioGroupComponent,\n  DynamicFormDatepickerControlComponent,\n  BaseFormActionsComponent,\n  DynamicFormUIArrayComponent,\n  DynamicFormUIControlComponent,\n  DynamicFormButtonControlComponent,\n  DynamicFormTextAreaControlComponent,\n  DynamicFormCheckboxControlComponent,\n];\n\n@NgModule({\n  declarations: [\n    shared,\n    DynamicFormLayoutUIComponent,\n    DynamicFormLayoutItemComponent,\n    DynamicFormUiControlListComponent,\n    DynamicFormCounterControlComponent,\n    DynamicFormSwitchControlComponent,\n    ErrorsBlockComponent,\n    RemoveCancelButtonDirective,\n  ],\n  imports: [UiKitModule, CommonModule, ReactiveFormsModule, DynamicFormCoreModule],\n  // entryComponents: [\n  //   DynamicFormInputControlComponent,\n  //   DynamicFormSelectControlComponent,\n  //   DynamicFormNgSelectControlComponent,\n  //   DynamicFormGroupComponent,\n  //   DynamicFormDatepickerControlComponent,\n  //   DynamicFormRadioGroupComponent,\n  //   DynamicFormUIArrayComponent,\n  //   DynamicFormCounterControlComponent,\n  //   DynamicFormSwitchControlComponent,\n  //   DynamicFormButtonControlComponent,\n  //   DynamicFormTextAreaControlComponent,\n  // ],\n  exports: [shared, ErrorsBlockComponent],\n  providers: [UI_FORM_CONTROL_MAP_PROVIDER],\n})\nexport class DynamicFormUIModule {}\n"]}

package/esm2022/modules/dynamic-forms/dynamic-form-UI/index.mjs

@@ -0,0 +1,6 @@
+// Components
+export * from './components/dynamic-form/base-form-actions/base-form-actions.component';
+// Enums
+export * from './components/controls/dynamic-form-radio-group/enum/radio-group-orientation.enum';
+export * from './components/dynamic-form/base-form-actions/enums/base-form-action-types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWIvc3JjL21vZHVsZXMvZHluYW1pYy1mb3Jtcy9keW5hbWljLWZvcm0tVUkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsYUFBYTtBQUNiLGNBQWMseUVBQXlFLENBQUM7QUFFeEYsUUFBUTtBQUNSLGNBQWMsa0ZBQWtGLENBQUM7QUFDakcsY0FBYywwRUFBMEUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvbXBvbmVudHNcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9keW5hbWljLWZvcm0vYmFzZS1mb3JtLWFjdGlvbnMvYmFzZS1mb3JtLWFjdGlvbnMuY29tcG9uZW50JztcblxuLy8gRW51bXNcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9jb250cm9scy9keW5hbWljLWZvcm0tcmFkaW8tZ3JvdXAvZW51bS9yYWRpby1ncm91cC1vcmllbnRhdGlvbi5lbnVtJztcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9keW5hbWljLWZvcm0vYmFzZS1mb3JtLWFjdGlvbnMvZW51bXMvYmFzZS1mb3JtLWFjdGlvbi10eXBlcyc7XG4iXX0=

package/esm2022/modules/dynamic-forms/dynamic-form-UI/providers/ui-form-control-map.provider.mjs

@@ -0,0 +1,47 @@
+import { DYNAMIC_FORM_CONTROL_MAP_FN } from '../../dynamic-forms-core/tokens/form-control-map.token';
+import { ControlTypes } from '../../dynamic-forms-core/enums/control-types.enum';
+import { DynamicFormUIArrayComponent } from '../components/dynamic-form-array/dynamic-form-ui-array.component';
+import { DynamicFormCheckboxControlComponent, DynamicFormDatepickerControlComponent, DynamicFormGroupComponent, DynamicFormInputControlComponent, DynamicFormRadioGroupComponent, DynamicFormSelectControlComponent, DynamicFormTextAreaControlComponent, DynamicFormButtonControlComponent, DynamicFormNgSelectControlComponent, } from 'idp-apps-shared-ui/public-api';
+import { DynamicFormCounterControlComponent } from '../components/controls/dynamic-form-counter-control/dynamic-form-counter-control.component';
+import { DynamicFormSwitchControlComponent } from '../components/controls/dynamic-form-switch-control/dynamic-form-switch-control.component';
+export function uiFormControlMapFn(model) {
+    switch (model.type) {
+        case ControlTypes.DYNAMIC_FORM_CONTROL_TYPE_ARRAY:
+            return DynamicFormUIArrayComponent;
+        case ControlTypes.DYNAMIC_FORM_CONTROL_TYPE_CHECKBOX:
+            return DynamicFormCheckboxControlComponent;
+        case ControlTypes.DYNAMIC_FORM_CONTROL_TYPE_CHECKBOX_GROUP:
+            return null;
+        case ControlTypes.DYNAMIC_FORM_CONTROL_TYPE_DATEPICKER:
+            return DynamicFormDatepickerControlComponent;
+        case ControlTypes.DYNAMIC_FORM_CONTROL_TYPE_GROUP:
+            return DynamicFormGroupComponent;
+        case ControlTypes.DYNAMIC_FORM_CONTROL_TYPE_INPUT:
+            return DynamicFormInputControlComponent;
+        case ControlTypes.DYNAMIC_FORM_CONTROL_TYPE_RADIO_GROUP:
+            return DynamicFormRadioGroupComponent;
+        case ControlTypes.DYNAMIC_FORM_CONTROL_TYPE_RATING:
+            return null;
+        case ControlTypes.DYNAMIC_FORM_CONTROL_TYPE_SELECT:
+            return DynamicFormSelectControlComponent;
+        case ControlTypes.DYNAMIC_FORM_CONTROL_TYPE_TEXTAREA:
+            return DynamicFormTextAreaControlComponent;
+        case ControlTypes.DYNAMIC_FORM_CONTROL_TYPE_TIMEPICKER:
+            return null;
+        case ControlTypes.DYNAMIC_FORM_CONTROL_TYPE_COUNTER:
+            return DynamicFormCounterControlComponent;
+        case ControlTypes.DYNAMIC_FORM_CONTROL_TYPE_SWITCH:
+            return DynamicFormSwitchControlComponent;
+        case ControlTypes.DYNAMIC_FORM_CONTROL_TYPE_BUTTON:
+            return DynamicFormButtonControlComponent;
+        case ControlTypes.DYNAMIC_FORM_CONTROL_TYPE_NG_SELECT:
+            return DynamicFormNgSelectControlComponent;
+        default:
+            return null;
+    }
+}
+export const UI_FORM_CONTROL_MAP_PROVIDER = {
+    provide: DYNAMIC_FORM_CONTROL_MAP_FN,
+    useValue: uiFormControlMapFn,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/modules/dynamic-forms/dynamic-forms-core/components/dynamic-form-array.component.mjs

@@ -0,0 +1,16 @@
+import { Directive, Input } from '@angular/core';
+import { DynamicFormControlComponent } from './dynamic-form-control.component';
+import * as i0 from "@angular/core";
+export class DynamicFormArrayComponent extends DynamicFormControlComponent {
+    get array() {
+        return this.control;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFormArrayComponent, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: DynamicFormArrayComponent, inputs: { model: "model" }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFormArrayComponent, decorators: [{
+            type: Directive
+        }], propDecorators: { model: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHluYW1pYy1mb3JtLWFycmF5LmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9zcmMvbW9kdWxlcy9keW5hbWljLWZvcm1zL2R5bmFtaWMtZm9ybXMtY29yZS9jb21wb25lbnRzL2R5bmFtaWMtZm9ybS1hcnJheS5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHakQsT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sa0NBQWtDLENBQUM7O0FBRy9FLE1BQU0sT0FBTyx5QkFBMEIsU0FBUSwyQkFBMkI7SUFJeEUsSUFBSSxLQUFLO1FBQ1AsT0FBYSxJQUFJLENBQUMsT0FBTyxDQUFDO0lBQzVCLENBQUM7K0dBTlUseUJBQXlCO21HQUF6Qix5QkFBeUI7OzRGQUF6Qix5QkFBeUI7a0JBRHJDLFNBQVM7OEJBR2lCLEtBQUs7c0JBQTdCLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIElucHV0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBGb3JtQXJyYXkgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5pbXBvcnQgeyBEeW5hbWljRm9ybUFycmF5TW9kZWwgfSBmcm9tICcuLi9tb2RlbHMvZm9ybS1hcnJheS9keW5hbWljLWZvcm0tYXJyYXkubW9kZWwnO1xuaW1wb3J0IHsgRHluYW1pY0Zvcm1Db250cm9sQ29tcG9uZW50IH0gZnJvbSAnLi9keW5hbWljLWZvcm0tY29udHJvbC5jb21wb25lbnQnO1xuXG5ARGlyZWN0aXZlKClcbmV4cG9ydCBjbGFzcyBEeW5hbWljRm9ybUFycmF5Q29tcG9uZW50IGV4dGVuZHMgRHluYW1pY0Zvcm1Db250cm9sQ29tcG9uZW50IHtcblxuICBASW5wdXQoKSBwdWJsaWMgb3ZlcnJpZGUgbW9kZWw6IER5bmFtaWNGb3JtQXJyYXlNb2RlbDtcblxuICBnZXQgYXJyYXkoKTogRm9ybUFycmF5IHtcbiAgICByZXR1cm4gPGFueT4gdGhpcy5jb250cm9sO1xuICB9XG59XG4iXX0=

package/esm2022/modules/dynamic-forms/dynamic-forms-core/components/dynamic-form-component.mjs

@@ -0,0 +1,82 @@
+import { EventEmitter, Input, Output, Directive } from '@angular/core';
+import { FormControlEvents } from '../enums/form-control-events.enum';
+import { StaticControlModel } from './../models/form-static-control/static-control.model';
+import * as i0 from "@angular/core";
+export class DynamicFormComponent {
+    constructor(changeDetectorRef) {
+        this.changeDetectorRef = changeDetectorRef;
+        this.formLayoutMap = new Map();
+        this.blur = new EventEmitter();
+        this.change = new EventEmitter();
+        this.focus = new EventEmitter();
+        this.customEvent = new EventEmitter();
+        this.DEFAULT_LAYOUT_KEY = 'default';
+    }
+    trackByFn(_index, model) {
+        return model.id;
+    }
+    onEvent($event, type) {
+        switch (type) {
+            case FormControlEvents.Blur: {
+                this.blur.emit($event);
+                break;
+            }
+            case FormControlEvents.Change: {
+                this.change.emit($event);
+                break;
+            }
+            case FormControlEvents.Focus: {
+                this.focus.emit($event);
+                break;
+            }
+            case FormControlEvents.Custom: {
+                this.customEvent.emit($event);
+                break;
+            }
+            default: {
+                return;
+            }
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes['formModel']) {
+            this.formLayoutMap = this.formModel.reduce((map, control) => {
+                if (control instanceof StaticControlModel) {
+                    return map;
+                }
+                const key = control.layout && control.layout.id || this.DEFAULT_LAYOUT_KEY;
+                const cache = map.get(key);
+                if (cache && Array.isArray(cache)) {
+                    cache.push(control);
+                }
+                else {
+                    map.set(key, [control]);
+                }
+                return map;
+            }, new Map());
+        }
+    }
+    get defaultControls() {
+        return this.formLayoutMap.get(this.DEFAULT_LAYOUT_KEY);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFormComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: DynamicFormComponent, inputs: { formGroupValue: "formGroupValue", formModel: "formModel", formLayout: "formLayout" }, outputs: { blur: "blur", change: "change", focus: "focus", customEvent: "customEvent" }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFormComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { formGroupValue: [{
+                type: Input
+            }], formModel: [{
+                type: Input
+            }], formLayout: [{
+                type: Input
+            }], blur: [{
+                type: Output
+            }], change: [{
+                type: Output
+            }], focus: [{
+                type: Output
+            }], customEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/modules/dynamic-forms/dynamic-forms-core/components/dynamic-form-control-container.component.mjs

@@ -0,0 +1,189 @@
+import { EventEmitter, Input, Output, ChangeDetectorRef, Directive, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { ControlTypes } from '../enums/control-types.enum';
+import { isString, isFunction } from '../../../../core/utils/type-checks.utils';
+import { FormControlEvents } from '../enums/form-control-events.enum';
+// noinspection TypeScriptPreferShortImport
+import { FormValueControlModel } from '../models/form-value-control/form-value-control.model';
+import * as i0 from "@angular/core";
+export class DynamicFormControlContainerComponent {
+    get componentType() {
+        throw new Error('Component type was not provided');
+    }
+    get hasHint() {
+        return isString(this.model.hint);
+    }
+    get hint() {
+        return this.model.hint || null;
+    }
+    get hasLabel() {
+        return isString(this.model.label);
+    }
+    get isCheckbox() {
+        return this.model.type === ControlTypes.DYNAMIC_FORM_CONTROL_TYPE_CHECKBOX;
+    }
+    get isInvalid() {
+        return this.control.invalid;
+    }
+    get isValid() {
+        return this.control.valid;
+    }
+    constructor(componentFactoryResolver, injector, applicationRef, elRef) {
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.injector = injector;
+        this.applicationRef = applicationRef;
+        this.elRef = elRef;
+        this.blur = new EventEmitter();
+        this.change = new EventEmitter();
+        this.focus = new EventEmitter();
+        this.customEvent = new EventEmitter();
+        this.context = null;
+        this.controlContainer = this.elRef;
+        this.clearControlSubs$ = new Subject();
+    }
+    ngOnInit() {
+        if (this.model) {
+            this.createFormControlComponent();
+            this.setSubscriptions();
+        }
+    }
+    onBlur($event) {
+        this.hasFocus = false;
+        this.blur.emit(this.createDynamicFormControlEvent($event, FormControlEvents.Blur));
+    }
+    onFocus($event) {
+        this.hasFocus = true;
+        this.focus.emit(this.createDynamicFormControlEvent($event, FormControlEvents.Focus));
+    }
+    onChange($event) {
+        this.change.emit(this.createDynamicFormControlEvent($event, FormControlEvents.Change));
+    }
+    onCustomEvent($event) {
+        this.customEvent.emit(this.createDynamicFormControlEvent($event.customEvent, $event.customEventType));
+    }
+    ngOnDestroy() {
+        if (this.componentRef && this.componentRef.instance) {
+            this.destroyFormControlComponent();
+            return;
+        }
+        this.unsubscribe();
+    }
+    createFormControlComponent() {
+        const componentType = this.componentType;
+        if (!this.controlContainer) {
+            throw new Error('You need to provide controls container element');
+        }
+        if (!componentType) {
+            throw new Error('Please provide componentType to create');
+        }
+        this.componentRef = this.componentFactoryResolver
+            .resolveComponentFactory(componentType)
+            .create(this.injector);
+        const instance = this.componentRef.instance;
+        const inputs = {
+            group: this.group,
+            layout: this.layout,
+            model: this.model,
+            ...this.model.additional,
+        };
+        this.setInputs(instance, inputs);
+        this.applicationRef.attachView(this.componentRef.hostView);
+        this.controlContainer.nativeElement.appendChild(this.componentRef.hostView.rootNodes[0]);
+        this.componentRef.injector.get(ChangeDetectorRef).detectChanges();
+    }
+    setSubscriptions() {
+        this.subscribeOnEvents(this.componentRef.instance);
+        if (this.group) {
+            this.control = this.group.get(this.model.id);
+            this.subscribeOnValueChange();
+        }
+        this.model.disabledUpdates$.pipe(takeUntil(this.clearControlSubs$)).subscribe(value => this.onModelDisabledUpdates(value));
+        if (this.model instanceof FormValueControlModel) {
+            const model = this.model;
+            model.valueUpdates.pipe(takeUntil(this.clearControlSubs$)).subscribe(value => this.onModelValueUpdates(value));
+        }
+        if (this.model.groupModel && this.model.relations.length > 0) {
+            this.setRelationSubscriptions();
+        }
+    }
+    setRelationSubscriptions() {
+        this.model.relations.forEach(relation => {
+            const relatedControl = this.group.controls[relation.controlId];
+            const relatedControlModel = this.model.groupModel
+                .find(control => control.id === relation.controlId);
+            if (!relatedControl || !relatedControlModel || !isFunction(relation.onValueChanged)) {
+                return;
+            }
+            relatedControl
+                .valueChanges
+                .pipe(takeUntil(this.clearControlSubs$))
+                .subscribe(() => relation.onValueChanged(relatedControlModel, relatedControl, this.model, this.group.controls[this.model.id]));
+        });
+    }
+    subscribeOnEvents(instance) {
+        instance.blur.pipe(takeUntil(this.clearControlSubs$)).subscribe(($event) => this.onBlur($event));
+        instance.change.pipe(takeUntil(this.clearControlSubs$)).subscribe(($event) => this.onChange($event));
+        instance.focus.pipe(takeUntil(this.clearControlSubs$)).subscribe(($event) => this.onFocus($event));
+        if (instance.customEvent !== undefined) {
+            instance.customEvent.pipe(takeUntil(this.clearControlSubs$)).subscribe(($event) => this.onCustomEvent($event));
+        }
+    }
+    subscribeOnValueChange() {
+        this.control.valueChanges.pipe(takeUntil(this.clearControlSubs$)).subscribe(value => this.onControlValueChanges(value));
+    }
+    setInputs(instance, inputs) {
+        Object
+            .keys(inputs)
+            .forEach(key => instance[key] = inputs[key]);
+    }
+    destroyFormControlComponent() {
+        if (this.componentRef) {
+            this.unsubscribe();
+            this.applicationRef.detachView(this.componentRef.hostView);
+            this.componentRef.destroy();
+        }
+    }
+    createDynamicFormControlEvent($event, type) {
+        return { $event, context: this.context, control: this.control, group: this.group, model: this.model, type };
+    }
+    unsubscribe() {
+        this.clearControlSubs$.next(null);
+    }
+    onControlValueChanges(value) {
+        if (this.model instanceof FormValueControlModel) {
+            const model = this.model;
+            if (model.value !== value) {
+                model.valueUpdates.next(value);
+            }
+        }
+    }
+    onModelValueUpdates(value) {
+        if (this.control.value !== value) {
+            this.control.setValue(value);
+        }
+    }
+    onModelDisabledUpdates(value) {
+        value ? this.control.disable() : this.control.enable();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFormControlContainerComponent, deps: [{ token: i0.ComponentFactoryResolver }, { token: i0.Injector }, { token: i0.ApplicationRef }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: DynamicFormControlContainerComponent, inputs: { group: "group", layout: "layout", model: "model" }, outputs: { blur: "blur", change: "change", focus: "focus", customEvent: "customEvent" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFormControlContainerComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i0.ComponentFactoryResolver }, { type: i0.Injector }, { type: i0.ApplicationRef }, { type: i0.ElementRef }], propDecorators: { group: [{
+                type: Input
+            }], layout: [{
+                type: Input
+            }], model: [{
+                type: Input
+            }], blur: [{
+                type: Output
+            }], change: [{
+                type: Output
+            }], focus: [{
+                type: Output
+            }], customEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-form-control-container.component.js","sourceRoot":"","sources":["../../../../../../lib/src/modules/dynamic-forms/dynamic-forms-core/components/dynamic-form-control-container.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ComponentFactoryResolver,\n  ComponentRef,\n  EventEmitter,\n  OnDestroy,\n  OnInit,\n  Type,\n  Input,\n  Output,\n  Injector,\n  Injectable,\n  ApplicationRef,\n  EmbeddedViewRef,\n  ElementRef,\n  ChangeDetectorRef,\n  Directive,\n} from '@angular/core';\nimport { FormControl, FormGroup, AbstractControl } from '@angular/forms';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { ControlTypes } from '../enums/control-types.enum';\nimport { isString, isFunction } from '../../../../core/utils/type-checks.utils';\nimport { FormControlEvents } from '../enums/form-control-events.enum';\nimport {\n  IDynamicFormControlCustomEvent,\n  IDynamicFormControlEvent,\n} from '../interfaces/components/form-control/dynamic-form-control-event.interface';\nimport { IDynamicFormLayout } from '../interfaces/layout/form-layout.interface';\n// noinspection TypeScriptPreferShortImport\nimport { DynamicFormArrayGroupModel } from '../models/form-array/form-array-group/dynamic-form-array-group.model';\nimport { DynamicFormControlModel } from '../models/form-control/dynamic-form-control.model';\n// noinspection TypeScriptPreferShortImport\nimport { FormValueControlModel } from '../models/form-value-control/form-value-control.model';\nimport { DynamicFormControlComponent } from './dynamic-form-control.component';\n\n@Directive()\nexport class DynamicFormControlContainerComponent implements OnInit, OnDestroy {\n\n  @Input() public group: FormGroup;\n  @Input() public layout: IDynamicFormLayout;\n  @Input() public model: DynamicFormControlModel;\n\n  @Output() public blur: EventEmitter<IDynamicFormControlEvent> = new EventEmitter();\n  @Output() public change: EventEmitter<IDynamicFormControlEvent> = new EventEmitter();\n  @Output() public focus: EventEmitter<IDynamicFormControlEvent> = new EventEmitter();\n  @Output() public customEvent?: EventEmitter<IDynamicFormControlEvent> = new EventEmitter();\n\n  public context: DynamicFormArrayGroupModel | null = null;\n  public control: FormControl;\n  public hasFocus: boolean;\n\n  public controlContainer: ElementRef<HTMLElement> = this.elRef;\n\n  protected componentRef: ComponentRef<DynamicFormControlComponent>;\n  protected clearControlSubs$ = new Subject();\n\n  public get componentType(): Type<DynamicFormControlComponent> | null {\n    throw new Error('Component type was not provided');\n  }\n\n  get hasHint(): boolean {\n    return isString((<FormValueControlModel<any>>this.model).hint);\n  }\n\n  get hint(): string | null {\n    return (<FormValueControlModel<any>>this.model).hint || null;\n  }\n\n  get hasLabel(): boolean {\n    return isString(this.model.label);\n  }\n\n  get isCheckbox(): boolean {\n    return this.model.type === ControlTypes.DYNAMIC_FORM_CONTROL_TYPE_CHECKBOX;\n  }\n\n  get isInvalid(): boolean {\n    return this.control.invalid;\n  }\n\n  get isValid(): boolean {\n    return this.control.valid;\n  }\n\n  constructor(\n    protected componentFactoryResolver: ComponentFactoryResolver,\n    protected injector: Injector,\n    protected applicationRef: ApplicationRef,\n    private elRef: ElementRef,\n  ) {\n  }\n\n  public ngOnInit(): void {\n    if (this.model) {\n      this.createFormControlComponent();\n      this.setSubscriptions();\n    }\n  }\n\n  public onBlur($event: FocusEvent | IDynamicFormControlEvent | any): void {\n    this.hasFocus = false;\n    this.blur.emit(this.createDynamicFormControlEvent($event, FormControlEvents.Blur));\n  }\n\n  public onFocus($event: FocusEvent | FormControlEvents | any): void {\n    this.hasFocus = true;\n    this.focus.emit(this.createDynamicFormControlEvent($event, FormControlEvents.Focus));\n  }\n\n  public onChange($event: Event | IDynamicFormControlEvent | any): void {\n    this.change.emit(this.createDynamicFormControlEvent($event, FormControlEvents.Change));\n  }\n\n  public onCustomEvent($event: IDynamicFormControlCustomEvent): void {\n    this.customEvent.emit(this.createDynamicFormControlEvent($event.customEvent, $event.customEventType));\n  }\n\n  public ngOnDestroy(): void {\n    if (this.componentRef && this.componentRef.instance) {\n      this.destroyFormControlComponent();\n      return;\n    }\n    this.unsubscribe();\n  }\n\n  public createFormControlComponent(): void {\n\n    const componentType = this.componentType;\n\n    if (!this.controlContainer) {\n      throw new Error('You need to provide controls container element');\n    }\n\n    if (!componentType) {\n      throw new Error('Please provide componentType to create');\n    }\n\n    this.componentRef = this.componentFactoryResolver\n      .resolveComponentFactory(componentType)\n      .create(this.injector);\n\n    const instance = this.componentRef.instance;\n\n    const inputs = {\n      group: this.group,\n      layout: this.layout,\n      model: this.model,\n      ...(<FormValueControlModel<{}>>this.model).additional,\n    };\n\n    this.setInputs(instance, inputs);\n\n    this.applicationRef.attachView(this.componentRef.hostView);\n    this.controlContainer.nativeElement.appendChild((<EmbeddedViewRef<any>>this.componentRef.hostView).rootNodes[0]);\n    this.componentRef.injector.get(ChangeDetectorRef).detectChanges();\n  }\n\n  public setSubscriptions(): void {\n    this.subscribeOnEvents(this.componentRef.instance);\n\n    if (this.group) {\n      this.control = <FormControl>this.group.get(this.model.id);\n\n      this.subscribeOnValueChange();\n    }\n\n    this.model.disabledUpdates$.pipe(\n      takeUntil(this.clearControlSubs$),\n    ).subscribe(value => this.onModelDisabledUpdates(value));\n\n    if (this.model instanceof FormValueControlModel) {\n      const model = <FormValueControlModel<any>>this.model;\n\n      model.valueUpdates.pipe(\n        takeUntil(this.clearControlSubs$),\n      ).subscribe(value => this.onModelValueUpdates(value));\n    }\n\n    if (this.model.groupModel && this.model.relations.length > 0) {\n      this.setRelationSubscriptions();\n    }\n  }\n\n  public setRelationSubscriptions(): void {\n    this.model.relations.forEach(relation => {\n      const relatedControl: AbstractControl = this.group.controls[relation.controlId];\n      const relatedControlModel: DynamicFormControlModel = this.model.groupModel\n        .find(control => control.id === relation.controlId);\n\n      if (!relatedControl || !relatedControlModel || !isFunction(relation.onValueChanged)) {\n        return;\n      }\n\n      relatedControl\n        .valueChanges\n        .pipe(takeUntil(this.clearControlSubs$))\n        .subscribe(() => relation.onValueChanged(\n          relatedControlModel,\n          relatedControl,\n          this.model,\n          this.group.controls[this.model.id],\n          ),\n        );\n\n    });\n  }\n\n  public subscribeOnEvents(instance: DynamicFormControlComponent): void {\n    instance.blur.pipe(takeUntil(this.clearControlSubs$)).subscribe(($event: any) => this.onBlur($event));\n    instance.change.pipe(takeUntil(this.clearControlSubs$)).subscribe(($event: any) => this.onChange($event));\n    instance.focus.pipe(takeUntil(this.clearControlSubs$)).subscribe(($event: any) => this.onFocus($event));\n\n    if (instance.customEvent !== undefined) {\n      instance.customEvent.pipe(takeUntil(this.clearControlSubs$)).subscribe(($event: any) => this.onCustomEvent($event));\n    }\n  }\n\n  public subscribeOnValueChange(): void {\n    this.control.valueChanges.pipe(\n      takeUntil(this.clearControlSubs$),\n    ).subscribe(value => this.onControlValueChanges(value));\n  }\n\n  protected setInputs(instance, inputs): void {\n    Object\n      .keys(inputs)\n      .forEach(key => instance[key] = inputs[key]);\n  }\n\n  protected destroyFormControlComponent(): void {\n    if (this.componentRef) {\n      this.unsubscribe();\n      this.applicationRef.detachView(this.componentRef.hostView);\n      this.componentRef.destroy();\n    }\n  }\n\n  protected createDynamicFormControlEvent($event: any, type: string): IDynamicFormControlEvent {\n    return { $event, context: this.context, control: this.control, group: this.group, model: this.model, type };\n  }\n\n  protected unsubscribe(): void {\n    this.clearControlSubs$.next(null);\n  }\n\n  protected onControlValueChanges(value: any): void {\n\n    if (this.model instanceof FormValueControlModel) {\n\n      const model = <FormValueControlModel<any>>this.model;\n\n      if (model.value !== value) {\n        model.valueUpdates.next(value);\n      }\n    }\n  }\n\n  protected onModelValueUpdates(value: any): void {\n\n    if (this.control.value !== value) {\n      this.control.setValue(value);\n    }\n  }\n\n  protected onModelDisabledUpdates(value: boolean): void {\n    value ? this.control.disable() : this.control.enable();\n  }\n\n}\n"]}