@ni/nimble-angular 12.1.0 → 12.1.2

package/directives/radio/nimble-radio-control-value-accessor.directive.d.ts

@@ -1,5 +1,5 @@
 import { ElementRef, Injector, OnInit, Renderer2 } from '@angular/core';
-import { RadioControlValueAccessor, ɵangular_packages_forms_forms_r } from '@angular/forms';
+import { RadioControlValueAccessor, RadioControlRegistry } from '../../thirdparty/directives/radio_control_value_accessor';
 import * as i0 from "@angular/core";
 /**
  * Control Value Accessor implementation for the radio group.
@@ -8,7 +8,7 @@ export declare class NimbleRadioControlValueAccessorDirective extends RadioContr
     private readonly elementRef;
     private static _nextOpenId;
     private _privateOnChange?;
-    constructor(renderer: Renderer2, elementRef: ElementRef, _registry: ɵangular_packages_forms_forms_r, _injector: Injector);
+    constructor(renderer: Renderer2, elementRef: ElementRef, _registry: RadioControlRegistry, _injector: Injector);
     private static allocateId;
     ngOnInit(): void;
     /**

package/directives/radio/nimble-radio.module.d.ts

@@ -2,8 +2,9 @@ import * as i0 from "@angular/core";
 import * as i1 from "./nimble-radio-control-value-accessor.directive";
 import * as i2 from "./nimble-radio.directive";
 import * as i3 from "@angular/common";
+import * as i4 from "../../thirdparty/directives/radio_control_value_accessor";
 export declare class NimbleRadioModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<NimbleRadioModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<NimbleRadioModule, [typeof i1.NimbleRadioControlValueAccessorDirective, typeof i2.NimbleRadioDirective], [typeof i3.CommonModule], [typeof i1.NimbleRadioControlValueAccessorDirective, typeof i2.NimbleRadioDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NimbleRadioModule, [typeof i1.NimbleRadioControlValueAccessorDirective, typeof i2.NimbleRadioDirective], [typeof i3.CommonModule, typeof i4.RadioControlRegistryModule], [typeof i1.NimbleRadioControlValueAccessorDirective, typeof i2.NimbleRadioDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<NimbleRadioModule>;
 }

package/esm2015/directives/radio/nimble-radio-control-value-accessor.directive.js

@@ -1,15 +1,14 @@
 import { Directive, forwardRef } from '@angular/core';
 // eslint-disable-next-line camelcase
-import { NG_VALUE_ACCESSOR, RadioControlValueAccessor } from '@angular/forms';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
 import { RadioGroup } from '@ni/nimble-components/dist/esm/radio-group';
+import { RadioControlValueAccessor } from '../../thirdparty/directives/radio_control_value_accessor';
 import * as i0 from "@angular/core";
-import * as i1 from "@angular/forms";
+import * as i1 from "../../thirdparty/directives/radio_control_value_accessor";
 /**
  * Control Value Accessor implementation for the radio group.
  */
 export class NimbleRadioControlValueAccessorDirective extends RadioControlValueAccessor {
-    // Type ɵangular_packages_forms_forms_r from base class isn't in camelcase
-    // eslint-disable-next-line camelcase
     constructor(renderer, elementRef, _registry, _injector) {
         super(renderer, elementRef, _registry, _injector);
         this.elementRef = elementRef;
@@ -20,6 +19,7 @@ export class NimbleRadioControlValueAccessorDirective extends RadioControlValueA
         return id;
     }
     ngOnInit() {
+        super.ngOnInit();
         // We need each button element to have a unique string value, because the FAST radio group looks at
         // these values when trying to manage the checked state.
         this.elementRef.nativeElement.value = NimbleRadioControlValueAccessorDirective.allocateId();
@@ -63,7 +63,7 @@ export class NimbleRadioControlValueAccessorDirective extends RadioControlValueA
     }
 }
 NimbleRadioControlValueAccessorDirective._nextOpenId = 0;
-NimbleRadioControlValueAccessorDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: NimbleRadioControlValueAccessorDirective, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i1.ɵangular_packages_forms_forms_r }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive });
+NimbleRadioControlValueAccessorDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: NimbleRadioControlValueAccessorDirective, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i1.RadioControlRegistry }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive });
 NimbleRadioControlValueAccessorDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.5", type: NimbleRadioControlValueAccessorDirective, selector: "nimble-radio[formControlName],nimble-radio[formControl],nimble-radio[ngModel]", host: { listeners: { "change": "nimbleOnChange($event.target.checked)", "blur": "onTouched()" } }, providers: [{
             provide: NG_VALUE_ACCESSOR,
             useExisting: forwardRef(() => NimbleRadioControlValueAccessorDirective),
@@ -82,5 +82,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.5", ngImpor
                             multi: true
                         }]
                 }]
