@impartner/design-components 1.2.0 → 2.0.0

package/esm2022/lib/form-field/controls/radio/radio-button/radio-button.component.mjs

@@ -0,0 +1,260 @@
+import { Attribute, ChangeDetectionStrategy, Component, ElementRef, EventEmitter, Inject, Input, Optional, Output, ViewChild } from '@angular/core';
+import { nanoid } from 'nanoid';
+import { coerceBooleanPropertyValue, coerceNumberPropertyValue } from '../../../../../utilities';
+import { mixinTabIndex } from '../../../shared/tab-index.mixin';
+import { IMPDC_RADIO_BUTTON, IMPDC_RADIO_GROUP } from '../injection-tokens';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/unique-selection-dispatcher.service";
+import * as i2 from "../../shared/toggle/toggle.component";
+import * as i3 from "../../shared/toggle/components/toggle-input/toggle-input.component";
+class RadioButtonComponentBase {
+    constructor() { }
+}
+const _RadioButtonComponentMixinBase = mixinTabIndex(RadioButtonComponentBase);
+export class RadioButtonComponent extends _RadioButtonComponentMixinBase {
+    /**
+     * Whether or not the radio input is checked/selected.
+     */
+    get checked() {
+        return this._checked;
+    }
+    set checked(value) {
+        const newCheckedValue = coerceBooleanPropertyValue(value);
+        if (this._checked !== newCheckedValue) {
+            this._checked = newCheckedValue;
+            if (newCheckedValue &&
+                this._radioGroup &&
+                this._radioGroup.value !== this.value) {
+                this._radioGroup.selected = this;
+            }
+            else if (!newCheckedValue &&
+                this._radioGroup &&
+                this._radioGroup.value === this.value) {
+                this._radioGroup.selected = null;
+            }
+            if (newCheckedValue) {
+                this._radioDispatcher.notify(this.id, this.name);
+            }
+            this._changeDetector.markForCheck();
+        }
+    }
+    /**
+     * The specific value represented by the radio button.
+     */
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        if (this._value !== value) {
+            this._value = value;
+            if (this._radioGroup) {
+                if (!this.checked) {
+                    this.checked = this._radioGroup.value === value;
+                }
+                if (this.checked) {
+                    this._radioGroup.selected = this;
+                }
+            }
+        }
+    }
+    /**
+     * Whether or not the radio button displays inline; Inherited from the parent `RadioGroupDirective` when available.
+     */
+    get inline() {
+        return (this._inline || (this._radioGroup && this._radioGroup.inline) || false);
+    }
+    set inline(value) {
+        this._inline = coerceBooleanPropertyValue(value);
+    }
+    /**
+     * Used to enable or disable the radio button, but will always return `true` when the parent
+     * `RadioGroupDirective` is already disabled.
+     */
+    get disabled() {
+        return (this._disabled || (this._radioGroup != null && this._radioGroup.disabled));
+    }
+    set disabled(value) {
+        const newDisabledState = coerceBooleanPropertyValue(value);
+        if (this._disabled !== newDisabledState) {
+            this._disabled = newDisabledState;
+            this._changeDetector.markForCheck();
+        }
+    }
+    /** @ignore */
+    get required() {
+        return (this._required || (this._radioGroup != null && this._radioGroup.required));
+    }
+    set required(value) {
+        this._required = coerceBooleanPropertyValue(value);
+    }
+    get _errorState() {
+        return this._radioGroup ? this._radioGroup.errorState : false;
+    }
+    constructor(_changeDetector, _radioDispatcher, tabIndex, _radioGroup) {
+        super();
+        this._changeDetector = _changeDetector;
+        this._radioDispatcher = _radioDispatcher;
+        this._radioGroup = _radioGroup;
+        this._uid = `impdc-radio-button-${nanoid()}`;
+        this._removeUniqueSelectionListener = () => { };
+        this.id = this._uid;
+        this._checked = false;
+        this._value = null;
+        this._disabled = false;
+        this._required = false;
+        /**
+         * The primary label text for the radio button.
+         */
+        this.label = '';
+        /**
+         * Text to provide additional description or context for the radio button. Does
+         * not display if `inline` is `true`.
+         */
+        this.description = '';
+        /**
+         * Event emitted when the radio button becomes selected/checked.
+         */
+        this.change = new EventEmitter();
+        if (tabIndex) {
+            this.tabIndex = coerceNumberPropertyValue(tabIndex, 0);
+        }
+    }
+    /** @ignore */
+    ngOnInit() {
+        if (this._radioGroup) {
+            this.checked = this._radioGroup.value === this._value;
+            if (this.checked) {
+                this._radioGroup.selected = this;
+            }
+            this.name = this._radioGroup.name;
+        }
+        this._removeUniqueSelectionListener = this._radioDispatcher.listen((id, name) => {
+            if (id !== this.id && name === this.name) {
+                this.checked = false;
+            }
+        });
+    }
+    /** @ignore */
+    ngDoCheck() {
+        this._updateTabIndex();
+    }
+    /** @ignore */
+    ngAfterViewInit() {
+        this._updateTabIndex();
+    }
+    /** @ignore */
+    ngOnDestroy() {
+        this._removeUniqueSelectionListener();
+    }
+    /** @ignore */
+    markForCheck() {
+        this._changeDetector.markForCheck();
+    }
+    _emitChangesEvent() {
+        this.change.emit({ source: this, value: this._value });
+    }
+    _onBlur() {
+        if (this._radioGroup) {
+            this._radioGroup.touch();
+        }
+    }
+    _onInputChange(event) {
+        event.stopPropagation();
+        if (!this.checked && !this.disabled) {
+            const groupValueChanged = this._radioGroup && this.value !== this._radioGroup.value;
+            this.checked = true;
+            this._emitChangesEvent();
+            if (this._radioGroup) {
+                this._radioGroup.onChangeFn(this.value);
+                if (groupValueChanged) {
+                    this._radioGroup.emitChangesEvent();
+                }
+            }
+        }
+    }
+    _updateTabIndex() {
+        const radioGroup = this._radioGroup;
+        let tabIndexValue;
+        if (!radioGroup || !radioGroup.selected || this.disabled) {
+            tabIndexValue = this.tabIndex;
+        }
+        else {
+            tabIndexValue = radioGroup.selected === this ? this.tabIndex : -1;
+        }
+        if (tabIndexValue !== this._previousTabIndex) {
+            const inputElt = this._inputElement?.nativeElement;
+            if (inputElt) {
+                inputElt.setAttribute('tabindex', tabIndexValue + '');
+                this._previousTabIndex = tabIndexValue;
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.1", ngImport: i0, type: RadioButtonComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.UniqueSelectionDispatcher }, { token: 'tabindex', attribute: true }, { token: IMPDC_RADIO_GROUP, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.0.1", type: RadioButtonComponent, selector: "impdc-radio-button", inputs: { tabIndex: "tabIndex", id: "id", name: "name", ariaLabel: ["aria-label", "ariaLabel"], ariaLabelledby: ["aria-labelledby", "ariaLabelledby"], ariaDescribedby: ["aria-describedby", "ariaDescribedby"], checked: "checked", value: "value", inline: "inline", disabled: "disabled", required: "required", label: "label", description: "description" }, outputs: { change: "change" }, host: { properties: { "attr.id": "id", "attr.tabindex": "null", "attr.aria-label": "null", "attr.aria-labelledby": "null", "attr.aria-describedby": "null", "class.impdc-radio-button--required": "required", "class.impdc-radio-button--invalid": "_errorState", "class.impdc-radio-button--disabled": "disabled", "class.impdc-radio-button--inline": "inline" }, classAttribute: "impdc-radio-button" }, providers: [
+            {
+                provide: IMPDC_RADIO_BUTTON,
+                useExisting: RadioButtonComponent
+            }
+        ], viewQueries: [{ propertyName: "_inputElement", first: true, predicate: ["nativeInput"], descendants: true, read: ElementRef }], exportAs: ["impdcRadioButton"], usesInheritance: true, ngImport: i0, template: "<impdc-toggle [label]=\"label\" [description]=\"description\" [inline]=\"inline\">\n  <input\n    #nativeInput\n    impdc-toggle-input\n    type=\"radio\"\n    class=\"impdc-radio-button__native-control\"\n    [class.is-invalid]=\"_errorState\"\n    [checked]=\"checked\"\n    [disabled]=\"disabled\"\n    [attr.name]=\"name\"\n    [attr.value]=\"value\"\n    [required]=\"required\"\n    [attr.aria-label]=\"ariaLabel\"\n    [attr.aria-labelledby]=\"ariaLabelledby\"\n    [attr.aria-describedby]=\"ariaDescribedby\"\n    (change)=\"_onInputChange($event)\"\n    (blur)=\"_onBlur()\" />\n</impdc-toggle>\n", styles: [":host{display:block;opacity:var(--impartner-hex-input-opacity, 1)}:host.impdc-radio-button--inline{display:inline-block}:host.impdc-radio-button--inline:not(:last-of-type){margin-right:4rem}:host:not(.impdc-radio-button--inline):not(:last-of-type){margin-bottom:1.6rem}:host.impdc-radio-button--disabled{--impartner-hex-input-opacity: .5}:host.impdc-radio-button--invalid ::ng-deep .form-check-label{color:var(--impd-color-red-600)}\n"], dependencies: [{ kind: "component", type: i2.ToggleComponent, selector: "impdc-toggle", inputs: ["isSwitch", "label", "description", "inline", "switchIcons"] }, { kind: "component", type: i3.ToggleInputComponent, selector: "input[impdc-toggle-input]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.1", ngImport: i0, type: RadioButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'impdc-radio-button', host: {
+                        class: 'impdc-radio-button',
+                        '[attr.id]': 'id',
+                        '[attr.tabindex]': 'null',
+                        '[attr.aria-label]': 'null',
+                        '[attr.aria-labelledby]': 'null',
+                        '[attr.aria-describedby]': 'null',
+                        '[class.impdc-radio-button--required]': 'required',
+                        '[class.impdc-radio-button--invalid]': '_errorState',
+                        '[class.impdc-radio-button--disabled]': 'disabled',
+                        '[class.impdc-radio-button--inline]': 'inline'
+                    }, inputs: ['tabIndex'], exportAs: 'impdcRadioButton', changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        {
+                            provide: IMPDC_RADIO_BUTTON,
+                            useExisting: RadioButtonComponent
+                        }
+                    ], template: "<impdc-toggle [label]=\"label\" [description]=\"description\" [inline]=\"inline\">\n  <input\n    #nativeInput\n    impdc-toggle-input\n    type=\"radio\"\n    class=\"impdc-radio-button__native-control\"\n    [class.is-invalid]=\"_errorState\"\n    [checked]=\"checked\"\n    [disabled]=\"disabled\"\n    [attr.name]=\"name\"\n    [attr.value]=\"value\"\n    [required]=\"required\"\n    [attr.aria-label]=\"ariaLabel\"\n    [attr.aria-labelledby]=\"ariaLabelledby\"\n    [attr.aria-describedby]=\"ariaDescribedby\"\n    (change)=\"_onInputChange($event)\"\n    (blur)=\"_onBlur()\" />\n</impdc-toggle>\n", styles: [":host{display:block;opacity:var(--impartner-hex-input-opacity, 1)}:host.impdc-radio-button--inline{display:inline-block}:host.impdc-radio-button--inline:not(:last-of-type){margin-right:4rem}:host:not(.impdc-radio-button--inline):not(:last-of-type){margin-bottom:1.6rem}:host.impdc-radio-button--disabled{--impartner-hex-input-opacity: .5}:host.impdc-radio-button--invalid ::ng-deep .form-check-label{color:var(--impd-color-red-600)}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i1.UniqueSelectionDispatcher }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['tabindex']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [IMPDC_RADIO_GROUP]
+                }, {
+                    type: Optional
+                }] }], propDecorators: { _inputElement: [{
+                type: ViewChild,
+                args: ['nativeInput', { read: ElementRef }]
+            }], id: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input,
+                args: ['aria-label']
+            }], ariaLabelledby: [{
+                type: Input,
+                args: ['aria-labelledby']
+            }], ariaDescribedby: [{
+                type: Input,
+                args: ['aria-describedby']
+            }], checked: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], inline: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }], change: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"radio-button.component.js","sourceRoot":"","sources":["../../../../../../../../../projects/design-components/src/lib/form-field/controls/radio/radio-button/radio-button.component.ts","../../../../../../../../../projects/design-components/src/lib/form-field/controls/radio/radio-button/radio-button.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  Attribute,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  DoCheck,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  Input,\n  OnDestroy,\n  OnInit,\n  Optional,\n  Output,\n  ViewChild\n} from '@angular/core';\nimport { nanoid } from 'nanoid';\nimport {\n  BooleanInput,\n  coerceBooleanPropertyValue,\n  coerceNumberPropertyValue\n} from '../../../../../utilities';\nimport { UniqueSelectionDispatcher } from '../../../services/unique-selection-dispatcher.service';\nimport { HasTabIndex, mixinTabIndex } from '../../../shared/tab-index.mixin';\nimport { IMPDC_RADIO_BUTTON, IMPDC_RADIO_GROUP } from '../injection-tokens';\nimport { RadioChangeEvent, IRadioButton, IRadioGroup } from '../interfaces';\n\nabstract class RadioButtonComponentBase {\n  abstract disabled: boolean;\n  constructor() {}\n}\n\nconst _RadioButtonComponentMixinBase = mixinTabIndex(RadioButtonComponentBase);\n\n@Component({\n  selector: 'impdc-radio-button',\n  templateUrl: './radio-button.component.html',\n  styleUrls: ['./radio-button.component.scss'],\n  // eslint-disable-next-line @angular-eslint/no-host-metadata-property\n  host: {\n    class: 'impdc-radio-button',\n    '[attr.id]': 'id',\n    '[attr.tabindex]': 'null',\n    '[attr.aria-label]': 'null',\n    '[attr.aria-labelledby]': 'null',\n    '[attr.aria-describedby]': 'null',\n    '[class.impdc-radio-button--required]': 'required',\n    '[class.impdc-radio-button--invalid]': '_errorState',\n    '[class.impdc-radio-button--disabled]': 'disabled',\n    '[class.impdc-radio-button--inline]': 'inline'\n  },\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['tabIndex'],\n  exportAs: 'impdcRadioButton',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [\n    {\n      provide: IMPDC_RADIO_BUTTON,\n      useExisting: RadioButtonComponent\n    }\n  ]\n})\nexport class RadioButtonComponent\n  extends _RadioButtonComponentMixinBase\n  implements\n    IRadioButton,\n    HasTabIndex,\n    OnInit,\n    OnDestroy,\n    DoCheck,\n    AfterViewInit\n{\n  private readonly _uid: string = `impdc-radio-button-${nanoid()}`;\n  private _removeUniqueSelectionListener: () => void = () => {};\n  private _previousTabIndex?: number;\n\n  @ViewChild('nativeInput', { read: ElementRef })\n  private _inputElement!: ElementRef<HTMLInputElement>;\n\n  @Input()\n  public id: string = this._uid;\n\n  /**\n   * The unique name for a group of radio options; Inherited from the parent `RadioGroupDirective` when available.\n   */\n  @Input()\n  public name!: string;\n\n  /**\n   * Property for setting ARIA \"label\" attribute.\n   */\n  @Input('aria-label')\n  public ariaLabel?: string;\n\n  /**\n   * Property for setting ARIA \"labelled by\" attribute.\n   */\n  @Input('aria-labelledby')\n  public ariaLabelledby?: string;\n\n  /**\n   * Property for setting ARIA \"described by\" attribute.\n   */\n  @Input('aria-describedby')\n  public ariaDescribedby?: string;\n\n  /**\n   * Whether or not the radio input is checked/selected.\n   */\n  @Input()\n  public get checked(): boolean {\n    return this._checked;\n  }\n  public set checked(value: BooleanInput) {\n    const newCheckedValue = coerceBooleanPropertyValue(value);\n\n    if (this._checked !== newCheckedValue) {\n      this._checked = newCheckedValue;\n\n      if (\n        newCheckedValue &&\n        this._radioGroup &&\n        this._radioGroup.value !== this.value\n      ) {\n        this._radioGroup.selected = this;\n      } else if (\n        !newCheckedValue &&\n        this._radioGroup &&\n        this._radioGroup.value === this.value\n      ) {\n        this._radioGroup.selected = null;\n      }\n\n      if (newCheckedValue) {\n        this._radioDispatcher.notify(this.id, this.name);\n      }\n\n      this._changeDetector.markForCheck();\n    }\n  }\n  protected _checked = false;\n\n  /**\n   * The specific value represented by the radio button.\n   */\n  @Input()\n  public get value(): any {\n    return this._value;\n  }\n  public set value(value: any) {\n    if (this._value !== value) {\n      this._value = value;\n\n      if (this._radioGroup) {\n        if (!this.checked) {\n          this.checked = this._radioGroup.value === value;\n        }\n\n        if (this.checked) {\n          this._radioGroup.selected = this;\n        }\n      }\n    }\n  }\n  protected _value: any = null;\n\n  /**\n   * Whether or not the radio button displays inline; Inherited from the parent `RadioGroupDirective` when available.\n   */\n  @Input()\n  public get inline(): boolean {\n    return (\n      this._inline || (this._radioGroup && this._radioGroup.inline) || false\n    );\n  }\n  public set inline(value: BooleanInput) {\n    this._inline = coerceBooleanPropertyValue(value);\n  }\n  protected _inline?: boolean;\n\n  /**\n   * Used to enable or disable the radio button, but will always return `true` when the parent\n   * `RadioGroupDirective` is already disabled.\n   */\n  @Input()\n  public get disabled(): boolean {\n    return (\n      this._disabled || (this._radioGroup != null && this._radioGroup.disabled)\n    );\n  }\n  public set disabled(value: BooleanInput) {\n    const newDisabledState = coerceBooleanPropertyValue(value);\n\n    if (this._disabled !== newDisabledState) {\n      this._disabled = newDisabledState;\n      this._changeDetector.markForCheck();\n    }\n  }\n  protected _disabled = false;\n\n  /** @ignore */\n  @Input()\n  public get required(): boolean {\n    return (\n      this._required || (this._radioGroup != null && this._radioGroup.required)\n    );\n  }\n  public set required(value: BooleanInput) {\n    this._required = coerceBooleanPropertyValue(value);\n  }\n  protected _required = false;\n\n  /**\n   * The primary label text for the radio button.\n   */\n  @Input()\n  public label = '';\n\n  /**\n   * Text to provide additional description or context for the radio button. Does\n   * not display if `inline` is `true`.\n   */\n  @Input()\n  public description = '';\n\n  /**\n   * Event emitted when the radio button becomes selected/checked.\n   */\n  @Output()\n  // eslint-disable-next-line @angular-eslint/no-output-native\n  public readonly change = new EventEmitter<RadioChangeEvent>();\n\n  protected get _errorState(): boolean {\n    return this._radioGroup ? this._radioGroup.errorState : false;\n  }\n\n  constructor(\n    private readonly _changeDetector: ChangeDetectorRef,\n    private _radioDispatcher: UniqueSelectionDispatcher,\n    @Attribute('tabindex') tabIndex?: string,\n    @Inject(IMPDC_RADIO_GROUP) @Optional() readonly _radioGroup?: IRadioGroup\n  ) {\n    super();\n\n    if (tabIndex) {\n      this.tabIndex = coerceNumberPropertyValue(tabIndex, 0);\n    }\n  }\n\n  /** @ignore */\n  public ngOnInit(): void {\n    if (this._radioGroup) {\n      this.checked = this._radioGroup.value === this._value;\n\n      if (this.checked) {\n        this._radioGroup.selected = this;\n      }\n\n      this.name = this._radioGroup.name;\n    }\n\n    this._removeUniqueSelectionListener = this._radioDispatcher.listen(\n      (id, name) => {\n        if (id !== this.id && name === this.name) {\n          this.checked = false;\n        }\n      }\n    );\n  }\n\n  /** @ignore */\n  public ngDoCheck(): void {\n    this._updateTabIndex();\n  }\n\n  /** @ignore */\n  public ngAfterViewInit(): void {\n    this._updateTabIndex();\n  }\n\n  /** @ignore */\n  public ngOnDestroy(): void {\n    this._removeUniqueSelectionListener();\n  }\n\n  /** @ignore */\n  public markForCheck(): void {\n    this._changeDetector.markForCheck();\n  }\n\n  protected _emitChangesEvent(): void {\n    this.change.emit({ source: this, value: this._value });\n  }\n\n  protected _onBlur(): void {\n    if (this._radioGroup) {\n      this._radioGroup.touch();\n    }\n  }\n\n  protected _onInputChange(event: Event): void {\n    event.stopPropagation();\n\n    if (!this.checked && !this.disabled) {\n      const groupValueChanged =\n        this._radioGroup && this.value !== this._radioGroup.value;\n      this.checked = true;\n      this._emitChangesEvent();\n\n      if (this._radioGroup) {\n        this._radioGroup.onChangeFn(this.value);\n\n        if (groupValueChanged) {\n          this._radioGroup.emitChangesEvent();\n        }\n      }\n    }\n  }\n\n  protected _updateTabIndex(): void {\n    const radioGroup = this._radioGroup;\n    let tabIndexValue: number;\n\n    if (!radioGroup || !radioGroup.selected || this.disabled) {\n      tabIndexValue = this.tabIndex;\n    } else {\n      tabIndexValue = radioGroup.selected === this ? this.tabIndex : -1;\n    }\n\n    if (tabIndexValue !== this._previousTabIndex) {\n      const inputElt: HTMLInputElement | undefined =\n        this._inputElement?.nativeElement;\n\n      if (inputElt) {\n        inputElt.setAttribute('tabindex', tabIndexValue + '');\n        this._previousTabIndex = tabIndexValue;\n      }\n    }\n  }\n}\n","<impdc-toggle [label]=\"label\" [description]=\"description\" [inline]=\"inline\">\n  <input\n    #nativeInput\n    impdc-toggle-input\n    type=\"radio\"\n    class=\"impdc-radio-button__native-control\"\n    [class.is-invalid]=\"_errorState\"\n    [checked]=\"checked\"\n    [disabled]=\"disabled\"\n    [attr.name]=\"name\"\n    [attr.value]=\"value\"\n    [required]=\"required\"\n    [attr.aria-label]=\"ariaLabel\"\n    [attr.aria-labelledby]=\"ariaLabelledby\"\n    [attr.aria-describedby]=\"ariaDescribedby\"\n    (change)=\"_onInputChange($event)\"\n    (blur)=\"_onBlur()\" />\n</impdc-toggle>\n"]}

