@ni/nimble-angular 20.7.11 → 21.0.1

package/esm2022/table-column/text/nimble-table-column-text.directive.mjs

@@ -0,0 +1,76 @@
+import { Directive, Input } from '@angular/core';
+import { tableColumnTextTag } from '@ni/nimble-components/dist/esm/table-column/text';
+import { toBooleanProperty, toNullableNumberProperty } from '@ni/nimble-angular/internal-utilities';
+import { NimbleTableColumnBaseDirective } from '@ni/nimble-angular/table-column';
+import * as i0 from "@angular/core";
+export { tableColumnTextTag };
+/**
+ * Directive to provide Angular integration for the table column element for text.
+ */
+export class NimbleTableColumnTextDirective extends NimbleTableColumnBaseDirective {
+    get fieldName() {
+        return this.elementRef.nativeElement.fieldName;
+    }
+    set fieldName(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'fieldName', value);
+    }
+    get placeholder() {
+        return this.elementRef.nativeElement.placeholder;
+    }
+    set placeholder(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'placeholder', value);
+    }
+    get fractionalWidth() {
+        return this.elementRef.nativeElement.fractionalWidth;
+    }
+    set fractionalWidth(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'fractionalWidth', toNullableNumberProperty(value));
+    }
+    get minPixelWidth() {
+        return this.elementRef.nativeElement.minPixelWidth;
+    }
+    set minPixelWidth(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'minPixelWidth', toNullableNumberProperty(value));
+    }
+    get groupIndex() {
+        return this.elementRef.nativeElement.groupIndex;
+    }
+    set groupIndex(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'groupIndex', toNullableNumberProperty(value));
+    }
+    get groupingDisabled() {
+        return this.elementRef.nativeElement.groupingDisabled;
+    }
+    set groupingDisabled(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'groupingDisabled', toBooleanProperty(value));
+    }
+    constructor(renderer, elementRef) {
+        super(renderer, elementRef);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NimbleTableColumnTextDirective, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: NimbleTableColumnTextDirective, selector: "nimble-table-column-text", inputs: { fieldName: ["field-name", "fieldName"], placeholder: "placeholder", fractionalWidth: ["fractional-width", "fractionalWidth"], minPixelWidth: ["min-pixel-width", "minPixelWidth"], groupIndex: ["group-index", "groupIndex"], groupingDisabled: ["grouping-disabled", "groupingDisabled"] }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NimbleTableColumnTextDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'nimble-table-column-text'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }]; }, propDecorators: { fieldName: [{
+                type: Input,
+                args: ['field-name']
+            }], placeholder: [{
+                type: Input
+            }], fractionalWidth: [{
+                type: Input,
+                args: ['fractional-width']
+            }], minPixelWidth: [{
+                type: Input,
+                args: ['min-pixel-width']
+            }], groupIndex: [{
+                type: Input,
+                args: ['group-index']
+            }], groupingDisabled: [{
+                type: Input,
+                args: ['grouping-disabled']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/table-column/text/nimble-table-column-text.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { NimbleTableColumnTextDirective } from './nimble-table-column-text.directive';
+import '@ni/nimble-components/dist/esm/table-column/text';
+import * as i0 from "@angular/core";
+export class NimbleTableColumnTextModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NimbleTableColumnTextModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: NimbleTableColumnTextModule, declarations: [NimbleTableColumnTextDirective], imports: [CommonModule], exports: [NimbleTableColumnTextDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NimbleTableColumnTextModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NimbleTableColumnTextModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [NimbleTableColumnTextDirective],
+                    imports: [CommonModule],
+                    exports: [NimbleTableColumnTextDirective]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmltYmxlLXRhYmxlLWNvbHVtbi10ZXh0Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25pL25pbWJsZS1hbmd1bGFyL3RhYmxlLWNvbHVtbi90ZXh0L25pbWJsZS10YWJsZS1jb2x1bW4tdGV4dC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLDhCQUE4QixFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFFdEYsT0FBTyxrREFBa0QsQ0FBQzs7QUFPMUQsTUFBTSxPQUFPLDJCQUEyQjsrR0FBM0IsMkJBQTJCO2dIQUEzQiwyQkFBMkIsaUJBSnJCLDhCQUE4QixhQUNuQyxZQUFZLGFBQ1osOEJBQThCO2dIQUUvQiwyQkFBMkIsWUFIMUIsWUFBWTs7NEZBR2IsMkJBQTJCO2tCQUx2QyxRQUFRO21CQUFDO29CQUNOLFlBQVksRUFBRSxDQUFDLDhCQUE4QixDQUFDO29CQUM5QyxPQUFPLEVBQUUsQ0FBQyxZQUFZLENBQUM7b0JBQ3ZCLE9BQU8sRUFBRSxDQUFDLDhCQUE4QixDQUFDO2lCQUM1QyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmltYmxlVGFibGVDb2x1bW5UZXh0RGlyZWN0aXZlIH0gZnJvbSAnLi9uaW1ibGUtdGFibGUtY29sdW1uLXRleHQuZGlyZWN0aXZlJztcblxuaW1wb3J0ICdAbmkvbmltYmxlLWNvbXBvbmVudHMvZGlzdC9lc20vdGFibGUtY29sdW1uL3RleHQnO1xuXG5ATmdNb2R1bGUoe1xuICAgIGRlY2xhcmF0aW9uczogW05pbWJsZVRhYmxlQ29sdW1uVGV4dERpcmVjdGl2ZV0sXG4gICAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXG4gICAgZXhwb3J0czogW05pbWJsZVRhYmxlQ29sdW1uVGV4dERpcmVjdGl2ZV1cbn0pXG5leHBvcnQgY2xhc3MgTmltYmxlVGFibGVDb2x1bW5UZXh0TW9kdWxlIHsgfVxuIl19

package/esm2022/thirdparty/directives/checkbox_value_accessor.mjs

@@ -0,0 +1,70 @@
+/**
+ * [Nimble]
+ * Copied from https://github.com/angular/angular/blob/16.2.12/packages/forms/src/directives/checkbox_value_accessor.ts
+ * with the following modifications:
+ * - Update imports
+ * - Remove all configuration from the CheckboxControlValueAccessor's `@Directive` decorator
+ */
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Directive } from '@angular/core';
+import { BuiltInControlValueAccessor } from './control_value_accessor';
+import * as i0 from "@angular/core";
+/* [Nimble] Do not register as a value accessor provider
+const CHECKBOX_VALUE_ACCESSOR: Provider = {
+  provide: NG_VALUE_ACCESSOR,
+  useExisting: forwardRef(() => CheckboxControlValueAccessor),
+  multi: true,
+};
+*/
+/**
+ * @description
+ * A `ControlValueAccessor` for writing a value and listening to changes on a checkbox input
+ * element.
+ *
+ * @usageNotes
+ *
+ * ### Using a checkbox with a reactive form.
+ *
+ * The following example shows how to use a checkbox with a reactive form.
+ *
+ * ```ts
+ * const rememberLoginControl = new FormControl();
+ * ```
+ *
+ * ```
+ * <input type="checkbox" [formControl]="rememberLoginControl">
+ * ```
+ *
+ * @ngModule ReactiveFormsModule
+ * @ngModule FormsModule
+ * @publicApi
+ */
+/* [Nimble] Remove all configuration from @Directive decorator
+@Directive({
+  selector:
+      'input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]',
+  host: {'(change)': 'onChange($event.target.checked)', '(blur)': 'onTouched()'},
+  providers: [CHECKBOX_VALUE_ACCESSOR]
+})
+*/
+export class CheckboxControlValueAccessor extends BuiltInControlValueAccessor {
+    /**
+     * Sets the "checked" property on the input element.
+     * @nodoc
+     */
+    writeValue(value) {
+        this.setProperty('checked', value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CheckboxControlValueAccessor, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: CheckboxControlValueAccessor, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CheckboxControlValueAccessor, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2tib3hfdmFsdWVfYWNjZXNzb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uaS9uaW1ibGUtYW5ndWxhci9zcmMvdGhpcmRwYXJ0eS9kaXJlY3RpdmVzL2NoZWNrYm94X3ZhbHVlX2FjY2Vzc29yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVIOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBQyxTQUFTLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFHeEMsT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7O0FBRXZFOzs7Ozs7RUFNRTtBQUVGOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBc0JHO0FBQ0g7Ozs7Ozs7RUFPRTtBQUVGLE1BQU0sT0FBTyw0QkFBNkIsU0FBUSwyQkFBMkI7SUFFM0U7OztPQUdHO0lBQ0gsVUFBVSxDQUFDLEtBQVU7UUFDbkIsSUFBSSxDQUFDLFdBQVcsQ0FBQyxTQUFTLEVBQUUsS0FBSyxDQUFDLENBQUM7SUFDckMsQ0FBQzsrR0FSVSw0QkFBNEI7bUdBQTVCLDRCQUE0Qjs7NEZBQTVCLDRCQUE0QjtrQkFEeEMsU0FBUyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogW05pbWJsZV1cbiAqIENvcGllZCBmcm9tIGh0dHBzOi8vZ2l0aHViLmNvbS9hbmd1bGFyL2FuZ3VsYXIvYmxvYi8xNi4yLjEyL3BhY2thZ2VzL2Zvcm1zL3NyYy9kaXJlY3RpdmVzL2NoZWNrYm94X3ZhbHVlX2FjY2Vzc29yLnRzXG4gKiB3aXRoIHRoZSBmb2xsb3dpbmcgbW9kaWZpY2F0aW9uczpcbiAqIC0gVXBkYXRlIGltcG9ydHNcbiAqIC0gUmVtb3ZlIGFsbCBjb25maWd1cmF0aW9uIGZyb20gdGhlIENoZWNrYm94Q29udHJvbFZhbHVlQWNjZXNzb3IncyBgQERpcmVjdGl2ZWAgZGVjb3JhdG9yXG4gKi9cblxuLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7RGlyZWN0aXZlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHR5cGUgeyBDb250cm9sVmFsdWVBY2Nlc3NvciB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcbmltcG9ydCB7IEJ1aWx0SW5Db250cm9sVmFsdWVBY2Nlc3NvciB9IGZyb20gJy4vY29udHJvbF92YWx1ZV9hY2Nlc3Nvcic7XG5cbi8qIFtOaW1ibGVdIERvIG5vdCByZWdpc3RlciBhcyBhIHZhbHVlIGFjY2Vzc29yIHByb3ZpZGVyXG5jb25zdCBDSEVDS0JPWF9WQUxVRV9BQ0NFU1NPUjogUHJvdmlkZXIgPSB7XG4gIHByb3ZpZGU6IE5HX1ZBTFVFX0FDQ0VTU09SLFxuICB1c2VFeGlzdGluZzogZm9yd2FyZFJlZigoKSA9PiBDaGVja2JveENvbnRyb2xWYWx1ZUFjY2Vzc29yKSxcbiAgbXVsdGk6IHRydWUsXG59O1xuKi9cblxuLyoqXG4gKiBAZGVzY3JpcHRpb25cbiAqIEEgYENvbnRyb2xWYWx1ZUFjY2Vzc29yYCBmb3Igd3JpdGluZyBhIHZhbHVlIGFuZCBsaXN0ZW5pbmcgdG8gY2hhbmdlcyBvbiBhIGNoZWNrYm94IGlucHV0XG4gKiBlbGVtZW50LlxuICpcbiAqIEB1c2FnZU5vdGVzXG4gKlxuICogIyMjIFVzaW5nIGEgY2hlY2tib3ggd2l0aCBhIHJlYWN0aXZlIGZvcm0uXG4gKlxuICogVGhlIGZvbGxvd2luZyBleGFtcGxlIHNob3dzIGhvdyB0byB1c2UgYSBjaGVja2JveCB3aXRoIGEgcmVhY3RpdmUgZm9ybS5cbiAqXG4gKiBgYGB0c1xuICogY29uc3QgcmVtZW1iZXJMb2dpbkNvbnRyb2wgPSBuZXcgRm9ybUNvbnRyb2woKTtcbiAqIGBgYFxuICpcbiAqIGBgYFxuICogPGlucHV0IHR5cGU9XCJjaGVja2JveFwiIFtmb3JtQ29udHJvbF09XCJyZW1lbWJlckxvZ2luQ29udHJvbFwiPlxuICogYGBgXG4gKlxuICogQG5nTW9kdWxlIFJlYWN0aXZlRm9ybXNNb2R1bGVcbiAqIEBuZ01vZHVsZSBGb3Jtc01vZHVsZVxuICogQHB1YmxpY0FwaVxuICovXG4vKiBbTmltYmxlXSBSZW1vdmUgYWxsIGNvbmZpZ3VyYXRpb24gZnJvbSBARGlyZWN0aXZlIGRlY29yYXRvclxuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOlxuICAgICAgJ2lucHV0W3R5cGU9Y2hlY2tib3hdW2Zvcm1Db250cm9sTmFtZV0saW5wdXRbdHlwZT1jaGVja2JveF1bZm9ybUNvbnRyb2xdLGlucHV0W3R5cGU9Y2hlY2tib3hdW25nTW9kZWxdJyxcbiAgaG9zdDogeycoY2hhbmdlKSc6ICdvbkNoYW5nZSgkZXZlbnQudGFyZ2V0LmNoZWNrZWQpJywgJyhibHVyKSc6ICdvblRvdWNoZWQoKSd9LFxuICBwcm92aWRlcnM6IFtDSEVDS0JPWF9WQUxVRV9BQ0NFU1NPUl1cbn0pXG4qL1xuQERpcmVjdGl2ZSgpXG5leHBvcnQgY2xhc3MgQ2hlY2tib3hDb250cm9sVmFsdWVBY2Nlc3NvciBleHRlbmRzIEJ1aWx0SW5Db250cm9sVmFsdWVBY2Nlc3NvciBpbXBsZW1lbnRzXG4gICAgQ29udHJvbFZhbHVlQWNjZXNzb3Ige1xuICAvKipcbiAgICogU2V0cyB0aGUgXCJjaGVja2VkXCIgcHJvcGVydHkgb24gdGhlIGlucHV0IGVsZW1lbnQuXG4gICAqIEBub2RvY1xuICAgKi9cbiAgd3JpdGVWYWx1ZSh2YWx1ZTogYW55KTogdm9pZCB7XG4gICAgdGhpcy5zZXRQcm9wZXJ0eSgnY2hlY2tlZCcsIHZhbHVlKTtcbiAgfVxufVxuIl19

package/esm2022/thirdparty/directives/control_value_accessor.mjs

@@ -0,0 +1,216 @@
+/**
+ * [Nimble]
+ * Copied from https://github.com/angular/angular/blob/16.2.12/packages/forms/src/directives/control_value_accessor.ts
+ * with the following modifications:
+ * - Update imports
+ * - Commented out ControlValueAccessor which is exported from @angular/forms
+ * - Commented out NG_VALUE_ACCESSOR which is exported from @angular/forms
+ */
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * @description
+ * Defines an interface that acts as a bridge between the Angular forms API and a
+ * native element in the DOM.
+ *
+ * Implement this interface to create a custom form control directive
+ * that integrates with Angular forms.
+ *
+ * @see {@link DefaultValueAccessor}
+ *
+ * @publicApi
+ */
+/* [Nimble] Commenting out public interface
+export interface ControlValueAccessor {
+  /**
+   * @description
+   * Writes a new value to the element.
+   *
+   * This method is called by the forms API to write to the view when programmatic
+   * changes from model to view are requested.
+   *
+   * @usageNotes
+   * ### Write a value to the element
+   *
+   * The following example writes a value to the native DOM element.
+   *
+   * ```ts
+   * writeValue(value: any): void {
+   *   this._renderer.setProperty(this._elementRef.nativeElement, 'value', value);
+   * }
+   * ```
+   *
+   * @param obj The new value for the element
+   *
+  writeValue(obj: any): void;
+
+  /**
+   * @description
+   * Registers a callback function that is called when the control's value
+   * changes in the UI.
+   *
+   * This method is called by the forms API on initialization to update the form
+   * model when values propagate from the view to the model.
+   *
+   * When implementing the `registerOnChange` method in your own value accessor,
+   * save the given function so your class calls it at the appropriate time.
+   *
+   * @usageNotes
+   * ### Store the change function
+   *
+   * The following example stores the provided function as an internal method.
+   *
+   * ```ts
+   * registerOnChange(fn: (_: any) => void): void {
+   *   this._onChange = fn;
+   * }
+   * ```
+   *
+   * When the value changes in the UI, call the registered
+   * function to allow the forms API to update itself:
+   *
+   * ```ts
+   * host: {
+   *    '(change)': '_onChange($event.target.value)'
+   * }
+   * ```
+   *
+   * @param fn The callback function to register
+   *
+  registerOnChange(fn: any): void;
+
+  /**
+   * @description
+   * Registers a callback function that is called by the forms API on initialization
+   * to update the form model on blur.
+   *
+   * When implementing `registerOnTouched` in your own value accessor, save the given
+   * function so your class calls it when the control should be considered
+   * blurred or "touched".
+   *
+   * @usageNotes
+   * ### Store the callback function
+   *
+   * The following example stores the provided function as an internal method.
+   *
+   * ```ts
+   * registerOnTouched(fn: any): void {
+   *   this._onTouched = fn;
+   * }
+   * ```
+   *
+   * On blur (or equivalent), your class should call the registered function to allow
+   * the forms API to update itself:
+   *
+   * ```ts
+   * host: {
+   *    '(blur)': '_onTouched()'
+   * }
+   * ```
+   *
+   * @param fn The callback function to register
+   *
+  registerOnTouched(fn: any): void;
+
+  /**
+   * @description
+   * Function that is called by the forms API when the control status changes to
+   * or from 'DISABLED'. Depending on the status, it enables or disables the
+   * appropriate DOM element.
+   *
+   * @usageNotes
+   * The following is an example of writing the disabled property to a native DOM element:
+   *
+   * ```ts
+   * setDisabledState(isDisabled: boolean): void {
+   *   this._renderer.setProperty(this._elementRef.nativeElement, 'disabled', isDisabled);
+   * }
+   * ```
+   *
+   * @param isDisabled The disabled status to set on the element
+   *
+  setDisabledState?(isDisabled: boolean): void;
+}
+*/
+/**
+ * Base class for all ControlValueAccessor classes defined in Forms package.
+ * Contains common logic and utility functions.
+ *
+ * Note: this is an *internal-only* class and should not be extended or used directly in
+ * applications code.
+ */
+export class BaseControlValueAccessor {
+    constructor(_renderer, _elementRef) {
+        this._renderer = _renderer;
+        this._elementRef = _elementRef;
+        /**
+         * The registered callback function called when a change or input event occurs on the input
+         * element.
+         * @nodoc
+         */
+        this.onChange = (_) => { };
+        /**
+         * The registered callback function called when a blur event occurs on the input element.
+         * @nodoc
+         */
+        this.onTouched = () => { };
+    }
+    /**
+     * Helper method that sets a property on a target element using the current Renderer
+     * implementation.
+     * @nodoc
+     */
+    setProperty(key, value) {
+        this._renderer.setProperty(this._elementRef.nativeElement, key, value);
+    }
+    /**
+     * Registers a function called when the control is touched.
+     * @nodoc
+     */
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    /**
+     * Registers a function called when the control value changes.
+     * @nodoc
+     */
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    /**
+     * Sets the "disabled" property on the range input element.
+     * @nodoc
+     */
+    setDisabledState(isDisabled) {
+        this.setProperty('disabled', isDisabled);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BaseControlValueAccessor, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: BaseControlValueAccessor, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BaseControlValueAccessor, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }]; } });
+/**
+ * Base class for all built-in ControlValueAccessor classes (except DefaultValueAccessor, which is
+ * used in case no other CVAs can be found). We use this class to distinguish between default CVA,
+ * built-in CVAs and custom CVAs, so that Forms logic can recognize built-in CVAs and treat custom
+ * ones with higher priority (when both built-in and custom CVAs are present).
+ *
+ * Note: this is an *internal-only* class and should not be extended or used directly in
+ * applications code.
+ */
+export class BuiltInControlValueAccessor extends BaseControlValueAccessor {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BuiltInControlValueAccessor, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: BuiltInControlValueAccessor, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BuiltInControlValueAccessor, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"control_value_accessor.js","sourceRoot":"","sources":["../../../../../../projects/ni/nimble-angular/src/thirdparty/directives/control_value_accessor.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;GAMG;AAEH,OAAO,EAAC,SAAS,EAAwB,MAAM,eAAe,CAAC;;AAE/D;;;;;;;;;;;GAWG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+GE;AAEF;;;;;;GAMG;AAEH,MAAM,OAAO,wBAAwB;IAcnC,YAAoB,SAAoB,EAAU,WAAuB;QAArD,cAAS,GAAT,SAAS,CAAW;QAAU,gBAAW,GAAX,WAAW,CAAY;QAbzE;;;;WAIG;QACH,aAAQ,GAAG,CAAC,CAAM,EAAE,EAAE,GAAE,CAAC,CAAC;QAE1B;;;WAGG;QACH,cAAS,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;IAEuD,CAAC;IAE7E;;;;OAIG;IACO,WAAW,CAAC,GAAW,EAAE,KAAU;QAC3C,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;IACzE,CAAC;IAED;;;OAGG;IACH,iBAAiB,CAAC,EAAc;QAC9B,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACtB,CAAC;IAED;;;OAGG;IACH,gBAAgB,CAAC,EAAkB;QACjC,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;IACrB,CAAC;IAED;;;OAGG;IACH,gBAAgB,CAAC,UAAmB;QAClC,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IAC3C,CAAC;+GA/CU,wBAAwB;mGAAxB,wBAAwB;;4FAAxB,wBAAwB;kBADpC,SAAS;;AAmDV;;;;;;;;GAQG;AAEH,MAAM,OAAO,2BAA4B,SAAQ,wBAAwB;+GAA5D,2BAA2B;mGAA3B,2BAA2B;;4FAA3B,2BAA2B;kBADvC,SAAS","sourcesContent":["/**\n * [Nimble]\n * Copied from https://github.com/angular/angular/blob/16.2.12/packages/forms/src/directives/control_value_accessor.ts\n * with the following modifications:\n * - Update imports\n * - Commented out ControlValueAccessor which is exported from @angular/forms\n * - Commented out NG_VALUE_ACCESSOR which is exported from @angular/forms\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Directive, ElementRef, Renderer2} from '@angular/core';\n\n/**\n * @description\n * Defines an interface that acts as a bridge between the Angular forms API and a\n * native element in the DOM.\n *\n * Implement this interface to create a custom form control directive\n * that integrates with Angular forms.\n *\n * @see {@link DefaultValueAccessor}\n *\n * @publicApi\n */\n/* [Nimble] Commenting out public interface\nexport interface ControlValueAccessor {\n  /**\n   * @description\n   * Writes a new value to the element.\n   *\n   * This method is called by the forms API to write to the view when programmatic\n   * changes from model to view are requested.\n   *\n   * @usageNotes\n   * ### Write a value to the element\n   *\n   * The following example writes a value to the native DOM element.\n   *\n   * ```ts\n   * writeValue(value: any): void {\n   *   this._renderer.setProperty(this._elementRef.nativeElement, 'value', value);\n   * }\n   * ```\n   *\n   * @param obj The new value for the element\n   *\n  writeValue(obj: any): void;\n\n  /**\n   * @description\n   * Registers a callback function that is called when the control's value\n   * changes in the UI.\n   *\n   * This method is called by the forms API on initialization to update the form\n   * model when values propagate from the view to the model.\n   *\n   * When implementing the `registerOnChange` method in your own value accessor,\n   * save the given function so your class calls it at the appropriate time.\n   *\n   * @usageNotes\n   * ### Store the change function\n   *\n   * The following example stores the provided function as an internal method.\n   *\n   * ```ts\n   * registerOnChange(fn: (_: any) => void): void {\n   *   this._onChange = fn;\n   * }\n   * ```\n   *\n   * When the value changes in the UI, call the registered\n   * function to allow the forms API to update itself:\n   *\n   * ```ts\n   * host: {\n   *    '(change)': '_onChange($event.target.value)'\n   * }\n   * ```\n   *\n   * @param fn The callback function to register\n   *\n  registerOnChange(fn: any): void;\n\n  /**\n   * @description\n   * Registers a callback function that is called by the forms API on initialization\n   * to update the form model on blur.\n   *\n   * When implementing `registerOnTouched` in your own value accessor, save the given\n   * function so your class calls it when the control should be considered\n   * blurred or \"touched\".\n   *\n   * @usageNotes\n   * ### Store the callback function\n   *\n   * The following example stores the provided function as an internal method.\n   *\n   * ```ts\n   * registerOnTouched(fn: any): void {\n   *   this._onTouched = fn;\n   * }\n   * ```\n   *\n   * On blur (or equivalent), your class should call the registered function to allow\n   * the forms API to update itself:\n   *\n   * ```ts\n   * host: {\n   *    '(blur)': '_onTouched()'\n   * }\n   * ```\n   *\n   * @param fn The callback function to register\n   *\n  registerOnTouched(fn: any): void;\n\n  /**\n   * @description\n   * Function that is called by the forms API when the control status changes to\n   * or from 'DISABLED'. Depending on the status, it enables or disables the\n   * appropriate DOM element.\n   *\n   * @usageNotes\n   * The following is an example of writing the disabled property to a native DOM element:\n   *\n   * ```ts\n   * setDisabledState(isDisabled: boolean): void {\n   *   this._renderer.setProperty(this._elementRef.nativeElement, 'disabled', isDisabled);\n   * }\n   * ```\n   *\n   * @param isDisabled The disabled status to set on the element\n   *\n  setDisabledState?(isDisabled: boolean): void;\n}\n*/\n\n/**\n * Base class for all ControlValueAccessor classes defined in Forms package.\n * Contains common logic and utility functions.\n *\n * Note: this is an *internal-only* class and should not be extended or used directly in\n * applications code.\n */\n@Directive()\nexport class BaseControlValueAccessor {\n  /**\n   * The registered callback function called when a change or input event occurs on the input\n   * element.\n   * @nodoc\n   */\n  onChange = (_: any) => {};\n\n  /**\n   * The registered callback function called when a blur event occurs on the input element.\n   * @nodoc\n   */\n  onTouched = () => {};\n\n  constructor(private _renderer: Renderer2, private _elementRef: ElementRef) {}\n\n  /**\n   * Helper method that sets a property on a target element using the current Renderer\n   * implementation.\n   * @nodoc\n   */\n  protected setProperty(key: string, value: any): void {\n    this._renderer.setProperty(this._elementRef.nativeElement, key, value);\n  }\n\n  /**\n   * Registers a function called when the control is touched.\n   * @nodoc\n   */\n  registerOnTouched(fn: () => void): void {\n    this.onTouched = fn;\n  }\n\n  /**\n   * Registers a function called when the control value changes.\n   * @nodoc\n   */\n  registerOnChange(fn: (_: any) => {}): void {\n    this.onChange = fn;\n  }\n\n  /**\n   * Sets the \"disabled\" property on the range input element.\n   * @nodoc\n   */\n  setDisabledState(isDisabled: boolean): void {\n    this.setProperty('disabled', isDisabled);\n  }\n}\n\n/**\n * Base class for all built-in ControlValueAccessor classes (except DefaultValueAccessor, which is\n * used in case no other CVAs can be found). We use this class to distinguish between default CVA,\n * built-in CVAs and custom CVAs, so that Forms logic can recognize built-in CVAs and treat custom\n * ones with higher priority (when both built-in and custom CVAs are present).\n *\n * Note: this is an *internal-only* class and should not be extended or used directly in\n * applications code.\n */\n@Directive()\nexport class BuiltInControlValueAccessor extends BaseControlValueAccessor {\n}\n\n/**\n * Used to provide a `ControlValueAccessor` for form controls.\n *\n * See `DefaultValueAccessor` for how to implement one.\n *\n * @publicApi\n */\n/* [Nimble] Commenting out public injection token\nexport const NG_VALUE_ACCESSOR =\n    new InjectionToken<ReadonlyArray<ControlValueAccessor>>('NgValueAccessor');\n*/"]}

package/esm2022/thirdparty/directives/default_value_accessor.mjs

@@ -0,0 +1,141 @@
+/**
+ * [Nimble]
+ * Copied from https://github.com/angular/angular/blob/16.2.12/packages/forms/src/directives/default_value_accessor.ts
+ * with the following modifications:
+ * - Update imports
+ * - Update implementation of `_isAndroid()` to not use private APIs
+ * - Remove all configuration from DefaultValueAccessor's `@Directive` decorator
+ */
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Directive, Inject, Optional } from '@angular/core';
+import { COMPOSITION_BUFFER_MODE } from '@angular/forms';
+import { BaseControlValueAccessor } from './control_value_accessor';
+import * as i0 from "@angular/core";
+/* [Nimble] Do not register as a default value accessor provider
+export const DEFAULT_VALUE_ACCESSOR: any = {
+  provide: NG_VALUE_ACCESSOR,
+  useExisting: forwardRef(() => DefaultValueAccessor),
+  multi: true
+};
+*/
+/**
+ * We must check whether the agent is Android because composition events
+ * behave differently between iOS and Android.
+ */
+function _isAndroid() {
+    // [Nimble] Get user agent without using private Angular APIs
+    // const userAgent = getDOM() ? getDOM().getUserAgent() : '';
+    const userAgent = window.navigator.userAgent;
+    return /android (\d+)/.test(userAgent.toLowerCase());
+}
+/* [Nimble] Pulled from Angular forms instead
+/**
+ * @description
+ * Provide this token to control if form directives buffer IME input until
+ * the "compositionend" event occurs.
+ * @publicApi
+ *
+export const COMPOSITION_BUFFER_MODE = new InjectionToken<boolean>('CompositionEventMode');
+*/
+/**
+ * The default `ControlValueAccessor` for writing a value and listening to changes on input
+ * elements. The accessor is used by the `FormControlDirective`, `FormControlName`, and
+ * `NgModel` directives.
+ *
+ * {@searchKeywords ngDefaultControl}
+ *
+ * @usageNotes
+ *
+ * ### Using the default value accessor
+ *
+ * The following example shows how to use an input element that activates the default value accessor
+ * (in this case, a text field).
+ *
+ * ```ts
+ * const firstNameControl = new FormControl();
+ * ```
+ *
+ * ```
+ * <input type="text" [formControl]="firstNameControl">
+ * ```
+ *
+ * This value accessor is used by default for `<input type="text">` and `<textarea>` elements, but
+ * you could also use it for custom components that have similar behavior and do not require special
+ * processing. In order to attach the default value accessor to a custom element, add the
+ * `ngDefaultControl` attribute as shown below.
+ *
+ * ```
+ * <custom-input-component ngDefaultControl [(ngModel)]="value"></custom-input-component>
+ * ```
+ *
+ * @ngModule ReactiveFormsModule
+ * @ngModule FormsModule
+ * @publicApi
+ */
+/* [Nimble] Remove all configuration from @Directive decorator
+@Directive({
+  selector:
+      'input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]',
+  // TODO: vsavkin replace the above selector with the one below it once
+  // https://github.com/angular/angular/issues/3011 is implemented
+  // selector: '[ngModel],[formControl],[formControlName]',
+  host: {
+    '(input)': '$any(this)._handleInput($event.target.value)',
+    '(blur)': 'onTouched()',
+    '(compositionstart)': '$any(this)._compositionStart()',
+    '(compositionend)': '$any(this)._compositionEnd($event.target.value)'
+  },
+  providers: [DEFAULT_VALUE_ACCESSOR]
+})
+*/
+export class DefaultValueAccessor extends BaseControlValueAccessor {
+    constructor(renderer, elementRef, _compositionMode) {
+        super(renderer, elementRef);
+        this._compositionMode = _compositionMode;
+        /** Whether the user is creating a composition string (IME events). */
+        this._composing = false;
+        if (this._compositionMode == null) {
+            this._compositionMode = !_isAndroid();
+        }
+    }
+    /**
+     * Sets the "value" property on the input element.
+     * @nodoc
+     */
+    writeValue(value) {
+        const normalizedValue = value == null ? '' : value;
+        this.setProperty('value', normalizedValue);
+    }
+    /** @internal */
+    _handleInput(value) {
+        if (!this._compositionMode || (this._compositionMode && !this._composing)) {
+            this.onChange(value);
+        }
+    }
+    /** @internal */
+    _compositionStart() {
+        this._composing = true;
+    }
+    /** @internal */
+    _compositionEnd(value) {
+        this._composing = false;
+        this._compositionMode && this.onChange(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DefaultValueAccessor, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: COMPOSITION_BUFFER_MODE, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: DefaultValueAccessor, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DefaultValueAccessor, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [COMPOSITION_BUFFER_MODE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"default_value_accessor.js","sourceRoot":"","sources":["../../../../../../projects/ni/nimble-angular/src/thirdparty/directives/default_value_accessor.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;GAMG;AAEH,OAAO,EAAC,SAAS,EAAc,MAAM,EAAE,QAAQ,EAAY,MAAM,eAAe,CAAC;AAEjF,OAAO,EAAwB,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAC/E,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;;AAEpE;;;;;;EAME;AAEF;;;GAGG;AACH,SAAS,UAAU;IACjB,6DAA6D;IAC7D,6DAA6D;IAC7D,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC;IAC7C,OAAO,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;;EAQE;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH;;;;;;;;;;;;;;;EAeE;AAEF,MAAM,OAAO,oBAAqB,SAAQ,wBAAwB;IAIhE,YACI,QAAmB,EAAE,UAAsB,EACU,gBAAyB;QAChF,KAAK,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QAD2B,qBAAgB,GAAhB,gBAAgB,CAAS;QALlF,sEAAsE;QAC9D,eAAU,GAAG,KAAK,CAAC;QAMzB,IAAI,IAAI,CAAC,gBAAgB,IAAI,IAAI,EAAE;YACjC,IAAI,CAAC,gBAAgB,GAAG,CAAC,UAAU,EAAE,CAAC;SACvC;IACH,CAAC;IAED;;;OAGG;IACH,UAAU,CAAC,KAAU;QACnB,MAAM,eAAe,GAAG,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;QACnD,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC;IAC7C,CAAC;IAED,gBAAgB;IAChB,YAAY,CAAC,KAAU;QACrB,IAAI,CAAC,IAAI,CAAC,gBAAgB,IAAI,CAAC,IAAI,CAAC,gBAAgB,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE;YACzE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;SACtB;IACH,CAAC;IAED,gBAAgB;IAChB,iBAAiB;QACf,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;IACzB,CAAC;IAED,gBAAgB;IAChB,eAAe,CAAC,KAAU;QACxB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QACxB,IAAI,CAAC,gBAAgB,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAChD,CAAC;+GAtCU,oBAAoB,qEAMP,uBAAuB;mGANpC,oBAAoB;;4FAApB,oBAAoB;kBADhC,SAAS;;0BAOH,QAAQ;;0BAAI,MAAM;2BAAC,uBAAuB","sourcesContent":["/**\n * [Nimble]\n * Copied from https://github.com/angular/angular/blob/16.2.12/packages/forms/src/directives/default_value_accessor.ts\n * with the following modifications:\n * - Update imports\n * - Update implementation of `_isAndroid()` to not use private APIs\n * - Remove all configuration from DefaultValueAccessor's `@Directive` decorator\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Directive, ElementRef, Inject, Optional, Renderer2} from '@angular/core';\n\nimport { ControlValueAccessor, COMPOSITION_BUFFER_MODE } from '@angular/forms';\nimport { BaseControlValueAccessor } from './control_value_accessor';\n\n/* [Nimble] Do not register as a default value accessor provider\nexport const DEFAULT_VALUE_ACCESSOR: any = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => DefaultValueAccessor),\n  multi: true\n};\n*/\n\n/**\n * We must check whether the agent is Android because composition events\n * behave differently between iOS and Android.\n */\nfunction _isAndroid(): boolean {\n  // [Nimble] Get user agent without using private Angular APIs\n  // const userAgent = getDOM() ? getDOM().getUserAgent() : '';\n  const userAgent = window.navigator.userAgent;\n  return /android (\\d+)/.test(userAgent.toLowerCase());\n}\n\n/* [Nimble] Pulled from Angular forms instead\n/**\n * @description\n * Provide this token to control if form directives buffer IME input until\n * the \"compositionend\" event occurs.\n * @publicApi\n *\nexport const COMPOSITION_BUFFER_MODE = new InjectionToken<boolean>('CompositionEventMode');\n*/\n\n/**\n * The default `ControlValueAccessor` for writing a value and listening to changes on input\n * elements. The accessor is used by the `FormControlDirective`, `FormControlName`, and\n * `NgModel` directives.\n *\n * {@searchKeywords ngDefaultControl}\n *\n * @usageNotes\n *\n * ### Using the default value accessor\n *\n * The following example shows how to use an input element that activates the default value accessor\n * (in this case, a text field).\n *\n * ```ts\n * const firstNameControl = new FormControl();\n * ```\n *\n * ```\n * <input type=\"text\" [formControl]=\"firstNameControl\">\n * ```\n *\n * This value accessor is used by default for `<input type=\"text\">` and `<textarea>` elements, but\n * you could also use it for custom components that have similar behavior and do not require special\n * processing. In order to attach the default value accessor to a custom element, add the\n * `ngDefaultControl` attribute as shown below.\n *\n * ```\n * <custom-input-component ngDefaultControl [(ngModel)]=\"value\"></custom-input-component>\n * ```\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\n/* [Nimble] Remove all configuration from @Directive decorator\n@Directive({\n  selector:\n      'input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]',\n  // TODO: vsavkin replace the above selector with the one below it once\n  // https://github.com/angular/angular/issues/3011 is implemented\n  // selector: '[ngModel],[formControl],[formControlName]',\n  host: {\n    '(input)': '$any(this)._handleInput($event.target.value)',\n    '(blur)': 'onTouched()',\n    '(compositionstart)': '$any(this)._compositionStart()',\n    '(compositionend)': '$any(this)._compositionEnd($event.target.value)'\n  },\n  providers: [DEFAULT_VALUE_ACCESSOR]\n})\n*/\n@Directive()\nexport class DefaultValueAccessor extends BaseControlValueAccessor implements ControlValueAccessor {\n  /** Whether the user is creating a composition string (IME events). */\n  private _composing = false;\n\n  constructor(\n      renderer: Renderer2, elementRef: ElementRef,\n      @Optional() @Inject(COMPOSITION_BUFFER_MODE) private _compositionMode: boolean) {\n    super(renderer, elementRef);\n    if (this._compositionMode == null) {\n      this._compositionMode = !_isAndroid();\n    }\n  }\n\n  /**\n   * Sets the \"value\" property on the input element.\n   * @nodoc\n   */\n  writeValue(value: any): void {\n    const normalizedValue = value == null ? '' : value;\n    this.setProperty('value', normalizedValue);\n  }\n\n  /** @internal */\n  _handleInput(value: any): void {\n    if (!this._compositionMode || (this._compositionMode && !this._composing)) {\n      this.onChange(value);\n    }\n  }\n\n  /** @internal */\n  _compositionStart(): void {\n    this._composing = true;\n  }\n\n  /** @internal */\n  _compositionEnd(value: any): void {\n    this._composing = false;\n    this._compositionMode && this.onChange(value);\n  }\n}\n"]}