-        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i1.ɵangular_packages_forms_forms_r }, { type: i0.Injector }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nimble-radio-control-value-accessor.directive.js","sourceRoot":"","sources":["../../../../../../projects/ni/nimble-angular/src/directives/radio/nimble-radio-control-value-accessor.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAc,UAAU,EAA+B,MAAM,eAAe,CAAC;AAC/F,qCAAqC;AACrC,OAAO,EAAE,iBAAiB,EAAE,yBAAyB,EAAmC,MAAM,gBAAgB,CAAC;AAC/G,OAAO,EAAE,UAAU,EAAE,MAAM,4CAA4C,CAAC;;;AAGxE;;GAEG;AAaH,MAAM,OAAO,wCAAyC,SAAQ,yBAAyB;IAInF,0EAA0E;IAC1E,qCAAqC;IACrC,YAAmB,QAAmB,EAAmB,UAAsB,EAAE,SAA0C,EAAE,SAAmB;QAC5I,KAAK,CAAC,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;QADG,eAAU,GAAV,UAAU,CAAY;IAE/E,CAAC;IAEO,MAAM,CAAC,UAAU;QACrB,MAAM,EAAE,GAAG,wCAAwC,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;QAC3E,wCAAwC,CAAC,WAAW,IAAI,CAAC,CAAC;QAC1D,OAAO,EAAE,CAAC;IACd,CAAC;IAEM,QAAQ;QACX,mGAAmG;QACnG,wDAAwD;QACvD,IAAI,CAAC,UAAU,CAAC,aAAuB,CAAC,KAAK,GAAG,wCAAwC,CAAC,UAAU,EAAE,CAAC;IAC3G,CAAC;IAED;;;OAGG;IACa,UAAU,CAAC,KAAc;QACrC,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACxB,MAAM,WAAW,GAAI,IAAI,CAAC,UAAU,CAAC,aAAuB,CAAC,aAAa,CAAC;QAC3E,IAAI,IAAI,CAAC,KAAK,KAAK,KAAK,IAAI,WAAW,IAAI,WAAW,YAAY,UAAU,EAAE;YAC1E,2FAA2F;YAC3F,8FAA8F;YAC9F,0FAA0F;YAC1F,uFAAuF;YACvF,wEAAwE;YACxE,yFAAyF;YACzF,2FAA2F;YAC3F,gEAAgE;YAChE,WAAW,CAAC,KAAK,GAAI,IAAI,CAAC,UAAU,CAAC,aAAuB,CAAC,KAAK,CAAC;SACtE;IACL,CAAC;IAED,uFAAuF;IACvF,kGAAkG;IAClG,mGAAmG;IACnG,gCAAgC;IAChC,EAAE;IACF,oGAAoG;IACpG,sGAAsG;IACtG,2CAA2C;IACpC,cAAc,CAAC,OAAgB;QAClC,IAAI,OAAO,IAAI,IAAI,CAAC,gBAAgB,EAAE;YAClC,IAAI,CAAC,gBAAgB,EAAE,CAAC;SAC3B;IACL,CAAC;IAEe,gBAAgB,CAAC,EAA8C;QAC3E,KAAK,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC;QAC3B,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC;QACtC,IAAI,CAAC,QAAQ,GAAG,GAAS,EAAE,GAAE,CAAC,CAAC;IACnC,CAAC;;AA3Dc,oDAAW,GAAG,CAAC,CAAC;qIADtB,wCAAwC;yHAAxC,wCAAwC,2MANtC,CAAC;YACR,OAAO,EAAE,iBAAiB;YAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,CAAC,wCAAwC,CAAC;YACvE,KAAK,EAAE,IAAI;SACd,CAAC;2FAEO,wCAAwC;kBAZpD,SAAS;mBAAC;oBACP,QAAQ,EACJ,+EAA+E;oBACnF,2EAA2E;oBAC3E,qEAAqE;oBACrE,IAAI,EAAE,EAAE,UAAU,EAAE,uCAAuC,EAAE,QAAQ,EAAE,aAAa,EAAE;oBACtF,SAAS,EAAE,CAAC;4BACR,OAAO,EAAE,iBAAiB;4BAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,yCAAyC,CAAC;4BACvE,KAAK,EAAE,IAAI;yBACd,CAAC;iBACL","sourcesContent":["import { Directive, ElementRef, forwardRef, Injector, OnInit, Renderer2 } from '@angular/core';\n// eslint-disable-next-line camelcase\nimport { NG_VALUE_ACCESSOR, RadioControlValueAccessor, ɵangular_packages_forms_forms_r } from '@angular/forms';\nimport { RadioGroup } from '@ni/nimble-components/dist/esm/radio-group';\nimport type { Radio } from '@ni/nimble-components/dist/esm/radio';\n\n/**\n * Control Value Accessor implementation for the radio group.\n */\n@Directive({\n    selector:\n        'nimble-radio[formControlName],nimble-radio[formControl],nimble-radio[ngModel]',\n    // The following host metadata is duplicated from RadioControlValueAccessor\n    // eslint-disable-next-line @angular-eslint/no-host-metadata-property\n    host: { '(change)': 'nimbleOnChange($event.target.checked)', '(blur)': 'onTouched()' },\n    providers: [{\n        provide: NG_VALUE_ACCESSOR,\n        useExisting: forwardRef(() => NimbleRadioControlValueAccessorDirective),\n        multi: true\n    }]\n})\nexport class NimbleRadioControlValueAccessorDirective extends RadioControlValueAccessor implements OnInit {\n    private static _nextOpenId = 0;\n    private _privateOnChange?: () => void;\n\n    // Type ɵangular_packages_forms_forms_r from base class isn't in camelcase\n    // eslint-disable-next-line camelcase\n    public constructor(renderer: Renderer2, private readonly elementRef: ElementRef, _registry: ɵangular_packages_forms_forms_r, _injector: Injector) {\n        super(renderer, elementRef, _registry, _injector);\n    }\n\n    private static allocateId(): string {\n        const id = NimbleRadioControlValueAccessorDirective._nextOpenId.toString();\n        NimbleRadioControlValueAccessorDirective._nextOpenId += 1;\n        return id;\n    }\n\n    public ngOnInit(): void {\n        // We need each button element to have a unique string value, because the FAST radio group looks at\n        // these values when trying to manage the checked state.\n        (this.elementRef.nativeElement as Radio).value = NimbleRadioControlValueAccessorDirective.allocateId();\n    }\n\n    /**\n     * Sets the \"checked\" property value on the radio input element.\n     * @nodoc\n     */\n    public override writeValue(value: unknown): void {\n        super.writeValue(value);\n        const parentGroup = (this.elementRef.nativeElement as Radio).parentElement;\n        if (this.value === value && parentGroup && parentGroup instanceof RadioGroup) {\n            // This is a workaround to a problem where all of the buttons are initialized as unchecked.\n            // The radio group tries to synchronize its value and the checked states of the radio buttons.\n            // In response to the slotchange DOM event, the radio group sets the checked state of each\n            // newly slotted button, based on whether the button's value matches the group's value.\n            // If the group's value is uninitialized, it unchecks all radio buttons.\n            // Unfortunately, this occurs _after_ the CVA initializes the checked state of each radio\n            // button, meaning the initially checked button gets unchecked by the group. To avoid this,\n            // we need to set the group's value to match the checked button.\n            parentGroup.value = (this.elementRef.nativeElement as Radio).value;\n        }\n    }\n\n    // There is a bug in FAST (https://github.com/microsoft/fast/issues/6381) that prevents\n    // RadioControlValueAccessor from working properly. The default onChange handler is supposed to be\n    // called _only_ when radio buttons are checked, but the FAST bug causes it to be called when radio\n    // buttons are _unchecked_, too.\n    //\n    // To work around this, we effectively disable the base class's onChange handler and replace it with\n    // our own nimbleOnChange. NimbleOnChange calls the original onChange (now cached as _privateOnChange)\n    // only if the changed item became checked.\n    public nimbleOnChange(checked: boolean): void {\n        if (checked && this._privateOnChange) {\n            this._privateOnChange();\n        }\n    }\n\n    public override registerOnChange(fn: (_: unknown) => { [key: string]: unknown }): void {\n        super.registerOnChange(fn);\n        this._privateOnChange = this.onChange;\n        this.onChange = (): void => {};\n    }\n}"]}
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i1.RadioControlRegistry }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nimble-radio-control-value-accessor.directive.js","sourceRoot":"","sources":["../../../../../../projects/ni/nimble-angular/src/directives/radio/nimble-radio-control-value-accessor.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAc,UAAU,EAA+B,MAAM,eAAe,CAAC;AAC/F,qCAAqC;AACrC,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,4CAA4C,CAAC;AAExE,OAAO,EAAE,yBAAyB,EAAwB,MAAM,0DAA0D,CAAC;;;AAE3H;;GAEG;AAaH,MAAM,OAAO,wCAAyC,SAAQ,yBAAyB;IAInF,YAAmB,QAAmB,EAAmB,UAAsB,EAAE,SAA+B,EAAE,SAAmB;QACjI,KAAK,CAAC,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;QADG,eAAU,GAAV,UAAU,CAAY;IAE/E,CAAC;IAEO,MAAM,CAAC,UAAU;QACrB,MAAM,EAAE,GAAG,wCAAwC,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;QAC3E,wCAAwC,CAAC,WAAW,IAAI,CAAC,CAAC;QAC1D,OAAO,EAAE,CAAC;IACd,CAAC;IAEe,QAAQ;QACpB,KAAK,CAAC,QAAQ,EAAE,CAAC;QACjB,mGAAmG;QACnG,wDAAwD;QACvD,IAAI,CAAC,UAAU,CAAC,aAAuB,CAAC,KAAK,GAAG,wCAAwC,CAAC,UAAU,EAAE,CAAC;IAC3G,CAAC;IAED;;;OAGG;IACa,UAAU,CAAC,KAAc;QACrC,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACxB,MAAM,WAAW,GAAI,IAAI,CAAC,UAAU,CAAC,aAAuB,CAAC,aAAa,CAAC;QAC3E,IAAI,IAAI,CAAC,KAAK,KAAK,KAAK,IAAI,WAAW,IAAI,WAAW,YAAY,UAAU,EAAE;YAC1E,2FAA2F;YAC3F,8FAA8F;YAC9F,0FAA0F;YAC1F,uFAAuF;YACvF,wEAAwE;YACxE,yFAAyF;YACzF,2FAA2F;YAC3F,gEAAgE;YAChE,WAAW,CAAC,KAAK,GAAI,IAAI,CAAC,UAAU,CAAC,aAAuB,CAAC,KAAK,CAAC;SACtE;IACL,CAAC;IAED,uFAAuF;IACvF,kGAAkG;IAClG,mGAAmG;IACnG,gCAAgC;IAChC,EAAE;IACF,oGAAoG;IACpG,sGAAsG;IACtG,2CAA2C;IACpC,cAAc,CAAC,OAAgB;QAClC,IAAI,OAAO,IAAI,IAAI,CAAC,gBAAgB,EAAE;YAClC,IAAI,CAAC,gBAAgB,EAAE,CAAC;SAC3B;IACL,CAAC;IAEe,gBAAgB,CAAC,EAA8C;QAC3E,KAAK,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC;QAC3B,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC;QACtC,IAAI,CAAC,QAAQ,GAAG,GAAS,EAAE,GAAE,CAAC,CAAC;IACnC,CAAC;;AA1Dc,oDAAW,GAAG,CAAC,CAAC;qIADtB,wCAAwC;yHAAxC,wCAAwC,2MANtC,CAAC;YACR,OAAO,EAAE,iBAAiB;YAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,CAAC,wCAAwC,CAAC;YACvE,KAAK,EAAE,IAAI;SACd,CAAC;2FAEO,wCAAwC;kBAZpD,SAAS;mBAAC;oBACP,QAAQ,EACJ,+EAA+E;oBACnF,2EAA2E;oBAC3E,qEAAqE;oBACrE,IAAI,EAAE,EAAE,UAAU,EAAE,uCAAuC,EAAE,QAAQ,EAAE,aAAa,EAAE;oBACtF,SAAS,EAAE,CAAC;4BACR,OAAO,EAAE,iBAAiB;4BAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,yCAAyC,CAAC;4BACvE,KAAK,EAAE,IAAI;yBACd,CAAC;iBACL","sourcesContent":["import { Directive, ElementRef, forwardRef, Injector, OnInit, Renderer2 } from '@angular/core';\n// eslint-disable-next-line camelcase\nimport { NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { RadioGroup } from '@ni/nimble-components/dist/esm/radio-group';\nimport type { Radio } from '@ni/nimble-components/dist/esm/radio';\nimport { RadioControlValueAccessor, RadioControlRegistry } from '../../thirdparty/directives/radio_control_value_accessor';\n\n/**\n * Control Value Accessor implementation for the radio group.\n */\n@Directive({\n    selector:\n        'nimble-radio[formControlName],nimble-radio[formControl],nimble-radio[ngModel]',\n    // The following host metadata is duplicated from RadioControlValueAccessor\n    // eslint-disable-next-line @angular-eslint/no-host-metadata-property\n    host: { '(change)': 'nimbleOnChange($event.target.checked)', '(blur)': 'onTouched()' },\n    providers: [{\n        provide: NG_VALUE_ACCESSOR,\n        useExisting: forwardRef(() => NimbleRadioControlValueAccessorDirective),\n        multi: true\n    }]\n})\nexport class NimbleRadioControlValueAccessorDirective extends RadioControlValueAccessor implements OnInit {\n    private static _nextOpenId = 0;\n    private _privateOnChange?: () => void;\n\n    public constructor(renderer: Renderer2, private readonly elementRef: ElementRef, _registry: RadioControlRegistry, _injector: Injector) {\n        super(renderer, elementRef, _registry, _injector);\n    }\n\n    private static allocateId(): string {\n        const id = NimbleRadioControlValueAccessorDirective._nextOpenId.toString();\n        NimbleRadioControlValueAccessorDirective._nextOpenId += 1;\n        return id;\n    }\n\n    public override ngOnInit(): void {\n        super.ngOnInit();\n        // We need each button element to have a unique string value, because the FAST radio group looks at\n        // these values when trying to manage the checked state.\n        (this.elementRef.nativeElement as Radio).value = NimbleRadioControlValueAccessorDirective.allocateId();\n    }\n\n    /**\n     * Sets the \"checked\" property value on the radio input element.\n     * @nodoc\n     */\n    public override writeValue(value: unknown): void {\n        super.writeValue(value);\n        const parentGroup = (this.elementRef.nativeElement as Radio).parentElement;\n        if (this.value === value && parentGroup && parentGroup instanceof RadioGroup) {\n            // This is a workaround to a problem where all of the buttons are initialized as unchecked.\n            // The radio group tries to synchronize its value and the checked states of the radio buttons.\n            // In response to the slotchange DOM event, the radio group sets the checked state of each\n            // newly slotted button, based on whether the button's value matches the group's value.\n            // If the group's value is uninitialized, it unchecks all radio buttons.\n            // Unfortunately, this occurs _after_ the CVA initializes the checked state of each radio\n            // button, meaning the initially checked button gets unchecked by the group. To avoid this,\n            // we need to set the group's value to match the checked button.\n            parentGroup.value = (this.elementRef.nativeElement as Radio).value;\n        }\n    }\n\n    // There is a bug in FAST (https://github.com/microsoft/fast/issues/6381) that prevents\n    // RadioControlValueAccessor from working properly. The default onChange handler is supposed to be\n    // called _only_ when radio buttons are checked, but the FAST bug causes it to be called when radio\n    // buttons are _unchecked_, too.\n    //\n    // To work around this, we effectively disable the base class's onChange handler and replace it with\n    // our own nimbleOnChange. NimbleOnChange calls the original onChange (now cached as _privateOnChange)\n    // only if the changed item became checked.\n    public nimbleOnChange(checked: boolean): void {\n        if (checked && this._privateOnChange) {\n            this._privateOnChange();\n        }\n    }\n\n    public override registerOnChange(fn: (_: unknown) => { [key: string]: unknown }): void {\n        super.registerOnChange(fn);\n        this._privateOnChange = this.onChange;\n        this.onChange = (): void => {};\n    }\n}"]}