package/esm2022/lib/form-field/controls/radio/radio-group/radio-group.directive.mjs

@@ -0,0 +1,289 @@
+import { ContentChildren, Directive, EventEmitter, Inject, Input, Optional, Output, Self } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { nanoid } from 'nanoid';
+import { coerceBooleanPropertyValue } from '../../../../../utilities';
+import { Subject } from 'rxjs';
+import { IMPDC_FORM_ROOT } from '../../../directives';
+import { ImpdcFormFieldControl, mixinErrorState } from '../../../shared';
+import { IMPDC_RADIO_BUTTON, IMPDC_RADIO_GROUP } from '../injection-tokens';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services";
+import * as i2 from "@angular/forms";
+const _RadioGroupDirectiveBase = mixinErrorState(class {
+    constructor(_defaultErrorStateMatcher, _formRoot, _parentForm, _parentFormGroup, ngControl) {
+        this._defaultErrorStateMatcher = _defaultErrorStateMatcher;
+        this._formRoot = _formRoot;
+        this._parentForm = _parentForm;
+        this._parentFormGroup = _parentFormGroup;
+        this.ngControl = ngControl;
+        this.stateChanges = new Subject();
+    }
+});
+/**
+ * The `RadioGroupDirective` (`<impdc-radio-group`) is a container for `RadioButtonComponent` (`<impdc-radio-button`).
+ * This directive/component can be used within a `FormFieldComponent` (`<impdc-form-field`).
+ * To use, import `RadioModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+export class RadioGroupDirective extends _RadioGroupDirectiveBase {
+    /**
+     * The unique name for the group of radio options; Autogenerated by default.
+     */
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value || this._uid;
+        this._updateRadioOptionNames();
+    }
+    /**
+     * Whether or not the nested radio options should display inline.
+     */
+    get inline() {
+        return this._inline;
+    }
+    set inline(value) {
+        this._inline = coerceBooleanPropertyValue(value);
+        this._markRadioOptionsForCheck();
+    }
+    /**
+     * A reference to the currently selected radio button component (eg. `<impdc-radio-button>`).
+     */
+    get selected() {
+        return this._selected;
+    }
+    set selected(selected) {
+        this._selected = selected;
+        this.value = selected ? selected.value : null;
+        this._checkSelectedRadioOption();
+    }
+    constructor(_changeDetector, _defaultErrorStateMatcher, _formRoot, _parentForm, _parentFormGroup, ngControl) {
+        super(_defaultErrorStateMatcher, _formRoot, _parentForm, _parentFormGroup, ngControl);
+        this._changeDetector = _changeDetector;
+        this._uid = `impdc-radio-group-${nanoid()}`;
+        this._initialized = false;
+        this._cvaOnChange = () => { };
+        this._cvaOnTouched = () => { };
+        this._name = this._uid;
+        this._inline = false;
+        this._selected = null;
+        /**
+         * Event emitted whenever a new radio option is selected.
+         */
+        this.change = new EventEmitter();
+        this._focused = false;
+        this._disabled = false;
+        this.controlType = 'impdc-radio-group';
+        this.supportsAffixes = false;
+        if (this.ngControl) {
+            this.ngControl.valueAccessor = this;
+        }
+    }
+    /** @ignore */
+    ngAfterContentInit() {
+        this._initialized = true;
+    }
+    /** @ignore */
+    ngDoCheck() {
+        const ngControl = this.ngControl;
+        if (!ngControl) {
+            return;
+        }
+        if (this._previousControl !== ngControl.control) {
+            if (this._previousControl !== undefined &&
+                ngControl.disabled !== null &&
+                ngControl.disabled !== this.disabled) {
+                this.disabled = ngControl?.disabled;
+            }
+            this._previousControl = ngControl.control;
+        }
+        this.updateErrorState();
+        this._markRadioOptionsForCheck();
+    }
+    /** @ignore */
+    ngOnDestroy() {
+        this.stateChanges.complete();
+    }
+    /* ImpdcFormFieldControl */
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        if (this._value !== value) {
+            this._value = value;
+            this._updateSelectedRadioOptionFromValue();
+            this._checkSelectedRadioOption();
+            this.stateChanges.next();
+        }
+    }
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value || this._uid;
+        this.stateChanges.next();
+    }
+    get focused() {
+        return this._focused;
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanPropertyValue(value);
+        this._markRadioOptionsForCheck();
+        this.stateChanges.next();
+    }
+    /**
+     * Used to set requiredness of control in a template-based manner;
+     * not necessary when using the Angular reactive forms API and `required` validator.
+     */
+    get required() {
+        return (this._required ??
+            this.ngControl?.control?.hasValidator(Validators.required) ??
+            false);
+    }
+    set required(value) {
+        this._required = coerceBooleanPropertyValue(value);
+        this.stateChanges.next();
+    }
+    /* ControlValueAccessor */
+    /** @ignore */
+    writeValue(value) {
+        this.value = value;
+        this._changeDetector.markForCheck();
+    }
+    /** @ignore */
+    registerOnChange(fn) {
+        this._cvaOnChange = fn;
+    }
+    /** @ignore */
+    registerOnTouched(fn) {
+        this._cvaOnTouched = fn;
+    }
+    /** @ignore */
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        this._changeDetector.markForCheck();
+    }
+    /* Internals */
+    /** @ignore */
+    emitChangesEvent() {
+        if (this._initialized) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            this.change.emit({ source: this._selected, value: this._value });
+        }
+    }
+    /** @ignore */
+    onChangeFn(value) {
+        this._cvaOnChange(value);
+    }
+    /** @ignore */
+    touch() {
+        if (this._cvaOnTouched) {
+            this._cvaOnTouched();
+        }
+    }
+    _checkSelectedRadioOption() {
+        if (this._selected && !this._selected.checked) {
+            this._selected.checked = true;
+        }
+    }
+    _markRadioOptionsForCheck() {
+        if (this._radioOptions) {
+            this._radioOptions.forEach(option => option.markForCheck());
+        }
+    }
+    _updateRadioOptionNames() {
+        if (this._radioOptions) {
+            this._radioOptions.forEach(option => {
+                option.name = this.name;
+                option.markForCheck();
+            });
+        }
+    }
+    _updateSelectedRadioOptionFromValue() {
+        const isAlreadySelected = this._selected !== null && this._selected.value === this._value;
+        if (this._radioOptions && !isAlreadySelected) {
+            this._selected = null;
+            this._radioOptions.forEach(option => {
+                option.checked = this.value === option.value;
+                if (option.checked) {
+                    this._selected = option;
+                }
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.1", ngImport: i0, type: RadioGroupDirective, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.ErrorStateMatcher }, { token: IMPDC_FORM_ROOT, optional: true }, { token: i2.NgForm, optional: true }, { token: i2.FormGroupDirective, optional: true }, { token: i2.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.1", type: RadioGroupDirective, selector: "impdc-radio-group", inputs: { name: "name", inline: "inline", selected: "selected", errorStateMatcher: "errorStateMatcher", value: "value", id: "id", disabled: "disabled", required: "required" }, outputs: { change: "change" }, host: { attributes: { "role": "radiogroup" }, properties: { "class.impdc-radio-group--required": "required", "class.impdc-radio-group--disabled": "disabled", "class.impdc-radio-group--invalid": "errorState", "class.impdc-radio-group--inline": "inline" }, classAttribute: "impdc-radio-group" }, providers: [
+            {
+                provide: ImpdcFormFieldControl,
+                useExisting: RadioGroupDirective
+            },
+            {
+                provide: IMPDC_RADIO_GROUP,
+                useExisting: RadioGroupDirective
+            }
+        ], queries: [{ propertyName: "_radioOptions", predicate: IMPDC_RADIO_BUTTON, descendants: true }], exportAs: ["impdcRadioGroup"], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.1", ngImport: i0, type: RadioGroupDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'impdc-radio-group',
+                    exportAs: 'impdcRadioGroup',
+                    providers: [
+                        {
+                            provide: ImpdcFormFieldControl,
+                            useExisting: RadioGroupDirective
+                        },
+                        {
+                            provide: IMPDC_RADIO_GROUP,
+                            useExisting: RadioGroupDirective
+                        }
+                    ],
+                    // eslint-disable-next-line @angular-eslint/no-host-metadata-property
+                    host: {
+                        role: 'radiogroup',
+                        class: 'impdc-radio-group',
+                        '[class.impdc-radio-group--required]': 'required',
+                        '[class.impdc-radio-group--disabled]': 'disabled',
+                        '[class.impdc-radio-group--invalid]': 'errorState',
+                        '[class.impdc-radio-group--inline]': 'inline'
+                    }
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i1.ErrorStateMatcher }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [IMPDC_FORM_ROOT]
+                }] }, { type: i2.NgForm, decorators: [{
+                    type: Optional
+                }] }, { type: i2.FormGroupDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i2.NgControl, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }], propDecorators: { _radioOptions: [{
+                type: ContentChildren,
+                args: [IMPDC_RADIO_BUTTON, { descendants: true }]
+            }], name: [{
+                type: Input
+            }], inline: [{
+                type: Input
+            }], selected: [{
+                type: Input
+            }], errorStateMatcher: [{
+                type: Input
+            }], change: [{
+                type: Output
+            }], value: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"radio-group.directive.js","sourceRoot":"","sources":["../../../../../../../../../projects/design-components/src/lib/form-field/controls/radio/radio-group/radio-group.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,eAAe,EACf,SAAS,EAET,YAAY,EACZ,MAAM,EACN,KAAK,EAEL,QAAQ,EACR,MAAM,EAEN,IAAI,EACL,MAAM,eAAe,CAAC;AACvB,OAAO,EAML,UAAU,EACX,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAEL,0BAA0B,EAC3B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAiB,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAErE,OAAO,EAEL,qBAAqB,EACrB,eAAe,EAChB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;;;;AAG5E,MAAM,wBAAwB,GAAG,eAAe,CAC9C;IAGE,YACS,yBAA4C,EAC5C,SAAwB,EACxB,WAAmB,EACnB,gBAAoC,EACpC,SAA2B;QAJ3B,8BAAyB,GAAzB,yBAAyB,CAAmB;QAC5C,cAAS,GAAT,SAAS,CAAe;QACxB,gBAAW,GAAX,WAAW,CAAQ;QACnB,qBAAgB,GAAhB,gBAAgB,CAAoB;QACpC,cAAS,GAAT,SAAS,CAAkB;QAPpB,iBAAY,GAAG,IAAI,OAAO,EAAQ,CAAC;IAQhD,CAAC;CACL,CACF,CAAC;AAEF;;;;GAIG;AAyBH,MAAM,OAAO,mBAGX,SAAQ,wBAAwB;IAoBhC;;OAEG;IACH,IACW,IAAI;QACb,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IACD,IAAW,IAAI,CAAC,KAAa;QAC3B,IAAI,CAAC,KAAK,GAAG,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC;QAChC,IAAI,CAAC,uBAAuB,EAAE,CAAC;IACjC,CAAC;IAGD;;OAEG;IACH,IACW,MAAM;QACf,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IACD,IAAW,MAAM,CAAC,KAAmB;QACnC,IAAI,CAAC,OAAO,GAAG,0BAA0B,CAAC,KAAK,CAAC,CAAC;QACjD,IAAI,CAAC,yBAAyB,EAAE,CAAC;IACnC,CAAC;IAGD;;OAEG;IACH,IACW,QAAQ;QACjB,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IACD,IAAW,QAAQ,CAAC,QAA6B;QAC/C,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;QAC9C,IAAI,CAAC,yBAAyB,EAAE,CAAC;IACnC,CAAC;IAcD,YACmB,eAAkC,EACnD,yBAA4C,EACP,SAAwB,EACjD,WAAmB,EACnB,gBAAoC,EAC5B,SAA2B;QAE/C,KAAK,CACH,yBAAyB,EACzB,SAAS,EACT,WAAW,EACX,gBAAgB,EAChB,SAAS,CACV,CAAC;QAbe,oBAAe,GAAf,eAAe,CAAmB;QA3DlC,SAAI,GAAG,qBAAqB,MAAM,EAAE,EAAE,CAAC;QAChD,iBAAY,GAAG,KAAK,CAAC;QAGvB,iBAAY,GAAyB,GAAG,EAAE,GAAE,CAAC,CAAC;QAC9C,kBAAa,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;QAavB,UAAK,GAAW,IAAI,CAAC,IAAI,CAAC;QAa1B,YAAO,GAAG,KAAK,CAAC;QAchB,cAAS,GAAwB,IAAI,CAAC;QAKhD;;WAEG;QAGa,WAAM,GACpB,IAAI,YAAY,EAAoB,CAAC;QAsF7B,aAAQ,GAAG,KAAK,CAAC;QAWjB,cAAS,GAAG,KAAK,CAAC;QAoBZ,gBAAW,GAAG,mBAAmB,CAAC;QAElC,oBAAe,GAAY,KAAK,CAAC;QArG/C,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,IAAI,CAAC,SAAS,CAAC,aAAa,GAAG,IAAI,CAAC;SACrC;IACH,CAAC;IAED,cAAc;IACP,kBAAkB;QACvB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;IAC3B,CAAC;IAED,cAAc;IACP,SAAS;QACd,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QAEjC,IAAI,CAAC,SAAS,EAAE;YACd,OAAO;SACR;QAED,IAAI,IAAI,CAAC,gBAAgB,KAAK,SAAS,CAAC,OAAO,EAAE;YAC/C,IACE,IAAI,CAAC,gBAAgB,KAAK,SAAS;gBACnC,SAAS,CAAC,QAAQ,KAAK,IAAI;gBAC3B,SAAS,CAAC,QAAQ,KAAK,IAAI,CAAC,QAAQ,EACpC;gBACA,IAAI,CAAC,QAAQ,GAAG,SAAS,EAAE,QAAQ,CAAC;aACrC;YAED,IAAI,CAAC,gBAAgB,GAAG,SAAS,CAAC,OAAO,CAAC;SAC3C;QAED,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,yBAAyB,EAAE,CAAC;IACnC,CAAC;IAED,cAAc;IACP,WAAW;QAChB,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;IAC/B,CAAC;IAED,2BAA2B;IAC3B,IACW,KAAK;QACd,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,IAAW,KAAK,CAAC,KAAU;QACzB,IAAI,IAAI,CAAC,MAAM,KAAK,KAAK,EAAE;YACzB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;YAEpB,IAAI,CAAC,mCAAmC,EAAE,CAAC;YAC3C,IAAI,CAAC,yBAAyB,EAAE,CAAC;YACjC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;SAC1B;IACH,CAAC;IAGD,IACW,EAAE;QACX,OAAO,IAAI,CAAC,GAAG,CAAC;IAClB,CAAC;IACD,IAAW,EAAE,CAAC,KAAa;QACzB,IAAI,CAAC,GAAG,GAAG,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC;QAC9B,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;IAC3B,CAAC;IAGD,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAGD,IACW,QAAQ;QACjB,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IACD,IAAW,QAAQ,CAAC,KAAmB;QACrC,IAAI,CAAC,SAAS,GAAG,0BAA0B,CAAC,KAAK,CAAC,CAAC;QACnD,IAAI,CAAC,yBAAyB,EAAE,CAAC;QACjC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;IAC3B,CAAC;IAGD;;;OAGG;IACH,IACW,QAAQ;QACjB,OAAO,CACL,IAAI,CAAC,SAAS;YACd,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,YAAY,CAAC,UAAU,CAAC,QAAQ,CAAC;YAC1D,KAAK,CACN,CAAC;IACJ,CAAC;IACD,IAAW,QAAQ,CAAC,KAAmB;QACrC,IAAI,CAAC,SAAS,GAAG,0BAA0B,CAAC,KAAK,CAAC,CAAC;QACnD,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;IAC3B,CAAC;IAOD,0BAA0B;IAC1B,cAAc;IACd,UAAU,CAAC,KAAU;QACnB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,CAAC;IACtC,CAAC;IAED,cAAc;IACd,gBAAgB,CAAC,EAAwB;QACvC,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;IACzB,CAAC;IAED,cAAc;IACd,iBAAiB,CAAC,EAAY;QAC5B,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;IAC1B,CAAC;IAED,cAAc;IACd,gBAAgB,CAAC,UAAmB;QAClC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;QAC3B,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,CAAC;IACtC,CAAC;IAED,eAAe;IAEf,cAAc;IACP,gBAAgB;QACrB,IAAI,IAAI,CAAC,YAAY,EAAE;YACrB,oEAAoE;YACpE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,SAAU,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;SACnE;IACH,CAAC;IAED,cAAc;IACP,UAAU,CAAC,KAAU;QAC1B,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC;IAED,cAAc;IACP,KAAK;QACV,IAAI,IAAI,CAAC,aAAa,EAAE;YACtB,IAAI,CAAC,aAAa,EAAE,CAAC;SACtB;IACH,CAAC;IAES,yBAAyB;QACjC,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE;YAC7C,IAAI,CAAC,SAAS,CAAC,OAAO,GAAG,IAAI,CAAC;SAC/B;IACH,CAAC;IAES,yBAAyB;QACjC,IAAI,IAAI,CAAC,aAAa,EAAE;YACtB,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC;SAC7D;IACH,CAAC;IAES,uBAAuB;QAC/B,IAAI,IAAI,CAAC,aAAa,EAAE;YACtB,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;gBAClC,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;gBACxB,MAAM,CAAC,YAAY,EAAE,CAAC;YACxB,CAAC,CAAC,CAAC;SACJ;IACH,CAAC;IAES,mCAAmC;QAC3C,MAAM,iBAAiB,GACrB,IAAI,CAAC,SAAS,KAAK,IAAI,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,KAAK,IAAI,CAAC,MAAM,CAAC;QAElE,IAAI,IAAI,CAAC,aAAa,IAAI,CAAC,iBAAiB,EAAE;YAC5C,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;YACtB,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;gBAClC,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC,KAAK,KAAK,MAAM,CAAC,KAAK,CAAC;gBAE7C,IAAI,MAAM,CAAC,OAAO,EAAE;oBAClB,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC;iBACzB;YACH,CAAC,CAAC,CAAC;SACJ;IACH,CAAC;8GAjRU,mBAAmB,oFA6ER,eAAe;kGA7E1B,mBAAmB,iiBApBnB;YACT;gBACE,OAAO,EAAE,qBAAqB;gBAC9B,WAAW,EAAE,mBAAmB;aACjC;YACD;gBACE,OAAO,EAAE,iBAAiB;gBAC1B,WAAW,EAAE,mBAAmB;aACjC;SACF,wDAwBgB,kBAAkB;;2FAbxB,mBAAmB;kBAxB/B,SAAS;mBAAC;oBACT,8DAA8D;oBAC9D,QAAQ,EAAE,mBAAmB;oBAC7B,QAAQ,EAAE,iBAAiB;oBAC3B,SAAS,EAAE;wBACT;4BACE,OAAO,EAAE,qBAAqB;4BAC9B,WAAW,qBAAqB;yBACjC;wBACD;4BACE,OAAO,EAAE,iBAAiB;4BAC1B,WAAW,qBAAqB;yBACjC;qBACF;oBACD,qEAAqE;oBACrE,IAAI,EAAE;wBACJ,IAAI,EAAE,YAAY;wBAClB,KAAK,EAAE,mBAAmB;wBAC1B,qCAAqC,EAAE,UAAU;wBACjD,qCAAqC,EAAE,UAAU;wBACjD,oCAAoC,EAAE,YAAY;wBAClD,mCAAmC,EAAE,QAAQ;qBAC9C;iBACF;;0BA8EI,QAAQ;;0BAAI,MAAM;2BAAC,eAAe;;0BAClC,QAAQ;;0BACR,QAAQ;;0BACR,IAAI;;0BAAI,QAAQ;yCAlET,aAAa;sBADtB,eAAe;uBAAC,kBAAkB,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE;gBAc/C,IAAI;sBADd,KAAK;gBAcK,MAAM;sBADhB,KAAK;gBAcK,QAAQ;sBADlB,KAAK;gBAYU,iBAAiB;sBADhC,KAAK;gBAQU,MAAM;sBAFrB,MAAM;gBA8DI,KAAK;sBADf,KAAK;gBAgBK,EAAE;sBADZ,KAAK;gBAgBK,QAAQ;sBADlB,KAAK;gBAgBK,QAAQ;sBADlB,KAAK","sourcesContent":["import {\n  AfterContentInit,\n  ChangeDetectorRef,\n  ContentChildren,\n  Directive,\n  DoCheck,\n  EventEmitter,\n  Inject,\n  Input,\n  OnDestroy,\n  Optional,\n  Output,\n  QueryList,\n  Self\n} from '@angular/core';\nimport {\n  AbstractControl,\n  ControlValueAccessor,\n  FormGroupDirective,\n  NgControl,\n  NgForm,\n  Validators\n} from '@angular/forms';\nimport { nanoid } from 'nanoid';\nimport {\n  BooleanInput,\n  coerceBooleanPropertyValue\n} from '../../../../../utilities';\nimport { Subject } from 'rxjs';\nimport { ImpdcFormRoot, IMPDC_FORM_ROOT } from '../../../directives';\nimport { ErrorStateMatcher } from '../../../services';\nimport {\n  IHasErrorState,\n  ImpdcFormFieldControl,\n  mixinErrorState\n} from '../../../shared';\nimport { IMPDC_RADIO_BUTTON, IMPDC_RADIO_GROUP } from '../injection-tokens';\nimport { RadioChangeEvent, IRadioButton, IRadioGroup } from '../interfaces';\n\nconst _RadioGroupDirectiveBase = mixinErrorState(\n  class {\n    public readonly stateChanges = new Subject<void>();\n\n    constructor(\n      public _defaultErrorStateMatcher: ErrorStateMatcher,\n      public _formRoot: ImpdcFormRoot,\n      public _parentForm: NgForm,\n      public _parentFormGroup: FormGroupDirective,\n      public ngControl: NgControl | null\n    ) {}\n  }\n);\n\n/**\n * The `RadioGroupDirective` (`<impdc-radio-group`) is a container for `RadioButtonComponent` (`<impdc-radio-button`).\n * This directive/component can be used within a `FormFieldComponent` (`<impdc-form-field`).\n * To use, import `RadioModule` or another module that imports and exports that module from `@impartner/design-components`.\n */\n@Directive({\n  // eslint-disable-next-line @angular-eslint/directive-selector\n  selector: 'impdc-radio-group',\n  exportAs: 'impdcRadioGroup',\n  providers: [\n    {\n      provide: ImpdcFormFieldControl,\n      useExisting: RadioGroupDirective\n    },\n    {\n      provide: IMPDC_RADIO_GROUP,\n      useExisting: RadioGroupDirective\n    }\n  ],\n  // eslint-disable-next-line @angular-eslint/no-host-metadata-property\n  host: {\n    role: 'radiogroup',\n    class: 'impdc-radio-group',\n    '[class.impdc-radio-group--required]': 'required',\n    '[class.impdc-radio-group--disabled]': 'disabled',\n    '[class.impdc-radio-group--invalid]': 'errorState',\n    '[class.impdc-radio-group--inline]': 'inline'\n  }\n})\nexport class RadioGroupDirective<\n    TRadioButton extends IRadioButton = IRadioButton\n  >\n  extends _RadioGroupDirectiveBase\n  implements\n    IRadioGroup,\n    ControlValueAccessor,\n    ImpdcFormFieldControl<any>,\n    AfterContentInit,\n    DoCheck,\n    OnDestroy,\n    IHasErrorState\n{\n  @ContentChildren(IMPDC_RADIO_BUTTON, { descendants: true })\n  protected _radioOptions!: QueryList<TRadioButton>;\n\n  protected readonly _uid = `impdc-radio-group-${nanoid()}`;\n  protected _initialized = false;\n\n  private _previousControl?: AbstractControl | null;\n  private _cvaOnChange: (value: any) => void = () => {};\n  private _cvaOnTouched = () => {};\n\n  /**\n   * The unique name for the group of radio options; Autogenerated by default.\n   */\n  @Input()\n  public get name(): string {\n    return this._name;\n  }\n  public set name(value: string) {\n    this._name = value || this._uid;\n    this._updateRadioOptionNames();\n  }\n  protected _name: string = this._uid;\n\n  /**\n   * Whether or not the nested radio options should display inline.\n   */\n  @Input()\n  public get inline(): boolean {\n    return this._inline;\n  }\n  public set inline(value: BooleanInput) {\n    this._inline = coerceBooleanPropertyValue(value);\n    this._markRadioOptionsForCheck();\n  }\n  protected _inline = false;\n\n  /**\n   * A reference to the currently selected radio button component (eg. `<impdc-radio-button>`).\n   */\n  @Input()\n  public get selected() {\n    return this._selected;\n  }\n  public set selected(selected: TRadioButton | null) {\n    this._selected = selected;\n    this.value = selected ? selected.value : null;\n    this._checkSelectedRadioOption();\n  }\n  protected _selected: TRadioButton | null = null;\n\n  @Input()\n  public override errorStateMatcher!: ErrorStateMatcher;\n\n  /**\n   * Event emitted whenever a new radio option is selected.\n   */\n  @Output()\n  // eslint-disable-next-line @angular-eslint/no-output-native\n  public readonly change: EventEmitter<RadioChangeEvent> =\n    new EventEmitter<RadioChangeEvent>();\n\n  constructor(\n    private readonly _changeDetector: ChangeDetectorRef,\n    _defaultErrorStateMatcher: ErrorStateMatcher,\n    @Optional() @Inject(IMPDC_FORM_ROOT) _formRoot: ImpdcFormRoot,\n    @Optional() _parentForm: NgForm,\n    @Optional() _parentFormGroup: FormGroupDirective,\n    @Self() @Optional() ngControl: NgControl | null\n  ) {\n    super(\n      _defaultErrorStateMatcher,\n      _formRoot,\n      _parentForm,\n      _parentFormGroup,\n      ngControl\n    );\n\n    if (this.ngControl) {\n      this.ngControl.valueAccessor = this;\n    }\n  }\n\n  /** @ignore */\n  public ngAfterContentInit(): void {\n    this._initialized = true;\n  }\n\n  /** @ignore */\n  public ngDoCheck(): void {\n    const ngControl = this.ngControl;\n\n    if (!ngControl) {\n      return;\n    }\n\n    if (this._previousControl !== ngControl.control) {\n      if (\n        this._previousControl !== undefined &&\n        ngControl.disabled !== null &&\n        ngControl.disabled !== this.disabled\n      ) {\n        this.disabled = ngControl?.disabled;\n      }\n\n      this._previousControl = ngControl.control;\n    }\n\n    this.updateErrorState();\n    this._markRadioOptionsForCheck();\n  }\n\n  /** @ignore */\n  public ngOnDestroy(): void {\n    this.stateChanges.complete();\n  }\n\n  /* ImpdcFormFieldControl */\n  @Input()\n  public get value(): any {\n    return this._value;\n  }\n  public set value(value: any) {\n    if (this._value !== value) {\n      this._value = value;\n\n      this._updateSelectedRadioOptionFromValue();\n      this._checkSelectedRadioOption();\n      this.stateChanges.next();\n    }\n  }\n  protected _value: any;\n\n  @Input()\n  public get id(): string {\n    return this._id;\n  }\n  public set id(value: string) {\n    this._id = value || this._uid;\n    this.stateChanges.next();\n  }\n  protected _id!: string;\n\n  public get focused(): boolean {\n    return this._focused;\n  }\n  protected _focused = false;\n\n  @Input()\n  public get disabled(): boolean {\n    return this._disabled;\n  }\n  public set disabled(value: BooleanInput) {\n    this._disabled = coerceBooleanPropertyValue(value);\n    this._markRadioOptionsForCheck();\n    this.stateChanges.next();\n  }\n  protected _disabled = false;\n\n  /**\n   * Used to set requiredness of control in a template-based manner;\n   * not necessary when using the Angular reactive forms API and `required` validator.\n   */\n  @Input()\n  public get required(): boolean {\n    return (\n      this._required ??\n      this.ngControl?.control?.hasValidator(Validators.required) ??\n      false\n    );\n  }\n  public set required(value: BooleanInput) {\n    this._required = coerceBooleanPropertyValue(value);\n    this.stateChanges.next();\n  }\n  private _required: boolean | undefined;\n\n  public readonly controlType = 'impdc-radio-group';\n\n  public readonly supportsAffixes: boolean = false;\n\n  /* ControlValueAccessor */\n  /** @ignore */\n  writeValue(value: any): void {\n    this.value = value;\n    this._changeDetector.markForCheck();\n  }\n\n  /** @ignore */\n  registerOnChange(fn: (value: any) => void): void {\n    this._cvaOnChange = fn;\n  }\n\n  /** @ignore */\n  registerOnTouched(fn: () => {}): void {\n    this._cvaOnTouched = fn;\n  }\n\n  /** @ignore */\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n    this._changeDetector.markForCheck();\n  }\n\n  /* Internals */\n\n  /** @ignore */\n  public emitChangesEvent(): void {\n    if (this._initialized) {\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      this.change.emit({ source: this._selected!, value: this._value });\n    }\n  }\n\n  /** @ignore */\n  public onChangeFn(value: any): void {\n    this._cvaOnChange(value);\n  }\n\n  /** @ignore */\n  public touch(): void {\n    if (this._cvaOnTouched) {\n      this._cvaOnTouched();\n    }\n  }\n\n  protected _checkSelectedRadioOption(): void {\n    if (this._selected && !this._selected.checked) {\n      this._selected.checked = true;\n    }\n  }\n\n  protected _markRadioOptionsForCheck(): void {\n    if (this._radioOptions) {\n      this._radioOptions.forEach(option => option.markForCheck());\n    }\n  }\n\n  protected _updateRadioOptionNames(): void {\n    if (this._radioOptions) {\n      this._radioOptions.forEach(option => {\n        option.name = this.name;\n        option.markForCheck();\n      });\n    }\n  }\n\n  protected _updateSelectedRadioOptionFromValue(): void {\n    const isAlreadySelected =\n      this._selected !== null && this._selected.value === this._value;\n\n    if (this._radioOptions && !isAlreadySelected) {\n      this._selected = null;\n      this._radioOptions.forEach(option => {\n        option.checked = this.value === option.value;\n\n        if (option.checked) {\n          this._selected = option;\n        }\n      });\n    }\n  }\n}\n"]}