@tft/crispr-forms 12.2.19 → 13.0.0

package/esm2020/index.mjs

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

package/esm2020/lib/abstracts/autocomplete-field.abstract.mjs

@@ -0,0 +1,30 @@
+import { Directive } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { debounceTime, distinctUntilChanged, map, startWith, switchMap } from 'rxjs/operators';
+import { crisprControlMixin } from './crispr-control.mixin';
+import { CrisprFieldComponent } from './crispr-field.abstract';
+import { observablifyOptions } from '../form.helpers';
+import * as i0 from "@angular/core";
+const AbstractAutocompleteFieldMixin = crisprControlMixin(CrisprFieldComponent);
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+export class AbstractAutocompleteComponent extends AbstractAutocompleteFieldMixin {
+    constructor() {
+        super(...arguments);
+        // we need a separate control for the UI because of the way the material autocomplete chiplist works
+        this.autocompleteInputControl = new FormControl('');
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.group.addControl(this.config.controlName, new FormControl());
+        // filter options by the search string using either the default filter function or one passed in through config
+        this.options$ = this.autocompleteInputControl.valueChanges.pipe(
+        // this is needed to have the options panel to open on focus
+        startWith(''), debounceTime(this.config.typeDebounceTime), distinctUntilChanged(), map(searchText => searchText || ''), switchMap((searchText) => observablifyOptions(this.config.options, this.group, searchText)));
+    }
+}
+AbstractAutocompleteComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: AbstractAutocompleteComponent, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+AbstractAutocompleteComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.1", type: AbstractAutocompleteComponent, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: AbstractAutocompleteComponent, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/abstracts/crispr-control.mixin.mjs