package/esm2015/directives/radio/nimble-radio.module.js

@@ -2,18 +2,19 @@ import { NgModule } from '@angular/core';
 import { CommonModule } from '@angular/common';
 import { NimbleRadioControlValueAccessorDirective } from './nimble-radio-control-value-accessor.directive';
 import { NimbleRadioDirective } from './nimble-radio.directive';
+import { RadioControlRegistryModule } from '../../thirdparty/directives/radio_control_value_accessor';
 import * as i0 from "@angular/core";
 export class NimbleRadioModule {
 }
 NimbleRadioModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: NimbleRadioModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-NimbleRadioModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: NimbleRadioModule, declarations: [NimbleRadioControlValueAccessorDirective, NimbleRadioDirective], imports: [CommonModule], exports: [NimbleRadioControlValueAccessorDirective, NimbleRadioDirective] });
-NimbleRadioModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: NimbleRadioModule, imports: [[CommonModule]] });
+NimbleRadioModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: NimbleRadioModule, declarations: [NimbleRadioControlValueAccessorDirective, NimbleRadioDirective], imports: [CommonModule, RadioControlRegistryModule], exports: [NimbleRadioControlValueAccessorDirective, NimbleRadioDirective] });
+NimbleRadioModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: NimbleRadioModule, imports: [[CommonModule, RadioControlRegistryModule]] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: NimbleRadioModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [NimbleRadioControlValueAccessorDirective, NimbleRadioDirective],
-                    imports: [CommonModule],
+                    imports: [CommonModule, RadioControlRegistryModule],
                     exports: [NimbleRadioControlValueAccessorDirective, NimbleRadioDirective]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmltYmxlLXJhZGlvLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25pL25pbWJsZS1hbmd1bGFyL3NyYy9kaXJlY3RpdmVzL3JhZGlvL25pbWJsZS1yYWRpby5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLHdDQUF3QyxFQUFFLE1BQU0saURBQWlELENBQUM7QUFDM0csT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7O0FBT2hFLE1BQU0sT0FBTyxpQkFBaUI7OzhHQUFqQixpQkFBaUI7K0dBQWpCLGlCQUFpQixpQkFKWCx3Q0FBd0MsRUFBRSxvQkFBb0IsYUFDbkUsWUFBWSxhQUNaLHdDQUF3QyxFQUFFLG9CQUFvQjsrR0FFL0QsaUJBQWlCLFlBSGpCLENBQUMsWUFBWSxDQUFDOzJGQUdkLGlCQUFpQjtrQkFMN0IsUUFBUTttQkFBQztvQkFDTixZQUFZLEVBQUUsQ0FBQyx3Q0FBd0MsRUFBRSxvQkFBb0IsQ0FBQztvQkFDOUUsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO29CQUN2QixPQUFPLEVBQUUsQ0FBQyx3Q0FBd0MsRUFBRSxvQkFBb0IsQ0FBQztpQkFDNUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE5pbWJsZVJhZGlvQ29udHJvbFZhbHVlQWNjZXNzb3JEaXJlY3RpdmUgfSBmcm9tICcuL25pbWJsZS1yYWRpby1jb250cm9sLXZhbHVlLWFjY2Vzc29yLmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBOaW1ibGVSYWRpb0RpcmVjdGl2ZSB9IGZyb20gJy4vbmltYmxlLXJhZGlvLmRpcmVjdGl2ZSc7XG5cbkBOZ01vZHVsZSh7XG4gICAgZGVjbGFyYXRpb25zOiBbTmltYmxlUmFkaW9Db250cm9sVmFsdWVBY2Nlc3NvckRpcmVjdGl2ZSwgTmltYmxlUmFkaW9EaXJlY3RpdmVdLFxuICAgIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdLFxuICAgIGV4cG9ydHM6IFtOaW1ibGVSYWRpb0NvbnRyb2xWYWx1ZUFjY2Vzc29yRGlyZWN0aXZlLCBOaW1ibGVSYWRpb0RpcmVjdGl2ZV1cbn0pXG5leHBvcnQgY2xhc3MgTmltYmxlUmFkaW9Nb2R1bGUgeyB9XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmltYmxlLXJhZGlvLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25pL25pbWJsZS1hbmd1bGFyL3NyYy9kaXJlY3RpdmVzL3JhZGlvL25pbWJsZS1yYWRpby5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLHdDQUF3QyxFQUFFLE1BQU0saURBQWlELENBQUM7QUFDM0csT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDaEUsT0FBTyxFQUFFLDBCQUEwQixFQUFFLE1BQU0sMERBQTBELENBQUM7O0FBT3RHLE1BQU0sT0FBTyxpQkFBaUI7OzhHQUFqQixpQkFBaUI7K0dBQWpCLGlCQUFpQixpQkFKWCx3Q0FBd0MsRUFBRSxvQkFBb0IsYUFDbkUsWUFBWSxFQUFFLDBCQUEwQixhQUN4Qyx3Q0FBd0MsRUFBRSxvQkFBb0I7K0dBRS9ELGlCQUFpQixZQUhqQixDQUFDLFlBQVksRUFBRSwwQkFBMEIsQ0FBQzsyRkFHMUMsaUJBQWlCO2tCQUw3QixRQUFRO21CQUFDO29CQUNOLFlBQVksRUFBRSxDQUFDLHdDQUF3QyxFQUFFLG9CQUFvQixDQUFDO29CQUM5RSxPQUFPLEVBQUUsQ0FBQyxZQUFZLEVBQUUsMEJBQTBCLENBQUM7b0JBQ25ELE9BQU8sRUFBRSxDQUFDLHdDQUF3QyxFQUFFLG9CQUFvQixDQUFDO2lCQUM1RSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmltYmxlUmFkaW9Db250cm9sVmFsdWVBY2Nlc3NvckRpcmVjdGl2ZSB9IGZyb20gJy4vbmltYmxlLXJhZGlvLWNvbnRyb2wtdmFsdWUtYWNjZXNzb3IuZGlyZWN0aXZlJztcbmltcG9ydCB7IE5pbWJsZVJhZGlvRGlyZWN0aXZlIH0gZnJvbSAnLi9uaW1ibGUtcmFkaW8uZGlyZWN0aXZlJztcbmltcG9ydCB7IFJhZGlvQ29udHJvbFJlZ2lzdHJ5TW9kdWxlIH0gZnJvbSAnLi4vLi4vdGhpcmRwYXJ0eS9kaXJlY3RpdmVzL3JhZGlvX2NvbnRyb2xfdmFsdWVfYWNjZXNzb3InO1xuXG5ATmdNb2R1bGUoe1xuICAgIGRlY2xhcmF0aW9uczogW05pbWJsZVJhZGlvQ29udHJvbFZhbHVlQWNjZXNzb3JEaXJlY3RpdmUsIE5pbWJsZVJhZGlvRGlyZWN0aXZlXSxcbiAgICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBSYWRpb0NvbnRyb2xSZWdpc3RyeU1vZHVsZV0sXG4gICAgZXhwb3J0czogW05pbWJsZVJhZGlvQ29udHJvbFZhbHVlQWNjZXNzb3JEaXJlY3RpdmUsIE5pbWJsZVJhZGlvRGlyZWN0aXZlXVxufSlcbmV4cG9ydCBjbGFzcyBOaW1ibGVSYWRpb01vZHVsZSB7IH1cbiJdfQ==

