@covalent/dynamic-forms 3.1.2-beta.6 → 4.0.0-beta.1

package/esm2020/dynamic-forms.component.mjs

@@ -0,0 +1,220 @@
+import { Component, Input, ChangeDetectionStrategy, ChangeDetectorRef, ContentChildren, QueryList, } from '@angular/core';
+import { FormBuilder } from '@angular/forms';
+import { TdDynamicFormsService } from './services/dynamic-forms.service';
+import { TdDynamicFormsErrorTemplateDirective } from './dynamic-element.component';
+import { timer, Subject } from 'rxjs';
+import { takeUntil, filter } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "./services/dynamic-forms.service";
+import * as i3 from "@angular/common";
+import * as i4 from "./dynamic-element.component";
+function TdDynamicFormsComponent_ng_template_2_td_dynamic_element_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "td-dynamic-element", 5, 6);
+} if (rf & 2) {
+    const element_r1 = i0.ɵɵnextContext().$implicit;
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("formControlName", element_r1.name)("dynamicControl", ctx_r2.dynamicForm.controls[element_r1.name])("id", element_r1.name)("name", element_r1.name)("label", element_r1.label || element_r1.name)("hint", element_r1.hint)("type", element_r1.type)("required", element_r1.required)("min", element_r1.min)("max", element_r1.max)("minLength", element_r1.minLength)("maxLength", element_r1.maxLength)("selections", element_r1.selections)("multiple", element_r1.multiple)("customConfig", element_r1.customConfig)("errorMessageTemplate", ctx_r2.getErrorTemplateRef(element_r1.name))("placeholder", element_r1.placeholder);
+} }
+function TdDynamicFormsComponent_ng_template_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 3);
+    i0.ɵɵtemplate(1, TdDynamicFormsComponent_ng_template_2_td_dynamic_element_1_Template, 2, 17, "td-dynamic-element", 4);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const element_r1 = ctx.$implicit;
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵstyleProp("max-width", element_r1.flex ? element_r1.flex : 100, "%")("flex", "1 1 " + (element_r1.flex ? element_r1.flex : 100) + "%")("-ms-flex", "1 1 " + (element_r1.flex ? element_r1.flex : 100) + "%")("-webkit-box-flex", 1);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r0.dynamicForm.controls[element_r1.name]);
+} }
+const _c0 = ["*"];
+export class TdDynamicFormsComponent {
+    constructor(_formBuilder, _dynamicFormsService, _changeDetectorRef) {
+        this._formBuilder = _formBuilder;
+        this._dynamicFormsService = _dynamicFormsService;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._renderedElements = [];
+        this._templateMap = new Map();
+        this._destroy$ = new Subject();
+        this._destroyControl$ = new Subject();
+        this.dynamicForm = this._formBuilder.group({});
+    }
+    /**
+     * elements: ITdDynamicElementConfig[]
+     * JS Object that will render the elements depending on its config.
+     * [name] property is required.
+     */
+    set elements(elements) {
+        if (elements) {
+            this._elements = elements;
+        }
+        else {
+            this._elements = [];
+        }
+        this._rerenderElements();
+    }
+    get elements() {
+        return this._renderedElements;
+    }
+    /**
+     * Getter property for dynamic [FormGroup].
+     */
+    get form() {
+        return this.dynamicForm;
+    }
+    /**
+     * Getter property for [valid] of dynamic [FormGroup].
+     */
+    get valid() {
+        if (this.dynamicForm) {
+            return this.dynamicForm.valid;
+        }
+        return false;
+    }
+    /**
+     * Getter property for [value] of dynamic [FormGroup].
+     */
+    get value() {
+        if (this.dynamicForm) {
+            return this.dynamicForm.value;
+        }
+        return {};
+    }
+    /**
+     * Getter property for [errors] of dynamic [FormGroup].
+     */
+    get errors() {
+        if (this.dynamicForm) {
+            const errors = {};
+            for (const name of Object.keys(this.dynamicForm.controls)) {
+                errors[name] = this.dynamicForm.controls[name].errors;
+            }
+            return errors;
+        }
+        return {};
+    }
+    /**
+     * Getter property for [controls] of dynamic [FormGroup].
+     */
+    get controls() {
+        if (this.dynamicForm) {
+            return this.dynamicForm.controls;
+        }
+        return {};
+    }
+    ngAfterContentInit() {
+        this._updateErrorTemplates();
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+        this._destroyControl$.complete();
+    }
+    /**
+     * Refreshes the form and rerenders all validator/element modifications.
+     */
+    refresh() {
+        this._rerenderElements();
+        this._updateErrorTemplates();
+    }
+    /**
+     * Getter method for error template references
+     */
+    getErrorTemplateRef(name) {
+        return this._templateMap.get(name);
+    }
+    /**
+     * Loads error templates and sets them in a map for faster access.
+     */
+    _updateErrorTemplates() {
+        this._templateMap = new Map();
+        for (const errorTemplate of this._errorTemplates.toArray()) {
+            this._templateMap.set(errorTemplate.tdDynamicFormsError, errorTemplate.templateRef);
+        }
+    }
+    _rerenderElements() {
+        this._clearRemovedElements();
+        this._renderedElements = [];
+        const duplicates = [];
+        this._elements.forEach((elem) => {
+            this._dynamicFormsService.validateDynamicElementName(elem.name);
+            if (duplicates.indexOf(elem.name) > -1) {
+                throw new Error(`Dynamic element name: "${elem.name}" is duplicated`);
+            }
+            duplicates.push(elem.name);
+            const dynamicElement = this.dynamicForm.get(elem.name);
+            if (!dynamicElement) {
+                this.dynamicForm.addControl(elem.name, this._dynamicFormsService.createFormControl(elem));
+                this._subscribeToControlStatusChanges(elem.name);
+            }
+            else {
+                dynamicElement.setValue(elem.default);
+                dynamicElement.markAsPristine();
+                dynamicElement.markAsUntouched();
+                if (elem.disabled) {
+                    dynamicElement.disable();
+                }
+                else {
+                    dynamicElement.enable();
+                }
+                dynamicElement.setValidators(this._dynamicFormsService.createValidators(elem));
+            }
+            // copy objects so they are only changes when calling this method
+            this._renderedElements.push(Object.assign({}, elem));
+        });
+        // call a change detection since the whole form might change
+        this._changeDetectorRef.detectChanges();
+        timer()
+            .toPromise()
+            .then(() => {
+            // call a markForCheck so elements are rendered correctly in OnPush
+            this._changeDetectorRef.markForCheck();
+        });
+    }
+    _clearRemovedElements() {
+        this._renderedElements = this._renderedElements.filter((renderedElement) => !this._elements.some((element) => element.name === renderedElement.name));
+        // remove elements that were removed from the array
+        this._renderedElements.forEach((elem) => {
+            this._destroyControl$.next(elem.name);
+            this.dynamicForm.removeControl(elem.name);
+        });
+    }
+    // Updates component when manually adding errors to controls
+    _subscribeToControlStatusChanges(elementName) {
+        const control = this.controls[elementName];
+        const controlDestroyed$ = this._destroyControl$.pipe(filter((destroyedElementName) => destroyedElementName === elementName));
+        control.statusChanges.pipe(takeUntil(this._destroy$), takeUntil(controlDestroyed$)).subscribe(() => {
+            this._changeDetectorRef.markForCheck();
+        });
+    }
+}
+/** @nocollapse */ /** @nocollapse */ TdDynamicFormsComponent.ɵfac = function TdDynamicFormsComponent_Factory(t) { return new (t || TdDynamicFormsComponent)(i0.ɵɵdirectiveInject(i1.FormBuilder), i0.ɵɵdirectiveInject(i2.TdDynamicFormsService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); };
+/** @nocollapse */ /** @nocollapse */ TdDynamicFormsComponent.ɵcmp = /** @pureOrBreakMyCode */ i0.ɵɵdefineComponent({ type: TdDynamicFormsComponent, selectors: [["td-dynamic-forms"]], contentQueries: function TdDynamicFormsComponent_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {
+        i0.ɵɵcontentQuery(dirIndex, TdDynamicFormsErrorTemplateDirective, 5);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx._errorTemplates = _t);
+    } }, inputs: { elements: "elements" }, ngContentSelectors: _c0, decls: 4, vars: 2, consts: [["novalidate", "", 3, "formGroup"], [1, "td-dynamic-form-wrapper"], ["ngFor", "", 3, "ngForOf"], [1, "td-dynamic-element-wrapper"], [3, "formControlName", "dynamicControl", "id", "name", "label", "hint", "type", "required", "min", "max", "minLength", "maxLength", "selections", "multiple", "customConfig", "errorMessageTemplate", "placeholder", 4, "ngIf"], [3, "formControlName", "dynamicControl", "id", "name", "label", "hint", "type", "required", "min", "max", "minLength", "maxLength", "selections", "multiple", "customConfig", "errorMessageTemplate", "placeholder"], ["dynamicElement", ""]], template: function TdDynamicFormsComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵprojectionDef();
+        i0.ɵɵelementStart(0, "form", 0);
+        i0.ɵɵelementStart(1, "div", 1);
+        i0.ɵɵtemplate(2, TdDynamicFormsComponent_ng_template_2_Template, 2, 9, "ng-template", 2);
+        i0.ɵɵelementEnd();
+        i0.ɵɵprojection(3);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵproperty("formGroup", ctx.dynamicForm);
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("ngForOf", ctx.elements);
+    } }, directives: [i1.ɵNgNoValidate, i1.NgControlStatusGroup, i1.FormGroupDirective, i3.NgForOf, i3.NgIf, i4.TdDynamicElementComponent, i1.NgControlStatus, i1.FormControlName, i1.RequiredValidator], styles: [".td-dynamic-form-wrapper[_ngcontent-%COMP%]{-ms-flex-flow:row wrap;flex-flow:row wrap;box-sizing:border-box;display:-ms-flexbox;display:flex;-ms-flex-align:center;align-items:center;-ms-flex-line-pack:center;align-content:center;max-width:100%;-ms-flex-pack:start;justify-content:flex-start}.td-dynamic-form-wrapper[_ngcontent-%COMP%]     .mat-form-field-infix{width:auto}.td-dynamic-form-wrapper[_ngcontent-%COMP%]     .td-dynamic-element-hint{font-size:75%;display:block}.td-dynamic-form-wrapper[_ngcontent-%COMP%]   .td-dynamic-element-wrapper[_ngcontent-%COMP%]{max-height:100%;box-sizing:border-box;position:relative;padding:4px 4px 8px}"], changeDetection: 0 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TdDynamicFormsComponent, [{
+        type: Component,
+        args: [{ selector: 'td-dynamic-forms', changeDetection: ChangeDetectionStrategy.OnPush, template: "<form [formGroup]=\"dynamicForm\" novalidate>\n  <div class=\"td-dynamic-form-wrapper\">\n    <ng-template let-element ngFor [ngForOf]=\"elements\">\n      <div\n        class=\"td-dynamic-element-wrapper\"\n        [style.max-width.%]=\"element.flex ? element.flex : 100\"\n        [style.flex]=\"'1 1 ' + (element.flex ? element.flex : 100) + '%'\"\n        [style.-ms-flex]=\"'1 1 ' + (element.flex ? element.flex : 100) + '%'\"\n        [style.-webkit-box-flex]=\"1\"\n      >\n        <td-dynamic-element\n          #dynamicElement\n          *ngIf=\"dynamicForm.controls[element.name]\"\n          [formControlName]=\"element.name\"\n          [dynamicControl]=\"dynamicForm.controls[element.name]\"\n          [id]=\"element.name\"\n          [name]=\"element.name\"\n          [label]=\"element.label || element.name\"\n          [hint]=\"element.hint\"\n          [type]=\"element.type\"\n          [required]=\"element.required\"\n          [min]=\"element.min\"\n          [max]=\"element.max\"\n          [minLength]=\"element.minLength\"\n          [maxLength]=\"element.maxLength\"\n          [selections]=\"element.selections\"\n          [multiple]=\"element.multiple\"\n          [customConfig]=\"element.customConfig\"\n          [errorMessageTemplate]=\"getErrorTemplateRef(element.name)\"\n          [placeholder]=\"element.placeholder\"\n        ></td-dynamic-element>\n      </div>\n    </ng-template>\n  </div>\n  <ng-content></ng-content>\n</form>\n", styles: [".td-dynamic-form-wrapper{-ms-flex-flow:row wrap;flex-flow:row wrap;box-sizing:border-box;display:-ms-flexbox;display:flex;-ms-flex-align:center;align-items:center;-ms-flex-line-pack:center;align-content:center;max-width:100%;-ms-flex-pack:start;justify-content:flex-start}.td-dynamic-form-wrapper ::ng-deep .mat-form-field-infix{width:auto}.td-dynamic-form-wrapper ::ng-deep .td-dynamic-element-hint{font-size:75%;display:block}.td-dynamic-form-wrapper .td-dynamic-element-wrapper{max-height:100%;box-sizing:border-box;position:relative;padding:4px 4px 8px}\n"] }]
+    }], function () { return [{ type: i1.FormBuilder }, { type: i2.TdDynamicFormsService }, { type: i0.ChangeDetectorRef }]; }, { _errorTemplates: [{
+            type: ContentChildren,
+            args: [TdDynamicFormsErrorTemplateDirective, { descendants: true }]
+        }], elements: [{
+            type: Input,
+            args: ['elements']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-forms.component.js","sourceRoot":"","sources":["../../../../src/platform/dynamic-forms/dynamic-forms.component.ts","../../../../src/platform/dynamic-forms/dynamic-forms.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  ContentChildren,\n  TemplateRef,\n  QueryList,\n  AfterContentInit,\n  OnDestroy,\n} from '@angular/core';\nimport { FormGroup, FormBuilder, AbstractControl } from '@angular/forms';\n\nimport { TdDynamicFormsService, ITdDynamicElementConfig } from './services/dynamic-forms.service';\nimport { TdDynamicFormsErrorTemplateDirective } from './dynamic-element.component';\n\nimport { timer, Subject, Observable } from 'rxjs';\nimport { takeUntil, filter } from 'rxjs/operators';\n\n@Component({\n  selector: 'td-dynamic-forms',\n  templateUrl: './dynamic-forms.component.html',\n  styleUrls: ['./dynamic-forms.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class TdDynamicFormsComponent implements AfterContentInit, OnDestroy {\n  private _renderedElements: ITdDynamicElementConfig[] = [];\n  private _elements: ITdDynamicElementConfig[];\n  private _templateMap: Map<string, TemplateRef<any>> = new Map<string, TemplateRef<any>>();\n  private _destroy$: Subject<any> = new Subject();\n  private _destroyControl$: Subject<string> = new Subject();\n\n  @ContentChildren(TdDynamicFormsErrorTemplateDirective, { descendants: true })\n  _errorTemplates: QueryList<TdDynamicFormsErrorTemplateDirective>;\n  dynamicForm: FormGroup;\n\n  /**\n   * elements: ITdDynamicElementConfig[]\n   * JS Object that will render the elements depending on its config.\n   * [name] property is required.\n   */\n  @Input('elements')\n  set elements(elements: ITdDynamicElementConfig[]) {\n    if (elements) {\n      this._elements = elements;\n    } else {\n      this._elements = [];\n    }\n    this._rerenderElements();\n  }\n  get elements(): ITdDynamicElementConfig[] {\n    return this._renderedElements;\n  }\n\n  /**\n   * Getter property for dynamic [FormGroup].\n   */\n  get form(): FormGroup {\n    return this.dynamicForm;\n  }\n\n  /**\n   * Getter property for [valid] of dynamic [FormGroup].\n   */\n  get valid(): boolean {\n    if (this.dynamicForm) {\n      return this.dynamicForm.valid;\n    }\n    return false;\n  }\n\n  /**\n   * Getter property for [value] of dynamic [FormGroup].\n   */\n  get value(): any {\n    if (this.dynamicForm) {\n      return this.dynamicForm.value;\n    }\n    return {};\n  }\n\n  /**\n   * Getter property for [errors] of dynamic [FormGroup].\n   */\n  get errors(): { [name: string]: any } {\n    if (this.dynamicForm) {\n      const errors: { [name: string]: any } = {};\n      for (const name of Object.keys(this.dynamicForm.controls)) {\n        errors[name] = this.dynamicForm.controls[name].errors;\n      }\n      return errors;\n    }\n    return {};\n  }\n\n  /**\n   * Getter property for [controls] of dynamic [FormGroup].\n   */\n  get controls(): { [key: string]: AbstractControl } {\n    if (this.dynamicForm) {\n      return this.dynamicForm.controls;\n    }\n    return {};\n  }\n\n  constructor(\n    private _formBuilder: FormBuilder,\n    private _dynamicFormsService: TdDynamicFormsService,\n    private _changeDetectorRef: ChangeDetectorRef,\n  ) {\n    this.dynamicForm = this._formBuilder.group({});\n  }\n\n  ngAfterContentInit(): void {\n    this._updateErrorTemplates();\n  }\n\n  ngOnDestroy(): void {\n    this._destroy$.next();\n    this._destroy$.complete();\n    this._destroyControl$.complete();\n  }\n\n  /**\n   * Refreshes the form and rerenders all validator/element modifications.\n   */\n  refresh(): void {\n    this._rerenderElements();\n    this._updateErrorTemplates();\n  }\n\n  /**\n   * Getter method for error template references\n   */\n  getErrorTemplateRef(name: string): TemplateRef<any> {\n    return this._templateMap.get(name);\n  }\n\n  /**\n   * Loads error templates and sets them in a map for faster access.\n   */\n  private _updateErrorTemplates(): void {\n    this._templateMap = new Map<string, TemplateRef<any>>();\n    for (const errorTemplate of this._errorTemplates.toArray()) {\n      this._templateMap.set(errorTemplate.tdDynamicFormsError, errorTemplate.templateRef);\n    }\n  }\n\n  private _rerenderElements(): void {\n    this._clearRemovedElements();\n    this._renderedElements = [];\n    const duplicates: string[] = [];\n    this._elements.forEach((elem: ITdDynamicElementConfig) => {\n      this._dynamicFormsService.validateDynamicElementName(elem.name);\n      if (duplicates.indexOf(elem.name) > -1) {\n        throw new Error(`Dynamic element name: \"${elem.name}\" is duplicated`);\n      }\n      duplicates.push(elem.name);\n      const dynamicElement: AbstractControl = this.dynamicForm.get(elem.name);\n      if (!dynamicElement) {\n        this.dynamicForm.addControl(elem.name, this._dynamicFormsService.createFormControl(elem));\n        this._subscribeToControlStatusChanges(elem.name);\n      } else {\n        dynamicElement.setValue(elem.default);\n        dynamicElement.markAsPristine();\n        dynamicElement.markAsUntouched();\n        if (elem.disabled) {\n          dynamicElement.disable();\n        } else {\n          dynamicElement.enable();\n        }\n        dynamicElement.setValidators(this._dynamicFormsService.createValidators(elem));\n      }\n      // copy objects so they are only changes when calling this method\n      this._renderedElements.push(Object.assign({}, elem));\n    });\n    // call a change detection since the whole form might change\n    this._changeDetectorRef.detectChanges();\n    timer()\n      .toPromise()\n      .then(() => {\n        // call a markForCheck so elements are rendered correctly in OnPush\n        this._changeDetectorRef.markForCheck();\n      });\n  }\n\n  private _clearRemovedElements(): void {\n    this._renderedElements = this._renderedElements.filter(\n      (renderedElement: ITdDynamicElementConfig) =>\n        !this._elements.some((element: ITdDynamicElementConfig) => element.name === renderedElement.name),\n    );\n    // remove elements that were removed from the array\n    this._renderedElements.forEach((elem: ITdDynamicElementConfig) => {\n      this._destroyControl$.next(elem.name);\n      this.dynamicForm.removeControl(elem.name);\n    });\n  }\n\n  // Updates component when manually adding errors to controls\n  private _subscribeToControlStatusChanges(elementName: string): void {\n    const control: AbstractControl = this.controls[elementName];\n\n    const controlDestroyed$: Observable<any> = this._destroyControl$.pipe(\n      filter((destroyedElementName: string) => destroyedElementName === elementName),\n    );\n\n    control.statusChanges.pipe(takeUntil(this._destroy$), takeUntil(controlDestroyed$)).subscribe(() => {\n      this._changeDetectorRef.markForCheck();\n    });\n  }\n}\n","<form [formGroup]=\"dynamicForm\" novalidate>\n  <div class=\"td-dynamic-form-wrapper\">\n    <ng-template let-element ngFor [ngForOf]=\"elements\">\n      <div\n        class=\"td-dynamic-element-wrapper\"\n        [style.max-width.%]=\"element.flex ? element.flex : 100\"\n        [style.flex]=\"'1 1 ' + (element.flex ? element.flex : 100) + '%'\"\n        [style.-ms-flex]=\"'1 1 ' + (element.flex ? element.flex : 100) + '%'\"\n        [style.-webkit-box-flex]=\"1\"\n      >\n        <td-dynamic-element\n          #dynamicElement\n          *ngIf=\"dynamicForm.controls[element.name]\"\n          [formControlName]=\"element.name\"\n          [dynamicControl]=\"dynamicForm.controls[element.name]\"\n          [id]=\"element.name\"\n          [name]=\"element.name\"\n          [label]=\"element.label || element.name\"\n          [hint]=\"element.hint\"\n          [type]=\"element.type\"\n          [required]=\"element.required\"\n          [min]=\"element.min\"\n          [max]=\"element.max\"\n          [minLength]=\"element.minLength\"\n          [maxLength]=\"element.maxLength\"\n          [selections]=\"element.selections\"\n          [multiple]=\"element.multiple\"\n          [customConfig]=\"element.customConfig\"\n          [errorMessageTemplate]=\"getErrorTemplateRef(element.name)\"\n          [placeholder]=\"element.placeholder\"\n        ></td-dynamic-element>\n      </div>\n    </ng-template>\n  </div>\n  <ng-content></ng-content>\n</form>\n"]}

package/esm2020/dynamic-forms.module.mjs

@@ -0,0 +1,118 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ReactiveFormsModule } from '@angular/forms';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatInputModule } from '@angular/material/input';
+import { MatSelectModule } from '@angular/material/select';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import { MatSliderModule } from '@angular/material/slider';
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { MatIconModule } from '@angular/material/icon';
+import { MatButtonModule } from '@angular/material/button';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import { CovalentCommonModule } from '@covalent/core/common';
+import { CovalentFileModule } from '@covalent/core/file';
+import { TdDynamicFormsComponent } from './dynamic-forms.component';
+import { TdDynamicElementComponent, TdDynamicElementDirective, TdDynamicFormsErrorTemplateDirective, } from './dynamic-element.component';
+import { DYNAMIC_FORMS_PROVIDER } from './services/dynamic-forms.service';
+import { TdDynamicInputComponent } from './dynamic-elements/dynamic-input/dynamic-input.component';
+import { TdDynamicFileInputComponent } from './dynamic-elements/dynamic-file-input/dynamic-file-input.component';
+import { TdDynamicTextareaComponent } from './dynamic-elements/dynamic-textarea/dynamic-textarea.component';
+import { TdDynamicSlideToggleComponent } from './dynamic-elements/dynamic-slide-toggle/dynamic-slide-toggle.component';
+import { TdDynamicCheckboxComponent } from './dynamic-elements/dynamic-checkbox/dynamic-checkbox.component';
+import { TdDynamicSliderComponent } from './dynamic-elements/dynamic-slider/dynamic-slider.component';
+import { TdDynamicSelectComponent } from './dynamic-elements/dynamic-select/dynamic-select.component';
+import { TdDynamicDatepickerComponent } from './dynamic-elements/dynamic-datepicker/dynamic-datepicker.component';
+import * as i0 from "@angular/core";
+const TD_DYNAMIC_FORMS = [
+    TdDynamicFormsComponent,
+    TdDynamicElementComponent,
+    TdDynamicElementDirective,
+    TdDynamicFormsErrorTemplateDirective,
+];
+const TD_DYNAMIC_FORMS_ENTRY_COMPONENTS = [
+    TdDynamicInputComponent,
+    TdDynamicFileInputComponent,
+    TdDynamicTextareaComponent,
+    TdDynamicSlideToggleComponent,
+    TdDynamicCheckboxComponent,
+    TdDynamicSliderComponent,
+    TdDynamicSelectComponent,
+    TdDynamicDatepickerComponent,
+];
+export class CovalentDynamicFormsModule {
+}
+/** @nocollapse */ /** @nocollapse */ CovalentDynamicFormsModule.ɵfac = function CovalentDynamicFormsModule_Factory(t) { return new (t || CovalentDynamicFormsModule)(); };
+/** @nocollapse */ /** @nocollapse */ CovalentDynamicFormsModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: CovalentDynamicFormsModule });
+/** @nocollapse */ /** @nocollapse */ CovalentDynamicFormsModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [DYNAMIC_FORMS_PROVIDER], imports: [[
+            CommonModule,
+            ReactiveFormsModule,
+            MatFormFieldModule,
+            MatInputModule,
+            MatSelectModule,
+            MatCheckboxModule,
+            MatSliderModule,
+            MatSlideToggleModule,
+            MatIconModule,
+            MatButtonModule,
+            MatDatepickerModule,
+            CovalentCommonModule,
+            CovalentFileModule,
+        ]] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CovalentDynamicFormsModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [TD_DYNAMIC_FORMS, TD_DYNAMIC_FORMS_ENTRY_COMPONENTS],
+                imports: [
+                    CommonModule,
+                    ReactiveFormsModule,
+                    MatFormFieldModule,
+                    MatInputModule,
+                    MatSelectModule,
+                    MatCheckboxModule,
+                    MatSliderModule,
+                    MatSlideToggleModule,
+                    MatIconModule,
+                    MatButtonModule,
+                    MatDatepickerModule,
+                    CovalentCommonModule,
+                    CovalentFileModule,
+                ],
+                exports: [TD_DYNAMIC_FORMS, TD_DYNAMIC_FORMS_ENTRY_COMPONENTS],
+                providers: [DYNAMIC_FORMS_PROVIDER],
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(CovalentDynamicFormsModule, { declarations: [TdDynamicFormsComponent,
+        TdDynamicElementComponent,
+        TdDynamicElementDirective,
+        TdDynamicFormsErrorTemplateDirective, TdDynamicInputComponent,
+        TdDynamicFileInputComponent,
+        TdDynamicTextareaComponent,
+        TdDynamicSlideToggleComponent,
+        TdDynamicCheckboxComponent,
+        TdDynamicSliderComponent,
+        TdDynamicSelectComponent,
+        TdDynamicDatepickerComponent], imports: [CommonModule,
+        ReactiveFormsModule,
+        MatFormFieldModule,
+        MatInputModule,
+        MatSelectModule,
+        MatCheckboxModule,
+        MatSliderModule,
+        MatSlideToggleModule,
+        MatIconModule,
+        MatButtonModule,
+        MatDatepickerModule,
+        CovalentCommonModule,
+        CovalentFileModule], exports: [TdDynamicFormsComponent,
+        TdDynamicElementComponent,
+        TdDynamicElementDirective,
+        TdDynamicFormsErrorTemplateDirective, TdDynamicInputComponent,
+        TdDynamicFileInputComponent,
+        TdDynamicTextareaComponent,
+        TdDynamicSlideToggleComponent,
+        TdDynamicCheckboxComponent,
+        TdDynamicSliderComponent,
+        TdDynamicSelectComponent,
+        TdDynamicDatepickerComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/index.mjs

@@ -0,0 +1,2 @@
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcGxhdGZvcm0vZHluYW1pYy1mb3Jtcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcHVibGljX2FwaSc7XG4iXX0=

package/esm2020/public_api.mjs

@@ -0,0 +1,13 @@
+export * from './dynamic-forms.module';
+export * from './dynamic-forms.component';
+export * from './dynamic-element.component';
+export * from './services/dynamic-forms.service';
+export * from './dynamic-elements/dynamic-textarea/dynamic-textarea.component';
+export * from './dynamic-elements/dynamic-slider/dynamic-slider.component';
+export * from './dynamic-elements/dynamic-slide-toggle/dynamic-slide-toggle.component';
+export * from './dynamic-elements/dynamic-select/dynamic-select.component';
+export * from './dynamic-elements/dynamic-input/dynamic-input.component';
+export * from './dynamic-elements/dynamic-file-input/dynamic-file-input.component';
+export * from './dynamic-elements/dynamic-datepicker/dynamic-datepicker.component';
+export * from './dynamic-elements/dynamic-checkbox/dynamic-checkbox.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wbGF0Zm9ybS9keW5hbWljLWZvcm1zL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLGdFQUFnRSxDQUFDO0FBQy9FLGNBQWMsNERBQTRELENBQUM7QUFDM0UsY0FBYyx3RUFBd0UsQ0FBQztBQUN2RixjQUFjLDREQUE0RCxDQUFDO0FBQzNFLGNBQWMsMERBQTBELENBQUM7QUFDekUsY0FBYyxvRUFBb0UsQ0FBQztBQUNuRixjQUFjLG9FQUFvRSxDQUFDO0FBQ25GLGNBQWMsZ0VBQWdFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2R5bmFtaWMtZm9ybXMubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vZHluYW1pYy1mb3Jtcy5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9keW5hbWljLWVsZW1lbnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvZHluYW1pYy1mb3Jtcy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vZHluYW1pYy1lbGVtZW50cy9keW5hbWljLXRleHRhcmVhL2R5bmFtaWMtdGV4dGFyZWEuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZHluYW1pYy1lbGVtZW50cy9keW5hbWljLXNsaWRlci9keW5hbWljLXNsaWRlci5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9keW5hbWljLWVsZW1lbnRzL2R5bmFtaWMtc2xpZGUtdG9nZ2xlL2R5bmFtaWMtc2xpZGUtdG9nZ2xlLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2R5bmFtaWMtZWxlbWVudHMvZHluYW1pYy1zZWxlY3QvZHluYW1pYy1zZWxlY3QuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZHluYW1pYy1lbGVtZW50cy9keW5hbWljLWlucHV0L2R5bmFtaWMtaW5wdXQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZHluYW1pYy1lbGVtZW50cy9keW5hbWljLWZpbGUtaW5wdXQvZHluYW1pYy1maWxlLWlucHV0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2R5bmFtaWMtZWxlbWVudHMvZHluYW1pYy1kYXRlcGlja2VyL2R5bmFtaWMtZGF0ZXBpY2tlci5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9keW5hbWljLWVsZW1lbnRzL2R5bmFtaWMtY2hlY2tib3gvZHluYW1pYy1jaGVja2JveC5jb21wb25lbnQnO1xuIl19

package/esm2020/services/dynamic-forms.service.mjs

@@ -0,0 +1,125 @@
+import { Injectable, SkipSelf, Optional } from '@angular/core';
+import { Validators, FormControl } from '@angular/forms';
+import { TdDynamicInputComponent } from '../dynamic-elements/dynamic-input/dynamic-input.component';
+import { TdDynamicFileInputComponent } from '../dynamic-elements/dynamic-file-input/dynamic-file-input.component';
+import { TdDynamicTextareaComponent } from '../dynamic-elements/dynamic-textarea/dynamic-textarea.component';
+import { TdDynamicSlideToggleComponent } from '../dynamic-elements/dynamic-slide-toggle/dynamic-slide-toggle.component';
+import { TdDynamicCheckboxComponent } from '../dynamic-elements/dynamic-checkbox/dynamic-checkbox.component';
+import { TdDynamicSliderComponent } from '../dynamic-elements/dynamic-slider/dynamic-slider.component';
+import { TdDynamicSelectComponent } from '../dynamic-elements/dynamic-select/dynamic-select.component';
+import { TdDynamicDatepickerComponent } from '../dynamic-elements/dynamic-datepicker/dynamic-datepicker.component';
+import * as i0 from "@angular/core";
+export var TdDynamicType;
+(function (TdDynamicType) {
+    TdDynamicType["Text"] = "text";
+    TdDynamicType["Boolean"] = "boolean";
+    TdDynamicType["Number"] = "number";
+    TdDynamicType["Array"] = "array";
+    TdDynamicType["Date"] = "date";
+})(TdDynamicType || (TdDynamicType = {}));
+export var TdDynamicElement;
+(function (TdDynamicElement) {
+    TdDynamicElement["Input"] = "input";
+    TdDynamicElement["Datepicker"] = "datepicker";
+    TdDynamicElement["Password"] = "password";
+    TdDynamicElement["Textarea"] = "textarea";
+    TdDynamicElement["Slider"] = "slider";
+    TdDynamicElement["SlideToggle"] = "slide-toggle";
+    TdDynamicElement["Checkbox"] = "checkbox";
+    TdDynamicElement["Select"] = "select";
+    TdDynamicElement["FileInput"] = "file-input";
+})(TdDynamicElement || (TdDynamicElement = {}));
+export const DYNAMIC_ELEMENT_NAME_REGEX = /^[^0-9][^\@]*$/;
+export class TdDynamicFormsService {
+    /**
+     * Method to validate if the [name] is a proper element name.
+     * Throws error if name is not valid.
+     */
+    validateDynamicElementName(name) {
+        if (!DYNAMIC_ELEMENT_NAME_REGEX.test(name)) {
+            throw new Error('Dynamic element name: "${name}" is not valid.');
+        }
+    }
+    /**
+     * Gets component to be rendered depending on [TdDynamicElement | TdDynamicType]
+     * Throws error if it does not exists or not supported.
+     */
+    getDynamicElement(element) {
+        switch (element) {
+            case TdDynamicType.Text:
+            case TdDynamicType.Number:
+            case TdDynamicElement.Input:
+            case TdDynamicElement.Password:
+                return TdDynamicInputComponent;
+            case TdDynamicElement.Textarea:
+                return TdDynamicTextareaComponent;
+            case TdDynamicType.Boolean:
+            case TdDynamicElement.SlideToggle:
+                return TdDynamicSlideToggleComponent;
+            case TdDynamicElement.Checkbox:
+                return TdDynamicCheckboxComponent;
+            case TdDynamicElement.Slider:
+                return TdDynamicSliderComponent;
+            case TdDynamicType.Array:
+            case TdDynamicElement.Select:
+                return TdDynamicSelectComponent;
+            case TdDynamicElement.FileInput:
+                return TdDynamicFileInputComponent;
+            case TdDynamicElement.Datepicker:
+            case TdDynamicType.Date:
+                return TdDynamicDatepickerComponent;
+            default:
+                throw new Error(`Error: type ${element} does not exist or not supported.`);
+        }
+    }
+    /**
+     * Creates form control for element depending [ITdDynamicElementConfig] properties.
+     */
+    createFormControl(config) {
+        const validator = this.createValidators(config);
+        return new FormControl({ value: config.default, disabled: config.disabled }, validator);
+    }
+    /**
+     * Creates form validationdepending [ITdDynamicElementConfig] properties.
+     */
+    createValidators(config) {
+        let validator;
+        if (config.required) {
+            validator = Validators.required;
+        }
+        if (config.max || config.max === 0) {
+            validator = Validators.compose([validator, Validators.max(parseFloat(config.max))]);
+        }
+        if (config.min || config.min === 0) {
+            validator = Validators.compose([validator, Validators.min(parseFloat(config.min))]);
+        }
+        if (config.maxLength || config.maxLength === 0) {
+            validator = Validators.compose([validator, Validators.maxLength(parseFloat(config.maxLength))]);
+        }
+        if (config.minLength || config.minLength === 0) {
+            validator = Validators.compose([validator, Validators.minLength(parseFloat(config.minLength))]);
+        }
+        // Add provided custom validators to the validator function
+        if (config.validators) {
+            config.validators.forEach((validatorConfig) => {
+                validator = Validators.compose([validator, validatorConfig.validator]);
+            });
+        }
+        return validator;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ TdDynamicFormsService.ɵfac = function TdDynamicFormsService_Factory(t) { return new (t || TdDynamicFormsService)(); };
+/** @nocollapse */ /** @nocollapse */ TdDynamicFormsService.ɵprov = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjectable({ token: TdDynamicFormsService, factory: TdDynamicFormsService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TdDynamicFormsService, [{
+        type: Injectable
+    }], null, null); })();
+export function DYNAMIC_FORMS_PROVIDER_FACTORY(parent) {
+    return parent || new TdDynamicFormsService();
+}
+export const DYNAMIC_FORMS_PROVIDER = {
+    // If there is already a service available, use that. Otherwise, provide a new one.
+    provide: TdDynamicFormsService,
+    deps: [[new Optional(), new SkipSelf(), TdDynamicFormsService]],
+    useFactory: DYNAMIC_FORMS_PROVIDER_FACTORY,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-forms.service.js","sourceRoot":"","sources":["../../../../../src/platform/dynamic-forms/services/dynamic-forms.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Provider, SkipSelf, Optional, Type } from '@angular/core';\nimport { Validators, ValidatorFn, FormControl, AbstractControl } from '@angular/forms';\n\nimport { TdDynamicInputComponent } from '../dynamic-elements/dynamic-input/dynamic-input.component';\nimport { TdDynamicFileInputComponent } from '../dynamic-elements/dynamic-file-input/dynamic-file-input.component';\nimport { TdDynamicTextareaComponent } from '../dynamic-elements/dynamic-textarea/dynamic-textarea.component';\nimport { TdDynamicSlideToggleComponent } from '../dynamic-elements/dynamic-slide-toggle/dynamic-slide-toggle.component';\nimport { TdDynamicCheckboxComponent } from '../dynamic-elements/dynamic-checkbox/dynamic-checkbox.component';\nimport { TdDynamicSliderComponent } from '../dynamic-elements/dynamic-slider/dynamic-slider.component';\nimport { TdDynamicSelectComponent } from '../dynamic-elements/dynamic-select/dynamic-select.component';\nimport { TdDynamicDatepickerComponent } from '../dynamic-elements/dynamic-datepicker/dynamic-datepicker.component';\n\nexport enum TdDynamicType {\n  Text = 'text',\n  Boolean = 'boolean',\n  Number = 'number',\n  Array = 'array',\n  Date = 'date',\n}\n\nexport enum TdDynamicElement {\n  Input = 'input',\n  Datepicker = 'datepicker',\n  Password = 'password',\n  Textarea = 'textarea',\n  Slider = 'slider',\n  SlideToggle = 'slide-toggle',\n  Checkbox = 'checkbox',\n  Select = 'select',\n  FileInput = 'file-input',\n}\n\nexport interface ITdDynamicElementValidator {\n  validator: ValidatorFn;\n}\n\n// Property values to be set in custom component\nexport interface ITdDynamicElementCustomConfig {\n  [name: string]: any;\n}\n\nexport interface ITdDynamicElementConfig {\n  label?: string;\n  name: string;\n  hint?: string;\n  type: TdDynamicType | TdDynamicElement | Type<any>;\n  required?: boolean;\n  disabled?: boolean;\n  min?: any;\n  max?: any;\n  minLength?: any;\n  maxLength?: any;\n  selections?: string[] | { value: any; label: string }[];\n  multiple?: boolean;\n  default?: any;\n  flex?: number;\n  validators?: ITdDynamicElementValidator[];\n  customConfig?: ITdDynamicElementCustomConfig;\n  placeholder?: string;\n}\n\nexport const DYNAMIC_ELEMENT_NAME_REGEX: RegExp = /^[^0-9][^\\@]*$/;\n\n@Injectable()\nexport class TdDynamicFormsService {\n  /**\n   * Method to validate if the [name] is a proper element name.\n   * Throws error if name is not valid.\n   */\n  validateDynamicElementName(name: string): void {\n    if (!DYNAMIC_ELEMENT_NAME_REGEX.test(name)) {\n      throw new Error('Dynamic element name: \"${name}\" is not valid.');\n    }\n  }\n\n  /**\n   * Gets component to be rendered depending on [TdDynamicElement | TdDynamicType]\n   * Throws error if it does not exists or not supported.\n   */\n  getDynamicElement(element: TdDynamicElement | TdDynamicType | Type<any>): any {\n    switch (element) {\n      case TdDynamicType.Text:\n      case TdDynamicType.Number:\n      case TdDynamicElement.Input:\n      case TdDynamicElement.Password:\n        return TdDynamicInputComponent;\n      case TdDynamicElement.Textarea:\n        return TdDynamicTextareaComponent;\n      case TdDynamicType.Boolean:\n      case TdDynamicElement.SlideToggle:\n        return TdDynamicSlideToggleComponent;\n      case TdDynamicElement.Checkbox:\n        return TdDynamicCheckboxComponent;\n      case TdDynamicElement.Slider:\n        return TdDynamicSliderComponent;\n      case TdDynamicType.Array:\n      case TdDynamicElement.Select:\n        return TdDynamicSelectComponent;\n      case TdDynamicElement.FileInput:\n        return TdDynamicFileInputComponent;\n      case TdDynamicElement.Datepicker:\n      case TdDynamicType.Date:\n        return TdDynamicDatepickerComponent;\n      default:\n        throw new Error(`Error: type ${element} does not exist or not supported.`);\n    }\n  }\n\n  /**\n   * Creates form control for element depending [ITdDynamicElementConfig] properties.\n   */\n  createFormControl(config: ITdDynamicElementConfig): FormControl {\n    const validator: ValidatorFn = this.createValidators(config);\n    return new FormControl({ value: config.default, disabled: config.disabled }, validator);\n  }\n\n  /**\n   * Creates form validationdepending [ITdDynamicElementConfig] properties.\n   */\n  createValidators(config: ITdDynamicElementConfig): ValidatorFn {\n    let validator: ValidatorFn;\n    if (config.required) {\n      validator = Validators.required;\n    }\n    if (config.max || config.max === 0) {\n      validator = Validators.compose([validator, Validators.max(parseFloat(config.max))]);\n    }\n    if (config.min || config.min === 0) {\n      validator = Validators.compose([validator, Validators.min(parseFloat(config.min))]);\n    }\n    if (config.maxLength || config.maxLength === 0) {\n      validator = Validators.compose([validator, Validators.maxLength(parseFloat(config.maxLength))]);\n    }\n    if (config.minLength || config.minLength === 0) {\n      validator = Validators.compose([validator, Validators.minLength(parseFloat(config.minLength))]);\n    }\n    // Add provided custom validators to the validator function\n    if (config.validators) {\n      config.validators.forEach((validatorConfig: ITdDynamicElementValidator) => {\n        validator = Validators.compose([validator, validatorConfig.validator]);\n      });\n    }\n    return validator;\n  }\n}\n\nexport function DYNAMIC_FORMS_PROVIDER_FACTORY(parent: TdDynamicFormsService): TdDynamicFormsService {\n  return parent || new TdDynamicFormsService();\n}\n\nexport const DYNAMIC_FORMS_PROVIDER: Provider = {\n  // If there is already a service available, use that. Otherwise, provide a new one.\n  provide: TdDynamicFormsService,\n  deps: [[new Optional(), new SkipSelf(), TdDynamicFormsService]],\n  useFactory: DYNAMIC_FORMS_PROVIDER_FACTORY,\n};\n"]}