@@ -0,0 +1,27 @@
+import { ControlType } from '../models/crispr-field.config';
+export function crisprControlMixin(BaseClass) {
+    return class extends BaseClass {
+        set value(value) {
+            this.setControlValue(value);
+            this._value = value;
+        }
+        get value() {
+            return this._value;
+        }
+        ngOnInit() {
+            super.ngOnInit();
+            this.control = this.group.get(this.config.controlName);
+            this.setControlValue(this.value);
+            // setTimeouts are ugly but this seems to be the only way to get the computed field to compute initial values
+            setTimeout(() => {
+                this.control.updateValueAndValidity();
+            });
+        }
+        setControlValue(value) {
+            if (value && this.control && this.config.controlType !== ControlType.SUB_GROUP) {
+                this.control.setValue(value);
+            }
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/abstracts/crispr-field.abstract.mjs

@@ -0,0 +1,17 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+export class CrisprFieldComponent {
+    ngOnInit() {
+        this.applyDefaultConfig();
+    }
+    applyDefaultConfig() {
+        this.config = this.defaultConfig ? { ...this.defaultConfig, ...this.config } : this.config;
+    }
+}
+CrisprFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: CrisprFieldComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CrisprFieldComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.1", type: CrisprFieldComponent, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: CrisprFieldComponent, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3Jpc3ByLWZpZWxkLmFic3RyYWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jcmlzcHItZm9ybXMvc3JjL2xpYi9hYnN0cmFjdHMvY3Jpc3ByLWZpZWxkLmFic3RyYWN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE9BQU8sRUFBVSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBR2xELGtFQUFrRTtBQUNsRSxNQUFNLE9BQWdCLG9CQUFvQjtJQUl4QyxRQUFRO1FBQ04sSUFBSSxDQUFDLGtCQUFrQixFQUFFLENBQUM7SUFDNUIsQ0FBQztJQUVELGtCQUFrQjtRQUNoQixJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsQ0FBQyxDQUFDLEVBQUMsR0FBRyxJQUFJLENBQUMsYUFBYSxFQUFFLEdBQUcsSUFBSSxDQUFDLE1BQU0sRUFBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDO0lBQzNGLENBQUM7O2lIQVZtQixvQkFBb0I7cUdBQXBCLG9CQUFvQjsyRkFBcEIsb0JBQW9CO2tCQUZ6QyxTQUFTIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUge1xuICBDcmlzcHJGaWVsZENvbmZpZyxcbn0gZnJvbSAnLi4vbW9kZWxzJztcbmltcG9ydCB7IE9uSW5pdCwgRGlyZWN0aXZlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBEaXJlY3RpdmUoKVxuLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEBhbmd1bGFyLWVzbGludC9kaXJlY3RpdmUtY2xhc3Mtc3VmZml4XG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQ3Jpc3ByRmllbGRDb21wb25lbnQ8QyBleHRlbmRzIENyaXNwckZpZWxkQ29uZmlnPiBpbXBsZW1lbnRzIE9uSW5pdCB7XG4gIGNvbmZpZzogQztcbiAgZGVmYXVsdENvbmZpZz86IFBhcnRpYWw8Qz5cblxuICBuZ09uSW5pdCgpIHtcbiAgICB0aGlzLmFwcGx5RGVmYXVsdENvbmZpZygpO1xuICB9XG5cbiAgYXBwbHlEZWZhdWx0Q29uZmlnKCkge1xuICAgIHRoaXMuY29uZmlnID0gdGhpcy5kZWZhdWx0Q29uZmlnID8gey4uLnRoaXMuZGVmYXVsdENvbmZpZywgLi4udGhpcy5jb25maWd9IDogdGhpcy5jb25maWc7XG4gIH1cbn1cblxuXG4iXX0=

package/esm2020/lib/abstracts/index.mjs

@@ -0,0 +1,4 @@
+export * from './autocomplete-field.abstract';
+export * from './crispr-control.mixin';
+export * from './crispr-field.abstract';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NyaXNwci1mb3Jtcy9zcmMvbGliL2Fic3RyYWN0cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXV0b2NvbXBsZXRlLWZpZWxkLmFic3RyYWN0JztcclxuZXhwb3J0ICogZnJvbSAnLi9jcmlzcHItY29udHJvbC5taXhpbic7XHJcbmV4cG9ydCAqIGZyb20gJy4vY3Jpc3ByLWZpZWxkLmFic3RyYWN0JztcclxuIl19

package/esm2020/lib/crispr-forms.module.mjs

@@ -0,0 +1,66 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ReactiveFormsModule } from '@angular/forms';
+// custom modules
+import { MaterialModule } from './material/material.module';
+import { FormValidationHandlerModule } from '@tft/form-validation-handler';
+// components
+import { CrisprFormComponent } from './form/form.component';
+import { FormGroupListModule } from './form-group-list';
+// directives
+import { CrisprFieldModule } from './field.directive';
+import { SubGroupModule } from './sub-group';
+import { CrisprPipesModule } from './pipes/crispr-pipes.module';
+import { FieldContainerModule } from './field-container';
+import * as i0 from "@angular/core";
+export class CrisprFormsModule {
+}
+CrisprFormsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: CrisprFormsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CrisprFormsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: CrisprFormsModule, declarations: [CrisprFormComponent], imports: [CommonModule,
+        ReactiveFormsModule,
+        FormValidationHandlerModule,
+        FormGroupListModule,
+        FieldContainerModule,
+        CrisprFieldModule,
+        SubGroupModule,
+        MaterialModule,
+        CrisprPipesModule], exports: [CrisprFormComponent,
+        FieldContainerModule,
+        MaterialModule] });
+CrisprFormsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: CrisprFormsModule, imports: [[
+            CommonModule,
+            ReactiveFormsModule,
+            FormValidationHandlerModule,
+            FormGroupListModule,
+            FieldContainerModule,
+            CrisprFieldModule,
+            SubGroupModule,
+            MaterialModule,
+            CrisprPipesModule,
+        ], FieldContainerModule,
+        MaterialModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: CrisprFormsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        FormValidationHandlerModule,
+                        FormGroupListModule,
+                        FieldContainerModule,
+                        CrisprFieldModule,
+                        SubGroupModule,
+                        MaterialModule,
+                        CrisprPipesModule,
+                    ],
+                    declarations: [
+                        CrisprFormComponent,
+                    ],
+                    exports: [
+                        CrisprFormComponent,
+                        FieldContainerModule,
+                        MaterialModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3Jpc3ByLWZvcm1zLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY3Jpc3ByLWZvcm1zL3NyYy9saWIvY3Jpc3ByLWZvcm1zLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUNyRCxpQkFBaUI7QUFDakIsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLDRCQUE0QixDQUFBO0FBRTNELE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBRTNFLGFBQWE7QUFDYixPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUM1RCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN4RCxhQUFhO0FBQ2IsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDdEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUM3QyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQzs7QUF1QnpELE1BQU0sT0FBTyxpQkFBaUI7OzhHQUFqQixpQkFBaUI7K0dBQWpCLGlCQUFpQixpQkFSMUIsbUJBQW1CLGFBWG5CLFlBQVk7UUFDWixtQkFBbUI7UUFDbkIsMkJBQTJCO1FBQzNCLG1CQUFtQjtRQUNuQixvQkFBb0I7UUFDcEIsaUJBQWlCO1FBQ2pCLGNBQWM7UUFDZCxjQUFjO1FBQ2QsaUJBQWlCLGFBTWpCLG1CQUFtQjtRQUNuQixvQkFBb0I7UUFDcEIsY0FBYzsrR0FHTCxpQkFBaUIsWUFwQm5CO1lBQ1AsWUFBWTtZQUNaLG1CQUFtQjtZQUNuQiwyQkFBMkI7WUFDM0IsbUJBQW1CO1lBQ25CLG9CQUFvQjtZQUNwQixpQkFBaUI7WUFDakIsY0FBYztZQUNkLGNBQWM7WUFDZCxpQkFBaUI7U0FDbEIsRUFNQyxvQkFBb0I7UUFDcEIsY0FBYzsyRkFHTCxpQkFBaUI7a0JBckI3QixRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRTt3QkFDUCxZQUFZO3dCQUNaLG1CQUFtQjt3QkFDbkIsMkJBQTJCO3dCQUMzQixtQkFBbUI7d0JBQ25CLG9CQUFvQjt3QkFDcEIsaUJBQWlCO3dCQUNqQixjQUFjO3dCQUNkLGNBQWM7d0JBQ2QsaUJBQWlCO3FCQUNsQjtvQkFDRCxZQUFZLEVBQUU7d0JBQ1osbUJBQW1CO3FCQUNwQjtvQkFDRCxPQUFPLEVBQUU7d0JBQ1AsbUJBQW1CO3dCQUNuQixvQkFBb0I7d0JBQ3BCLGNBQWM7cUJBQ2Y7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IFJlYWN0aXZlRm9ybXNNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG4vLyBjdXN0b20gbW9kdWxlc1xuaW1wb3J0IHsgTWF0ZXJpYWxNb2R1bGUgfSBmcm9tICcuL21hdGVyaWFsL21hdGVyaWFsLm1vZHVsZSdcblxuaW1wb3J0IHsgRm9ybVZhbGlkYXRpb25IYW5kbGVyTW9kdWxlIH0gZnJvbSAnQHRmdC9mb3JtLXZhbGlkYXRpb24taGFuZGxlcic7XG5cbi8vIGNvbXBvbmVudHNcbmltcG9ydCB7IENyaXNwckZvcm1Db21wb25lbnQgfSBmcm9tICcuL2Zvcm0vZm9ybS5jb21wb25lbnQnO1xuaW1wb3J0IHsgRm9ybUdyb3VwTGlzdE1vZHVsZSB9IGZyb20gJy4vZm9ybS1ncm91cC1saXN0Jztcbi8vIGRpcmVjdGl2ZXNcbmltcG9ydCB7IENyaXNwckZpZWxkTW9kdWxlIH0gZnJvbSAnLi9maWVsZC5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgU3ViR3JvdXBNb2R1bGUgfSBmcm9tICcuL3N1Yi1ncm91cCc7XG5pbXBvcnQgeyBDcmlzcHJQaXBlc01vZHVsZSB9IGZyb20gJy4vcGlwZXMvY3Jpc3ByLXBpcGVzLm1vZHVsZSc7XG5pbXBvcnQgeyBGaWVsZENvbnRhaW5lck1vZHVsZSB9IGZyb20gJy4vZmllbGQtY29udGFpbmVyJztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW1xuICAgIENvbW1vbk1vZHVsZSxcbiAgICBSZWFjdGl2ZUZvcm1zTW9kdWxlLFxuICAgIEZvcm1WYWxpZGF0aW9uSGFuZGxlck1vZHVsZSxcbiAgICBGb3JtR3JvdXBMaXN0TW9kdWxlLFxuICAgIEZpZWxkQ29udGFpbmVyTW9kdWxlLFxuICAgIENyaXNwckZpZWxkTW9kdWxlLFxuICAgIFN1Ykdyb3VwTW9kdWxlLFxuICAgIE1hdGVyaWFsTW9kdWxlLFxuICAgIENyaXNwclBpcGVzTW9kdWxlLFxuICBdLFxuICBkZWNsYXJhdGlvbnM6IFtcbiAgICBDcmlzcHJGb3JtQ29tcG9uZW50LFxuICBdLFxuICBleHBvcnRzOiBbXG4gICAgQ3Jpc3ByRm9ybUNvbXBvbmVudCxcbiAgICBGaWVsZENvbnRhaW5lck1vZHVsZSxcbiAgICBNYXRlcmlhbE1vZHVsZVxuICBdXG59KVxuZXhwb3J0IGNsYXNzIENyaXNwckZvcm1zTW9kdWxlIHsgfVxuIl19

package/esm2020/lib/field-component-map.const.mjs

@@ -0,0 +1,25 @@
+import { isControlConfig } from './form.helpers';
+import { ControlType } from './models';
+export const FIELD_COMPONENTS = {
+    groupList: import('./form-group-list').then(({ FormGroupListComponent }) => FormGroupListComponent),
+    subGroup: import('./sub-group').then(({ SubGroupComponent }) => SubGroupComponent),
+    button: import('./material').then(({ ButtonComponent }) => ButtonComponent),
+    input: import('./material').then(({ InputFieldComponent }) => InputFieldComponent),
+    select: import('./material').then(({ SelectFieldComponent }) => SelectFieldComponent),
+    radio: import('./material').then(({ RadioFieldComponent }) => RadioFieldComponent),
+    autocomplete: import('./material').then(({ AutocompleteFieldComponent }) => AutocompleteFieldComponent),
+    autocompleteChiplist: import('./material').then(({ AutocompleteChiplistFieldComponent }) => AutocompleteChiplistFieldComponent),
+    textarea: import('./material').then(({ TextareaFieldComponent }) => TextareaFieldComponent),
+    checkbox: import('./material').then(({ CheckboxFieldComponent }) => CheckboxFieldComponent),
+    slider: import('./material').then(({ SliderFieldComponent }) => SliderFieldComponent),
+    datepicker: import('./material').then(({ DatepickerFieldComponent }) => DatepickerFieldComponent),
+    fileUpload: import('./material').then(({ FileUploadFieldComponent }) => FileUploadFieldComponent),
+    imageUpload: import('./material').then(({ ImageUploadFieldComponent }) => ImageUploadFieldComponent),
+    heading: import('./material').then(({ HeadingComponent }) => HeadingComponent),
+    divider: import('./material').then(({ DividerComponent }) => DividerComponent),
+    unitConversion: import('./material').then(({ UnitConversionFieldComponent }) => UnitConversionFieldComponent)
+};
+export function isControlComponent(component) {
+    return isControlConfig(component.config) || component.config.controlType === ControlType.BUTTON;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/field-container/field-container.component.mjs

@@ -0,0 +1,85 @@
+import { Component, Input, ChangeDetectionStrategy, NgModule } from '@angular/core';
+import { of } from 'rxjs';
+import { FormGroup } from '@angular/forms';
+import { tap, distinctUntilChanged } from 'rxjs/operators';
+import { computeValueFromFields } from '../form.helpers';
+import { CommonModule } from '@angular/common';
+import { HeadingModule } from '../material/heading/heading.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../material/heading/heading.component";
+import * as i2 from "@angular/common";
+export class FieldContainerComponent {
+    constructor() {
+        // boolean whether field-container is inline
+        this.inlineField = false;
+        this.subs = [];
+    }
+    ngOnInit() {
+        this.disabled$ = this.connectDisabledCallback(this.group, this.config);
+        // we tried moving this into afterViewChecked and afterContentChecked lifecycle hooks without any luck
+        if (this.config.computeValue) {
+            this.subs.push(this.config.computeValue(this.group).pipe(distinctUntilChanged(), tap(computedValue => this.group.get(this.config.controlName).setValue(computedValue))).subscribe());
+        }
+        else if (this.config.computeFieldConfig) {
+            console.warn(`computeFieldConfig property is deprecated, please use computeValue. Example here: https://stackblitz.com/github/nayfin/tft-documentation?file=src%2Fapp%2Fcrispr-forms-demo%2Ffeatures%2Fcomputed-field%2Fcomputed-field.component.ts`);
+            this.subs.push(computeValueFromFields(this.group, this.config.computeFieldConfig).pipe(distinctUntilChanged(), tap(computedValue => this.group.get(this.config.controlName).setValue(computedValue))).subscribe());
+        }
+    }
+    ngOnDestroy() {
+        this.subs.forEach(sub => sub.unsubscribe);
+    }
+    /**
+     * Connects user defined disabledCallback function to the the view, so that the control is enabled/disabled
+     * appropriately. It also keeps the form will hide disabled fields in the UI unless `hideDisabled` is set to
+     * false in the controls config
+     * @param group used to get valueChanges from control
+     * @param config configuration object used to
+     */
+    connectDisabledCallback(group, config = null) {
+        const control = group.get(config.controlName);
+        // If the disabled$ function exists on the field config then call it with the disabledCallbackConfig
+        // as a parameter otherwise return an observable of true.
+        return config?.disabledCallback && config.disabledCallback instanceof Function
+            ? config.disabledCallback(group, config.disabledCallbackConfig || null).pipe(
+            // This enables/disables when callback conditions are met
+            tap((shouldDisable) => shouldDisable ? control.disable() : control.enable()))
+            : of(false);
+    }
+}
+FieldContainerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: FieldContainerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+FieldContainerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.1", type: FieldContainerComponent, selector: "crispr-field-container", inputs: { config: "config", group: "group", inlineField: "inlineField" }, ngImport: i0, template: "<div\n  *ngIf=\"(disabled$ | async) ? !config.hideDisabled : true\"\n  [ngClass]=\"config.classes\"\n  [class.inline-field]=\"inlineField\"\n  class=\"field-container\">\n\n  <crispr-heading\n    *ngIf=\"config.heading\"\n    [config]=\"config.heading\">\n  </crispr-heading>\n\n  <ng-content>\n  </ng-content>\n\n</div>\n", styles: ["::ng-deep mat-form-field.mat-form-field{display:block}.inline-field{display:inline-block}\n"], components: [{ type: i1.HeadingComponent, selector: "crispr-heading", inputs: ["config"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], pipes: { "async": i2.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush, preserveWhitespaces: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: FieldContainerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'crispr-field-container', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div\n  *ngIf=\"(disabled$ | async) ? !config.hideDisabled : true\"\n  [ngClass]=\"config.classes\"\n  [class.inline-field]=\"inlineField\"\n  class=\"field-container\">\n\n  <crispr-heading\n    *ngIf=\"config.heading\"\n    [config]=\"config.heading\">\n  </crispr-heading>\n\n  <ng-content>\n  </ng-content>\n\n</div>\n", styles: ["::ng-deep mat-form-field.mat-form-field{display:block}.inline-field{display:inline-block}\n"] }]
+        }], propDecorators: { config: [{
+                type: Input
+            }], group: [{
+                type: Input
+            }], inlineField: [{
+                type: Input
+            }] } });
+export class FieldContainerModule {
+}
+FieldContainerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: FieldContainerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FieldContainerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: FieldContainerModule, declarations: [FieldContainerComponent], imports: [CommonModule,
+        HeadingModule], exports: [FieldContainerComponent] });
+FieldContainerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: FieldContainerModule, imports: [[
+            CommonModule,
+            HeadingModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: FieldContainerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        HeadingModule,
+                    ],
+                    exports: [
+                        FieldContainerComponent
+                    ],
+                    declarations: [
+                        FieldContainerComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"field-container.component.js","sourceRoot":"","sources":["../../../../../../libs/crispr-forms/src/lib/field-container/field-container.component.ts","../../../../../../libs/crispr-forms/src/lib/field-container/field-container.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAU,KAAK,EAAE,uBAAuB,EAAa,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEvG,OAAO,EAAc,EAAE,EAAgB,MAAM,MAAM,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,GAAG,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;;;;AAQtE,MAAM,OAAO,uBAAuB;IANpC;QAWE,4CAA4C;QACnC,gBAAW,GAAG,KAAK,CAAC;QAI7B,SAAI,GAAmB,EAAE,CAAC;KA4C3B;IA1CC,QAAQ;QACN,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QACvE,sGAAsG;QACtG,IAAI,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE;YAC5B,IAAI,CAAC,IAAI,CAAC,IAAI,CACZ,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CACvC,oBAAoB,EAAE,EACtB,GAAG,CAAC,aAAa,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CACtF,CAAC,SAAS,EAAE,CACd,CAAC;SACH;aAAM,IAAI,IAAI,CAAC,MAAM,CAAC,kBAAkB,EAAE;YACzC,OAAO,CAAC,IAAI,CAAC,uOAAuO,CAAC,CAAA;YACrP,IAAI,CAAC,IAAI,CAAC,IAAI,CACZ,sBAAsB,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,IAAI,CACrE,oBAAoB,EAAE,EACtB,GAAG,CAAC,aAAa,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CACtF,CAAC,SAAS,EAAE,CACd,CAAC;SACH;IACH,CAAC;IAED,WAAW;QACT,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IAC5C,CAAC;IACD;;;;;;OAMG;IACH,uBAAuB,CAAC,KAAgB,EAAE,SAA8B,IAAI;QAC1E,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QAC9C,oGAAoG;QACpG,yDAAyD;QACzD,OAAO,MAAM,EAAE,gBAAgB,IAAI,MAAM,CAAC,gBAAgB,YAAY,QAAQ;YAC5E,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,sBAAsB,IAAI,IAAI,CAAC,CAAC,IAAI;YAC1E,yDAAyD;YACzD,GAAG,CAAC,CAAC,aAAa,EAAE,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAC7E;YACD,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;IAChB,CAAC;;oHArDU,uBAAuB;wGAAvB,uBAAuB,wICfpC,oUAeA;2FDAa,uBAAuB;kBANnC,SAAS;+BACE,wBAAwB,mBAGjB,uBAAuB,CAAC,MAAM;8BAItC,MAAM;sBAAd,KAAK;gBAEG,KAAK;sBAAb,KAAK;gBAEG,WAAW;sBAAnB,KAAK;;AA8DR,MAAM,OAAO,oBAAoB;;iHAApB,oBAAoB;kHAApB,oBAAoB,iBApEpB,uBAAuB,aAyDhC,YAAY;QACZ,aAAa,aA1DJ,uBAAuB;kHAoEvB,oBAAoB,YAZtB;YACP,YAAY;YACZ,aAAa;SACd;2FASU,oBAAoB;kBAbhC,QAAQ;mBAAC;oBACR,OAAO,EAAE;wBACP,YAAY;wBACZ,aAAa;qBACd;oBACD,OAAO,EAAE;wBACP,uBAAuB;qBACxB;oBACD,YAAY,EAAE;wBACZ,uBAAuB;qBACxB;iBACF","sourcesContent":["import { Component, OnInit, Input, ChangeDetectionStrategy, OnDestroy, NgModule } from '@angular/core';\nimport type { CrisprControlConfig } from '../models';\nimport { Observable, of, Subscription } from 'rxjs';\nimport { FormGroup } from '@angular/forms';\nimport { tap, distinctUntilChanged } from 'rxjs/operators';\nimport { computeValueFromFields } from '../form.helpers';\nimport { CommonModule } from '@angular/common';\nimport { HeadingModule } from '../material/heading/heading.component';\n\n@Component({\n  selector: 'crispr-field-container',\n  templateUrl: './field-container.component.html',\n  styleUrls: ['./field-container.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class FieldContainerComponent implements OnInit, OnDestroy {\n  // the configuration object for the field\n  @Input() config: CrisprControlConfig;\n  // the parent formGroup\n  @Input() group: FormGroup;\n  // boolean whether field-container is inline\n  @Input() inlineField = false;\n  // used to determine whether or not field should be shown\n  disabled$: Observable<boolean>;\n\n  subs: Subscription[] = [];\n\n  ngOnInit() {\n    this.disabled$ = this.connectDisabledCallback(this.group, this.config);\n    // we tried moving this into afterViewChecked and afterContentChecked lifecycle hooks without any luck\n    if (this.config.computeValue) {\n      this.subs.push(\n        this.config.computeValue(this.group).pipe(\n          distinctUntilChanged(),\n          tap(computedValue => this.group.get(this.config.controlName).setValue(computedValue))\n        ).subscribe(),\n      );\n    } else if (this.config.computeFieldConfig) {\n      console.warn(`computeFieldConfig property is deprecated, please use computeValue. Example here: https://stackblitz.com/github/nayfin/tft-documentation?file=src%2Fapp%2Fcrispr-forms-demo%2Ffeatures%2Fcomputed-field%2Fcomputed-field.component.ts`)\n      this.subs.push(\n        computeValueFromFields(this.group, this.config.computeFieldConfig).pipe(\n          distinctUntilChanged(),\n          tap(computedValue => this.group.get(this.config.controlName).setValue(computedValue))\n        ).subscribe(),\n      );\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.subs.forEach(sub => sub.unsubscribe);\n  }\n  /**\n   * Connects user defined disabledCallback function to the the view, so that the control is enabled/disabled\n   * appropriately. It also keeps the form will hide disabled fields in the UI unless `hideDisabled` is set to\n   * false in the controls config\n   * @param group used to get valueChanges from control\n   * @param config configuration object used to\n   */\n  connectDisabledCallback(group: FormGroup, config: CrisprControlConfig = null) {\n    const control = group.get(config.controlName);\n    // If the disabled$ function exists on the field config then call it with the disabledCallbackConfig\n    // as a parameter otherwise return an observable of true.\n    return config?.disabledCallback && config.disabledCallback instanceof Function\n      ? config.disabledCallback(group, config.disabledCallbackConfig || null).pipe(\n        // This enables/disables when callback conditions are met\n        tap((shouldDisable) => shouldDisable ? control.disable() : control.enable())\n      )\n      : of(false);\n  }\n}\n@NgModule({\n  imports: [\n    CommonModule,\n    HeadingModule,\n  ],\n  exports: [\n    FieldContainerComponent\n  ],\n  declarations: [\n    FieldContainerComponent\n  ]\n})\n\nexport class FieldContainerModule {\n}\n","<div\n  *ngIf=\"(disabled$ | async) ? !config.hideDisabled : true\"\n  [ngClass]=\"config.classes\"\n  [class.inline-field]=\"inlineField\"\n  class=\"field-container\">\n\n  <crispr-heading\n    *ngIf=\"config.heading\"\n    [config]=\"config.heading\">\n  </crispr-heading>\n\n  <ng-content>\n  </ng-content>\n\n</div>\n"]}

package/esm2020/lib/field-container/index.mjs

@@ -0,0 +1,2 @@
+export * from './field-container.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NyaXNwci1mb3Jtcy9zcmMvbGliL2ZpZWxkLWNvbnRhaW5lci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDZCQUE2QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9maWVsZC1jb250YWluZXIuY29tcG9uZW50JztcbiJdfQ==

package/esm2020/lib/field.directive.mjs

@@ -0,0 +1,77 @@
+import { Directive, Input, ViewContainerRef, Renderer2, NgModule, ChangeDetectorRef } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { FIELD_COMPONENTS, isControlComponent } from './field-component-map.const';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+export class CrisprFieldDirective {
+    constructor(container, renderer, cdr) {
+        this.container = container;
+        this.renderer = renderer;
+        this.cdr = cdr;
+    }
+    async ngOnInit() {
+        /**
+         * create component and set values from config on its instance
+         */
+        const component = this.config.component || await FIELD_COMPONENTS[this.config.controlType];
+        const componentRef = this.container.createComponent(component);
+        this.component = componentRef.instance;
+        this.component.config = this.config;
+        if (isControlComponent(this.component)) {
+            this.component.group = this.group;
+            if ('value' in this.component) {
+                this.component.value = this.value;
+            }
+        }
+        this.cdr.detectChanges();
+        // adds any config classes to the dynamically generated component
+        // doing this here keeps us from having to extend a base component into each field component individually
+        if (!this.config.classes)
+            return;
+        this.config.classes.forEach((klass) => {
+            // check for passing multiple classes in one array element
+            if (klass.includes(' ')) {
+                throw Error(`Improperly formatted class. '${klass}' cannot contain spaces.`);
+            }
+            else {
+                this.renderer.addClass(componentRef.location.nativeElement, klass);
+            }
+        });
+    }
+}
+CrisprFieldDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: CrisprFieldDirective, deps: [{ token: i0.ViewContainerRef }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+CrisprFieldDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.1", type: CrisprFieldDirective, selector: "[crisprField]", inputs: { config: "config", group: "group", value: "value" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: CrisprFieldDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[crisprField]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.Renderer2 }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { config: [{
+                type: Input
+            }], group: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }] } });
+export class CrisprFieldModule {
+}
+CrisprFieldModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: CrisprFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CrisprFieldModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: CrisprFieldModule, declarations: [CrisprFieldDirective], imports: [CommonModule], exports: [CrisprFieldDirective] });
+CrisprFieldModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: CrisprFieldModule, imports: [[
+            CommonModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: CrisprFieldModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                    ],
+                    exports: [
+                        CrisprFieldDirective
+                    ],
+                    declarations: [
+                        CrisprFieldDirective
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/form/form.component.mjs

@@ -0,0 +1,54 @@
+import { Component, Input, Output, EventEmitter, ChangeDetectionStrategy, ViewChild, ElementRef } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { buildFormGroupFromConfig } from '../form.helpers';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@tft/form-validation-handler";
+import * as i3 from "@angular/common";
+import * as i4 from "../field.directive";
+import * as i5 from "../pipes/initial-control-value.pipe";
+export class CrisprFormComponent {
+    constructor() {
+        this.form = new FormGroup({});
+        this.value = null;
+        this.submitted = new EventEmitter();
+        // proxy value and status change events through to consuming component
+        this.valueChanges = this.form.valueChanges;
+        this.statusChanges = this.form.statusChanges;
+        this.subs = [];
+    }
+    ngOnInit() {
+        // build out the form, note that we pass in the form as the third argument and the function modifies it
+        buildFormGroupFromConfig(this.config, this.value, this.form);
+    }
+    handleSubmit() {
+        this.form.markAllAsTouched();
+        this.submitted.emit(this.form);
+    }
+    triggerSubmit() {
+        this.submitTrigger.nativeElement.click();
+    }
+}
+CrisprFormComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: CrisprFormComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+CrisprFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.1", type: CrisprFormComponent, selector: "crispr-form", inputs: { config: "config", form: "form", value: "value" }, outputs: { submitted: "submitted", valueChanges: "valueChanges", statusChanges: "statusChanges" }, viewQueries: [{ propertyName: "submitTrigger", first: true, predicate: ["submitTrigger"], descendants: true }], ngImport: i0, template: "<form\n  class=\"crispr-form\"\n  [ngClass]=\"config.classes\"\n  [formGroup]=\"form\"\n  (ngSubmit)=\"handleSubmit()\"\n  [autocomplete]=\"config.autocomplete || 'off'\"\n  [errorDictionary]=\"config.errorDictionary\"\n  #ngFormElement=\"ngForm\">\n\n  <ng-container\n    *ngFor=\"let field of config.fields;\"\n    crisprField\n    [value]=\"value | initialControlValue : field\"\n    [config]=\"field\"\n    [group]=\"form\">\n  </ng-container>\n  <!-- Hidden button, programmatically clicked when crispr form triggerSubmit function called.\n    Uses a hidden button with type=\"submit\" because it will trigger both native form submit event\n    (which the error handler has to listen for) and ngSubmit event  -->\n  <button #submitTrigger class=\"submit-trigger\" type=\"submit\">\n  </button>\n</form>\n", styles: [".submit-trigger{display:none}\n"], directives: [{ type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i2.ControlErrorsFormDirective, selector: "form", inputs: ["errorDictionary"] }, { type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i2.ControlErrorContainerDirective, selector: "[controlErrorContainer], [formGroup]" }, { type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i4.CrisprFieldDirective, selector: "[crisprField]", inputs: ["config", "group", "value"] }], pipes: { "initialControlValue": i5.InitialControlValuePipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush, preserveWhitespaces: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: CrisprFormComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'crispr-form', changeDetection: ChangeDetectionStrategy.OnPush, template: "<form\n  class=\"crispr-form\"\n  [ngClass]=\"config.classes\"\n  [formGroup]=\"form\"\n  (ngSubmit)=\"handleSubmit()\"\n  [autocomplete]=\"config.autocomplete || 'off'\"\n  [errorDictionary]=\"config.errorDictionary\"\n  #ngFormElement=\"ngForm\">\n\n  <ng-container\n    *ngFor=\"let field of config.fields;\"\n    crisprField\n    [value]=\"value | initialControlValue : field\"\n    [config]=\"field\"\n    [group]=\"form\">\n  </ng-container>\n  <!-- Hidden button, programmatically clicked when crispr form triggerSubmit function called.\n    Uses a hidden button with type=\"submit\" because it will trigger both native form submit event\n    (which the error handler has to listen for) and ngSubmit event  -->\n  <button #submitTrigger class=\"submit-trigger\" type=\"submit\">\n  </button>\n</form>\n", styles: [".submit-trigger{display:none}\n"] }]
+        }], propDecorators: { config: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], submitted: [{
+                type: Output
+            }], valueChanges: [{
+                type: Output
+            }], statusChanges: [{
+                type: Output
+            }], submitTrigger: [{
+                type: ViewChild,
+                args: ['submitTrigger']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/form-group-list/form-group-list.component.mjs

@@ -0,0 +1,51 @@
+import { Component, ChangeDetectionStrategy } from '@angular/core';
+import { createControlForType } from '../form.helpers';
+import { CrisprFieldComponent, crisprControlMixin } from '../abstracts';
+import * as i0 from "@angular/core";
+import * as i1 from "../field-container/field-container.component";
+import * as i2 from "@angular/material/button";
+import * as i3 from "@angular/material/icon";
+import * as i4 from "@angular/forms";
+import * as i5 from "@tft/form-validation-handler";
+import * as i6 from "@angular/common";
+import * as i7 from "../field.directive";
+import * as i8 from "../pipes/initial-control-value.pipe";
+const defaultConfig = {
+    addButtonLabel: 'ADD ITEM',
+    minListLength: 1,
+};
+const FormGroupListMixin = crisprControlMixin(CrisprFieldComponent);
+export class FormGroupListComponent extends FormGroupListMixin {
+    constructor() {
+        super(...arguments);
+        this.defaultConfig = defaultConfig;
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        // TODO: this is required to ngFor of controls in template, must be a better way
+        this.formArray = this.control;
+    }
+    setControlValue(values) {
+        if (this.control) {
+            if (values?.length > 0) {
+                values.forEach(value => this.addGroup(value));
+            }
+            else if (this.config.displayInitialItem) {
+                this.addGroup();
+            }
+        }
+    }
+    addGroup(value = null) {
+        this.control.push(createControlForType(this.config.itemConfig, value));
+    }
+    deleteGroup(index) {
+        this.control.removeAt(index);
+    }
+}
+FormGroupListComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: FormGroupListComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+FormGroupListComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.1", type: FormGroupListComponent, selector: "crispr-form-group-list", usesInheritance: true, ngImport: i0, template: "\n<crispr-field-container\n  [config]=\"config\"\n  [group]=\"group\"\n  [formGroup]=\"group\">\n\n  <div [formArrayName]=\"config.controlName\">\n    <!-- TODO: add sortBy function -->\n    <div *ngFor=\"let control of formArray?.controls; let i = index;\">\n      <!-- TODO: use content projection to allow custom item label component -->\n      <div class=\"item-header\">\n        <span class=\"mat-h2\" *ngIf=\"config.itemLabelBuilder\"> {{  config.itemLabelBuilder(i) }} </span>\n        <button\n          mat-icon-button\n          *ngIf=\"i + 1 > config.minListLength\">\n          <mat-icon (click)=\"deleteGroup(i)\">delete</mat-icon>\n        </button>\n      </div>\n      <div\n        [formGroupName]=\"i\">\n        <ng-container\n          *ngFor=\"let field of config.itemConfig.fields;\"\n          crisprField\n          [config]=\"field\"\n          [value]=\"value && value[i] | initialControlValue : field\"\n          [group]=\"control\">\n        </ng-container>\n      </div>\n    </div>\n  </div>\n  <div class=\"group-footer\">\n    <button\n      type=\"button\"\n      class=\"add\"\n      mat-raised-button\n      [color]=\"config.addButtonColor\"\n      (click)=\"addGroup()\">\n      {{config.addItemLabel || config.addButtonLabel}}\n    </button>\n  </div>\n\n</crispr-field-container>\n", styles: [".item-header{display:flex;justify-content:space-between}.group-footer{display:flex;justify-content:flex-end}.group-footer button.add{margin-bottom:16px}\n"], components: [{ type: i1.FieldContainerComponent, selector: "crispr-field-container", inputs: ["config", "group", "inlineField"] }, { type: i2.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { type: i3.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], directives: [{ type: i4.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i4.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i5.ControlErrorContainerDirective, selector: "[controlErrorContainer], [formGroup]" }, { type: i4.FormArrayName, selector: "[formArrayName]", inputs: ["formArrayName"] }, { type: i6.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i4.FormGroupName, selector: "[formGroupName]", inputs: ["formGroupName"] }, { type: i7.CrisprFieldDirective, selector: "[crisprField]", inputs: ["config", "group", "value"] }], pipes: { "initialControlValue": i8.InitialControlValuePipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush, preserveWhitespaces: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: FormGroupListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'crispr-form-group-list', changeDetection: ChangeDetectionStrategy.OnPush, template: "\n<crispr-field-container\n  [config]=\"config\"\n  [group]=\"group\"\n  [formGroup]=\"group\">\n\n  <div [formArrayName]=\"config.controlName\">\n    <!-- TODO: add sortBy function -->\n    <div *ngFor=\"let control of formArray?.controls; let i = index;\">\n      <!-- TODO: use content projection to allow custom item label component -->\n      <div class=\"item-header\">\n        <span class=\"mat-h2\" *ngIf=\"config.itemLabelBuilder\"> {{  config.itemLabelBuilder(i) }} </span>\n        <button\n          mat-icon-button\n          *ngIf=\"i + 1 > config.minListLength\">\n          <mat-icon (click)=\"deleteGroup(i)\">delete</mat-icon>\n        </button>\n      </div>\n      <div\n        [formGroupName]=\"i\">\n        <ng-container\n          *ngFor=\"let field of config.itemConfig.fields;\"\n          crisprField\n          [config]=\"field\"\n          [value]=\"value && value[i] | initialControlValue : field\"\n          [group]=\"control\">\n        </ng-container>\n      </div>\n    </div>\n  </div>\n  <div class=\"group-footer\">\n    <button\n      type=\"button\"\n      class=\"add\"\n      mat-raised-button\n      [color]=\"config.addButtonColor\"\n      (click)=\"addGroup()\">\n      {{config.addItemLabel || config.addButtonLabel}}\n    </button>\n  </div>\n\n</crispr-field-container>\n", styles: [".item-header{display:flex;justify-content:space-between}.group-footer{display:flex;justify-content:flex-end}.group-footer button.add{margin-bottom:16px}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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