package/esm2015/thirdparty/directives/control_value_accessor.js

@@ -0,0 +1,215 @@
+/**
+ * [Nimble]
+ * Copied from https://github.com/angular/angular/blob/14.2.6/packages/forms/src/directives/control_value_accessor.ts
+ * with the following modifications:
+ * - 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 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);
+    }
+}
+BaseControlValueAccessor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: BaseControlValueAccessor, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+BaseControlValueAccessor.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.5", type: BaseControlValueAccessor, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.5", 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 {
+}
+BuiltInControlValueAccessor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: BuiltInControlValueAccessor, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+BuiltInControlValueAccessor.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.5", type: BuiltInControlValueAccessor, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.5", 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;;;;;;GAMG;AAEH;;;;;;GAMG;AAEH,OAAO,EAAC,SAAS,EAAwC,MAAM,eAAe,CAAC;;AAE/E;;;;;;;;;;;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;;qHA/CU,wBAAwB;yGAAxB,wBAAwB;2FAAxB,wBAAwB;kBADpC,SAAS;;AAmDV;;;;;;;;GAQG;AAEH,MAAM,OAAO,2BAA4B,SAAQ,wBAAwB;;wHAA5D,2BAA2B;4GAA3B,2BAA2B;2FAA3B,2BAA2B;kBADvC,SAAS","sourcesContent":["/**\n * [Nimble]\n * Copied from https://github.com/angular/angular/blob/14.2.6/packages/forms/src/directives/control_value_accessor.ts\n * with the following modifications:\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, InjectionToken, 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 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/esm2015/thirdparty/directives/radio_control_value_accessor.js

@@ -0,0 +1,197 @@
+/**
+ * [Nimble]
+ * Copied from https://github.com/angular/angular/blob/14.2.6/packages/forms/src/directives/radio_control_value_accessor.ts
+ * with the following modifications:
+ * - Changed throwNameError() to throw Error instead of RuntimeError. This makes the file compile with Angular version 12.
+ * - Removed now-unused import for RuntimeErrorCode and RuntimeError
+ * - Updated import of ControlValueAccessor, NgControl, and NG_VALUE_ACCESSOR to pull from package export
+ */
+/**
+ * @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, forwardRef, Injectable, Input, NgModule } from '@angular/core';
+import { BuiltInControlValueAccessor } from './control_value_accessor';
+import { NgControl, NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+export const RADIO_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => RadioControlValueAccessor),
+    multi: true
+};
+function throwNameError() {
+    /* [Nimble] RuntimeErrorCode is not exported from @angular/forms in version 12; falling back to version 12 behavior
+    throw new RuntimeError(RuntimeErrorCode.NAME_AND_FORM_CONTROL_NAME_MUST_MATCH, `
+    */
+    throw new Error(`
+      If you define both a name and a formControlName attribute on your radio button, their values
+      must match. Ex: <input type="radio" formControlName="food" name="food">
+    `);
+}
+/**
+ * Internal-only NgModule that works as a host for the `RadioControlRegistry` tree-shakable
+ * provider. Note: the `InternalFormsSharedModule` can not be used here directly, since it's
+ * declared *after* the `RadioControlRegistry` class and the `providedIn` doesn't support
+ * `forwardRef` logic.
+ */
+export class RadioControlRegistryModule {
+}
+RadioControlRegistryModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: RadioControlRegistryModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+RadioControlRegistryModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: RadioControlRegistryModule });
+RadioControlRegistryModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: RadioControlRegistryModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: RadioControlRegistryModule, decorators: [{
+            type: NgModule
+        }] });
+/**
+ * @description
+ * Class used by Angular to track radio buttons. For internal use only.
+ */
+export class RadioControlRegistry {
+    constructor() {
+        this._accessors = [];
+    }
+    /**
+     * @description
+     * Adds a control to the internal registry. For internal use only.
+     */
+    add(control, accessor) {
+        this._accessors.push([control, accessor]);
+    }
+    /**
+     * @description
+     * Removes a control from the internal registry. For internal use only.
+     */
+    remove(accessor) {
+        for (let i = this._accessors.length - 1; i >= 0; --i) {
+            if (this._accessors[i][1] === accessor) {
+                this._accessors.splice(i, 1);
+                return;
+            }
+        }
+    }
+    /**
+     * @description
+     * Selects a radio button. For internal use only.
+     */
+    select(accessor) {
+        this._accessors.forEach((c) => {
+            if (this._isSameGroup(c, accessor) && c[1] !== accessor) {
+                c[1].fireUncheck(accessor.value);
+            }
+        });
+    }
+    _isSameGroup(controlPair, accessor) {
+        if (!controlPair[0].control)
+            return false;
+        // @ts-expect-error: [Nimble] Use of internal NgControl member _parent
+        return controlPair[0]._parent === accessor._control._parent &&
+            controlPair[1].name === accessor.name;
+    }
+}
+RadioControlRegistry.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: RadioControlRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+RadioControlRegistry.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: RadioControlRegistry, providedIn: RadioControlRegistryModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: RadioControlRegistry, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: RadioControlRegistryModule }]
+        }] });
+/**
+ * @description
+ * The `ControlValueAccessor` for writing radio control values and listening to radio control
+ * changes. The value accessor is used by the `FormControlDirective`, `FormControlName`, and
+ * `NgModel` directives.
+ *
+ * @usageNotes
+ *
+ * ### Using radio buttons with reactive form directives
+ *
+ * The follow example shows how to use radio buttons in a reactive form. When using radio buttons in
+ * a reactive form, radio buttons in the same group should have the same `formControlName`.
+ * Providing a `name` attribute is optional.
+ *
+ * {@example forms/ts/reactiveRadioButtons/reactive_radio_button_example.ts region='Reactive'}
+ *
+ * @ngModule ReactiveFormsModule
+ * @ngModule FormsModule
+ * @publicApi
+ */
+export class RadioControlValueAccessor extends BuiltInControlValueAccessor {
+    constructor(renderer, elementRef, _registry, _injector) {
+        super(renderer, elementRef);
+        this._registry = _registry;
+        this._injector = _injector;
+        /**
+         * The registered callback function called when a change event occurs on the input element.
+         * Note: we declare `onChange` here (also used as host listener) as a function with no arguments
+         * to override the `onChange` function (which expects 1 argument) in the parent
+         * `BaseControlValueAccessor` class.
+         * @nodoc
+         */
+        this.onChange = () => { };
+    }
+    /** @nodoc */
+    ngOnInit() {
+        this._control = this._injector.get(NgControl);
+        this._checkName();
+        this._registry.add(this._control, this);
+    }
+    /** @nodoc */
+    ngOnDestroy() {
+        this._registry.remove(this);
+    }
+    /**
+     * Sets the "checked" property value on the radio input element.
+     * @nodoc
+     */
+    writeValue(value) {
+        this._state = value === this.value;
+        this.setProperty('checked', this._state);
+    }
+    /**
+     * Registers a function called when the control value changes.
+     * @nodoc
+     */
+    registerOnChange(fn) {
+        this._fn = fn;
+        this.onChange = () => {
+            fn(this.value);
+            this._registry.select(this);
+        };
+    }
+    /**
+     * Sets the "value" on the radio input element and unchecks it.
+     *
+     * @param value
+     */
+    fireUncheck(value) {
+        this.writeValue(value);
+    }
+    _checkName() {
+        if (this.name && this.formControlName && this.name !== this.formControlName &&
+            // @ts-expect-error: [Nimble] ngDevMode is not defined
+            (typeof ngDevMode === 'undefined' || ngDevMode)) {
+            throwNameError();
+        }
+        if (!this.name && this.formControlName)
+            this.name = this.formControlName;
+    }
+}
+RadioControlValueAccessor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: RadioControlValueAccessor, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: RadioControlRegistry }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive });
+RadioControlValueAccessor.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.5", type: RadioControlValueAccessor, selector: "input[type=radio][formControlName],input[type=radio][formControl],input[type=radio][ngModel]", inputs: { name: "name", formControlName: "formControlName", value: "value" }, host: { listeners: { "change": "onChange()", "blur": "onTouched()" } }, providers: [RADIO_VALUE_ACCESSOR], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: RadioControlValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[type=radio][formControlName],input[type=radio][formControl],input[type=radio][ngModel]',
+                    host: { '(change)': 'onChange()', '(blur)': 'onTouched()' },
+                    providers: [RADIO_VALUE_ACCESSOR]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }, { type: RadioControlRegistry }, { type: i0.Injector }]; }, propDecorators: { name: [{
+                type: Input
+            }], formControlName: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"radio_control_value_accessor.js","sourceRoot":"","sources":["../../../../../../projects/ni/nimble-angular/src/thirdparty/directives/radio_control_value_accessor.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;GAMG;AAEH,OAAO,EAAC,SAAS,EAAc,UAAU,EAAE,UAAU,EAAY,KAAK,EAAE,QAAQ,EAA+B,MAAM,eAAe,CAAC;AAErI,OAAO,EAAC,2BAA2B,EAAC,MAAM,0BAA0B,CAAC;AACrE,OAAO,EAAuB,SAAS,EAAE,iBAAiB,EAAC,MAAM,gBAAgB,CAAC;;AAElF,MAAM,CAAC,MAAM,oBAAoB,GAAQ;IACvC,OAAO,EAAE,iBAAiB;IAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,CAAC,yBAAyB,CAAC;IACxD,KAAK,EAAE,IAAI;CACZ,CAAC;AAEF,SAAS,cAAc;IACrB;;MAEE;IACF,MAAM,IAAI,KAAK,CAAC;;;KAGb,CAAC,CAAC;AACP,CAAC;AAED;;;;;GAKG;AAEH,MAAM,OAAO,0BAA0B;;uHAA1B,0BAA0B;wHAA1B,0BAA0B;wHAA1B,0BAA0B;2FAA1B,0BAA0B;kBADtC,QAAQ;;AAIT;;;GAGG;AAEH,MAAM,OAAO,oBAAoB;IADjC;QAEU,eAAU,GAAU,EAAE,CAAC;KA2ChC;IAzCC;;;OAGG;IACH,GAAG,CAAC,OAAkB,EAAE,QAAmC;QACzD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC5C,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,QAAmC;QACxC,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,EAAE;YACpD,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,QAAQ,EAAE;gBACtC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;gBAC7B,OAAO;aACR;SACF;IACH,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,QAAmC;QACxC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;YAC5B,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,QAAQ,EAAE;gBACvD,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;aAClC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,YAAY,CAChB,WAAmD,EACnD,QAAmC;QACrC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,OAAO;YAAE,OAAO,KAAK,CAAC;QAC1C,sEAAsE;QACtE,OAAO,WAAW,CAAC,CAAC,CAAC,CAAC,OAAO,KAAK,QAAQ,CAAC,QAAQ,CAAC,OAAO;YACvD,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC;IAC5C,CAAC;;iHA3CU,oBAAoB;qHAApB,oBAAoB,cADR,0BAA0B;2FACtC,oBAAoB;kBADhC,UAAU;mBAAC,EAAC,UAAU,EAAE,0BAA0B,EAAC;;AA+CpD;;;;;;;;;;;;;;;;;;;GAmBG;AAOH,MAAM,OAAO,yBAA0B,SAAQ,2BAA2B;IA0CxE,YACI,QAAmB,EAAE,UAAsB,EAAU,SAA+B,EAC5E,SAAmB;QAC7B,KAAK,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QAF2B,cAAS,GAAT,SAAS,CAAsB;QAC5E,cAAS,GAAT,SAAS,CAAU;QAhC/B;;;;;;WAMG;QACM,aAAQ,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;IA2B7B,CAAC;IAED,aAAa;IACb,QAAQ;QACN,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC9C,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IAC1C,CAAC;IAED,aAAa;IACb,WAAW;QACT,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACH,UAAU,CAAC,KAAU;QACnB,IAAI,CAAC,MAAM,GAAG,KAAK,KAAK,IAAI,CAAC,KAAK,CAAC;QACnC,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAC3C,CAAC;IAED;;;OAGG;IACM,gBAAgB,CAAC,EAAkB;QAC1C,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC;QACd,IAAI,CAAC,QAAQ,GAAG,GAAG,EAAE;YACnB,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACf,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC9B,CAAC,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,WAAW,CAAC,KAAU;QACpB,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IAEO,UAAU;QAChB,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,eAAe;YACvE,sDAAsD;YACtD,CAAC,OAAO,SAAS,KAAK,WAAW,IAAI,SAAS,CAAC,EAAE;YACnD,cAAc,EAAE,CAAC;SAClB;QACD,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,eAAe;YAAE,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,eAAe,CAAC;IAC3E,CAAC;;sHAjGU,yBAAyB,qEA2CgC,oBAAoB;0GA3C7E,yBAAyB,6QAFzB,CAAC,oBAAoB,CAAC;2FAEtB,yBAAyB;kBANrC,SAAS;mBAAC;oBACT,QAAQ,EACJ,8FAA8F;oBAClG,IAAI,EAAE,EAAC,UAAU,EAAE,YAAY,EAAE,QAAQ,EAAE,aAAa,EAAC;oBACzD,SAAS,EAAE,CAAC,oBAAoB,CAAC;iBAClC;2GA4CqE,oBAAoB,iDAjB/E,IAAI;sBAAZ,KAAK;gBAQG,eAAe;sBAAvB,KAAK;gBAMG,KAAK;sBAAb,KAAK","sourcesContent":["/**\n * [Nimble]\n * Copied from https://github.com/angular/angular/blob/14.2.6/packages/forms/src/directives/radio_control_value_accessor.ts\n * with the following modifications:\n * - Changed throwNameError() to throw Error instead of RuntimeError. This makes the file compile with Angular version 12.\n * - Removed now-unused import for RuntimeErrorCode and RuntimeError\n * - Updated import of ControlValueAccessor, NgControl, and NG_VALUE_ACCESSOR to pull from package export\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, forwardRef, Injectable, Injector, Input, NgModule, OnDestroy, OnInit, Renderer2} from '@angular/core';\n\nimport {BuiltInControlValueAccessor} from './control_value_accessor';\nimport {ControlValueAccessor, NgControl, NG_VALUE_ACCESSOR} from '@angular/forms';\n\nexport const RADIO_VALUE_ACCESSOR: any = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => RadioControlValueAccessor),\n  multi: true\n};\n\nfunction throwNameError() {\n  /* [Nimble] RuntimeErrorCode is not exported from @angular/forms in version 12; falling back to version 12 behavior\n  throw new RuntimeError(RuntimeErrorCode.NAME_AND_FORM_CONTROL_NAME_MUST_MATCH, `\n  */\n  throw new Error(`\n      If you define both a name and a formControlName attribute on your radio button, their values\n      must match. Ex: <input type=\"radio\" formControlName=\"food\" name=\"food\">\n    `);\n}\n\n/**\n * Internal-only NgModule that works as a host for the `RadioControlRegistry` tree-shakable\n * provider. Note: the `InternalFormsSharedModule` can not be used here directly, since it's\n * declared *after* the `RadioControlRegistry` class and the `providedIn` doesn't support\n * `forwardRef` logic.\n */\n@NgModule()\nexport class RadioControlRegistryModule {\n}\n\n/**\n * @description\n * Class used by Angular to track radio buttons. For internal use only.\n */\n@Injectable({providedIn: RadioControlRegistryModule})\nexport class RadioControlRegistry {\n  private _accessors: any[] = [];\n\n  /**\n   * @description\n   * Adds a control to the internal registry. For internal use only.\n   */\n  add(control: NgControl, accessor: RadioControlValueAccessor) {\n    this._accessors.push([control, accessor]);\n  }\n\n  /**\n   * @description\n   * Removes a control from the internal registry. For internal use only.\n   */\n  remove(accessor: RadioControlValueAccessor) {\n    for (let i = this._accessors.length - 1; i >= 0; --i) {\n      if (this._accessors[i][1] === accessor) {\n        this._accessors.splice(i, 1);\n        return;\n      }\n    }\n  }\n\n  /**\n   * @description\n   * Selects a radio button. For internal use only.\n   */\n  select(accessor: RadioControlValueAccessor) {\n    this._accessors.forEach((c) => {\n      if (this._isSameGroup(c, accessor) && c[1] !== accessor) {\n        c[1].fireUncheck(accessor.value);\n      }\n    });\n  }\n\n  private _isSameGroup(\n      controlPair: [NgControl, RadioControlValueAccessor],\n      accessor: RadioControlValueAccessor): boolean {\n    if (!controlPair[0].control) return false;\n    // @ts-expect-error: [Nimble] Use of internal NgControl member _parent\n    return controlPair[0]._parent === accessor._control._parent &&\n        controlPair[1].name === accessor.name;\n  }\n}\n\n/**\n * @description\n * The `ControlValueAccessor` for writing radio control values and listening to radio control\n * changes. The value accessor is used by the `FormControlDirective`, `FormControlName`, and\n * `NgModel` directives.\n *\n * @usageNotes\n *\n * ### Using radio buttons with reactive form directives\n *\n * The follow example shows how to use radio buttons in a reactive form. When using radio buttons in\n * a reactive form, radio buttons in the same group should have the same `formControlName`.\n * Providing a `name` attribute is optional.\n *\n * {@example forms/ts/reactiveRadioButtons/reactive_radio_button_example.ts region='Reactive'}\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\n@Directive({\n  selector:\n      'input[type=radio][formControlName],input[type=radio][formControl],input[type=radio][ngModel]',\n  host: {'(change)': 'onChange()', '(blur)': 'onTouched()'},\n  providers: [RADIO_VALUE_ACCESSOR]\n})\nexport class RadioControlValueAccessor extends BuiltInControlValueAccessor implements\n    ControlValueAccessor, OnDestroy, OnInit {\n  /** @internal */\n  // TODO(issue/24571): remove '!'.\n  _state!: boolean;\n  /** @internal */\n  // TODO(issue/24571): remove '!'.\n  _control!: NgControl;\n  /** @internal */\n  // TODO(issue/24571): remove '!'.\n  _fn!: Function;\n\n  /**\n   * The registered callback function called when a change event occurs on the input element.\n   * Note: we declare `onChange` here (also used as host listener) as a function with no arguments\n   * to override the `onChange` function (which expects 1 argument) in the parent\n   * `BaseControlValueAccessor` class.\n   * @nodoc\n   */\n  override onChange = () => {};\n\n  /**\n   * @description\n   * Tracks the name of the radio input element.\n   */\n  // TODO(issue/24571): remove '!'.\n  @Input() name!: string;\n\n  /**\n   * @description\n   * Tracks the name of the `FormControl` bound to the directive. The name corresponds\n   * to a key in the parent `FormGroup` or `FormArray`.\n   */\n  // TODO(issue/24571): remove '!'.\n  @Input() formControlName!: string;\n\n  /**\n   * @description\n   * Tracks the value of the radio input element\n   */\n  @Input() value: any;\n\n  constructor(\n      renderer: Renderer2, elementRef: ElementRef, private _registry: RadioControlRegistry,\n      private _injector: Injector) {\n    super(renderer, elementRef);\n  }\n\n  /** @nodoc */\n  ngOnInit(): void {\n    this._control = this._injector.get(NgControl);\n    this._checkName();\n    this._registry.add(this._control, this);\n  }\n\n  /** @nodoc */\n  ngOnDestroy(): void {\n    this._registry.remove(this);\n  }\n\n  /**\n   * Sets the \"checked\" property value on the radio input element.\n   * @nodoc\n   */\n  writeValue(value: any): void {\n    this._state = value === this.value;\n    this.setProperty('checked', this._state);\n  }\n\n  /**\n   * Registers a function called when the control value changes.\n   * @nodoc\n   */\n  override registerOnChange(fn: (_: any) => {}): void {\n    this._fn = fn;\n    this.onChange = () => {\n      fn(this.value);\n      this._registry.select(this);\n    };\n  }\n\n  /**\n   * Sets the \"value\" on the radio input element and unchecks it.\n   *\n   * @param value\n   */\n  fireUncheck(value: any): void {\n    this.writeValue(value);\n  }\n\n  private _checkName(): void {\n    if (this.name && this.formControlName && this.name !== this.formControlName &&\n        // @ts-expect-error: [Nimble] ngDevMode is not defined\n        (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throwNameError();\n    }\n    if (!this.name && this.formControlName) this.name = this.formControlName;\n  }\n}"]}