@messaia/cdk 13.3.5-rc28 → 13.3.5-rc29

package/esm2020/lib/chips/components/chips.component.mjs

@@ -250,8 +250,10 @@ export class VdChipsComponent extends AbstractMatFormField {
             if (this.projection) {
                 _params.projection = this.projection;
             }
+            /* Get endpoint */
+            let endpoint = typeof this.endpoint === 'function' ? this.endpoint(this) : this.endpoint;
             /* Get base url */
-            var urlParts = this.endpoint.split('?');
+            var urlParts = endpoint.split('?');
             this.http.get(`${urlParts[0]}/${value}${urlParts.length > 1 ? `?${urlParts[1]}` : ''}`, { params: Utils.cleanObject(_params) }).subscribe(x => {
                 this.loading = false;
                 /* Add chip for selected option */
@@ -456,4 +458,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImpor
             }], default: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chips.component.js","sourceRoot":"","sources":["../../../../../../projects/cdk/src/lib/chips/components/chips.component.ts","../../../../../../projects/cdk/src/lib/chips/components/chips.component.html"],"names":[],"mappings":"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","sourcesContent":["import { FocusMonitor } from '@angular/cdk/a11y';\r\nimport { CdkPortal } from '@angular/cdk/portal';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { Component, ContentChild, Directive, ElementRef, EventEmitter, Injector, Input, Optional, Output, Self, TemplateRef, ViewChild, ViewContainerRef } from '@angular/core';\r\nimport { FormControl, FormGroupDirective, NgControl, NgForm } from '@angular/forms';\r\nimport { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';\r\nimport { ErrorStateMatcher } from '@angular/material/core';\r\nimport { MatFormFieldControl } from '@angular/material/form-field';\r\nimport { MatInput } from '@angular/material/input';\r\nimport { BehaviorSubject } from 'rxjs';\r\nimport { debounceTime, skip } from 'rxjs/operators';\r\nimport { SuffixButton } from '../../common/common.module';\r\nimport { Utils } from '../../common/functions/utils';\r\nimport { AbstractMatFormField } from '../../forms/helpers/abstract-mat-form-field';\r\n\r\n/**\r\n * VdChipDirective class\r\n */\r\n@Directive({ selector: '[vd-chip]ng-template' })\r\nexport class VdChipDirective extends CdkPortal {\r\n\tconstructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef) {\r\n\t\tsuper(templateRef, viewContainerRef);\r\n\t}\r\n}\r\n\r\n/**\r\n * VdAutocompleteOptionDirective class\r\n */\r\n@Directive({ selector: '[vd-autocomplete-option]ng-template' })\r\nexport class VdAutocompleteOptionDirective extends CdkPortal {\r\n\tconstructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef) {\r\n\t\tsuper(templateRef, viewContainerRef);\r\n\t}\r\n}\r\n\r\n/**\r\n * VdChipsComponent class\r\n */\r\n@Component({\r\n\tselector: 'vd-chips',\r\n\ttemplateUrl: './chips.component.html',\r\n\tstyleUrls: ['./chips.component.scss'],\r\n\tproviders: [\r\n\t\t{ provide: MatFormFieldControl, useExisting: VdChipsComponent }\r\n\t]\r\n})\r\nexport class VdChipsComponent extends AbstractMatFormField<any> {\r\n\r\n\t/**\r\n\t * The http service from to get the data\r\n\t */\r\n\tprotected http: HttpClient = null;\r\n\r\n\t/** \r\n\t * The select element.\r\n\t */\r\n\t@ViewChild(MatInput, { static: true })\r\n\tpublic chipInput: MatInput;\r\n\r\n\t/**\r\n\t * Represents a value that changes over time. \r\n\t * Observers can subscribe to the subject to receive pdf file changes\r\n\t */\r\n\tprivate _endpointChange = new BehaviorSubject(null);\r\n\r\n\t/**\r\n\t * Set up reactive formcontrol\r\n\t */\r\n\tpublic autoCompleteChipList: FormControl = new FormControl();\r\n\r\n\t/**\r\n\t * The list of filtered options\r\n\t */\r\n\tpublic filteredOptions: any[];\r\n\r\n\t/**\r\n\t * searchOperators: string[]\r\n\t */\r\n\tpublic searchOperators: string[] = [\"!=\", \"!\", \"<>\", \">=\", \">\", \"<=\", \"<\", \"^\", \"$\", \"~\"];\r\n\r\n\t/**\r\n\t * The list of chips\r\n\t */\r\n\t@Input()\r\n\tpublic chips = [];\r\n\r\n\t/**\r\n\t * VdChip template\r\n\t */\r\n\t@ContentChild(VdChipDirective)\r\n\tpublic chipTemplate: VdChipDirective;\r\n\r\n\t/**\r\n\t * AutocompleteOption template\r\n\t */\r\n\t@ContentChild(VdAutocompleteOptionDirective)\r\n\tpublic autocompleteOptionTemplate: VdAutocompleteOptionDirective;\r\n\r\n\t/**\r\n\t * _endpoint: string\r\n\t */\r\n\tpublic _endpoint: string;\r\n\r\n\t/**\r\n\t * Gets or sets endpoint\r\n\t */\r\n\t@Input()\r\n\tget endpoint(): any { return this._endpoint; }\r\n\tset endpoint(endpoint: any) {\r\n\t\tthis._endpoint = endpoint;\r\n\t\tthis.clear();\r\n\t\tthis._endpointChange.next([this.endpoint, this.path, this.params, this.projection]);\r\n\t}\r\n\r\n\t/**\r\n\t * _params: any\r\n\t */\r\n\tpublic _params: any;\r\n\r\n\t/**\r\n\t * params: any\r\n\t */\r\n\t@Input()\r\n\tget params() { return this._params; }\r\n\tset params(params: any) {\r\n\t\t/* Remove empty params */\r\n\t\tObject.keys(params).forEach((key) => {\r\n\t\t\tif ((params[key] == null || params[key] == '' || params[key] == 'undefined')) {\r\n\t\t\t\tdelete params[key];\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\tif (JSON.stringify(this._params) !== JSON.stringify(params)) {\r\n\t\t\tthis._params = params;\r\n\t\t\tthis._endpointChange.next([this.endpoint, this.path, this._params, this.projection]);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * _projection: any\r\n\t */\r\n\tpublic _projection: string;\r\n\r\n\t/**\r\n\t * projection: any\r\n\t */\r\n\t@Input()\r\n\tget projection() { return this._projection; }\r\n\tset projection(projection: string) {\r\n\t\tthis._projection = projection;\r\n\t\tthis.clear();\r\n\t\tthis._endpointChange.next([this.endpoint, this.path, this.params, this.projection]);\r\n\t}\r\n\r\n\t/**\r\n\t * _path: any\r\n\t */\r\n\tpublic _path: any = '';\r\n\r\n\t/**\r\n\t * Gets or sets path\r\n\t */\r\n\t@Input()\r\n\tget path() { return this._path; }\r\n\tset path(path) {\r\n\t\tthis._path = path;\r\n\t\tthis.clear();\r\n\t\tthis._endpointChange.next([this.endpoint, this.path, this.params, this.projection]);\r\n\t}\r\n\r\n\t/**\r\n\t * Sets the disabled.\r\n\t * @param disabled\r\n\t */\r\n\tpublic get disabled() {\r\n\t\tif (this._readonly) {\r\n\t\t\treturn true;\r\n\t\t}\r\n\r\n\t\treturn super.disabled;\r\n\t}\r\n\r\n\t/**\r\n\t * context: any\r\n\t * The current context\r\n\t */\r\n\t@Input()\r\n\tpublic context: any;\r\n\r\n\t/**\r\n\t * key: string\r\n\t */\r\n\t@Input()\r\n\tpublic key: string = 'id';\r\n\r\n\t/**\r\n\t * searchField: string\r\n\t */\r\n\t@Input()\r\n\tpublic searchField: string = 'search';\r\n\r\n\t/**\r\n\t * searchFields: string\r\n\t */\r\n\t@Input()\r\n\tpublic searchFields: string[] = [];\r\n\r\n\t/**\r\n\t * termMinlength: number\r\n\t */\r\n\t@Input()\r\n\tpublic termMinlength: number = 2;\r\n\r\n\t/**\r\n\t * limit: number\r\n\t */\r\n\t@Input()\r\n\tpublic limit: number = 30;\r\n\r\n\t/**\r\n\t * removable: boolean\r\n\t */\r\n\t@Input()\r\n\tpublic removable: boolean = true;\r\n\r\n\t/**\r\n\t * debounce?: number\r\n\t * Debounce timeout between keypresses. Defaults to 400.\r\n\t */\r\n\t@Input('debounce')\r\n\tpublic debounce: number = 400;\r\n\r\n\t/**\r\n\t * autocompleteCssClass: string\r\n\t */\r\n\t@Input()\r\n\tpublic autocompleteCssClass: string = '';\r\n\r\n\t/**\r\n\t * initSelect?: function\r\n\t */\r\n\t@Output()\r\n\tpublic initSelect: EventEmitter<any> = new EventEmitter<any>();\r\n\r\n\t/**\r\n\t * selected?: function\r\n\t */\r\n\t@Output()\r\n\tpublic selected: EventEmitter<any> = new EventEmitter<any>();\r\n\r\n\t/**\r\n\t * cleared?: function\r\n\t */\r\n\t@Output()\r\n\tpublic cleared: EventEmitter<any> = new EventEmitter<any>();\r\n\r\n\t/**\r\n\t * launch?: function\r\n\t */\r\n\t@Output('launch')\r\n\tpublic onLaunch: EventEmitter<any> = new EventEmitter<any>();\r\n\r\n\t/**\r\n\t * suffixButtons: SuffixButton<any>[]\r\n\t */\r\n\t@Input()\r\n\tpublic suffixButtons: SuffixButton[] = [];\r\n\r\n\t/**\r\n\t * chipFocus?: function\r\n\t * Method to be executed when a chip is focused.\r\n\t * Sends chip value as event.\r\n\t */\r\n\t@Output()\r\n\tpublic chipFocus: EventEmitter<any> = new EventEmitter<any>();\r\n\r\n\t/** \r\n\t * Whether the select has a value.\r\n\t */\r\n\tget empty(): boolean { return this.chips.length <= 0; }\r\n\r\n\t/**\r\n\t * Default chip\r\n\t */\r\n\t@Input()\r\n\tget default() { return this.chips[0]; }\r\n\tset default(_chip) {\r\n\t\tif (_chip) {\r\n\t\t\t/* Add chip for selected option */\r\n\t\t\tthis.chips = [_chip];\r\n\r\n\t\t\t/* \tSet the value (ngModel) */\r\n\t\t\tthis.value = _chip[this.key];\r\n\r\n\t\t\t/* Diabled the input, allow only one chip */\r\n\t\t\tthis.autoCompleteChipList.disable();\r\n\r\n\t\t\t/* Reset the autocomplete input text value */\r\n\t\t\tthis.stateChanges.next();\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Whether the `MatFormField` label should try to float.\r\n\t */\r\n\tpublic get shouldLabelFloat(): boolean {\r\n\t\treturn super.shouldLabelFloat || !this.chipInput?.empty;\r\n\t}\r\n\r\n\t/**\r\n\t * loading: boolean\r\n\t */\r\n\tpublic loading: boolean;\r\n\r\n\t/**\r\n\t * emptyResult: boolean\r\n\t */\r\n\tpublic emptyResult: boolean;\r\n\r\n\t/**\r\n\t * Constructor\r\n\t * @param ngControl \r\n\t * @param parentForm \r\n\t * @param parentFormGroup \r\n\t * @param defaultErrorStateMatcher \r\n\t * @param focusMonitor \r\n\t * @param elementRef \r\n\t */\r\n\tconstructor(protected injector: Injector, @Optional() @Self() ngControl: NgControl, @Optional() parentForm: NgForm, @Optional() parentFormGroup: FormGroupDirective, defaultErrorStateMatcher: ErrorStateMatcher, focusMonitor: FocusMonitor, elementRef: ElementRef) {\r\n\t\tsuper(\"app-vd-chips\", ngControl, parentForm, parentFormGroup, defaultErrorStateMatcher, focusMonitor, elementRef);\r\n\t\tthis.http = injector.get(HttpClient);\r\n\t}\r\n\r\n\t/**\r\n\t * From ControlValueAccessor interface\r\n\t * @param value \r\n\t */\r\n\twriteValue(value: any) {\r\n\t\t/* Set the value */\r\n\t\tthis._value = value;\r\n\r\n\t\t/* Clear the chips list */\r\n\t\tthis.chips = [];\r\n\r\n\t\tif (value && this.chips?.length <= 0) {\r\n\t\t\tthis.loading = true;\r\n\t\t\tlet _params: any = {};\r\n\r\n\t\t\t/* Add includes, if any */\r\n\t\t\tif (this._params?.includes) {\r\n\t\t\t\t_params.includes = this._params.includes;\r\n\t\t\t}\r\n\r\n\t\t\t/* Add projection, if any */\r\n\t\t\tif (this.projection) {\r\n\t\t\t\t_params.projection = this.projection;\r\n\t\t\t}\r\n\r\n\t\t\t/* Get base url */\r\n\t\t\tvar urlParts = this.endpoint.split('?');\r\n\t\t\tthis.http.get(`${urlParts[0]}/${value}${urlParts.length > 1 ? `?${urlParts[1]}` : ''}`, { params: Utils.cleanObject(_params) }).subscribe(x => {\r\n\t\t\t\tthis.loading = false;\r\n\r\n\t\t\t\t/* Add chip for selected option */\r\n\t\t\t\tthis.chips.push(x);\r\n\r\n\t\t\t\t/* Emit selected event */\r\n\t\t\t\tthis.initSelect.emit(x);\r\n\r\n\t\t\t\t/* Diabled the input, allow only one chip */\r\n\t\t\t\tthis.autoCompleteChipList.disable();\r\n\t\t\t}, _ => this.loading = false);\r\n\t\t} else {\r\n\t\t\tthis.clear(false);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Sets control focus\r\n\t */\r\n\tpublic focus(): void {\r\n\t\tthis.chipInput?.focus();\r\n\t}\r\n\r\n\t/**\r\n\t * Lifecycle hook that is called after data-bound properties of a \r\n\t * directive are initialized.\r\n\t */\r\n\tngOnInit() {\r\n\t\tthis.autoCompleteChipList.valueChanges\r\n\t\t\t.pipe(debounceTime(this.debounce))\r\n\t\t\t.subscribe(v => this.filterOptions(v));\r\n\r\n\t\tthis.ngControl?.valueChanges?.pipe(skip(1)).subscribe((value: string) => {\r\n\t\t\tif (!value) {\r\n\t\t\t\tthis.chips = [];\r\n\t\t\t\tthis._value = \"\";\r\n\t\t\t\tthis.autoCompleteChipList.setValue(\"\");\r\n\t\t\t\tthis.autoCompleteChipList.enable();\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\t/**\r\n\t * Adds a chip\r\n\t * @param event \r\n\t * @param input \r\n\t */\r\n\tpublic addChip(event: MatAutocompleteSelectedEvent, input: any): void {\r\n\t\t/* Define selection constant */\r\n\t\tconst selection = event.option.value;\r\n\r\n\t\t/* Add chip for selected option */\r\n\t\tthis.chips.push(selection);\r\n\r\n\t\t/* Emit selected event */\r\n\t\tthis.selected.emit(selection);\r\n\r\n\t\t/* \tSet the value (ngModel) */\r\n\t\tthis.value = selection[this.key];\r\n\r\n\t\t/* Diabled the input, allow only one chip */\r\n\t\tthis.autoCompleteChipList.disable();\r\n\r\n\t\t/* Reset the autocomplete input text value */\r\n\t\tif (input) {\r\n\t\t\tinput.value = '';\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Removes all chips\r\n\t */\r\n\tpublic clear(triggerStateChanges: boolean = true): void {\r\n\t\t/* Remove key from chips array */\r\n\t\tthis.value = null;\r\n\t\tthis.chips = [];\r\n\r\n\t\t/* Mark the control as touched */\r\n\t\tif (this.ngControl.control) {\r\n\t\t\tthis.ngControl.control.markAsTouched();\r\n\t\t}\r\n\r\n\t\t/* Reset the value (ngModel) */\r\n\t\tthis.autoCompleteChipList.setValue(\"\");\r\n\r\n\t\tif (triggerStateChanges) {\r\n\t\t\tthis.stateChanges.next();\r\n\t\t}\r\n\r\n\t\t/* Enable the input */\r\n\t\tthis.autoCompleteChipList.enable();\r\n\t}\r\n\r\n\t/**\r\n\t * Filters options\r\n\t * @param text \r\n\t */\r\n\tprivate filterOptions(text: string) {\r\n\t\tthis.filteredOptions = [];\r\n\t\tif (this.endpoint && typeof text === 'string' && text.length >= this.termMinlength) {\r\n\t\t\t/* Init params if null */\r\n\t\t\tthis._params = this._params || {};\r\n\r\n\t\t\t/* Add search word to the params */\r\n\t\t\tif (this.searchField && this.searchFields.length <= 0) {\r\n\t\t\t\tvar result = new RegExp(`(\\\\${this.searchOperators.join('|\\\\')})?(.*)`).exec(this.searchField);\r\n\t\t\t\tthis._params[result[2]] = `${result[1] ? result[1] : ''}${text}`;\r\n\t\t\t}\r\n\r\n\t\t\t/* Add search word to the params */\r\n\t\t\tthis.searchFields?.map(x => x.trim())?.forEach(x => {\r\n\t\t\t\tvar result = new RegExp(`(\\\\${this.searchOperators.join('|\\\\')})?(.*)`).exec(x);\r\n\t\t\t\tthis._params[result[2]] = `${result[1] ? result[1] : ''}${text}`;\r\n\t\t\t});\r\n\r\n\t\t\t/* Add limit to the params */\r\n\t\t\tthis._params.limit = this.limit;\r\n\r\n\t\t\t/* Add projection, if any */\r\n\t\t\tif (this.projection) {\r\n\t\t\t\tthis._params.projection = this.projection;\r\n\t\t\t}\r\n\r\n\t\t\t/* Get results from server */\r\n\t\t\tthis.loading = true;\r\n\t\t\tthis.http.get(`${this.endpoint}${this.path || ''}`, { params: Utils.cleanObject(this._params) })\r\n\t\t\t\t.subscribe({\r\n\t\t\t\t\tnext: (x: any[]) => {\r\n\t\t\t\t\t\tthis.loading = false;\r\n\t\t\t\t\t\tthis.filteredOptions = x;\r\n\t\t\t\t\t\tthis.emptyResult = !x || !x.length;\r\n\t\t\t\t\t},\r\n\t\t\t\t\terror: () => this.loading = false\r\n\t\t\t\t});\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Handles removed event\r\n\t */\r\n\tpublic handleRemovedEvent(): void {\r\n\t\tthis.cleared?.emit(this.value);\r\n\t\tif (this.removable) {\r\n\t\t\tthis.clear();\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Handles launch button click\r\n\t */\r\n\tpublic handleLaunchClicked(): void {\r\n\t\tif (this.chips?.length > 0) {\r\n\t\t\tthis.onLaunch.emit(this.chips[0]);\r\n\t\t}\r\n\t}\r\n}","<mat-chip-list #chipList [required]=\"required\" [disabled]=\"readonly\">\r\n\t<!-- #region Chips -->\r\n\t<ng-template let-chip let-first=\"first\" let-index=\"index\" ngFor [ngForOf]=\"chips\">\r\n\t\t<mat-basic-chip [selectable]=\"!readonly\" [removable]=\"!readonly\" (removed)=\"handleRemovedEvent()\" disableRipple>\r\n\t\t\t<span class=\"vd-chip-content\">\r\n\t\t\t\t<span *ngIf=\"!chipTemplate?.templateRef\">\r\n\t\t\t\t\t<span *ngIf=\"!autocompleteOptionTemplate?.templateRef\">{{ chip }}</span>\r\n\t\t\t\t\t<ng-template *ngIf=\"autocompleteOptionTemplate?.templateRef\" [ngTemplateOutlet]=\"autocompleteOptionTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ option: chip }\"></ng-template>\r\n\t\t\t\t</span>\r\n\t\t\t\t<ng-template *ngIf=\"chipTemplate?.templateRef\" [ngTemplateOutlet]=\"chipTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ chip: chip }\"></ng-template>\r\n\t\t\t</span>\r\n\t\t\t<ng-template let-button let-first=\"first\" ngFor [ngForOf]=\"suffixButtons\">\r\n\t\t\t\t<a mat-icon-button *ngIf=\"!button.hide || !button.hide(chips[0], context)\" (click)=\"$event.stopPropagation(); button.event && button.event(chips[0], context)\">\r\n\t\t\t\t\t<mat-icon>{{button.icon}}</mat-icon>\r\n\t\t\t\t</a>\r\n\t\t\t</ng-template>\r\n\t\t\t<a mat-icon-button *ngIf=\"onLaunch?.observers?.length > 0\" (click)=\"$event.stopPropagation(); handleLaunchClicked()\">\r\n\t\t\t\t<mat-icon>launch</mat-icon>\r\n\t\t\t</a>\r\n\t\t\t<a mat-icon-button *ngIf=\"!readonly\">\r\n\t\t\t\t<mat-icon matChipRemove>close</mat-icon>\r\n\t\t\t</a>\r\n\t\t</mat-basic-chip>\r\n\t</ng-template>\r\n\t<!-- #endregion -->\r\n\r\n\t<!-- #region Search box -->\r\n\t<input matInput [hidden]=\"value && !empty\" placeholder=\"{{placeholder}}\" [readonly]=\"readonly\" [matChipInputFor]=\"chipList\" [matAutocomplete]=\"auto\" [formControl]=\"autoCompleteChipList\" #chipInput />\r\n\t<!-- #endregion -->\r\n\r\n\t<!-- #region Progress -->\r\n\t<mat-spinner diameter=\"18\" *ngIf=\"loading\"></mat-spinner>\r\n\t<!-- #endregion -->\r\n</mat-chip-list>\r\n\r\n<!-- #region Autocomplete -->\r\n<mat-autocomplete #auto=\"matAutocomplete\" (optionSelected)=\"addChip($event, chipInput)\" [class]=\"autocompleteCssClass\">\r\n\t<ng-template let-item let-first=\"first\" ngFor [ngForOf]=\"filteredOptions\">\r\n\t\t<mat-option [value]=\"item\">\r\n\t\t\t<span *ngIf=\"!autocompleteOptionTemplate?.templateRef\">{{ item }}</span>\r\n\t\t\t<ng-template *ngIf=\"autocompleteOptionTemplate?.templateRef\" [ngTemplateOutlet]=\"autocompleteOptionTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ option: item }\"></ng-template>\r\n\t\t</mat-option>\r\n\t</ng-template>\r\n</mat-autocomplete>\r\n<!-- #endregion -->"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chips.component.js","sourceRoot":"","sources":["../../../../../../projects/cdk/src/lib/chips/components/chips.component.ts","../../../../../../projects/cdk/src/lib/chips/components/chips.component.html"],"names":[],"mappings":"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","sourcesContent":["import { FocusMonitor } from '@angular/cdk/a11y';\r\nimport { CdkPortal } from '@angular/cdk/portal';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { Component, ContentChild, Directive, ElementRef, EventEmitter, Injector, Input, Optional, Output, Self, TemplateRef, ViewChild, ViewContainerRef } from '@angular/core';\r\nimport { FormControl, FormGroupDirective, NgControl, NgForm } from '@angular/forms';\r\nimport { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';\r\nimport { ErrorStateMatcher } from '@angular/material/core';\r\nimport { MatFormFieldControl } from '@angular/material/form-field';\r\nimport { MatInput } from '@angular/material/input';\r\nimport { BehaviorSubject } from 'rxjs';\r\nimport { debounceTime, skip } from 'rxjs/operators';\r\nimport { SuffixButton } from '../../common/common.module';\r\nimport { Utils } from '../../common/functions/utils';\r\nimport { AbstractMatFormField } from '../../forms/helpers/abstract-mat-form-field';\r\n\r\n/**\r\n * VdChipDirective class\r\n */\r\n@Directive({ selector: '[vd-chip]ng-template' })\r\nexport class VdChipDirective extends CdkPortal {\r\n\tconstructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef) {\r\n\t\tsuper(templateRef, viewContainerRef);\r\n\t}\r\n}\r\n\r\n/**\r\n * VdAutocompleteOptionDirective class\r\n */\r\n@Directive({ selector: '[vd-autocomplete-option]ng-template' })\r\nexport class VdAutocompleteOptionDirective extends CdkPortal {\r\n\tconstructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef) {\r\n\t\tsuper(templateRef, viewContainerRef);\r\n\t}\r\n}\r\n\r\n/**\r\n * VdChipsComponent class\r\n */\r\n@Component({\r\n\tselector: 'vd-chips',\r\n\ttemplateUrl: './chips.component.html',\r\n\tstyleUrls: ['./chips.component.scss'],\r\n\tproviders: [\r\n\t\t{ provide: MatFormFieldControl, useExisting: VdChipsComponent }\r\n\t]\r\n})\r\nexport class VdChipsComponent extends AbstractMatFormField<any> {\r\n\r\n\t/**\r\n\t * The http service from to get the data\r\n\t */\r\n\tprotected http: HttpClient = null;\r\n\r\n\t/** \r\n\t * The select element.\r\n\t */\r\n\t@ViewChild(MatInput, { static: true })\r\n\tpublic chipInput: MatInput;\r\n\r\n\t/**\r\n\t * Represents a value that changes over time. \r\n\t * Observers can subscribe to the subject to receive pdf file changes\r\n\t */\r\n\tprivate _endpointChange = new BehaviorSubject(null);\r\n\r\n\t/**\r\n\t * Set up reactive formcontrol\r\n\t */\r\n\tpublic autoCompleteChipList: FormControl = new FormControl();\r\n\r\n\t/**\r\n\t * The list of filtered options\r\n\t */\r\n\tpublic filteredOptions: any[];\r\n\r\n\t/**\r\n\t * searchOperators: string[]\r\n\t */\r\n\tpublic searchOperators: string[] = [\"!=\", \"!\", \"<>\", \">=\", \">\", \"<=\", \"<\", \"^\", \"$\", \"~\"];\r\n\r\n\t/**\r\n\t * The list of chips\r\n\t */\r\n\t@Input()\r\n\tpublic chips = [];\r\n\r\n\t/**\r\n\t * VdChip template\r\n\t */\r\n\t@ContentChild(VdChipDirective)\r\n\tpublic chipTemplate: VdChipDirective;\r\n\r\n\t/**\r\n\t * AutocompleteOption template\r\n\t */\r\n\t@ContentChild(VdAutocompleteOptionDirective)\r\n\tpublic autocompleteOptionTemplate: VdAutocompleteOptionDirective;\r\n\r\n\t/**\r\n\t * _endpoint: string\r\n\t */\r\n\tpublic _endpoint: string | Function;\r\n\r\n\t/**\r\n\t * Gets or sets endpoint\r\n\t */\r\n\t@Input()\r\n\tget endpoint(): string | Function { return this._endpoint; }\r\n\tset endpoint(endpoint: string | Function) {\r\n\t\tthis._endpoint = endpoint;\r\n\t\tthis.clear();\r\n\t\tthis._endpointChange.next([this.endpoint, this.path, this.params, this.projection]);\r\n\t}\r\n\r\n\t/**\r\n\t * _params: any\r\n\t */\r\n\tpublic _params: any;\r\n\r\n\t/**\r\n\t * params: any\r\n\t */\r\n\t@Input()\r\n\tget params() { return this._params; }\r\n\tset params(params: any) {\r\n\t\t/* Remove empty params */\r\n\t\tObject.keys(params).forEach((key) => {\r\n\t\t\tif ((params[key] == null || params[key] == '' || params[key] == 'undefined')) {\r\n\t\t\t\tdelete params[key];\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\tif (JSON.stringify(this._params) !== JSON.stringify(params)) {\r\n\t\t\tthis._params = params;\r\n\t\t\tthis._endpointChange.next([this.endpoint, this.path, this._params, this.projection]);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * _projection: any\r\n\t */\r\n\tpublic _projection: string;\r\n\r\n\t/**\r\n\t * projection: any\r\n\t */\r\n\t@Input()\r\n\tget projection() { return this._projection; }\r\n\tset projection(projection: string) {\r\n\t\tthis._projection = projection;\r\n\t\tthis.clear();\r\n\t\tthis._endpointChange.next([this.endpoint, this.path, this.params, this.projection]);\r\n\t}\r\n\r\n\t/**\r\n\t * _path: any\r\n\t */\r\n\tpublic _path: any = '';\r\n\r\n\t/**\r\n\t * Gets or sets path\r\n\t */\r\n\t@Input()\r\n\tget path() { return this._path; }\r\n\tset path(path) {\r\n\t\tthis._path = path;\r\n\t\tthis.clear();\r\n\t\tthis._endpointChange.next([this.endpoint, this.path, this.params, this.projection]);\r\n\t}\r\n\r\n\t/**\r\n\t * Sets the disabled.\r\n\t * @param disabled\r\n\t */\r\n\tpublic get disabled() {\r\n\t\tif (this._readonly) {\r\n\t\t\treturn true;\r\n\t\t}\r\n\r\n\t\treturn super.disabled;\r\n\t}\r\n\r\n\t/**\r\n\t * context: any\r\n\t * The current context\r\n\t */\r\n\t@Input()\r\n\tpublic context: any;\r\n\r\n\t/**\r\n\t * key: string\r\n\t */\r\n\t@Input()\r\n\tpublic key: string = 'id';\r\n\r\n\t/**\r\n\t * searchField: string\r\n\t */\r\n\t@Input()\r\n\tpublic searchField: string = 'search';\r\n\r\n\t/**\r\n\t * searchFields: string\r\n\t */\r\n\t@Input()\r\n\tpublic searchFields: string[] = [];\r\n\r\n\t/**\r\n\t * termMinlength: number\r\n\t */\r\n\t@Input()\r\n\tpublic termMinlength: number = 2;\r\n\r\n\t/**\r\n\t * limit: number\r\n\t */\r\n\t@Input()\r\n\tpublic limit: number = 30;\r\n\r\n\t/**\r\n\t * removable: boolean\r\n\t */\r\n\t@Input()\r\n\tpublic removable: boolean = true;\r\n\r\n\t/**\r\n\t * debounce?: number\r\n\t * Debounce timeout between keypresses. Defaults to 400.\r\n\t */\r\n\t@Input('debounce')\r\n\tpublic debounce: number = 400;\r\n\r\n\t/**\r\n\t * autocompleteCssClass: string\r\n\t */\r\n\t@Input()\r\n\tpublic autocompleteCssClass: string = '';\r\n\r\n\t/**\r\n\t * initSelect?: function\r\n\t */\r\n\t@Output()\r\n\tpublic initSelect: EventEmitter<any> = new EventEmitter<any>();\r\n\r\n\t/**\r\n\t * selected?: function\r\n\t */\r\n\t@Output()\r\n\tpublic selected: EventEmitter<any> = new EventEmitter<any>();\r\n\r\n\t/**\r\n\t * cleared?: function\r\n\t */\r\n\t@Output()\r\n\tpublic cleared: EventEmitter<any> = new EventEmitter<any>();\r\n\r\n\t/**\r\n\t * launch?: function\r\n\t */\r\n\t@Output('launch')\r\n\tpublic onLaunch: EventEmitter<any> = new EventEmitter<any>();\r\n\r\n\t/**\r\n\t * suffixButtons: SuffixButton<any>[]\r\n\t */\r\n\t@Input()\r\n\tpublic suffixButtons: SuffixButton[] = [];\r\n\r\n\t/**\r\n\t * chipFocus?: function\r\n\t * Method to be executed when a chip is focused.\r\n\t * Sends chip value as event.\r\n\t */\r\n\t@Output()\r\n\tpublic chipFocus: EventEmitter<any> = new EventEmitter<any>();\r\n\r\n\t/** \r\n\t * Whether the select has a value.\r\n\t */\r\n\tget empty(): boolean { return this.chips.length <= 0; }\r\n\r\n\t/**\r\n\t * Default chip\r\n\t */\r\n\t@Input()\r\n\tget default() { return this.chips[0]; }\r\n\tset default(_chip) {\r\n\t\tif (_chip) {\r\n\t\t\t/* Add chip for selected option */\r\n\t\t\tthis.chips = [_chip];\r\n\r\n\t\t\t/* \tSet the value (ngModel) */\r\n\t\t\tthis.value = _chip[this.key];\r\n\r\n\t\t\t/* Diabled the input, allow only one chip */\r\n\t\t\tthis.autoCompleteChipList.disable();\r\n\r\n\t\t\t/* Reset the autocomplete input text value */\r\n\t\t\tthis.stateChanges.next();\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Whether the `MatFormField` label should try to float.\r\n\t */\r\n\tpublic get shouldLabelFloat(): boolean {\r\n\t\treturn super.shouldLabelFloat || !this.chipInput?.empty;\r\n\t}\r\n\r\n\t/**\r\n\t * loading: boolean\r\n\t */\r\n\tpublic loading: boolean;\r\n\r\n\t/**\r\n\t * emptyResult: boolean\r\n\t */\r\n\tpublic emptyResult: boolean;\r\n\r\n\t/**\r\n\t * Constructor\r\n\t * @param ngControl \r\n\t * @param parentForm \r\n\t * @param parentFormGroup \r\n\t * @param defaultErrorStateMatcher \r\n\t * @param focusMonitor \r\n\t * @param elementRef \r\n\t */\r\n\tconstructor(protected injector: Injector, @Optional() @Self() ngControl: NgControl, @Optional() parentForm: NgForm, @Optional() parentFormGroup: FormGroupDirective, defaultErrorStateMatcher: ErrorStateMatcher, focusMonitor: FocusMonitor, elementRef: ElementRef) {\r\n\t\tsuper(\"app-vd-chips\", ngControl, parentForm, parentFormGroup, defaultErrorStateMatcher, focusMonitor, elementRef);\r\n\t\tthis.http = injector.get(HttpClient);\r\n\t}\r\n\r\n\t/**\r\n\t * From ControlValueAccessor interface\r\n\t * @param value \r\n\t */\r\n\twriteValue(value: any) {\r\n\t\t/* Set the value */\r\n\t\tthis._value = value;\r\n\r\n\t\t/* Clear the chips list */\r\n\t\tthis.chips = [];\r\n\r\n\t\tif (value && this.chips?.length <= 0) {\r\n\t\t\tthis.loading = true;\r\n\t\t\tlet _params: any = {};\r\n\r\n\t\t\t/* Add includes, if any */\r\n\t\t\tif (this._params?.includes) {\r\n\t\t\t\t_params.includes = this._params.includes;\r\n\t\t\t}\r\n\r\n\t\t\t/* Add projection, if any */\r\n\t\t\tif (this.projection) {\r\n\t\t\t\t_params.projection = this.projection;\r\n\t\t\t}\r\n\r\n\t\t\t/* Get endpoint */\r\n\t\t\tlet endpoint = typeof this.endpoint === 'function' ? this.endpoint(this) : (<string>this.endpoint);\r\n\r\n\t\t\t/* Get base url */\r\n\t\t\tvar urlParts = endpoint.split('?');\r\n\t\t\tthis.http.get(`${urlParts[0]}/${value}${urlParts.length > 1 ? `?${urlParts[1]}` : ''}`, { params: Utils.cleanObject(_params) }).subscribe(x => {\r\n\t\t\t\tthis.loading = false;\r\n\r\n\t\t\t\t/* Add chip for selected option */\r\n\t\t\t\tthis.chips.push(x);\r\n\r\n\t\t\t\t/* Emit selected event */\r\n\t\t\t\tthis.initSelect.emit(x);\r\n\r\n\t\t\t\t/* Diabled the input, allow only one chip */\r\n\t\t\t\tthis.autoCompleteChipList.disable();\r\n\t\t\t}, _ => this.loading = false);\r\n\t\t} else {\r\n\t\t\tthis.clear(false);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Sets control focus\r\n\t */\r\n\tpublic focus(): void {\r\n\t\tthis.chipInput?.focus();\r\n\t}\r\n\r\n\t/**\r\n\t * Lifecycle hook that is called after data-bound properties of a \r\n\t * directive are initialized.\r\n\t */\r\n\tngOnInit() {\r\n\t\tthis.autoCompleteChipList.valueChanges\r\n\t\t\t.pipe(debounceTime(this.debounce))\r\n\t\t\t.subscribe(v => this.filterOptions(v));\r\n\r\n\t\tthis.ngControl?.valueChanges?.pipe(skip(1)).subscribe((value: string) => {\r\n\t\t\tif (!value) {\r\n\t\t\t\tthis.chips = [];\r\n\t\t\t\tthis._value = \"\";\r\n\t\t\t\tthis.autoCompleteChipList.setValue(\"\");\r\n\t\t\t\tthis.autoCompleteChipList.enable();\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\t/**\r\n\t * Adds a chip\r\n\t * @param event \r\n\t * @param input \r\n\t */\r\n\tpublic addChip(event: MatAutocompleteSelectedEvent, input: any): void {\r\n\t\t/* Define selection constant */\r\n\t\tconst selection = event.option.value;\r\n\r\n\t\t/* Add chip for selected option */\r\n\t\tthis.chips.push(selection);\r\n\r\n\t\t/* Emit selected event */\r\n\t\tthis.selected.emit(selection);\r\n\r\n\t\t/* \tSet the value (ngModel) */\r\n\t\tthis.value = selection[this.key];\r\n\r\n\t\t/* Diabled the input, allow only one chip */\r\n\t\tthis.autoCompleteChipList.disable();\r\n\r\n\t\t/* Reset the autocomplete input text value */\r\n\t\tif (input) {\r\n\t\t\tinput.value = '';\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Removes all chips\r\n\t */\r\n\tpublic clear(triggerStateChanges: boolean = true): void {\r\n\t\t/* Remove key from chips array */\r\n\t\tthis.value = null;\r\n\t\tthis.chips = [];\r\n\r\n\t\t/* Mark the control as touched */\r\n\t\tif (this.ngControl.control) {\r\n\t\t\tthis.ngControl.control.markAsTouched();\r\n\t\t}\r\n\r\n\t\t/* Reset the value (ngModel) */\r\n\t\tthis.autoCompleteChipList.setValue(\"\");\r\n\r\n\t\tif (triggerStateChanges) {\r\n\t\t\tthis.stateChanges.next();\r\n\t\t}\r\n\r\n\t\t/* Enable the input */\r\n\t\tthis.autoCompleteChipList.enable();\r\n\t}\r\n\r\n\t/**\r\n\t * Filters options\r\n\t * @param text \r\n\t */\r\n\tprivate filterOptions(text: string) {\r\n\t\tthis.filteredOptions = [];\r\n\t\tif (this.endpoint && typeof text === 'string' && text.length >= this.termMinlength) {\r\n\t\t\t/* Init params if null */\r\n\t\t\tthis._params = this._params || {};\r\n\r\n\t\t\t/* Add search word to the params */\r\n\t\t\tif (this.searchField && this.searchFields.length <= 0) {\r\n\t\t\t\tvar result = new RegExp(`(\\\\${this.searchOperators.join('|\\\\')})?(.*)`).exec(this.searchField);\r\n\t\t\t\tthis._params[result[2]] = `${result[1] ? result[1] : ''}${text}`;\r\n\t\t\t}\r\n\r\n\t\t\t/* Add search word to the params */\r\n\t\t\tthis.searchFields?.map(x => x.trim())?.forEach(x => {\r\n\t\t\t\tvar result = new RegExp(`(\\\\${this.searchOperators.join('|\\\\')})?(.*)`).exec(x);\r\n\t\t\t\tthis._params[result[2]] = `${result[1] ? result[1] : ''}${text}`;\r\n\t\t\t});\r\n\r\n\t\t\t/* Add limit to the params */\r\n\t\t\tthis._params.limit = this.limit;\r\n\r\n\t\t\t/* Add projection, if any */\r\n\t\t\tif (this.projection) {\r\n\t\t\t\tthis._params.projection = this.projection;\r\n\t\t\t}\r\n\r\n\t\t\t/* Get results from server */\r\n\t\t\tthis.loading = true;\r\n\t\t\tthis.http.get(`${this.endpoint}${this.path || ''}`, { params: Utils.cleanObject(this._params) })\r\n\t\t\t\t.subscribe({\r\n\t\t\t\t\tnext: (x: any[]) => {\r\n\t\t\t\t\t\tthis.loading = false;\r\n\t\t\t\t\t\tthis.filteredOptions = x;\r\n\t\t\t\t\t\tthis.emptyResult = !x || !x.length;\r\n\t\t\t\t\t},\r\n\t\t\t\t\terror: () => this.loading = false\r\n\t\t\t\t});\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Handles removed event\r\n\t */\r\n\tpublic handleRemovedEvent(): void {\r\n\t\tthis.cleared?.emit(this.value);\r\n\t\tif (this.removable) {\r\n\t\t\tthis.clear();\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Handles launch button click\r\n\t */\r\n\tpublic handleLaunchClicked(): void {\r\n\t\tif (this.chips?.length > 0) {\r\n\t\t\tthis.onLaunch.emit(this.chips[0]);\r\n\t\t}\r\n\t}\r\n}","<mat-chip-list #chipList [required]=\"required\" [disabled]=\"readonly\">\r\n\t<!-- #region Chips -->\r\n\t<ng-template let-chip let-first=\"first\" let-index=\"index\" ngFor [ngForOf]=\"chips\">\r\n\t\t<mat-basic-chip [selectable]=\"!readonly\" [removable]=\"!readonly\" (removed)=\"handleRemovedEvent()\" disableRipple>\r\n\t\t\t<span class=\"vd-chip-content\">\r\n\t\t\t\t<span *ngIf=\"!chipTemplate?.templateRef\">\r\n\t\t\t\t\t<span *ngIf=\"!autocompleteOptionTemplate?.templateRef\">{{ chip }}</span>\r\n\t\t\t\t\t<ng-template *ngIf=\"autocompleteOptionTemplate?.templateRef\" [ngTemplateOutlet]=\"autocompleteOptionTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ option: chip }\"></ng-template>\r\n\t\t\t\t</span>\r\n\t\t\t\t<ng-template *ngIf=\"chipTemplate?.templateRef\" [ngTemplateOutlet]=\"chipTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ chip: chip }\"></ng-template>\r\n\t\t\t</span>\r\n\t\t\t<ng-template let-button let-first=\"first\" ngFor [ngForOf]=\"suffixButtons\">\r\n\t\t\t\t<a mat-icon-button *ngIf=\"!button.hide || !button.hide(chips[0], context)\" (click)=\"$event.stopPropagation(); button.event && button.event(chips[0], context)\">\r\n\t\t\t\t\t<mat-icon>{{button.icon}}</mat-icon>\r\n\t\t\t\t</a>\r\n\t\t\t</ng-template>\r\n\t\t\t<a mat-icon-button *ngIf=\"onLaunch?.observers?.length > 0\" (click)=\"$event.stopPropagation(); handleLaunchClicked()\">\r\n\t\t\t\t<mat-icon>launch</mat-icon>\r\n\t\t\t</a>\r\n\t\t\t<a mat-icon-button *ngIf=\"!readonly\">\r\n\t\t\t\t<mat-icon matChipRemove>close</mat-icon>\r\n\t\t\t</a>\r\n\t\t</mat-basic-chip>\r\n\t</ng-template>\r\n\t<!-- #endregion -->\r\n\r\n\t<!-- #region Search box -->\r\n\t<input matInput [hidden]=\"value && !empty\" placeholder=\"{{placeholder}}\" [readonly]=\"readonly\" [matChipInputFor]=\"chipList\" [matAutocomplete]=\"auto\" [formControl]=\"autoCompleteChipList\" #chipInput />\r\n\t<!-- #endregion -->\r\n\r\n\t<!-- #region Progress -->\r\n\t<mat-spinner diameter=\"18\" *ngIf=\"loading\"></mat-spinner>\r\n\t<!-- #endregion -->\r\n</mat-chip-list>\r\n\r\n<!-- #region Autocomplete -->\r\n<mat-autocomplete #auto=\"matAutocomplete\" (optionSelected)=\"addChip($event, chipInput)\" [class]=\"autocompleteCssClass\">\r\n\t<ng-template let-item let-first=\"first\" ngFor [ngForOf]=\"filteredOptions\">\r\n\t\t<mat-option [value]=\"item\">\r\n\t\t\t<span *ngIf=\"!autocompleteOptionTemplate?.templateRef\">{{ item }}</span>\r\n\t\t\t<ng-template *ngIf=\"autocompleteOptionTemplate?.templateRef\" [ngTemplateOutlet]=\"autocompleteOptionTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ option: item }\"></ng-template>\r\n\t\t</mat-option>\r\n\t</ng-template>\r\n</mat-autocomplete>\r\n<!-- #endregion -->"]}

