@messaia/cdk 0.0.0-CDK

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

@@ -0,0 +1,125 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MatAutocompleteModule } from '@angular/material/autocomplete';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import { MatNativeDateModule } from '@angular/material/core';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatIconModule } from '@angular/material/icon';
+import { MatInputModule } from '@angular/material/input';
+import { MatSelectModule } from '@angular/material/select';
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { VdChipsModule } from '../chips/chips.module';
+import { VdCommonModule } from '../common/public_api';
+import { VdSelectModule } from '../select/select.module';
+import { VdCodeDirective, VdCustomDirective, VdEditorDirective, VdFileDirective, VdGenericFormComponent } from './components/generic-form/generic-form.component';
+import { MatFormFieldEditorDirective } from './directives/mat-form-field-editor.directive';
+import { MatFormFieldReadonlyDirective } from './directives/mat-form-field-readonly.directive';
+import { EqualValidator } from './validators/equal-validator.directive';
+import { NativeElementInjectorDirective } from './validators/native-element-injector.directive';
+import { UniqueValidatorDirective } from './validators/unique-validator-directive';
+import * as i0 from "@angular/core";
+export { formFieldGroupMetadataKey } from './constants/constants';
+export { FormFieldType } from './enums/form-field-type';
+export { FormField, FormGroup } from './functions/decorators';
+export { getFormGroups } from './functions/functions';
+export { AbstractMatFormField } from './helpers/abstract-mat-form-field';
+export { ValueAccessorBase } from './helpers/value-accessor-base';
+export { FormFieldDefinition } from './models/form-field-definition';
+export { FormFieldGroup } from './models/form-field-group';
+export { EqualValidator } from './validators/equal-validator.directive';
+export { NativeElementInjectorDirective, UniqueValidatorDirective, MatFormFieldEditorDirective };
+const DECLARATIONS = [
+    EqualValidator,
+    UniqueValidatorDirective,
+    NativeElementInjectorDirective,
+    MatFormFieldReadonlyDirective,
+    MatFormFieldEditorDirective,
+    VdEditorDirective,
+    VdCodeDirective,
+    VdFileDirective,
+    VdCustomDirective,
+    VdGenericFormComponent
+];
+export class VdFormsModule {
+}
+/** @nocollapse */ /** @nocollapse */ VdFormsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: VdFormsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ VdFormsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: VdFormsModule, declarations: [EqualValidator,
+        UniqueValidatorDirective,
+        NativeElementInjectorDirective,
+        MatFormFieldReadonlyDirective,
+        MatFormFieldEditorDirective,
+        VdEditorDirective,
+        VdCodeDirective,
+        VdFileDirective,
+        VdCustomDirective,
+        VdGenericFormComponent], imports: [CommonModule,
+        VdCommonModule,
+        VdSelectModule,
+        VdChipsModule,
+        FormsModule,
+        ReactiveFormsModule,
+        MatFormFieldModule,
+        MatSelectModule,
+        MatIconModule,
+        MatInputModule,
+        MatDatepickerModule,
+        MatCheckboxModule,
+        MatSlideToggleModule,
+        MatDatepickerModule,
+        MatNativeDateModule,
+        MatAutocompleteModule], exports: [EqualValidator,
+        UniqueValidatorDirective,
+        NativeElementInjectorDirective,
+        MatFormFieldReadonlyDirective,
+        MatFormFieldEditorDirective,
+        VdEditorDirective,
+        VdCodeDirective,
+        VdFileDirective,
+        VdCustomDirective,
+        VdGenericFormComponent] });
+/** @nocollapse */ /** @nocollapse */ VdFormsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: VdFormsModule, imports: [[
+            CommonModule,
+            VdCommonModule,
+            VdSelectModule,
+            VdChipsModule,
+            FormsModule,
+            ReactiveFormsModule,
+            MatFormFieldModule,
+            MatSelectModule,
+            MatIconModule,
+            MatInputModule,
+            MatDatepickerModule,
+            MatCheckboxModule,
+            MatSlideToggleModule,
+            MatDatepickerModule,
+            MatNativeDateModule,
+            MatAutocompleteModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: VdFormsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        VdCommonModule,
+                        VdSelectModule,
+                        VdChipsModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        MatFormFieldModule,
+                        MatSelectModule,
+                        MatIconModule,
+                        MatInputModule,
+                        MatDatepickerModule,
+                        MatCheckboxModule,
+                        MatSlideToggleModule,
+                        MatDatepickerModule,
+                        MatNativeDateModule,
+                        MatAutocompleteModule
+                    ],
+                    declarations: [DECLARATIONS],
+                    exports: [DECLARATIONS]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/forms/functions/decorators.mjs

@@ -0,0 +1,127 @@
+import { headerMetadataKey } from "../../common/constants/constants";
+import { formFieldGroupMetadataKey } from "../constants/constants";
+import { FormFieldType } from "../enums/form-field-type";
+import { FormFieldDefinition } from "../models/form-field-definition";
+import { FormFieldGroup } from "../models/form-field-group";
+import { getFormGroups } from "./functions";
+/**
+ * Property decorator to create form fields
+ * @param args
+ * @returns
+ */
+export function FormField(args) {
+    return function (target, propertyKey) {
+        /* Get property name */
+        var propertyName = args.name || propertyKey;
+        /* Get property type */
+        var propertyType = Reflect.getMetadata("design:type", target, propertyKey)?.name;
+        /* Create table column */
+        var formField = new FormFieldDefinition(Object.assign(args, {
+            name: args.name || propertyKey,
+            header: args.header || Reflect.getMetadata(headerMetadataKey, target, propertyKey) || propertyName,
+            autocompleteTemplate: args.autocompleteTemplate || ((option) => option[formField.autocompleteText]),
+            chipTemplate: args.chipTemplate || ((chip) => chip[formField.chipText])
+        }));
+        /* Type enum */
+        if (formField.enumType) {
+            formField.type || (formField.type = FormFieldType.Enum);
+        }
+        /* Type VdSelect */
+        else if (formField.endpoint) {
+            formField.type || (formField.type = FormFieldType.VdSelect);
+        }
+        /* Type Select */
+        else if (formField.options) {
+            formField.type || (formField.type = FormFieldType.Select);
+        }
+        /* Type TextArea */
+        else if (formField.rows) {
+            formField.type || (formField.type = FormFieldType.TextArea);
+        }
+        /* Type File */
+        else if (formField.filePath) {
+            formField.type || (formField.type = FormFieldType.File);
+        }
+        /* Other types */
+        else {
+            switch (propertyType.toLowerCase()) {
+                case 'number':
+                    formField.type || (formField.type = FormFieldType.Text);
+                    formField.inputType || (formField.inputType = 'number');
+                    break;
+                case 'date':
+                    formField.type || (formField.type = FormFieldType.Date);
+                    break;
+                case 'boolean':
+                    formField.type || (formField.type = FormFieldType.Checkbox);
+                    break;
+                default:
+                    formField.type || (formField.type = FormFieldType.Text);
+                    break;
+            }
+        }
+        /* Get existing table groups */
+        let formFieldGroups = Reflect.getMetadata(formFieldGroupMetadataKey, target) || [];
+        /* Get the group */
+        var group = formFieldGroups.filter(x => x.name?.trim() == formField.groupName?.trim())[0];
+        /* The group already exists, add the new form field */
+        if (group) {
+            group.fields.push(formField);
+        }
+        /* Create a new group */
+        else {
+            group = new FormFieldGroup({ name: formField.groupName || null, header: formField.groupHeader, fields: [formField] });
+            formFieldGroups.push(group);
+        }
+        /* Sort the fields by row */
+        group.fields = group.fields?.sort((a, b) => (a.row || 0 > b.row || 0) ? 1 : ((b.row || 0 > a.row || 0) ? -1 : 0)) || [];
+        /* Group the fields */
+        group.groups = Object.values((group.fields).reduce(function (r, a) {
+            r[a.row] = r[a.row] || [];
+            r[a.row].push(a);
+            return r;
+        }, Object.create(null)));
+        /* Add new table column */
+        Reflect.defineMetadata(formFieldGroupMetadataKey, formFieldGroups, target);
+    };
+}
+/**
+ * Property decorator to create form fields
+ * @param args
+ * @returns
+ */
+export function FormGroup(type, header, name) {
+    return function (target, propertyKey) {
+        /* Set proprety name as group name, if empty */
+        name || (name = propertyKey);
+        /* Get from groups */
+        var groups = getFormGroups(Reflect.construct(type, []));
+        /* Get all fields */
+        var fields = groups.map(x => x.fields).reduce((a, b) => a.concat(b), []) || [];
+        /* Get existing table groups */
+        let formFieldGroups = Reflect.getMetadata(formFieldGroupMetadataKey, target) || [];
+        /* Get the group */
+        var group = formFieldGroups.filter(x => x.name?.trim() == name?.trim())[0];
+        /* The group already exist, add the fields to it */
+        if (group) {
+            fields.forEach(x => x.groupName = name);
+            group.fields.push(...fields);
+        }
+        /* Create the new group */
+        else {
+            group = new FormFieldGroup({ name: name, header: header, fields: fields });
+            formFieldGroups.push(group);
+        }
+        /* Sort the fields by row */
+        group.fields = group?.fields?.sort((a, b) => (a.row || 0 > b.row || 0) ? 1 : ((b.row || 0 > a.row || 0) ? -1 : 0)) || [];
+        /* Group the fields */
+        group.groups = Object.values((group.fields).reduce(function (r, a) {
+            r[a.row] = r[a.row] || [];
+            r[a.row].push(a);
+            return r;
+        }, Object.create(null)));
+        /* Add new table column */
+        Reflect.defineMetadata(formFieldGroupMetadataKey, formFieldGroups, target);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../../../../../projects/cdk/src/lib/forms/functions/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import { Type } from \"@angular/core\";\r\nimport { headerMetadataKey } from \"../../common/constants/constants\";\r\nimport { formFieldGroupMetadataKey } from \"../constants/constants\";\r\nimport { FormFieldType } from \"../enums/form-field-type\";\r\nimport { FormFieldDefinition } from \"../models/form-field-definition\";\r\nimport { FormFieldGroup } from \"../models/form-field-group\";\r\nimport { getFormGroups } from \"./functions\";\r\n\r\n/**\r\n * Property decorator to create form fields\r\n * @param args \r\n * @returns \r\n */\r\nexport function FormField(args: Partial<FormFieldDefinition>): Function {\r\n    return function (target: any, propertyKey: string) {\r\n        /* Get property name */\r\n        var propertyName = args.name || propertyKey;\r\n\r\n        /* Get property type */\r\n        var propertyType: string = Reflect.getMetadata(\"design:type\", target, propertyKey)?.name;\r\n\r\n        /* Create table column */\r\n        var formField = new FormFieldDefinition(Object.assign(args, <FormFieldDefinition>{\r\n            name: args.name || propertyKey,\r\n            header: args.header || Reflect.getMetadata(headerMetadataKey, target, propertyKey) || propertyName,\r\n            autocompleteTemplate: args.autocompleteTemplate || ((option: any) => option[formField.autocompleteText]),\r\n            chipTemplate: args.chipTemplate || ((chip: any) => chip[formField.chipText])\r\n        }));\r\n\r\n        /* Type enum */\r\n        if (formField.enumType) {\r\n            formField.type ||= FormFieldType.Enum;\r\n        }\r\n\r\n        /* Type VdSelect */\r\n        else if (formField.endpoint) {\r\n            formField.type ||= FormFieldType.VdSelect;\r\n        }\r\n\r\n        /* Type Select */\r\n        else if (formField.options) {\r\n            formField.type ||= FormFieldType.Select;\r\n        }\r\n\r\n        /* Type TextArea */\r\n        else if (formField.rows) {\r\n            formField.type ||= FormFieldType.TextArea;\r\n        }\r\n\r\n        /* Type File */\r\n        else if (formField.filePath) {\r\n            formField.type ||= FormFieldType.File;\r\n        }\r\n\r\n        /* Other types */\r\n        else {\r\n            switch (propertyType.toLowerCase()) {\r\n                case 'number':\r\n                    formField.type ||= FormFieldType.Text;\r\n                    formField.inputType ||= 'number';\r\n                    break;\r\n\r\n                case 'date':\r\n                    formField.type ||= FormFieldType.Date;\r\n                    break;\r\n\r\n                case 'boolean':\r\n                    formField.type ||= FormFieldType.Checkbox;\r\n                    break;\r\n\r\n                default:\r\n                    formField.type ||= FormFieldType.Text;\r\n                    break;\r\n            }\r\n        }\r\n\r\n        /* Get existing table groups */\r\n        let formFieldGroups: FormFieldGroup[] = Reflect.getMetadata(formFieldGroupMetadataKey, target) || [];\r\n\r\n        /* Get the group */\r\n        var group = formFieldGroups.filter(x => x.name?.trim() == formField.groupName?.trim())[0];\r\n\r\n        /* The group already exists, add the new form field */\r\n        if (group) {\r\n            group.fields.push(formField);\r\n        }\r\n\r\n        /* Create a new group */\r\n        else {\r\n            group = new FormFieldGroup({ name: formField.groupName || null, header: formField.groupHeader, fields: [formField] });\r\n            formFieldGroups.push(group);\r\n        }\r\n\r\n        /* Sort the fields by row */\r\n        group.fields = group.fields?.sort((a, b) => (a.row || 0 > b.row || 0) ? 1 : ((b.row || 0 > a.row || 0) ? -1 : 0)) || [];\r\n\r\n        /* Group the fields */\r\n        group.groups = Object.values((group.fields).reduce(function (r, a) {\r\n            r[a.row] = r[a.row] || [];\r\n            r[a.row].push(a);\r\n            return r;\r\n        }, Object.create(null))) as [FormFieldDefinition[]];\r\n\r\n        /* Add new table column */\r\n        Reflect.defineMetadata(formFieldGroupMetadataKey, formFieldGroups, target);\r\n    };\r\n}\r\n\r\n/**\r\n * Property decorator to create form fields\r\n * @param args \r\n * @returns \r\n */\r\nexport function FormGroup<T>(type: Type<T>, header: string, name?: string): Function {\r\n    return function (target: any, propertyKey: string) {\r\n        /* Set proprety name as group name, if empty */\r\n        name ||= propertyKey;\r\n\r\n        /* Get from groups */\r\n        var groups = getFormGroups(Reflect.construct(type, []));\r\n\r\n        /* Get all fields */\r\n        var fields = groups.map(x => x.fields).reduce((a, b) => a.concat(b), []) || [];\r\n\r\n        /* Get existing table groups */\r\n        let formFieldGroups: FormFieldGroup[] = Reflect.getMetadata(formFieldGroupMetadataKey, target) || [];\r\n\r\n        /* Get the group */\r\n        var group = formFieldGroups.filter(x => x.name?.trim() == name?.trim())[0];\r\n\r\n        /* The group already exist, add the fields to it */\r\n        if (group) {\r\n            fields.forEach(x => x.groupName = name);\r\n            group.fields.push(...fields);\r\n        }\r\n\r\n        /* Create the new group */\r\n        else {\r\n            group = new FormFieldGroup({ name: name, header: header, fields: fields });\r\n            formFieldGroups.push(group);\r\n        }\r\n\r\n        /* Sort the fields by row */\r\n        group.fields = group?.fields?.sort((a, b) => (a.row || 0 > b.row || 0) ? 1 : ((b.row || 0 > a.row || 0) ? -1 : 0)) || [];\r\n\r\n        /* Group the fields */\r\n        group.groups = Object.values((group.fields).reduce(function (r, a) {\r\n            r[a.row] = r[a.row] || [];\r\n            r[a.row].push(a);\r\n            return r;\r\n        }, Object.create(null))) as [FormFieldDefinition[]];\r\n\r\n        /* Add new table column */\r\n        Reflect.defineMetadata(formFieldGroupMetadataKey, formFieldGroups, target);\r\n    };\r\n}"]}

package/esm2020/lib/forms/functions/functions.mjs

@@ -0,0 +1,10 @@
+import { formFieldGroupMetadataKey } from "../constants/constants";
+/**
+ * Gets poperties decoarated with @FormField grouped by row
+ * @param origin
+ * @returns
+ */
+export function getFormGroups(origin) {
+    return Reflect.getMetadata(formFieldGroupMetadataKey, origin);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuY3Rpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2RrL3NyYy9saWIvZm9ybXMvZnVuY3Rpb25zL2Z1bmN0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUduRTs7OztHQUlHO0FBQ0gsTUFBTSxVQUFVLGFBQWEsQ0FBQyxNQUFjO0lBQ3hDLE9BQU8sT0FBTyxDQUFDLFdBQVcsQ0FBQyx5QkFBeUIsRUFBRSxNQUFNLENBQXFCLENBQUM7QUFDdEYsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGZvcm1GaWVsZEdyb3VwTWV0YWRhdGFLZXkgfSBmcm9tIFwiLi4vY29uc3RhbnRzL2NvbnN0YW50c1wiO1xyXG5pbXBvcnQgeyBGb3JtRmllbGRHcm91cCB9IGZyb20gXCIuLi9tb2RlbHMvZm9ybS1maWVsZC1ncm91cFwiO1xyXG5cclxuLyoqXHJcbiAqIEdldHMgcG9wZXJ0aWVzIGRlY29hcmF0ZWQgd2l0aCBARm9ybUZpZWxkIGdyb3VwZWQgYnkgcm93XHJcbiAqIEBwYXJhbSBvcmlnaW4gXHJcbiAqIEByZXR1cm5zIFxyXG4gKi9cclxuZXhwb3J0IGZ1bmN0aW9uIGdldEZvcm1Hcm91cHMob3JpZ2luOiBvYmplY3QpOiBGb3JtRmllbGRHcm91cFtdIHtcclxuICAgIHJldHVybiBSZWZsZWN0LmdldE1ldGFkYXRhKGZvcm1GaWVsZEdyb3VwTWV0YWRhdGFLZXksIG9yaWdpbikgYXMgRm9ybUZpZWxkR3JvdXBbXTtcclxufSJdfQ==

package/esm2020/lib/forms/helpers/abstract-mat-form-field.mjs

@@ -0,0 +1,251 @@
+import { FocusMonitor } from "@angular/cdk/a11y";
+import { coerceBooleanProperty } from "@angular/cdk/coercion";
+import { Directive, ElementRef, HostBinding, HostListener, Input } from "@angular/core";
+import { FormGroupDirective, NgControl, NgForm } from "@angular/forms";
+import { ErrorStateMatcher, mixinErrorState } from "@angular/material/core";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@angular/material/core";
+import * as i3 from "@angular/cdk/a11y";
+/**
+ * _AbstractMatFormField class
+ */
+class _AbstractMatFormField {
+    constructor(_defaultErrorStateMatcher, _parentForm, _parentFormGroup, ngControl) {
+        this._defaultErrorStateMatcher = _defaultErrorStateMatcher;
+        this._parentForm = _parentForm;
+        this._parentFormGroup = _parentFormGroup;
+        this.ngControl = ngControl;
+    }
+}
+/**
+ * AbstractMatFormField class
+ */
+export class AbstractMatFormField extends mixinErrorState(_AbstractMatFormField) {
+    /**
+     * Constructor
+     * @param controlType
+     * @param ngControl
+     * @param _parentForm
+     * @param _parentFormGroup
+     * @param _defaultErrorStateMatcher
+     * @param _focusMonitor
+     * @param _elementRef
+     */
+    constructor(controlType, ngControl, _parentForm, _parentFormGroup, _defaultErrorStateMatcher, _focusMonitor, _elementRef) {
+        super(_defaultErrorStateMatcher, _parentForm, _parentFormGroup, ngControl);
+        this.controlType = controlType;
+        this.ngControl = ngControl;
+        this._parentForm = _parentForm;
+        this._parentFormGroup = _parentFormGroup;
+        this._defaultErrorStateMatcher = _defaultErrorStateMatcher;
+        this._focusMonitor = _focusMonitor;
+        this._elementRef = _elementRef;
+        /**
+         * The placeholder for this control.
+         */
+        this._placeholder = "";
+        /**
+         * Whether the control is required.
+         */
+        this._required = false;
+        /**
+         * Whether the control is disabled.
+         */
+        this._disabled = false;
+        /**
+         * The element ID
+         */
+        this.id = `${this.controlType}-${AbstractMatFormField.nextId++}`;
+        /**
+         * Used to indicate the IDs of the elements that describe the object.
+         */
+        this.describedBy = "";
+        /**
+         * Whether the control is focused.
+         */
+        this.focused = false;
+        if (this.ngControl) {
+            this.ngControl.valueAccessor = this;
+        }
+        _focusMonitor.monitor(this._elementRef.nativeElement, true).subscribe(origin => {
+            this.focused = !!origin;
+            this.stateChanges.next();
+        });
+    }
+    /**
+     * Sets the value
+     */
+    set value(value) {
+        this._value = value;
+        if (this.onChange) {
+            this.onChange(value);
+        }
+    }
+    /**
+     * Gets the value
+     */
+    get value() {
+        return this._value;
+    }
+    /**
+     * Sets the placeholder
+     */
+    set placeholder(placeholder) {
+        this._placeholder = placeholder;
+        this.stateChanges.next();
+    }
+    /**
+     * Gets the placeholder
+     */
+    get placeholder() {
+        return this._placeholder;
+    }
+    /**
+     * Sets the required
+     * @param required
+     */
+    set required(required) {
+        this._required = coerceBooleanProperty(required);
+        this.stateChanges.next();
+    }
+    /**
+     * Gets the required
+     */
+    get required() {
+        return this._required;
+    }
+    /**
+     * Multiple select option
+     */
+    get readonly() { return this._readonly; }
+    set readonly(readonly) {
+        this._readonly = coerceBooleanProperty(readonly);
+        this.stateChanges.next();
+    }
+    /**
+     * Gets the control is disabled.
+     * @param disabled
+     */
+    set disabled(disabled) {
+        this._disabled = coerceBooleanProperty(disabled);
+        if (this.focused) {
+            this.focused = false;
+            this.stateChanges.next();
+        }
+    }
+    /**
+     * Sets the disabled.
+     * @param disabled
+     */
+    get disabled() {
+        if (this.ngControl?.disabled !== null) {
+            return this.ngControl.disabled;
+        }
+        return this._disabled;
+    }
+    /**
+     * Gets the empty value
+     */
+    get empty() {
+        return !this._value;
+    }
+    /**
+     * Whether the `MatFormField` label should try to float.
+     */
+    get shouldLabelFloat() {
+        return this.focused || !this.empty;
+    }
+    /**
+     * Registers a function called when the control value changes.
+     */
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    /**
+     * Registers a callback function that is called by the forms API on initialization
+     * to update the form model on blur.
+     * @param fn
+     */
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    /**
+     * Writes a new value to the element.
+     * @param value
+     */
+    writeValue(value) {
+        this.value = value;
+    }
+    /**
+     * Sets the list of element IDs that currently describe this control.
+     * @param ids
+     */
+    setDescribedByIds(ids) {
+        this.describedBy = ids.join(" ");
+    }
+    /**
+     * Whether the control is focused.
+     */
+    onBlur() {
+        this.focused = false;
+        if (this.onTouched) {
+            this.onTouched();
+        }
+        this.stateChanges.next();
+    }
+    /**
+     * Handles a click on the control's container.
+     */
+    onContainerClick() {
+        if (!this.focused) {
+            this.focus();
+        }
+    }
+    /**
+     * A callback method that performs change-detection, invoked
+     * after the default change-detector runs.
+     * See `KeyValueDiffers` and `IterableDiffers` for implementing
+     * custom change checking for collections.
+     *
+     */
+    ngDoCheck() {
+        if (this.ngControl) {
+            this.updateErrorState();
+        }
+    }
+    /**
+     * A lifecycle method called before the directive's instance
+     * is destroyed. For internal use only.
+     */
+    ngOnDestroy() {
+        this.stateChanges.complete();
+        this._focusMonitor.stopMonitoring(this._elementRef.nativeElement);
+    }
+}
+/**
+ * The element ID
+ */
+AbstractMatFormField.nextId = 0;
+/** @nocollapse */ /** @nocollapse */ AbstractMatFormField.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: AbstractMatFormField, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ AbstractMatFormField.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.0", type: AbstractMatFormField, inputs: { placeholder: "placeholder", required: "required", readonly: "readonly", disabled: "disabled" }, host: { listeners: { "focusout": "onBlur()" }, properties: { "id": "this.id", "attr.aria-describedBy": "this.describedBy" } }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: AbstractMatFormField, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: undefined }, { type: i1.NgControl }, { type: i1.NgForm }, { type: i1.FormGroupDirective }, { type: i2.ErrorStateMatcher }, { type: i3.FocusMonitor }, { type: i0.ElementRef }]; }, propDecorators: { placeholder: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], id: [{
+                type: HostBinding
+            }], describedBy: [{
+                type: HostBinding,
+                args: ["attr.aria-describedBy"]
+            }], onBlur: [{
+                type: HostListener,
+                args: ["focusout"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-mat-form-field.js","sourceRoot":"","sources":["../../../../../../projects/cdk/src/lib/forms/helpers/abstract-mat-form-field.ts"],"names":[],"mappings":"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","sourcesContent":["import { FocusMonitor } from \"@angular/cdk/a11y\";\r\nimport { coerceBooleanProperty } from \"@angular/cdk/coercion\";\r\nimport { Directive, DoCheck, ElementRef, HostBinding, HostListener, Input, OnDestroy } from \"@angular/core\";\r\nimport { ControlValueAccessor, FormGroupDirective, NgControl, NgForm } from \"@angular/forms\";\r\nimport { ErrorStateMatcher, mixinErrorState } from \"@angular/material/core\";\r\nimport { MatFormFieldControl } from \"@angular/material/form-field\";\r\n\r\n/**\r\n * _AbstractMatFormField class\r\n */\r\nclass _AbstractMatFormField {\r\n    constructor(public _defaultErrorStateMatcher: ErrorStateMatcher, public _parentForm: NgForm, public _parentFormGroup: FormGroupDirective, public ngControl: NgControl) { }\r\n}\r\n\r\n/**\r\n * AbstractMatFormField class\r\n */\r\n@Directive()\r\nexport abstract class AbstractMatFormField<T> extends mixinErrorState(_AbstractMatFormField) implements DoCheck, OnDestroy, ControlValueAccessor, MatFormFieldControl<T> {\r\n\r\n    /**\r\n     * The value of the control.\r\n     */\r\n    protected _value: T;\r\n\r\n    /**\r\n     * Sets the value\r\n     */\r\n    public set value(value: T) {\r\n        this._value = value;\r\n        if (this.onChange) {\r\n            this.onChange(value);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Gets the value\r\n     */\r\n    public get value(): T {\r\n        return this._value;\r\n    }\r\n\r\n    /**\r\n     * The placeholder for this control.\r\n     */\r\n    public _placeholder: string = \"\";\r\n\r\n    /**\r\n     * Sets the placeholder\r\n     */\r\n    @Input()\r\n    public set placeholder(placeholder: string) {\r\n        this._placeholder = placeholder;\r\n        this.stateChanges.next();\r\n    }\r\n\r\n    /**\r\n     * Gets the placeholder\r\n     */\r\n    public get placeholder() {\r\n        return this._placeholder;\r\n    }\r\n\r\n    /**\r\n     * Whether the control is required.\r\n     */\r\n    public _required: boolean = false;\r\n\r\n    /**\r\n     * Sets the required\r\n     * @param required\r\n     */\r\n    @Input()\r\n    public set required(required: any) {\r\n        this._required = coerceBooleanProperty(required);\r\n        this.stateChanges.next();\r\n    }\r\n\r\n    /**\r\n     * Gets the required\r\n     */\r\n    public get required() {\r\n        return this._required;\r\n    }\r\n\r\n    /**\r\n     * Readonly\r\n     */\r\n    public _readonly: boolean;\r\n\r\n    /**\r\n     * Multiple select option\r\n     */\r\n    @Input()\r\n    get readonly() { return this._readonly; }\r\n    set readonly(readonly) {\r\n        this._readonly = coerceBooleanProperty(readonly);\r\n        this.stateChanges.next();\r\n    }\r\n\r\n    /**\r\n     * Whether the control is disabled.\r\n     */\r\n    public _disabled: boolean = false;\r\n\r\n    /**\r\n     * Gets the control is disabled.\r\n     * @param disabled\r\n     */\r\n    @Input()\r\n    public set disabled(disabled: any) {\r\n        this._disabled = coerceBooleanProperty(disabled);\r\n        if (this.focused) {\r\n            this.focused = false;\r\n            this.stateChanges.next();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Sets the disabled.\r\n     * @param disabled\r\n     */\r\n    public get disabled() {\r\n        if (this.ngControl?.disabled !== null) {\r\n            return this.ngControl.disabled;\r\n        }\r\n\r\n        return this._disabled;\r\n    }\r\n\r\n    /**\r\n     * Gets the empty value\r\n     */\r\n    public get empty(): boolean {\r\n        return !this._value;\r\n    }\r\n\r\n    /**\r\n     * Whether the `MatFormField` label should try to float.\r\n     */\r\n    public get shouldLabelFloat(): boolean {\r\n        return this.focused || !this.empty;\r\n    }\r\n\r\n    /**\r\n     * The element ID\r\n     */\r\n    private static nextId: number = 0;\r\n\r\n    /**\r\n     * The element ID\r\n     */\r\n    @HostBinding()\r\n    public id: string = `${this.controlType}-${AbstractMatFormField.nextId++}`;\r\n\r\n    /**\r\n     * Used to indicate the IDs of the elements that describe the object.\r\n     */\r\n    @HostBinding(\"attr.aria-describedBy\")\r\n    public describedBy: string = \"\";\r\n\r\n    /**\r\n     * Constructor\r\n     * @param controlType \r\n     * @param ngControl \r\n     * @param _parentForm \r\n     * @param _parentFormGroup \r\n     * @param _defaultErrorStateMatcher \r\n     * @param _focusMonitor \r\n     * @param _elementRef \r\n     */\r\n    constructor(public readonly controlType: string, public readonly ngControl: NgControl, public readonly _parentForm: NgForm, public readonly _parentFormGroup: FormGroupDirective, public readonly _defaultErrorStateMatcher: ErrorStateMatcher, protected readonly _focusMonitor: FocusMonitor, protected readonly _elementRef: ElementRef) {\r\n        super(_defaultErrorStateMatcher, _parentForm, _parentFormGroup, ngControl);\r\n\r\n        if (this.ngControl) {\r\n            this.ngControl.valueAccessor = this;\r\n        }\r\n\r\n        _focusMonitor.monitor(this._elementRef.nativeElement, true).subscribe(origin => {\r\n            this.focused = !!origin;\r\n            this.stateChanges.next();\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Registers a function called when the control value changes.\r\n     */\r\n    public registerOnChange(fn: (_: T) => void): void {\r\n        this.onChange = fn;\r\n    }\r\n\r\n    /**\r\n     * Registers a callback function that is called by the forms API on initialization\r\n     * to update the form model on blur.\r\n     * @param fn \r\n     */\r\n    public registerOnTouched(fn: () => void): void {\r\n        this.onTouched = fn;\r\n    }\r\n\r\n    /**\r\n     * Writes a new value to the element.\r\n     * @param value \r\n     */\r\n    public writeValue(value: T): void {\r\n        this.value = value;\r\n    }\r\n\r\n    /**\r\n     * Sets the list of element IDs that currently describe this control.\r\n     * @param ids \r\n     */\r\n    public setDescribedByIds(ids: string[]): void {\r\n        this.describedBy = ids.join(\" \");\r\n    }\r\n\r\n    /**\r\n     * Whether the control is focused.\r\n     */\r\n    public focused = false;\r\n\r\n    /**\r\n     * Whether the control is focused.\r\n     */\r\n    @HostListener(\"focusout\") onBlur() {\r\n        this.focused = false;\r\n        if (this.onTouched) {\r\n            this.onTouched();\r\n        }\r\n\r\n        this.stateChanges.next();\r\n    }\r\n\r\n    /**\r\n     * Sets focus of the control\r\n     */\r\n    public abstract focus(): void;\r\n\r\n    /**\r\n     * Handles a click on the control's container.\r\n     */\r\n    public onContainerClick(): void {\r\n        if (!this.focused) {\r\n            this.focus();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * The registered callback function called when an input \r\n     * event occurs on the input element.\r\n     */\r\n    protected onChange?: (value: T) => void;\r\n\r\n    /**\r\n     * The registered callback function called when a blur \r\n     * event occurs on the input element.\r\n     */\r\n    protected onTouched?: () => void;\r\n\r\n    /**\r\n     * A callback method that performs change-detection, invoked\r\n     * after the default change-detector runs.\r\n     * See `KeyValueDiffers` and `IterableDiffers` for implementing\r\n     * custom change checking for collections.\r\n     *\r\n     */\r\n    public ngDoCheck(): void {\r\n        if (this.ngControl) {\r\n            this.updateErrorState();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * A lifecycle method called before the directive's instance\r\n     * is destroyed. For internal use only.\r\n     */\r\n    public ngOnDestroy(): void {\r\n        this.stateChanges.complete();\r\n        this._focusMonitor.stopMonitoring(this._elementRef.nativeElement);\r\n    }\r\n}"]}