package/esm2020/lib/forms/components/generic-form/generic-form.component.mjs

@@ -182,12 +182,20 @@ export class VdGenericFormComponent {
             this.formGroup.updateValueAndValidity();
         }
     }
+    /**
+     * Check if the specified object is a function
+     * @param obj
+     * @returns
+     */
+    isFunction(obj) {
+        return obj && typeof obj === 'function';
+    }
 }
 /** @nocollapse */ /** @nocollapse */ VdGenericFormComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: VdGenericFormComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-/** @nocollapse */ /** @nocollapse */ VdGenericFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.0", type: VdGenericFormComponent, selector: "vd-generic-form", inputs: { formGroup: "formGroup", fieldGroups: "fieldGroups", groupName: "groupName", context: "context", separatorKeysCodes: "separatorKeysCodes" }, queries: [{ propertyName: "editorTemplate", first: true, predicate: VdEditorDirective, descendants: true }, { propertyName: "codeTemplate", first: true, predicate: VdCodeDirective, descendants: true }, { propertyName: "fileTemplate", first: true, predicate: VdFileDirective, descendants: true }, { propertyName: "customTemplate", first: true, predicate: VdCustomDirective, descendants: true }], ngImport: i0, template: "<div *ngIf=\"formGroup && fieldRows\" [formGroup]=\"formGroup\">\r\n    <!-- #region Fields -->\r\n    <div layout-gt-sm=\"row\" layout=\"column\" *ngFor=\"let fields of fieldRows\">\r\n        <ng-container *ngFor=\"let field of fields\" [ngSwitch]=\"field.type\">\r\n            <!-- #region Error handling -->\r\n            <ng-template #fieldErrors>\r\n                <div *ngFor=\"let errorMessage of formGroup.controls[field.name]['errorMessages']\">{{errorMessage}}</div>\r\n            </ng-template>\r\n            <!-- #endregion -->\r\n\r\n            <ng-container *ngIf=\"!field.hide || !field.hide(formGroup?.value, formGroup, context)\">\r\n                <ng-container *ngIf=\"field.wrapped\">\r\n                    <!-- #region Text input -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Text\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <input [type]=\"field.inputType\" [minlength]=\"field.minLength||null\" [maxlength]=\"field.maxLength||null\" matInput [formControlName]=\"field.name\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Textarea -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.TextArea\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <textarea matInput [formControlName]=\"field.name\" rows=\"field.rows||2\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\"></textarea>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Enum -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Enum\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <vd-select [formControlName]=\"field.name\" [enum]=\"field.enumType\" [key]=\"field.optionValue\" [text]=\"field.optionText\" [multiple]=\"field.multiple\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\" flex>\r\n                            <ng-template vd-select-trigger let-trigger=\"trigger\" *ngIf=\"field.triggerTemplate\">\r\n                                <div [innerHTML]=\"field.triggerTemplate(trigger)\"></div>\r\n                            </ng-template>\r\n                            <ng-template vd-select-option let-option=\"option\" *ngIf=\"field.optionTemplate\">\r\n                                <div [outerHTML]=\"field.optionTemplate(option)\"></div>\r\n                            </ng-template>\r\n                        </vd-select>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region VdSelect -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.VdSelect\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <vd-select [formControlName]=\"field.name\" [endpoint]=\"field.endpoint\" [params]=\"field.params?field.params(formGroup.value, formGroup, context):{}\" [projection]=\"field.projection\" [mapper]=\"field.mapper\" [compareWith]=\"field.compareWith\" [key]=\"field.optionValue\" [text]=\"field.optionText\" [multiple]=\"field.multiple\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\" (itemSelected)=\"field.itemSelect && field.itemSelect($event, formGroup?.value, formGroup, context);\" (itemChange)=\"field.itemChange && field.itemChange($event, formGroup?.value, formGroup, context);\" flex>\r\n                            <ng-template vd-select-trigger let-trigger=\"trigger\" *ngIf=\"field.triggerTemplate\">\r\n                                <div [innerHTML]=\"field.triggerTemplate(trigger)\"></div>\r\n                            </ng-template>\r\n                            <ng-template vd-select-option let-option=\"option\" *ngIf=\"field.optionTemplate\">\r\n                                <div [outerHTML]=\"field.optionTemplate(option)\"></div>\r\n                            </ng-template>\r\n                        </vd-select>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Chips -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Chips\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <mat-chip-list #chipList [formControlName]=\"field.name\" [disableControl]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                            <mat-chip *ngFor=\"let chip of formGroup.controls[field.name]?.value\" (removed)=\"removeChip(field, chip)\" color=\"primary\" selectable=\"true\" selected>\r\n                                <span>{{chip}}</span>\r\n                                <button matChipRemove>\r\n                                    <mat-icon>cancel</mat-icon>\r\n                                </button>\r\n                            </mat-chip>\r\n                            <input [placeholder]=\"field.header\" #chipInput [matChipInputFor]=\"chipList\" [matChipInputSeparatorKeyCodes]=\"separatorKeysCodes\" [matAutocomplete]=\"chipAutocomplete\" (input)=\"filterAutocomplete(field, chipInput)\" (matChipInputTokenEnd)=\"addChip(field, $event)\" autocomplete=\"off\">\r\n                        </mat-chip-list>\r\n                        <mat-autocomplete autoActiveFirstOption #chipAutocomplete=\"matAutocomplete\" [class]=\"field.autocompleteCssClass\" (optionSelected)=\"autocompleteValueSelected(field, $event, chipInput)\">\r\n                            <mat-option *ngFor=\"let option of autocompleteFilteredOptions[field.name]\" [value]=\"option.id\">\r\n                                {{option.name}}\r\n                            </mat-option>\r\n                        </mat-autocomplete>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region VdChips -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.VdChips\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <vd-chips #vdChip [formControlName]=\"field.name\" [endpoint]=\"field.endpoint\" [params]=\"field.params?field.params(formGroup?.value, formGroup, context):{}\" [searchField]=\"field.searchField\" [projection]=\"field.projection\" [key]=\"field.optionValue\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\" [removable]=\"!field.clear\" [context]=\"context\" [suffixButtons]=\"field.suffixButtons\" [autocompleteCssClass]=\"field.autocompleteCssClass\" (initSelect)=\"field.itemSelect && field.itemSelect($event, formGroup?.value, formGroup, context);\" (selected)=\"field.itemChange && field.itemChange($event, formGroup?.value, formGroup, context);\" (cleared)=\"field.clear && field.clear(formGroup?.value, formGroup, context);\" flex>\r\n                            <ng-template vd-chip let-chip=\"chip\" *ngIf=\"field.chipTemplate\">\r\n                                <div [outerHTML]=\"field.chipTemplate(chip)\"></div>\r\n                            </ng-template>\r\n                            <ng-template vd-autocomplete-option let-option=\"option\" *ngIf=\"field.autocompleteTemplate\">\r\n                                <div [outerHTML]=\"field.autocompleteTemplate(option)\"></div>\r\n                            </ng-template>\r\n                        </vd-chips>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-hint *ngIf=\"vdChip.emptyResult\" class=\"tc-red-400\" i18n=\"@@noResultsFound\">No results were found.</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Select -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Select\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <mat-select [formControlName]=\"field.name\" [multiple]=\"field.multiple\" flex>\r\n                            <mat-option *ngFor=\"let option of field.options\" [value]=\"option.id\">{{option.name}}</mat-option>\r\n                        </mat-select>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Autocomplete -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Autocomplete\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <input type=\"text\" matInput [formControlName]=\"field.name\" [matAutocomplete]=\"auto\" #autocompleteInput (input)=\"filterAutocomplete(field, autocompleteInput)\" autocomplete=\"off\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                        <mat-autocomplete autoActiveFirstOption #auto=\"matAutocomplete\" [class]=\"field.autocompleteCssClass\">\r\n                            <mat-option *ngFor=\"let option of autocompleteFilteredOptions[field.name]\" [value]=\"option.id\">\r\n                                {{option.name}}\r\n                            </mat-option>\r\n                        </mat-autocomplete>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Date -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Date\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <input matInput [formControlName]=\"field.name\" autocomplete=\"off\" [matDatepicker]=\"datePicker\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                        <mat-datepicker-toggle matSuffix [for]=\"datePicker\"></mat-datepicker-toggle>\r\n                        <mat-datepicker #datePicker></mat-datepicker>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n                </ng-container>\r\n\r\n                <!-- #region Checkbox -->\r\n                <div *ngSwitchCase=\"FormFieldType.Checkbox\" layout-margin appearance=\"outline\" class=\"pad-bottom-xs\">\r\n                    <mat-checkbox [formControlName]=\"field.name\" [disableControl]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">{{field.header}}</mat-checkbox>\r\n                </div>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region Editor -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.Editor\">\r\n                    <ng-template *ngIf=\"editorTemplate?.templateRef\" [ngTemplateOutlet]=\"editorTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region Code -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.Code\">\r\n                    <ng-template *ngIf=\"codeTemplate?.templateRef\" [ngTemplateOutlet]=\"codeTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region File -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.File\">\r\n                    <ng-template *ngIf=\"fileTemplate?.templateRef\" [ngTemplateOutlet]=\"fileTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region Custom -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.Custom\">\r\n                    <ng-template *ngIf=\"customTemplate?.templateRef\" [ngTemplateOutlet]=\"customTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n            </ng-container>\r\n        </ng-container>\r\n    </div>\r\n    <!-- #endregion -->\r\n</div>", styles: [""], components: [{ type: i1.MatFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }, { type: i2.VdSelectComponent, selector: "vd-select", inputs: ["multiple", "disabled", "sorted", "textPrefix", "endpoint", "params", "projection", "enum", "key", "text", "prefix", "options", "filteredOptions", "filterable", "cache", "sortBy", "mapper", "compareWith", "searchField"], outputs: ["change", "itemChange", "selected", "itemSelected", "launch"] }, { type: i3.MatChipList, selector: "mat-chip-list", inputs: ["errorStateMatcher", "multiple", "compareWith", "value", "required", "placeholder", "disabled", "aria-orientation", "selectable", "tabIndex"], outputs: ["change", "valueChange"], exportAs: ["matChipList"] }, { type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { type: i5.MatAutocomplete, selector: "mat-autocomplete", inputs: ["disableRipple"], exportAs: ["matAutocomplete"] }, { type: i6.MatOption, selector: "mat-option", exportAs: ["matOption"] }, { type: i7.VdChipsComponent, selector: "vd-chips", inputs: ["chips", "endpoint", "params", "projection", "path", "context", "key", "searchField", "searchFields", "termMinlength", "limit", "removable", "debounce", "autocompleteCssClass", "suffixButtons", "default"], outputs: ["initSelect", "selected", "cleared", "launch", "chipFocus"] }, { type: i8.MatSelect, selector: "mat-select", inputs: ["disabled", "disableRipple", "tabIndex"], exportAs: ["matSelect"] }, { type: i9.MatDatepickerToggle, selector: "mat-datepicker-toggle", inputs: ["for", "tabIndex", "aria-label", "disabled", "disableRipple"], exportAs: ["matDatepickerToggle"] }, { type: i9.MatDatepicker, selector: "mat-datepicker", exportAs: ["matDatepicker"] }, { type: i10.MatCheckbox, selector: "mat-checkbox", inputs: ["disableRipple", "color", "tabIndex", "aria-label", "aria-labelledby", "aria-describedby", "id", "required", "labelPosition", "name", "value", "checked", "disabled", "indeterminate"], outputs: ["change", "indeterminateChange"], exportAs: ["matCheckbox"] }], directives: [{ type: i11.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i12.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i12.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i11.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i11.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { type: i11.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { type: i13.MatFormFieldReadonlyDirective, selector: "mat-form-field" }, { type: i1.MatLabel, selector: "mat-label" }, { type: i14.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { type: i12.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: i12.MinLengthValidator, selector: "[minlength][formControlName],[minlength][formControl],[minlength][ngModel]", inputs: ["minlength"] }, { type: i12.MaxLengthValidator, selector: "[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]", inputs: ["maxlength"] }, { type: i12.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i12.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { type: i1.MatHint, selector: "mat-hint", inputs: ["align", "id"] }, { type: i1.MatError, selector: "mat-error", inputs: ["id"] }, { type: i11.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i15.VdSelectTriggerDirective, selector: "[vd-select-trigger]ng-template" }, { type: i16.VdSelectOptionDirective, selector: "[vd-select-option]ng-template" }, { type: i17.DisableControlDirective, selector: "[disableControl]", inputs: ["disableControl"] }, { type: i3.MatChip, selector: "mat-basic-chip, [mat-basic-chip], mat-chip, [mat-chip]", inputs: ["color", "disableRipple", "tabIndex", "selected", "value", "selectable", "disabled", "removable"], outputs: ["selectionChange", "destroyed", "removed"], exportAs: ["matChip"] }, { type: i3.MatChipRemove, selector: "[matChipRemove]" }, { type: i3.MatChipInput, selector: "input[matChipInputFor]", inputs: ["matChipInputFor", "matChipInputAddOnBlur", "matChipInputSeparatorKeyCodes", "placeholder", "id", "disabled"], outputs: ["matChipInputTokenEnd"], exportAs: ["matChipInput", "matChipInputFor"] }, { type: i5.MatAutocompleteTrigger, selector: "input[matAutocomplete], textarea[matAutocomplete]", exportAs: ["matAutocompleteTrigger"] }, { type: i7.VdChipDirective, selector: "[vd-chip]ng-template" }, { type: i7.VdAutocompleteOptionDirective, selector: "[vd-autocomplete-option]ng-template" }, { type: i9.MatDatepickerInput, selector: "input[matDatepicker]", inputs: ["matDatepicker", "min", "max", "matDatepickerFilter"], exportAs: ["matDatepickerInput"] }, { type: i1.MatSuffix, selector: "[matSuffix]" }] });
+/** @nocollapse */ /** @nocollapse */ VdGenericFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.0", type: VdGenericFormComponent, selector: "vd-generic-form", inputs: { formGroup: "formGroup", fieldGroups: "fieldGroups", groupName: "groupName", context: "context", separatorKeysCodes: "separatorKeysCodes" }, queries: [{ propertyName: "editorTemplate", first: true, predicate: VdEditorDirective, descendants: true }, { propertyName: "codeTemplate", first: true, predicate: VdCodeDirective, descendants: true }, { propertyName: "fileTemplate", first: true, predicate: VdFileDirective, descendants: true }, { propertyName: "customTemplate", first: true, predicate: VdCustomDirective, descendants: true }], ngImport: i0, template: "<div *ngIf=\"formGroup && fieldRows\" [formGroup]=\"formGroup\">\r\n    <!-- #region Fields -->\r\n    <div layout-gt-sm=\"row\" layout=\"column\" *ngFor=\"let fields of fieldRows\">\r\n        <ng-container *ngFor=\"let field of fields\" [ngSwitch]=\"field.type\">\r\n            <!-- #region Error handling -->\r\n            <ng-template #fieldErrors>\r\n                <div *ngFor=\"let errorMessage of formGroup.controls[field.name]['errorMessages']\">{{errorMessage}}</div>\r\n            </ng-template>\r\n            <!-- #endregion -->\r\n\r\n            <ng-container *ngIf=\"!field.hide || !field.hide(formGroup?.value, formGroup, context)\">\r\n                <ng-container *ngIf=\"field.wrapped\">\r\n                    <!-- #region Text input -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Text\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <input [type]=\"field.inputType\" [minlength]=\"field.minLength||null\" [maxlength]=\"field.maxLength||null\" matInput [formControlName]=\"field.name\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Textarea -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.TextArea\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <textarea matInput [formControlName]=\"field.name\" rows=\"field.rows||2\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\"></textarea>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Enum -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Enum\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <vd-select [formControlName]=\"field.name\" [enum]=\"field.enumType\" [key]=\"field.optionValue\" [text]=\"field.optionText\" [multiple]=\"field.multiple\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\" flex>\r\n                            <ng-template vd-select-trigger let-trigger=\"trigger\" *ngIf=\"field.triggerTemplate\">\r\n                                <div [innerHTML]=\"field.triggerTemplate(trigger)\"></div>\r\n                            </ng-template>\r\n                            <ng-template vd-select-option let-option=\"option\" *ngIf=\"field.optionTemplate\">\r\n                                <div [outerHTML]=\"field.optionTemplate(option)\"></div>\r\n                            </ng-template>\r\n                        </vd-select>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region VdSelect -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.VdSelect\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <vd-select [formControlName]=\"field.name\" [endpoint]=\"isFunction(field.endpoint)?field.endpoint(formGroup.value, formGroup, context):field.endpoint\" [params]=\"isFunction(field.params)?field.params(formGroup.value, formGroup, context):(field.params||{})\" [projection]=\"field.projection\" [mapper]=\"field.mapper\" [compareWith]=\"field.compareWith\" [key]=\"field.optionValue\" [text]=\"field.optionText\" [multiple]=\"field.multiple\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\" (itemSelected)=\"field.itemSelect && field.itemSelect($event, formGroup?.value, formGroup, context);\" (itemChange)=\"field.itemChange && field.itemChange($event, formGroup?.value, formGroup, context);\" flex>\r\n                            <ng-template vd-select-trigger let-trigger=\"trigger\" *ngIf=\"field.triggerTemplate\">\r\n                                <div [innerHTML]=\"field.triggerTemplate(trigger)\"></div>\r\n                            </ng-template>\r\n                            <ng-template vd-select-option let-option=\"option\" *ngIf=\"field.optionTemplate\">\r\n                                <div [outerHTML]=\"field.optionTemplate(option)\"></div>\r\n                            </ng-template>\r\n                        </vd-select>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Chips -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Chips\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <mat-chip-list #chipList [formControlName]=\"field.name\" [disableControl]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                            <mat-chip *ngFor=\"let chip of formGroup.controls[field.name]?.value\" (removed)=\"removeChip(field, chip)\" color=\"primary\" selectable=\"true\" selected>\r\n                                <span>{{chip}}</span>\r\n                                <button matChipRemove>\r\n                                    <mat-icon>cancel</mat-icon>\r\n                                </button>\r\n                            </mat-chip>\r\n                            <input [placeholder]=\"field.header\" #chipInput [matChipInputFor]=\"chipList\" [matChipInputSeparatorKeyCodes]=\"separatorKeysCodes\" [matAutocomplete]=\"chipAutocomplete\" (input)=\"filterAutocomplete(field, chipInput)\" (matChipInputTokenEnd)=\"addChip(field, $event)\" autocomplete=\"off\">\r\n                        </mat-chip-list>\r\n                        <mat-autocomplete autoActiveFirstOption #chipAutocomplete=\"matAutocomplete\" [class]=\"field.autocompleteCssClass\" (optionSelected)=\"autocompleteValueSelected(field, $event, chipInput)\">\r\n                            <mat-option *ngFor=\"let option of autocompleteFilteredOptions[field.name]\" [value]=\"option.id\">\r\n                                {{option.name}}\r\n                            </mat-option>\r\n                        </mat-autocomplete>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region VdChips -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.VdChips\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <vd-chips #vdChip [formControlName]=\"field.name\" [endpoint]=\"isFunction(field.endpoint)?field.endpoint(formGroup.value, formGroup, context):field.endpoint\" [params]=\"isFunction(field.params)?field.params(formGroup.value, formGroup, context):(field.params||{})\" [searchField]=\"field.searchField\" [projection]=\"field.projection\" [key]=\"field.optionValue\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\" [removable]=\"!field.clear\" [context]=\"context\" [suffixButtons]=\"field.suffixButtons\" [autocompleteCssClass]=\"field.autocompleteCssClass\" (initSelect)=\"field.itemSelect && field.itemSelect($event, formGroup?.value, formGroup, context);\" (selected)=\"field.itemChange && field.itemChange($event, formGroup?.value, formGroup, context);\" (cleared)=\"field.clear && field.clear(formGroup?.value, formGroup, context);\" flex>\r\n                            <ng-template vd-chip let-chip=\"chip\" *ngIf=\"field.chipTemplate\">\r\n                                <div [outerHTML]=\"field.chipTemplate(chip)\"></div>\r\n                            </ng-template>\r\n                            <ng-template vd-autocomplete-option let-option=\"option\" *ngIf=\"field.autocompleteTemplate\">\r\n                                <div [outerHTML]=\"field.autocompleteTemplate(option)\"></div>\r\n                            </ng-template>\r\n                        </vd-chips>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-hint *ngIf=\"vdChip.emptyResult\" class=\"tc-red-400\" i18n=\"@@noResultsFound\">No results were found.</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Select -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Select\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <mat-select [formControlName]=\"field.name\" [multiple]=\"field.multiple\" flex>\r\n                            <mat-option *ngFor=\"let option of field.options\" [value]=\"option.id\">{{option.name}}</mat-option>\r\n                        </mat-select>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Autocomplete -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Autocomplete\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <input type=\"text\" matInput [formControlName]=\"field.name\" [matAutocomplete]=\"auto\" #autocompleteInput (input)=\"filterAutocomplete(field, autocompleteInput)\" autocomplete=\"off\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                        <mat-autocomplete autoActiveFirstOption #auto=\"matAutocomplete\" [class]=\"field.autocompleteCssClass\">\r\n                            <mat-option *ngFor=\"let option of autocompleteFilteredOptions[field.name]\" [value]=\"option.id\">\r\n                                {{option.name}}\r\n                            </mat-option>\r\n                        </mat-autocomplete>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Date -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Date\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <input matInput [formControlName]=\"field.name\" autocomplete=\"off\" [matDatepicker]=\"datePicker\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                        <mat-datepicker-toggle matSuffix [for]=\"datePicker\"></mat-datepicker-toggle>\r\n                        <mat-datepicker #datePicker></mat-datepicker>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n                </ng-container>\r\n\r\n                <!-- #region Checkbox -->\r\n                <div *ngSwitchCase=\"FormFieldType.Checkbox\" layout-margin appearance=\"outline\" class=\"pad-bottom-xs\">\r\n                    <mat-checkbox [formControlName]=\"field.name\" [disableControl]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">{{field.header}}</mat-checkbox>\r\n                </div>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region Editor -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.Editor\">\r\n                    <ng-template *ngIf=\"editorTemplate?.templateRef\" [ngTemplateOutlet]=\"editorTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region Code -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.Code\">\r\n                    <ng-template *ngIf=\"codeTemplate?.templateRef\" [ngTemplateOutlet]=\"codeTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region File -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.File\">\r\n                    <ng-template *ngIf=\"fileTemplate?.templateRef\" [ngTemplateOutlet]=\"fileTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region Custom -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.Custom\">\r\n                    <ng-template *ngIf=\"customTemplate?.templateRef\" [ngTemplateOutlet]=\"customTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n            </ng-container>\r\n        </ng-container>\r\n    </div>\r\n    <!-- #endregion -->\r\n</div>", styles: [""], components: [{ type: i1.MatFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }, { type: i2.VdSelectComponent, selector: "vd-select", inputs: ["multiple", "disabled", "sorted", "textPrefix", "endpoint", "params", "projection", "enum", "key", "text", "prefix", "options", "filteredOptions", "filterable", "cache", "sortBy", "mapper", "compareWith", "searchField"], outputs: ["change", "itemChange", "selected", "itemSelected", "launch"] }, { type: i3.MatChipList, selector: "mat-chip-list", inputs: ["errorStateMatcher", "multiple", "compareWith", "value", "required", "placeholder", "disabled", "aria-orientation", "selectable", "tabIndex"], outputs: ["change", "valueChange"], exportAs: ["matChipList"] }, { type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { type: i5.MatAutocomplete, selector: "mat-autocomplete", inputs: ["disableRipple"], exportAs: ["matAutocomplete"] }, { type: i6.MatOption, selector: "mat-option", exportAs: ["matOption"] }, { type: i7.VdChipsComponent, selector: "vd-chips", inputs: ["chips", "endpoint", "params", "projection", "path", "context", "key", "searchField", "searchFields", "termMinlength", "limit", "removable", "debounce", "autocompleteCssClass", "suffixButtons", "default"], outputs: ["initSelect", "selected", "cleared", "launch", "chipFocus"] }, { type: i8.MatSelect, selector: "mat-select", inputs: ["disabled", "disableRipple", "tabIndex"], exportAs: ["matSelect"] }, { type: i9.MatDatepickerToggle, selector: "mat-datepicker-toggle", inputs: ["for", "tabIndex", "aria-label", "disabled", "disableRipple"], exportAs: ["matDatepickerToggle"] }, { type: i9.MatDatepicker, selector: "mat-datepicker", exportAs: ["matDatepicker"] }, { type: i10.MatCheckbox, selector: "mat-checkbox", inputs: ["disableRipple", "color", "tabIndex", "aria-label", "aria-labelledby", "aria-describedby", "id", "required", "labelPosition", "name", "value", "checked", "disabled", "indeterminate"], outputs: ["change", "indeterminateChange"], exportAs: ["matCheckbox"] }], directives: [{ type: i11.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i12.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i12.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i11.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i11.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { type: i11.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { type: i13.MatFormFieldReadonlyDirective, selector: "mat-form-field" }, { type: i1.MatLabel, selector: "mat-label" }, { type: i14.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { type: i12.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: i12.MinLengthValidator, selector: "[minlength][formControlName],[minlength][formControl],[minlength][ngModel]", inputs: ["minlength"] }, { type: i12.MaxLengthValidator, selector: "[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]", inputs: ["maxlength"] }, { type: i12.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i12.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { type: i1.MatHint, selector: "mat-hint", inputs: ["align", "id"] }, { type: i1.MatError, selector: "mat-error", inputs: ["id"] }, { type: i11.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i15.VdSelectTriggerDirective, selector: "[vd-select-trigger]ng-template" }, { type: i16.VdSelectOptionDirective, selector: "[vd-select-option]ng-template" }, { type: i17.DisableControlDirective, selector: "[disableControl]", inputs: ["disableControl"] }, { type: i3.MatChip, selector: "mat-basic-chip, [mat-basic-chip], mat-chip, [mat-chip]", inputs: ["color", "disableRipple", "tabIndex", "selected", "value", "selectable", "disabled", "removable"], outputs: ["selectionChange", "destroyed", "removed"], exportAs: ["matChip"] }, { type: i3.MatChipRemove, selector: "[matChipRemove]" }, { type: i3.MatChipInput, selector: "input[matChipInputFor]", inputs: ["matChipInputFor", "matChipInputAddOnBlur", "matChipInputSeparatorKeyCodes", "placeholder", "id", "disabled"], outputs: ["matChipInputTokenEnd"], exportAs: ["matChipInput", "matChipInputFor"] }, { type: i5.MatAutocompleteTrigger, selector: "input[matAutocomplete], textarea[matAutocomplete]", exportAs: ["matAutocompleteTrigger"] }, { type: i7.VdChipDirective, selector: "[vd-chip]ng-template" }, { type: i7.VdAutocompleteOptionDirective, selector: "[vd-autocomplete-option]ng-template" }, { type: i9.MatDatepickerInput, selector: "input[matDatepicker]", inputs: ["matDatepicker", "min", "max", "matDatepickerFilter"], exportAs: ["matDatepickerInput"] }, { type: i1.MatSuffix, selector: "[matSuffix]" }] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: VdGenericFormComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'vd-generic-form', template: "<div *ngIf=\"formGroup && fieldRows\" [formGroup]=\"formGroup\">\r\n    <!-- #region Fields -->\r\n    <div layout-gt-sm=\"row\" layout=\"column\" *ngFor=\"let fields of fieldRows\">\r\n        <ng-container *ngFor=\"let field of fields\" [ngSwitch]=\"field.type\">\r\n            <!-- #region Error handling -->\r\n            <ng-template #fieldErrors>\r\n                <div *ngFor=\"let errorMessage of formGroup.controls[field.name]['errorMessages']\">{{errorMessage}}</div>\r\n            </ng-template>\r\n            <!-- #endregion -->\r\n\r\n            <ng-container *ngIf=\"!field.hide || !field.hide(formGroup?.value, formGroup, context)\">\r\n                <ng-container *ngIf=\"field.wrapped\">\r\n                    <!-- #region Text input -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Text\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <input [type]=\"field.inputType\" [minlength]=\"field.minLength||null\" [maxlength]=\"field.maxLength||null\" matInput [formControlName]=\"field.name\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Textarea -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.TextArea\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <textarea matInput [formControlName]=\"field.name\" rows=\"field.rows||2\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\"></textarea>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Enum -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Enum\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <vd-select [formControlName]=\"field.name\" [enum]=\"field.enumType\" [key]=\"field.optionValue\" [text]=\"field.optionText\" [multiple]=\"field.multiple\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\" flex>\r\n                            <ng-template vd-select-trigger let-trigger=\"trigger\" *ngIf=\"field.triggerTemplate\">\r\n                                <div [innerHTML]=\"field.triggerTemplate(trigger)\"></div>\r\n                            </ng-template>\r\n                            <ng-template vd-select-option let-option=\"option\" *ngIf=\"field.optionTemplate\">\r\n                                <div [outerHTML]=\"field.optionTemplate(option)\"></div>\r\n                            </ng-template>\r\n                        </vd-select>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region VdSelect -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.VdSelect\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <vd-select [formControlName]=\"field.name\" [endpoint]=\"field.endpoint\" [params]=\"field.params?field.params(formGroup.value, formGroup, context):{}\" [projection]=\"field.projection\" [mapper]=\"field.mapper\" [compareWith]=\"field.compareWith\" [key]=\"field.optionValue\" [text]=\"field.optionText\" [multiple]=\"field.multiple\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\" (itemSelected)=\"field.itemSelect && field.itemSelect($event, formGroup?.value, formGroup, context);\" (itemChange)=\"field.itemChange && field.itemChange($event, formGroup?.value, formGroup, context);\" flex>\r\n                            <ng-template vd-select-trigger let-trigger=\"trigger\" *ngIf=\"field.triggerTemplate\">\r\n                                <div [innerHTML]=\"field.triggerTemplate(trigger)\"></div>\r\n                            </ng-template>\r\n                            <ng-template vd-select-option let-option=\"option\" *ngIf=\"field.optionTemplate\">\r\n                                <div [outerHTML]=\"field.optionTemplate(option)\"></div>\r\n                            </ng-template>\r\n                        </vd-select>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Chips -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Chips\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <mat-chip-list #chipList [formControlName]=\"field.name\" [disableControl]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                            <mat-chip *ngFor=\"let chip of formGroup.controls[field.name]?.value\" (removed)=\"removeChip(field, chip)\" color=\"primary\" selectable=\"true\" selected>\r\n                                <span>{{chip}}</span>\r\n                                <button matChipRemove>\r\n                                    <mat-icon>cancel</mat-icon>\r\n                                </button>\r\n                            </mat-chip>\r\n                            <input [placeholder]=\"field.header\" #chipInput [matChipInputFor]=\"chipList\" [matChipInputSeparatorKeyCodes]=\"separatorKeysCodes\" [matAutocomplete]=\"chipAutocomplete\" (input)=\"filterAutocomplete(field, chipInput)\" (matChipInputTokenEnd)=\"addChip(field, $event)\" autocomplete=\"off\">\r\n                        </mat-chip-list>\r\n                        <mat-autocomplete autoActiveFirstOption #chipAutocomplete=\"matAutocomplete\" [class]=\"field.autocompleteCssClass\" (optionSelected)=\"autocompleteValueSelected(field, $event, chipInput)\">\r\n                            <mat-option *ngFor=\"let option of autocompleteFilteredOptions[field.name]\" [value]=\"option.id\">\r\n                                {{option.name}}\r\n                            </mat-option>\r\n                        </mat-autocomplete>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region VdChips -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.VdChips\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <vd-chips #vdChip [formControlName]=\"field.name\" [endpoint]=\"field.endpoint\" [params]=\"field.params?field.params(formGroup?.value, formGroup, context):{}\" [searchField]=\"field.searchField\" [projection]=\"field.projection\" [key]=\"field.optionValue\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\" [removable]=\"!field.clear\" [context]=\"context\" [suffixButtons]=\"field.suffixButtons\" [autocompleteCssClass]=\"field.autocompleteCssClass\" (initSelect)=\"field.itemSelect && field.itemSelect($event, formGroup?.value, formGroup, context);\" (selected)=\"field.itemChange && field.itemChange($event, formGroup?.value, formGroup, context);\" (cleared)=\"field.clear && field.clear(formGroup?.value, formGroup, context);\" flex>\r\n                            <ng-template vd-chip let-chip=\"chip\" *ngIf=\"field.chipTemplate\">\r\n                                <div [outerHTML]=\"field.chipTemplate(chip)\"></div>\r\n                            </ng-template>\r\n                            <ng-template vd-autocomplete-option let-option=\"option\" *ngIf=\"field.autocompleteTemplate\">\r\n                                <div [outerHTML]=\"field.autocompleteTemplate(option)\"></div>\r\n                            </ng-template>\r\n                        </vd-chips>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-hint *ngIf=\"vdChip.emptyResult\" class=\"tc-red-400\" i18n=\"@@noResultsFound\">No results were found.</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Select -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Select\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <mat-select [formControlName]=\"field.name\" [multiple]=\"field.multiple\" flex>\r\n                            <mat-option *ngFor=\"let option of field.options\" [value]=\"option.id\">{{option.name}}</mat-option>\r\n                        </mat-select>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Autocomplete -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Autocomplete\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <input type=\"text\" matInput [formControlName]=\"field.name\" [matAutocomplete]=\"auto\" #autocompleteInput (input)=\"filterAutocomplete(field, autocompleteInput)\" autocomplete=\"off\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                        <mat-autocomplete autoActiveFirstOption #auto=\"matAutocomplete\" [class]=\"field.autocompleteCssClass\">\r\n                            <mat-option *ngFor=\"let option of autocompleteFilteredOptions[field.name]\" [value]=\"option.id\">\r\n                                {{option.name}}\r\n                            </mat-option>\r\n                        </mat-autocomplete>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Date -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Date\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <input matInput [formControlName]=\"field.name\" autocomplete=\"off\" [matDatepicker]=\"datePicker\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                        <mat-datepicker-toggle matSuffix [for]=\"datePicker\"></mat-datepicker-toggle>\r\n                        <mat-datepicker #datePicker></mat-datepicker>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n                </ng-container>\r\n\r\n                <!-- #region Checkbox -->\r\n                <div *ngSwitchCase=\"FormFieldType.Checkbox\" layout-margin appearance=\"outline\" class=\"pad-bottom-xs\">\r\n                    <mat-checkbox [formControlName]=\"field.name\" [disableControl]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">{{field.header}}</mat-checkbox>\r\n                </div>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region Editor -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.Editor\">\r\n                    <ng-template *ngIf=\"editorTemplate?.templateRef\" [ngTemplateOutlet]=\"editorTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region Code -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.Code\">\r\n                    <ng-template *ngIf=\"codeTemplate?.templateRef\" [ngTemplateOutlet]=\"codeTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region File -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.File\">\r\n                    <ng-template *ngIf=\"fileTemplate?.templateRef\" [ngTemplateOutlet]=\"fileTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region Custom -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.Custom\">\r\n                    <ng-template *ngIf=\"customTemplate?.templateRef\" [ngTemplateOutlet]=\"customTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n            </ng-container>\r\n        </ng-container>\r\n    </div>\r\n    <!-- #endregion -->\r\n</div>", styles: [""] }]
+            args: [{ selector: 'vd-generic-form', template: "<div *ngIf=\"formGroup && fieldRows\" [formGroup]=\"formGroup\">\r\n    <!-- #region Fields -->\r\n    <div layout-gt-sm=\"row\" layout=\"column\" *ngFor=\"let fields of fieldRows\">\r\n        <ng-container *ngFor=\"let field of fields\" [ngSwitch]=\"field.type\">\r\n            <!-- #region Error handling -->\r\n            <ng-template #fieldErrors>\r\n                <div *ngFor=\"let errorMessage of formGroup.controls[field.name]['errorMessages']\">{{errorMessage}}</div>\r\n            </ng-template>\r\n            <!-- #endregion -->\r\n\r\n            <ng-container *ngIf=\"!field.hide || !field.hide(formGroup?.value, formGroup, context)\">\r\n                <ng-container *ngIf=\"field.wrapped\">\r\n                    <!-- #region Text input -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Text\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <input [type]=\"field.inputType\" [minlength]=\"field.minLength||null\" [maxlength]=\"field.maxLength||null\" matInput [formControlName]=\"field.name\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Textarea -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.TextArea\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <textarea matInput [formControlName]=\"field.name\" rows=\"field.rows||2\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\"></textarea>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Enum -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Enum\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <vd-select [formControlName]=\"field.name\" [enum]=\"field.enumType\" [key]=\"field.optionValue\" [text]=\"field.optionText\" [multiple]=\"field.multiple\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\" flex>\r\n                            <ng-template vd-select-trigger let-trigger=\"trigger\" *ngIf=\"field.triggerTemplate\">\r\n                                <div [innerHTML]=\"field.triggerTemplate(trigger)\"></div>\r\n                            </ng-template>\r\n                            <ng-template vd-select-option let-option=\"option\" *ngIf=\"field.optionTemplate\">\r\n                                <div [outerHTML]=\"field.optionTemplate(option)\"></div>\r\n                            </ng-template>\r\n                        </vd-select>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region VdSelect -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.VdSelect\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <vd-select [formControlName]=\"field.name\" [endpoint]=\"isFunction(field.endpoint)?field.endpoint(formGroup.value, formGroup, context):field.endpoint\" [params]=\"isFunction(field.params)?field.params(formGroup.value, formGroup, context):(field.params||{})\" [projection]=\"field.projection\" [mapper]=\"field.mapper\" [compareWith]=\"field.compareWith\" [key]=\"field.optionValue\" [text]=\"field.optionText\" [multiple]=\"field.multiple\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\" (itemSelected)=\"field.itemSelect && field.itemSelect($event, formGroup?.value, formGroup, context);\" (itemChange)=\"field.itemChange && field.itemChange($event, formGroup?.value, formGroup, context);\" flex>\r\n                            <ng-template vd-select-trigger let-trigger=\"trigger\" *ngIf=\"field.triggerTemplate\">\r\n                                <div [innerHTML]=\"field.triggerTemplate(trigger)\"></div>\r\n                            </ng-template>\r\n                            <ng-template vd-select-option let-option=\"option\" *ngIf=\"field.optionTemplate\">\r\n                                <div [outerHTML]=\"field.optionTemplate(option)\"></div>\r\n                            </ng-template>\r\n                        </vd-select>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Chips -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Chips\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <mat-chip-list #chipList [formControlName]=\"field.name\" [disableControl]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                            <mat-chip *ngFor=\"let chip of formGroup.controls[field.name]?.value\" (removed)=\"removeChip(field, chip)\" color=\"primary\" selectable=\"true\" selected>\r\n                                <span>{{chip}}</span>\r\n                                <button matChipRemove>\r\n                                    <mat-icon>cancel</mat-icon>\r\n                                </button>\r\n                            </mat-chip>\r\n                            <input [placeholder]=\"field.header\" #chipInput [matChipInputFor]=\"chipList\" [matChipInputSeparatorKeyCodes]=\"separatorKeysCodes\" [matAutocomplete]=\"chipAutocomplete\" (input)=\"filterAutocomplete(field, chipInput)\" (matChipInputTokenEnd)=\"addChip(field, $event)\" autocomplete=\"off\">\r\n                        </mat-chip-list>\r\n                        <mat-autocomplete autoActiveFirstOption #chipAutocomplete=\"matAutocomplete\" [class]=\"field.autocompleteCssClass\" (optionSelected)=\"autocompleteValueSelected(field, $event, chipInput)\">\r\n                            <mat-option *ngFor=\"let option of autocompleteFilteredOptions[field.name]\" [value]=\"option.id\">\r\n                                {{option.name}}\r\n                            </mat-option>\r\n                        </mat-autocomplete>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region VdChips -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.VdChips\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <vd-chips #vdChip [formControlName]=\"field.name\" [endpoint]=\"isFunction(field.endpoint)?field.endpoint(formGroup.value, formGroup, context):field.endpoint\" [params]=\"isFunction(field.params)?field.params(formGroup.value, formGroup, context):(field.params||{})\" [searchField]=\"field.searchField\" [projection]=\"field.projection\" [key]=\"field.optionValue\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\" [removable]=\"!field.clear\" [context]=\"context\" [suffixButtons]=\"field.suffixButtons\" [autocompleteCssClass]=\"field.autocompleteCssClass\" (initSelect)=\"field.itemSelect && field.itemSelect($event, formGroup?.value, formGroup, context);\" (selected)=\"field.itemChange && field.itemChange($event, formGroup?.value, formGroup, context);\" (cleared)=\"field.clear && field.clear(formGroup?.value, formGroup, context);\" flex>\r\n                            <ng-template vd-chip let-chip=\"chip\" *ngIf=\"field.chipTemplate\">\r\n                                <div [outerHTML]=\"field.chipTemplate(chip)\"></div>\r\n                            </ng-template>\r\n                            <ng-template vd-autocomplete-option let-option=\"option\" *ngIf=\"field.autocompleteTemplate\">\r\n                                <div [outerHTML]=\"field.autocompleteTemplate(option)\"></div>\r\n                            </ng-template>\r\n                        </vd-chips>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-hint *ngIf=\"vdChip.emptyResult\" class=\"tc-red-400\" i18n=\"@@noResultsFound\">No results were found.</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Select -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Select\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <mat-select [formControlName]=\"field.name\" [multiple]=\"field.multiple\" flex>\r\n                            <mat-option *ngFor=\"let option of field.options\" [value]=\"option.id\">{{option.name}}</mat-option>\r\n                        </mat-select>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Autocomplete -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Autocomplete\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <input type=\"text\" matInput [formControlName]=\"field.name\" [matAutocomplete]=\"auto\" #autocompleteInput (input)=\"filterAutocomplete(field, autocompleteInput)\" autocomplete=\"off\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                        <mat-autocomplete autoActiveFirstOption #auto=\"matAutocomplete\" [class]=\"field.autocompleteCssClass\">\r\n                            <mat-option *ngFor=\"let option of autocompleteFilteredOptions[field.name]\" [value]=\"option.id\">\r\n                                {{option.name}}\r\n                            </mat-option>\r\n                        </mat-autocomplete>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Date -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Date\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <input matInput [formControlName]=\"field.name\" autocomplete=\"off\" [matDatepicker]=\"datePicker\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                        <mat-datepicker-toggle matSuffix [for]=\"datePicker\"></mat-datepicker-toggle>\r\n                        <mat-datepicker #datePicker></mat-datepicker>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n                </ng-container>\r\n\r\n                <!-- #region Checkbox -->\r\n                <div *ngSwitchCase=\"FormFieldType.Checkbox\" layout-margin appearance=\"outline\" class=\"pad-bottom-xs\">\r\n                    <mat-checkbox [formControlName]=\"field.name\" [disableControl]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">{{field.header}}</mat-checkbox>\r\n                </div>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region Editor -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.Editor\">\r\n                    <ng-template *ngIf=\"editorTemplate?.templateRef\" [ngTemplateOutlet]=\"editorTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region Code -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.Code\">\r\n                    <ng-template *ngIf=\"codeTemplate?.templateRef\" [ngTemplateOutlet]=\"codeTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region File -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.File\">\r\n                    <ng-template *ngIf=\"fileTemplate?.templateRef\" [ngTemplateOutlet]=\"fileTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region Custom -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.Custom\">\r\n                    <ng-template *ngIf=\"customTemplate?.templateRef\" [ngTemplateOutlet]=\"customTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n            </ng-container>\r\n        </ng-container>\r\n    </div>\r\n    <!-- #endregion -->\r\n</div>", styles: [""] }]
         }], propDecorators: { formGroup: [{
                 type: Input
             }], fieldGroups: [{
@@ -211,4 +219,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImpor
                 type: ContentChild,
                 args: [VdCustomDirective]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generic-form.component.js","sourceRoot":"","sources":["../../../../../../../projects/cdk/src/lib/forms/components/generic-form/generic-form.component.ts","../../../../../../../projects/cdk/src/lib/forms/components/generic-form/generic-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import { COMMA, ENTER } from '@angular/cdk/keycodes';\r\nimport { CdkPortal } from '@angular/cdk/portal';\r\nimport { Component, ContentChild, Directive, Input, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';\r\nimport { FormGroup } from '@angular/forms';\r\nimport { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';\r\nimport { MatChipInputEvent } from '@angular/material/chips';\r\nimport { FormFieldType } from '../../enums/form-field-type';\r\nimport { FormFieldDefinition } from '../../models/form-field-definition';\r\nimport { FormFieldGroupDefinition } from '../../models/form-field-group-definition';\r\n\r\n/**\r\n * VdEditorDirective class\r\n */\r\n@Directive({ selector: '[vd-editor]ng-template' })\r\nexport class VdEditorDirective extends CdkPortal {\r\n    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef) {\r\n        super(templateRef, viewContainerRef);\r\n    }\r\n}\r\n\r\n/**\r\n * VdCodeDirective class\r\n */\r\n@Directive({ selector: '[vd-code]ng-template' })\r\nexport class VdCodeDirective extends CdkPortal {\r\n    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef) {\r\n        super(templateRef, viewContainerRef);\r\n    }\r\n}\r\n\r\n/**\r\n * VdFileDirective class\r\n */\r\n@Directive({ selector: '[vd-file]ng-template' })\r\nexport class VdFileDirective extends CdkPortal {\r\n    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef) {\r\n        super(templateRef, viewContainerRef);\r\n    }\r\n}\r\n\r\n/**\r\n * VdCustomDirective class\r\n */\r\n@Directive({ selector: '[vd-custom]ng-template' })\r\nexport class VdCustomDirective extends CdkPortal {\r\n    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef) {\r\n        super(templateRef, viewContainerRef);\r\n    }\r\n}\r\n\r\n@Component({\r\n    selector: 'vd-generic-form',\r\n    templateUrl: './generic-form.component.html',\r\n    styleUrls: ['./generic-form.component.scss']\r\n})\r\nexport class VdGenericFormComponent implements OnInit {\r\n    /**\r\n     * form: FormGroup\r\n     */\r\n    @Input()\r\n    public formGroup: FormGroup;\r\n\r\n    /**\r\n     * fieldGroups: FormFieldGroup[]\r\n     */\r\n    @Input()\r\n    public fieldGroups: FormFieldGroupDefinition[];\r\n\r\n    /**\r\n     * Group name\r\n     */\r\n    @Input()\r\n    public groupName: string;\r\n\r\n    /**\r\n     * context: any\r\n     * The current context\r\n     */\r\n    @Input()\r\n    public context: any;\r\n\r\n    /**\r\n     * separatorKeysCodes: number[]\r\n     */\r\n    @Input()\r\n    public separatorKeysCodes: number[] = [ENTER, COMMA];\r\n\r\n    /**\r\n     * fieldRows: FormFieldDefinition[]\r\n     */\r\n    public fieldRows: [FormFieldDefinition[]];\r\n\r\n    /**\r\n     * FormFieldType: typeof FormFieldType\r\n     */\r\n    public FormFieldType: typeof FormFieldType = FormFieldType;\r\n\r\n    /**\r\n     * Editor template\r\n     */\r\n    @ContentChild(VdEditorDirective)\r\n    public editorTemplate: VdEditorDirective;\r\n\r\n    /**\r\n     * Code template\r\n     */\r\n    @ContentChild(VdCodeDirective)\r\n    public codeTemplate: VdCodeDirective;\r\n\r\n    /**\r\n     * File template\r\n     */\r\n    @ContentChild(VdFileDirective)\r\n    public fileTemplate: VdFileDirective;\r\n\r\n    /**\r\n     * Custom template\r\n     */\r\n    @ContentChild(VdCustomDirective)\r\n    public customTemplate: VdCustomDirective;\r\n\r\n    /**\r\n     * Filterd options for autocomplete\r\n     */\r\n    public autocompleteFilteredOptions: {} = {};\r\n\r\n    /**\r\n     * A callback method that is invoked immediately after the\r\n     * default change detector has checked the directive's\r\n     * data-bound properties for the first time,\r\n     * and before any of the view or content children have been checked.\r\n     * It is invoked only once when the directive is instantiated.\r\n     */\r\n    ngOnInit(): void {\r\n        this.fieldRows = this.fieldGroups?.filter(x => x.name?.trim() == this.groupName?.trim())[0]?.groups;\r\n\r\n        /* Subscrie to change event */\r\n        this.fieldRows?.reduce((a, b) => a.concat(b), [])?.filter(y => y.change)?.forEach(x => {\r\n            this.formGroup.get(x.name)?.valueChanges?.subscribe(y => x.change(y, this.formGroup));\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Handles autocomplete event\r\n     * @param field \r\n     * @param event \r\n     */\r\n    public filterAutocomplete(field: FormFieldDefinition, event: any): void {\r\n        this.autocompleteFilteredOptions[field.name] = field.options?.filter(option => option.name.toLowerCase().includes(event.value?.toString()?.toLowerCase()));\r\n    }\r\n\r\n    /**\r\n     * Adds a chip when a autocomplete value is selected\r\n     * @param field \r\n     * @param event \r\n     */\r\n    public autocompleteValueSelected(field: FormFieldDefinition, event: MatAutocompleteSelectedEvent, chipInputEvent: any): void {\r\n        this._addChip(field, event.option.viewValue);\r\n        chipInputEvent.value = '';\r\n    }\r\n\r\n    /**\r\n     * Adds a chip\r\n     * @param field \r\n     * @param event \r\n     */\r\n    public addChip(field: FormFieldDefinition, event: MatChipInputEvent): void {\r\n        this._addChip(field, event.value);\r\n        event.chipInput!.clear();\r\n    }\r\n\r\n    /**\r\n     * Removes a chip\r\n     * @param field \r\n     * @param chip \r\n     */\r\n    public removeChip(field: FormFieldDefinition, chip: any): void {\r\n        /* Get the form control using the field name */\r\n        let control = this.formGroup?.controls[field.name];\r\n\r\n        /* Get the index of the chip */\r\n        const index = control.value.indexOf(chip);\r\n        if (index >= 0) {\r\n            control.value.splice(index, 1);\r\n            control.updateValueAndValidity();\r\n            this.formGroup.markAsDirty();\r\n            this.formGroup.updateValueAndValidity();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Adds a chip\r\n     * @param field \r\n     * @param value \r\n     */\r\n    private _addChip(field: FormFieldDefinition, value: string): void {\r\n        /* Get the form control using the field name */\r\n        let control = this.formGroup?.controls[field.name];\r\n\r\n        /* Get the value of the chip */\r\n        value = (value || '').trim();\r\n        if (control && value) {\r\n            switch (field.inputType) {\r\n                case 'number':\r\n                    let number = parseInt(value);\r\n                    if (number) {\r\n                        control.value.push(number);\r\n                    }\r\n                    break;\r\n\r\n                case 'float':\r\n                    let float = parseFloat(value);\r\n                    if (float) {\r\n                        control.value.push(float);\r\n                    }\r\n                    break;\r\n\r\n                default:\r\n                    control.value.push(value);\r\n                    break;\r\n            }\r\n\r\n            control.updateValueAndValidity();\r\n            this.formGroup.markAsDirty();\r\n            this.formGroup.updateValueAndValidity();\r\n        }\r\n    }\r\n}","<div *ngIf=\"formGroup && fieldRows\" [formGroup]=\"formGroup\">\r\n    <!-- #region Fields -->\r\n    <div layout-gt-sm=\"row\" layout=\"column\" *ngFor=\"let fields of fieldRows\">\r\n        <ng-container *ngFor=\"let field of fields\" [ngSwitch]=\"field.type\">\r\n            <!-- #region Error handling -->\r\n            <ng-template #fieldErrors>\r\n                <div *ngFor=\"let errorMessage of formGroup.controls[field.name]['errorMessages']\">{{errorMessage}}</div>\r\n            </ng-template>\r\n            <!-- #endregion -->\r\n\r\n            <ng-container *ngIf=\"!field.hide || !field.hide(formGroup?.value, formGroup, context)\">\r\n                <ng-container *ngIf=\"field.wrapped\">\r\n                    <!-- #region Text input -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Text\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <input [type]=\"field.inputType\" [minlength]=\"field.minLength||null\" [maxlength]=\"field.maxLength||null\" matInput [formControlName]=\"field.name\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Textarea -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.TextArea\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <textarea matInput [formControlName]=\"field.name\" rows=\"field.rows||2\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\"></textarea>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Enum -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Enum\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <vd-select [formControlName]=\"field.name\" [enum]=\"field.enumType\" [key]=\"field.optionValue\" [text]=\"field.optionText\" [multiple]=\"field.multiple\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\" flex>\r\n                            <ng-template vd-select-trigger let-trigger=\"trigger\" *ngIf=\"field.triggerTemplate\">\r\n                                <div [innerHTML]=\"field.triggerTemplate(trigger)\"></div>\r\n                            </ng-template>\r\n                            <ng-template vd-select-option let-option=\"option\" *ngIf=\"field.optionTemplate\">\r\n                                <div [outerHTML]=\"field.optionTemplate(option)\"></div>\r\n                            </ng-template>\r\n                        </vd-select>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region VdSelect -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.VdSelect\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <vd-select [formControlName]=\"field.name\" [endpoint]=\"field.endpoint\" [params]=\"field.params?field.params(formGroup.value, formGroup, context):{}\" [projection]=\"field.projection\" [mapper]=\"field.mapper\" [compareWith]=\"field.compareWith\" [key]=\"field.optionValue\" [text]=\"field.optionText\" [multiple]=\"field.multiple\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\" (itemSelected)=\"field.itemSelect && field.itemSelect($event, formGroup?.value, formGroup, context);\" (itemChange)=\"field.itemChange && field.itemChange($event, formGroup?.value, formGroup, context);\" flex>\r\n                            <ng-template vd-select-trigger let-trigger=\"trigger\" *ngIf=\"field.triggerTemplate\">\r\n                                <div [innerHTML]=\"field.triggerTemplate(trigger)\"></div>\r\n                            </ng-template>\r\n                            <ng-template vd-select-option let-option=\"option\" *ngIf=\"field.optionTemplate\">\r\n                                <div [outerHTML]=\"field.optionTemplate(option)\"></div>\r\n                            </ng-template>\r\n                        </vd-select>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Chips -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Chips\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <mat-chip-list #chipList [formControlName]=\"field.name\" [disableControl]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                            <mat-chip *ngFor=\"let chip of formGroup.controls[field.name]?.value\" (removed)=\"removeChip(field, chip)\" color=\"primary\" selectable=\"true\" selected>\r\n                                <span>{{chip}}</span>\r\n                                <button matChipRemove>\r\n                                    <mat-icon>cancel</mat-icon>\r\n                                </button>\r\n                            </mat-chip>\r\n                            <input [placeholder]=\"field.header\" #chipInput [matChipInputFor]=\"chipList\" [matChipInputSeparatorKeyCodes]=\"separatorKeysCodes\" [matAutocomplete]=\"chipAutocomplete\" (input)=\"filterAutocomplete(field, chipInput)\" (matChipInputTokenEnd)=\"addChip(field, $event)\" autocomplete=\"off\">\r\n                        </mat-chip-list>\r\n                        <mat-autocomplete autoActiveFirstOption #chipAutocomplete=\"matAutocomplete\" [class]=\"field.autocompleteCssClass\" (optionSelected)=\"autocompleteValueSelected(field, $event, chipInput)\">\r\n                            <mat-option *ngFor=\"let option of autocompleteFilteredOptions[field.name]\" [value]=\"option.id\">\r\n                                {{option.name}}\r\n                            </mat-option>\r\n                        </mat-autocomplete>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region VdChips -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.VdChips\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <vd-chips #vdChip [formControlName]=\"field.name\" [endpoint]=\"field.endpoint\" [params]=\"field.params?field.params(formGroup?.value, formGroup, context):{}\" [searchField]=\"field.searchField\" [projection]=\"field.projection\" [key]=\"field.optionValue\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\" [removable]=\"!field.clear\" [context]=\"context\" [suffixButtons]=\"field.suffixButtons\" [autocompleteCssClass]=\"field.autocompleteCssClass\" (initSelect)=\"field.itemSelect && field.itemSelect($event, formGroup?.value, formGroup, context);\" (selected)=\"field.itemChange && field.itemChange($event, formGroup?.value, formGroup, context);\" (cleared)=\"field.clear && field.clear(formGroup?.value, formGroup, context);\" flex>\r\n                            <ng-template vd-chip let-chip=\"chip\" *ngIf=\"field.chipTemplate\">\r\n                                <div [outerHTML]=\"field.chipTemplate(chip)\"></div>\r\n                            </ng-template>\r\n                            <ng-template vd-autocomplete-option let-option=\"option\" *ngIf=\"field.autocompleteTemplate\">\r\n                                <div [outerHTML]=\"field.autocompleteTemplate(option)\"></div>\r\n                            </ng-template>\r\n                        </vd-chips>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-hint *ngIf=\"vdChip.emptyResult\" class=\"tc-red-400\" i18n=\"@@noResultsFound\">No results were found.</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Select -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Select\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <mat-select [formControlName]=\"field.name\" [multiple]=\"field.multiple\" flex>\r\n                            <mat-option *ngFor=\"let option of field.options\" [value]=\"option.id\">{{option.name}}</mat-option>\r\n                        </mat-select>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Autocomplete -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Autocomplete\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <input type=\"text\" matInput [formControlName]=\"field.name\" [matAutocomplete]=\"auto\" #autocompleteInput (input)=\"filterAutocomplete(field, autocompleteInput)\" autocomplete=\"off\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                        <mat-autocomplete autoActiveFirstOption #auto=\"matAutocomplete\" [class]=\"field.autocompleteCssClass\">\r\n                            <mat-option *ngFor=\"let option of autocompleteFilteredOptions[field.name]\" [value]=\"option.id\">\r\n                                {{option.name}}\r\n                            </mat-option>\r\n                        </mat-autocomplete>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Date -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Date\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <input matInput [formControlName]=\"field.name\" autocomplete=\"off\" [matDatepicker]=\"datePicker\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                        <mat-datepicker-toggle matSuffix [for]=\"datePicker\"></mat-datepicker-toggle>\r\n                        <mat-datepicker #datePicker></mat-datepicker>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n                </ng-container>\r\n\r\n                <!-- #region Checkbox -->\r\n                <div *ngSwitchCase=\"FormFieldType.Checkbox\" layout-margin appearance=\"outline\" class=\"pad-bottom-xs\">\r\n                    <mat-checkbox [formControlName]=\"field.name\" [disableControl]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">{{field.header}}</mat-checkbox>\r\n                </div>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region Editor -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.Editor\">\r\n                    <ng-template *ngIf=\"editorTemplate?.templateRef\" [ngTemplateOutlet]=\"editorTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region Code -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.Code\">\r\n                    <ng-template *ngIf=\"codeTemplate?.templateRef\" [ngTemplateOutlet]=\"codeTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region File -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.File\">\r\n                    <ng-template *ngIf=\"fileTemplate?.templateRef\" [ngTemplateOutlet]=\"fileTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region Custom -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.Custom\">\r\n                    <ng-template *ngIf=\"customTemplate?.templateRef\" [ngTemplateOutlet]=\"customTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n            </ng-container>\r\n        </ng-container>\r\n    </div>\r\n    <!-- #endregion -->\r\n</div>"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generic-form.component.js","sourceRoot":"","sources":["../../../../../../../projects/cdk/src/lib/forms/components/generic-form/generic-form.component.ts","../../../../../../../projects/cdk/src/lib/forms/components/generic-form/generic-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import { COMMA, ENTER } from '@angular/cdk/keycodes';\r\nimport { CdkPortal } from '@angular/cdk/portal';\r\nimport { Component, ContentChild, Directive, Input, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';\r\nimport { FormGroup } from '@angular/forms';\r\nimport { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';\r\nimport { MatChipInputEvent } from '@angular/material/chips';\r\nimport { FormFieldType } from '../../enums/form-field-type';\r\nimport { FormFieldDefinition } from '../../models/form-field-definition';\r\nimport { FormFieldGroupDefinition } from '../../models/form-field-group-definition';\r\n\r\n/**\r\n * VdEditorDirective class\r\n */\r\n@Directive({ selector: '[vd-editor]ng-template' })\r\nexport class VdEditorDirective extends CdkPortal {\r\n    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef) {\r\n        super(templateRef, viewContainerRef);\r\n    }\r\n}\r\n\r\n/**\r\n * VdCodeDirective class\r\n */\r\n@Directive({ selector: '[vd-code]ng-template' })\r\nexport class VdCodeDirective extends CdkPortal {\r\n    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef) {\r\n        super(templateRef, viewContainerRef);\r\n    }\r\n}\r\n\r\n/**\r\n * VdFileDirective class\r\n */\r\n@Directive({ selector: '[vd-file]ng-template' })\r\nexport class VdFileDirective extends CdkPortal {\r\n    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef) {\r\n        super(templateRef, viewContainerRef);\r\n    }\r\n}\r\n\r\n/**\r\n * VdCustomDirective class\r\n */\r\n@Directive({ selector: '[vd-custom]ng-template' })\r\nexport class VdCustomDirective extends CdkPortal {\r\n    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef) {\r\n        super(templateRef, viewContainerRef);\r\n    }\r\n}\r\n\r\n@Component({\r\n    selector: 'vd-generic-form',\r\n    templateUrl: './generic-form.component.html',\r\n    styleUrls: ['./generic-form.component.scss']\r\n})\r\nexport class VdGenericFormComponent implements OnInit {\r\n    /**\r\n     * form: FormGroup\r\n     */\r\n    @Input()\r\n    public formGroup: FormGroup;\r\n\r\n    /**\r\n     * fieldGroups: FormFieldGroup[]\r\n     */\r\n    @Input()\r\n    public fieldGroups: FormFieldGroupDefinition[];\r\n\r\n    /**\r\n     * Group name\r\n     */\r\n    @Input()\r\n    public groupName: string;\r\n\r\n    /**\r\n     * context: any\r\n     * The current context\r\n     */\r\n    @Input()\r\n    public context: any;\r\n\r\n    /**\r\n     * separatorKeysCodes: number[]\r\n     */\r\n    @Input()\r\n    public separatorKeysCodes: number[] = [ENTER, COMMA];\r\n\r\n    /**\r\n     * fieldRows: FormFieldDefinition[]\r\n     */\r\n    public fieldRows: [FormFieldDefinition[]];\r\n\r\n    /**\r\n     * FormFieldType: typeof FormFieldType\r\n     */\r\n    public FormFieldType: typeof FormFieldType = FormFieldType;\r\n\r\n    /**\r\n     * Editor template\r\n     */\r\n    @ContentChild(VdEditorDirective)\r\n    public editorTemplate: VdEditorDirective;\r\n\r\n    /**\r\n     * Code template\r\n     */\r\n    @ContentChild(VdCodeDirective)\r\n    public codeTemplate: VdCodeDirective;\r\n\r\n    /**\r\n     * File template\r\n     */\r\n    @ContentChild(VdFileDirective)\r\n    public fileTemplate: VdFileDirective;\r\n\r\n    /**\r\n     * Custom template\r\n     */\r\n    @ContentChild(VdCustomDirective)\r\n    public customTemplate: VdCustomDirective;\r\n\r\n    /**\r\n     * Filterd options for autocomplete\r\n     */\r\n    public autocompleteFilteredOptions: {} = {};\r\n\r\n    /**\r\n     * A callback method that is invoked immediately after the\r\n     * default change detector has checked the directive's\r\n     * data-bound properties for the first time,\r\n     * and before any of the view or content children have been checked.\r\n     * It is invoked only once when the directive is instantiated.\r\n     */\r\n    ngOnInit(): void {\r\n        this.fieldRows = this.fieldGroups?.filter(x => x.name?.trim() == this.groupName?.trim())[0]?.groups;\r\n\r\n        /* Subscrie to change event */\r\n        this.fieldRows?.reduce((a, b) => a.concat(b), [])?.filter(y => y.change)?.forEach(x => {\r\n            this.formGroup.get(x.name)?.valueChanges?.subscribe(y => x.change(y, this.formGroup));\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Handles autocomplete event\r\n     * @param field \r\n     * @param event \r\n     */\r\n    public filterAutocomplete(field: FormFieldDefinition, event: any): void {\r\n        this.autocompleteFilteredOptions[field.name] = field.options?.filter(option => option.name.toLowerCase().includes(event.value?.toString()?.toLowerCase()));\r\n    }\r\n\r\n    /**\r\n     * Adds a chip when a autocomplete value is selected\r\n     * @param field \r\n     * @param event \r\n     */\r\n    public autocompleteValueSelected(field: FormFieldDefinition, event: MatAutocompleteSelectedEvent, chipInputEvent: any): void {\r\n        this._addChip(field, event.option.viewValue);\r\n        chipInputEvent.value = '';\r\n    }\r\n\r\n    /**\r\n     * Adds a chip\r\n     * @param field \r\n     * @param event \r\n     */\r\n    public addChip(field: FormFieldDefinition, event: MatChipInputEvent): void {\r\n        this._addChip(field, event.value);\r\n        event.chipInput!.clear();\r\n    }\r\n\r\n    /**\r\n     * Removes a chip\r\n     * @param field \r\n     * @param chip \r\n     */\r\n    public removeChip(field: FormFieldDefinition, chip: any): void {\r\n        /* Get the form control using the field name */\r\n        let control = this.formGroup?.controls[field.name];\r\n\r\n        /* Get the index of the chip */\r\n        const index = control.value.indexOf(chip);\r\n        if (index >= 0) {\r\n            control.value.splice(index, 1);\r\n            control.updateValueAndValidity();\r\n            this.formGroup.markAsDirty();\r\n            this.formGroup.updateValueAndValidity();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Adds a chip\r\n     * @param field \r\n     * @param value \r\n     */\r\n    private _addChip(field: FormFieldDefinition, value: string): void {\r\n        /* Get the form control using the field name */\r\n        let control = this.formGroup?.controls[field.name];\r\n\r\n        /* Get the value of the chip */\r\n        value = (value || '').trim();\r\n        if (control && value) {\r\n            switch (field.inputType) {\r\n                case 'number':\r\n                    let number = parseInt(value);\r\n                    if (number) {\r\n                        control.value.push(number);\r\n                    }\r\n                    break;\r\n\r\n                case 'float':\r\n                    let float = parseFloat(value);\r\n                    if (float) {\r\n                        control.value.push(float);\r\n                    }\r\n                    break;\r\n\r\n                default:\r\n                    control.value.push(value);\r\n                    break;\r\n            }\r\n\r\n            control.updateValueAndValidity();\r\n            this.formGroup.markAsDirty();\r\n            this.formGroup.updateValueAndValidity();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Check if the specified object is a function\r\n     * @param obj \r\n     * @returns \r\n     */\r\n    public isFunction(obj: any) {\r\n        return obj && typeof obj === 'function';\r\n    }\r\n}","<div *ngIf=\"formGroup && fieldRows\" [formGroup]=\"formGroup\">\r\n    <!-- #region Fields -->\r\n    <div layout-gt-sm=\"row\" layout=\"column\" *ngFor=\"let fields of fieldRows\">\r\n        <ng-container *ngFor=\"let field of fields\" [ngSwitch]=\"field.type\">\r\n            <!-- #region Error handling -->\r\n            <ng-template #fieldErrors>\r\n                <div *ngFor=\"let errorMessage of formGroup.controls[field.name]['errorMessages']\">{{errorMessage}}</div>\r\n            </ng-template>\r\n            <!-- #endregion -->\r\n\r\n            <ng-container *ngIf=\"!field.hide || !field.hide(formGroup?.value, formGroup, context)\">\r\n                <ng-container *ngIf=\"field.wrapped\">\r\n                    <!-- #region Text input -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Text\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <input [type]=\"field.inputType\" [minlength]=\"field.minLength||null\" [maxlength]=\"field.maxLength||null\" matInput [formControlName]=\"field.name\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Textarea -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.TextArea\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <textarea matInput [formControlName]=\"field.name\" rows=\"field.rows||2\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\"></textarea>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Enum -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Enum\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <vd-select [formControlName]=\"field.name\" [enum]=\"field.enumType\" [key]=\"field.optionValue\" [text]=\"field.optionText\" [multiple]=\"field.multiple\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\" flex>\r\n                            <ng-template vd-select-trigger let-trigger=\"trigger\" *ngIf=\"field.triggerTemplate\">\r\n                                <div [innerHTML]=\"field.triggerTemplate(trigger)\"></div>\r\n                            </ng-template>\r\n                            <ng-template vd-select-option let-option=\"option\" *ngIf=\"field.optionTemplate\">\r\n                                <div [outerHTML]=\"field.optionTemplate(option)\"></div>\r\n                            </ng-template>\r\n                        </vd-select>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region VdSelect -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.VdSelect\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <vd-select [formControlName]=\"field.name\" [endpoint]=\"isFunction(field.endpoint)?field.endpoint(formGroup.value, formGroup, context):field.endpoint\" [params]=\"isFunction(field.params)?field.params(formGroup.value, formGroup, context):(field.params||{})\" [projection]=\"field.projection\" [mapper]=\"field.mapper\" [compareWith]=\"field.compareWith\" [key]=\"field.optionValue\" [text]=\"field.optionText\" [multiple]=\"field.multiple\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\" (itemSelected)=\"field.itemSelect && field.itemSelect($event, formGroup?.value, formGroup, context);\" (itemChange)=\"field.itemChange && field.itemChange($event, formGroup?.value, formGroup, context);\" flex>\r\n                            <ng-template vd-select-trigger let-trigger=\"trigger\" *ngIf=\"field.triggerTemplate\">\r\n                                <div [innerHTML]=\"field.triggerTemplate(trigger)\"></div>\r\n                            </ng-template>\r\n                            <ng-template vd-select-option let-option=\"option\" *ngIf=\"field.optionTemplate\">\r\n                                <div [outerHTML]=\"field.optionTemplate(option)\"></div>\r\n                            </ng-template>\r\n                        </vd-select>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Chips -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Chips\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <mat-chip-list #chipList [formControlName]=\"field.name\" [disableControl]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                            <mat-chip *ngFor=\"let chip of formGroup.controls[field.name]?.value\" (removed)=\"removeChip(field, chip)\" color=\"primary\" selectable=\"true\" selected>\r\n                                <span>{{chip}}</span>\r\n                                <button matChipRemove>\r\n                                    <mat-icon>cancel</mat-icon>\r\n                                </button>\r\n                            </mat-chip>\r\n                            <input [placeholder]=\"field.header\" #chipInput [matChipInputFor]=\"chipList\" [matChipInputSeparatorKeyCodes]=\"separatorKeysCodes\" [matAutocomplete]=\"chipAutocomplete\" (input)=\"filterAutocomplete(field, chipInput)\" (matChipInputTokenEnd)=\"addChip(field, $event)\" autocomplete=\"off\">\r\n                        </mat-chip-list>\r\n                        <mat-autocomplete autoActiveFirstOption #chipAutocomplete=\"matAutocomplete\" [class]=\"field.autocompleteCssClass\" (optionSelected)=\"autocompleteValueSelected(field, $event, chipInput)\">\r\n                            <mat-option *ngFor=\"let option of autocompleteFilteredOptions[field.name]\" [value]=\"option.id\">\r\n                                {{option.name}}\r\n                            </mat-option>\r\n                        </mat-autocomplete>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region VdChips -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.VdChips\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <vd-chips #vdChip [formControlName]=\"field.name\" [endpoint]=\"isFunction(field.endpoint)?field.endpoint(formGroup.value, formGroup, context):field.endpoint\" [params]=\"isFunction(field.params)?field.params(formGroup.value, formGroup, context):(field.params||{})\" [searchField]=\"field.searchField\" [projection]=\"field.projection\" [key]=\"field.optionValue\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\" [removable]=\"!field.clear\" [context]=\"context\" [suffixButtons]=\"field.suffixButtons\" [autocompleteCssClass]=\"field.autocompleteCssClass\" (initSelect)=\"field.itemSelect && field.itemSelect($event, formGroup?.value, formGroup, context);\" (selected)=\"field.itemChange && field.itemChange($event, formGroup?.value, formGroup, context);\" (cleared)=\"field.clear && field.clear(formGroup?.value, formGroup, context);\" flex>\r\n                            <ng-template vd-chip let-chip=\"chip\" *ngIf=\"field.chipTemplate\">\r\n                                <div [outerHTML]=\"field.chipTemplate(chip)\"></div>\r\n                            </ng-template>\r\n                            <ng-template vd-autocomplete-option let-option=\"option\" *ngIf=\"field.autocompleteTemplate\">\r\n                                <div [outerHTML]=\"field.autocompleteTemplate(option)\"></div>\r\n                            </ng-template>\r\n                        </vd-chips>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-hint *ngIf=\"vdChip.emptyResult\" class=\"tc-red-400\" i18n=\"@@noResultsFound\">No results were found.</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Select -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Select\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <mat-select [formControlName]=\"field.name\" [multiple]=\"field.multiple\" flex>\r\n                            <mat-option *ngFor=\"let option of field.options\" [value]=\"option.id\">{{option.name}}</mat-option>\r\n                        </mat-select>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Autocomplete -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Autocomplete\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <input type=\"text\" matInput [formControlName]=\"field.name\" [matAutocomplete]=\"auto\" #autocompleteInput (input)=\"filterAutocomplete(field, autocompleteInput)\" autocomplete=\"off\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                        <mat-autocomplete autoActiveFirstOption #auto=\"matAutocomplete\" [class]=\"field.autocompleteCssClass\">\r\n                            <mat-option *ngFor=\"let option of autocompleteFilteredOptions[field.name]\" [value]=\"option.id\">\r\n                                {{option.name}}\r\n                            </mat-option>\r\n                        </mat-autocomplete>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n\r\n                    <!-- #region Date -->\r\n                    <mat-form-field *ngSwitchCase=\"FormFieldType.Date\" [attr.flex]=\"field.flex||0\" [class]=\"field.cssClass\" layout-margin appearance=\"outline\">\r\n                        <mat-label>{{field.header}}</mat-label>\r\n                        <input matInput [formControlName]=\"field.name\" autocomplete=\"off\" [matDatepicker]=\"datePicker\" [readonly]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">\r\n                        <mat-datepicker-toggle matSuffix [for]=\"datePicker\"></mat-datepicker-toggle>\r\n                        <mat-datepicker #datePicker></mat-datepicker>\r\n                        <mat-hint *ngIf=\"field.hint\">{{field.hint}}</mat-hint>\r\n                        <mat-error>\r\n                            <ng-container *ngTemplateOutlet=\"fieldErrors\"></ng-container>\r\n                        </mat-error>\r\n                    </mat-form-field>\r\n                    <!-- #endregion -->\r\n                </ng-container>\r\n\r\n                <!-- #region Checkbox -->\r\n                <div *ngSwitchCase=\"FormFieldType.Checkbox\" layout-margin appearance=\"outline\" class=\"pad-bottom-xs\">\r\n                    <mat-checkbox [formControlName]=\"field.name\" [disableControl]=\"field.readonly && field.readonly(formGroup?.value, formGroup, context)\">{{field.header}}</mat-checkbox>\r\n                </div>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region Editor -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.Editor\">\r\n                    <ng-template *ngIf=\"editorTemplate?.templateRef\" [ngTemplateOutlet]=\"editorTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region Code -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.Code\">\r\n                    <ng-template *ngIf=\"codeTemplate?.templateRef\" [ngTemplateOutlet]=\"codeTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region File -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.File\">\r\n                    <ng-template *ngIf=\"fileTemplate?.templateRef\" [ngTemplateOutlet]=\"fileTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n\r\n                <!-- #region Custom -->\r\n                <ng-container *ngSwitchCase=\"FormFieldType.Custom\">\r\n                    <ng-template *ngIf=\"customTemplate?.templateRef\" [ngTemplateOutlet]=\"customTemplate?.templateRef\" [ngTemplateOutletContext]=\"{ field: field, formGroup: formGroup }\"></ng-template>\r\n                </ng-container>\r\n                <!-- #endregion -->\r\n            </ng-container>\r\n        </ng-container>\r\n    </div>\r\n    <!-- #endregion -->\r\n</div>"]}