@sbb-esta/lyne-elements-dev 4.7.0-dev.1773388991 → 4.7.0-dev.1773396165

package/development/core/mixins/form-associated-radio-button-mixin.js

@@ -1,266 +1,253 @@
-import { SbbDisabledMixin } from "./disabled-mixin.js";
-import { SbbElementInternalsMixin } from "./element-internals-mixin.js";
-import { SbbFormAssociatedMixin } from "./form-associated-mixin.js";
-import { SbbRequiredMixin } from "./required-mixin.js";
 import { __esDecorate, __runInitializers } from "tslib";
 import { isServer } from "lit";
 import { property } from "lit/decorators.js";
+import { interactivityChecker, isArrowKeyPressed, getNextElementIndex } from "../a11y.js";
 import { SbbLanguageController } from "../controllers.js";
 import { i18nSelectionRequired } from "../i18n.js";
-import { getNextElementIndex, interactivityChecker, isArrowKeyPressed } from "../a11y.js";
-//#region src/elements/core/mixins/form-associated-radio-button-mixin.ts
-/**
-* A static registry that holds a collection of grouped `radio-buttons`.
-* Groups of radio buttons are local to the form they belong (or the `renderRoot` if they're not part of any form)
-* Multiple groups of radio with the same name can coexist (as long as they belong to a different form / renderRoot)
-* It is mainly used to support the standalone groups of radios.
-* @internal
-*/
-var radioButtonRegistry = /* @__PURE__ */ new WeakMap();
-/**
-* The SbbFormAssociatedRadioButtonMixin enables native form support for radio controls.
-*/
-var SbbFormAssociatedRadioButtonMixin = (superClass) => {
-	const conditionalSuperClass = superClass["_$sbbElement$"] ? superClass : SbbElementInternalsMixin(superClass);
-	return (() => {
-		let _classSuper = SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(conditionalSuperClass)));
-		let _instanceExtraInitializers = [];
-		let _set_checked_decorators;
-		let _set_name_decorators;
-		return class SbbFormAssociatedRadioButtonElement extends _classSuper {
-			static {
-				const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-				_set_checked_decorators = [property({ type: Boolean })];
-				_set_name_decorators = [property()];
-				__esDecorate(this, null, _set_checked_decorators, {
-					kind: "setter",
-					name: "checked",
-					static: false,
-					private: false,
-					access: {
-						has: (obj) => "checked" in obj,
-						set: (obj, value) => {
-							obj.checked = value;
-						}
-					},
-					metadata: _metadata
-				}, null, _instanceExtraInitializers);
-				__esDecorate(this, null, _set_name_decorators, {
-					kind: "setter",
-					name: "name",
-					static: false,
-					private: false,
-					access: {
-						has: (obj) => "name" in obj,
-						set: (obj, value) => {
-							obj.name = value;
-						}
-					},
-					metadata: _metadata
-				}, null, _instanceExtraInitializers);
-				if (_metadata) Object.defineProperty(this, Symbol.metadata, {
-					enumerable: true,
-					configurable: true,
-					writable: true,
-					value: _metadata
-				});
-			}
-			static {
-				this.role = "radio";
-			}
-			/**
-			* Whether the radio button is checked.
-			*/
-			set checked(value) {
-				this._checked = !!value;
-				this.toggleState("checked", this.checked);
-				this.internals.ariaChecked = this.checked.toString();
-				this.updateFormValue();
-				this._synchronizeGroupState();
-			}
-			get checked() {
-				return this._checked;
-			}
-			set name(value) {
-				super.name = value;
-				this._disconnectFromRegistry();
-				this._connectToRegistry();
-				this._synchronizeGroupState();
-			}
-			get name() {
-				return super.name;
-			}
-			/**
-			* Form type of element.
-			* @default 'radio'
-			*/
-			get type() {
-				return "radio";
-			}
-			constructor() {
-				super();
-				this._checked = (__runInitializers(this, _instanceExtraInitializers), false);
-				this._languageController = new SbbLanguageController(this);
-				this.addEventListener?.("keydown", (e) => this._handleArrowKeyDown(e));
-			}
-			connectedCallback() {
-				super.connectedCallback();
-				this._connectToRegistry();
-				this._synchronizeGroupState();
-			}
-			disconnectedCallback() {
-				super.disconnectedCallback();
-				this._disconnectFromRegistry();
-			}
-			/**
-			* Is called whenever the form is being reset.
-			* @internal
-			*/
-			formResetCallback() {
-				this.checked = this.hasAttribute("checked");
-			}
-			/**
-			*  Called when the browser is trying to restore element’s state to state in which case
-			*  reason is "restore", or when the browser is trying to fulfill autofill on behalf of
-			*  user in which case reason is "autocomplete".
-			* @internal
-			*/
-			formStateRestoreCallback(state, _reason) {
-				if (typeof state === "string" || state == null) this.checked = state === this.value;
-				else if (state instanceof FormData) this._readFormData(state).then((data) => {
-					this.checked = data === this.value;
-				});
-			}
-			async _readFormData(formData) {
-				const data = formData.get(this.name);
-				return data instanceof Blob ? JSON.parse(await data.text()) : data;
-			}
-			willUpdate(changedProperties) {
-				super.willUpdate(changedProperties);
-				if (changedProperties.has("disabled")) this.updateFocusableRadios();
-			}
-			firstUpdated(changedProperties) {
-				super.firstUpdated(changedProperties);
-				this.updateFocusableRadios();
-			}
-			/**
-			* Called on `value` change
-			* If 'checked', update the value. Otherwise, do nothing.
-			*/
-			updateFormValue() {
-				if (this.checked) super.updateFormValue();
-				else this.internals.setFormValue(null);
-			}
-			shouldValidate(name) {
-				return super.shouldValidate(name) || name === "checked" || name === "required";
-			}
-			/**
-			* Sets the validity of all associated radio buttons.
-			* If any radio button is required, all associated are required as well.
-			*/
-			validate() {
-				super.validate();
-				if (!this.associatedRadioButtons) return;
-				let required = false;
-				let checked = false;
-				for (const radio of this.associatedRadioButtons) {
-					required ||= radio.required;
-					checked ||= radio.checked;
-				}
-				if (required && !checked) this.associatedRadioButtons.forEach((r) => r.setValidityFlag("valueMissing", i18nSelectionRequired[this._languageController.current]));
-				else this.associatedRadioButtons.forEach((r) => r.removeValidityFlag("valueMissing"));
-			}
-			/**
-			* Only a single radio should be focusable in the group. Defined as:
-			* - the checked radio;
-			* - the first non-disabled radio in DOM order;
-			*/
-			updateFocusableRadios() {
-				if (!this.hasUpdated) return;
-				const radios = this._interactableGroupedRadios();
-				const checkedIndex = radios.findIndex((r) => r.checked && !r.disabled && !r.formDisabled);
-				const focusableIndex = checkedIndex !== -1 ? checkedIndex : radios.findIndex((r) => !r.disabled && !r.formDisabled);
-				if (focusableIndex !== -1) {
-					radios[focusableIndex].tabIndex = 0;
-					radios.splice(focusableIndex, 1);
-				}
-				radios.forEach((r) => r.removeAttribute("tabindex"));
-			}
-			async navigateByKeyboard(next) {
-				next.checked = true;
-				this.emitChangeEvents();
-				await next.updateComplete;
-				next.focus();
-			}
-			emitChangeEvents() {
-				this.dispatchEvent(new InputEvent("input", {
-					bubbles: true,
-					cancelable: true,
-					composed: true
-				}));
-				this.dispatchEvent(new Event("change", { bubbles: true }));
-			}
-			_synchronizeGroupState() {
-				if (this.checked) this._deselectGroupedRadios();
-				this.updateFocusableRadios();
-			}
-			/**
-			* Add `this` to the radioButton registry
-			*/
-			_connectToRegistry() {
-				if (!this.name || isServer) return;
-				const root = this.form ?? this.getRootNode();
-				this._radioButtonGroupsMap = radioButtonRegistry.get(root);
-				if (!this._radioButtonGroupsMap) {
-					this._radioButtonGroupsMap = /* @__PURE__ */ new Map();
-					radioButtonRegistry.set(root, this._radioButtonGroupsMap);
-				}
-				this.associatedRadioButtons = this._radioButtonGroupsMap.get(this.name);
-				if (!this.associatedRadioButtons) {
-					this.associatedRadioButtons = /* @__PURE__ */ new Set();
-					this._radioButtonGroupsMap.set(this.name, this.associatedRadioButtons);
-				}
-				const entries = Array.from(this.associatedRadioButtons);
-				this.associatedRadioButtons.clear();
-				const index = entries.findIndex((r) => this.compareDocumentPosition(r) & Node.DOCUMENT_POSITION_FOLLOWING);
-				if (index !== -1) entries.splice(index, 0, this);
-				else entries.push(this);
-				entries.forEach((r) => this.associatedRadioButtons.add(r));
-				this.validate();
-			}
-			/**
-			* Remove `this` from the radioButton registry and, if the group is empty, delete the entry from the groups Map
-			*/
-			_disconnectFromRegistry() {
-				this.associatedRadioButtons?.delete(this);
-				if (this.associatedRadioButtons?.size === 0) this._radioButtonGroupsMap?.delete(this.name);
-				else this.validate();
-				this.associatedRadioButtons = void 0;
-				this._radioButtonGroupsMap = void 0;
-			}
-			/**
-			* Return a list of 'interactable' grouped radios, ordered in DOM order
-			*/
-			_interactableGroupedRadios() {
-				return Array.from(this.associatedRadioButtons ?? []).filter((el) => interactivityChecker.isVisible(el));
-			}
-			/**
-			* Deselect other radio of the same group
-			*/
-			_deselectGroupedRadios() {
-				Array.from(this.associatedRadioButtons ?? []).filter((r) => r !== this).forEach((r) => r.checked = false);
-			}
-			async _handleArrowKeyDown(evt) {
-				if (!isArrowKeyPressed(evt)) return;
-				evt.preventDefault();
-				const enabledRadios = this._interactableGroupedRadios().filter((r) => !r.disabled && !r.formDisabled);
-				const nextIndex = getNextElementIndex(evt, enabledRadios.indexOf(this), enabledRadios.length);
-				await this.navigateByKeyboard(enabledRadios[nextIndex]);
-			}
-		};
-	})();
+import { SbbDisabledMixin } from "./disabled-mixin.js";
+import { SbbElementInternalsMixin } from "./element-internals-mixin.js";
+import { SbbFormAssociatedMixin } from "./form-associated-mixin.js";
+import { SbbRequiredMixin } from "./required-mixin.js";
+const radioButtonRegistry = /* @__PURE__ */ new WeakMap();
+const SbbFormAssociatedRadioButtonMixin = (superClass) => {
+  const conditionalSuperClass = superClass["_$sbbElement$"] ? superClass : SbbElementInternalsMixin(superClass);
+  let SbbFormAssociatedRadioButtonElement = (() => {
+    var _a;
+    let _classSuper = SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(conditionalSuperClass)));
+    let _instanceExtraInitializers = [];
+    let _set_checked_decorators;
+    let _set_name_decorators;
+    return _a = class extends _classSuper {
+      /**
+       * Whether the radio button is checked.
+       */
+      set checked(value) {
+        this._checked = !!value;
+        this.toggleState("checked", this.checked);
+        this.internals.ariaChecked = this.checked.toString();
+        this.updateFormValue();
+        this._synchronizeGroupState();
+      }
+      get checked() {
+        return this._checked;
+      }
+      set name(value) {
+        super.name = value;
+        this._disconnectFromRegistry();
+        this._connectToRegistry();
+        this._synchronizeGroupState();
+      }
+      get name() {
+        return super.name;
+      }
+      /**
+       * Form type of element.
+       * @default 'radio'
+       */
+      get type() {
+        return "radio";
+      }
+      constructor() {
+        super();
+        this._checked = (__runInitializers(this, _instanceExtraInitializers), false);
+        this._languageController = new SbbLanguageController(this);
+        this.addEventListener?.("keydown", (e) => this._handleArrowKeyDown(e));
+      }
+      connectedCallback() {
+        super.connectedCallback();
+        this._connectToRegistry();
+        this._synchronizeGroupState();
+      }
+      disconnectedCallback() {
+        super.disconnectedCallback();
+        this._disconnectFromRegistry();
+      }
+      /**
+       * Is called whenever the form is being reset.
+       * @internal
+       */
+      formResetCallback() {
+        this.checked = this.hasAttribute("checked");
+      }
+      /**
+       *  Called when the browser is trying to restore element’s state to state in which case
+       *  reason is "restore", or when the browser is trying to fulfill autofill on behalf of
+       *  user in which case reason is "autocomplete".
+       * @internal
+       */
+      formStateRestoreCallback(state, _reason) {
+        if (typeof state === "string" || state == null) {
+          this.checked = state === this.value;
+        } else if (state instanceof FormData) {
+          this._readFormData(state).then((data) => {
+            this.checked = data === this.value;
+          });
+        }
+      }
+      async _readFormData(formData) {
+        const data = formData.get(this.name);
+        return data instanceof Blob ? JSON.parse(await data.text()) : data;
+      }
+      willUpdate(changedProperties) {
+        super.willUpdate(changedProperties);
+        if (changedProperties.has("disabled")) {
+          this.updateFocusableRadios();
+        }
+      }
+      firstUpdated(changedProperties) {
+        super.firstUpdated(changedProperties);
+        this.updateFocusableRadios();
+      }
+      /**
+       * Called on `value` change
+       * If 'checked', update the value. Otherwise, do nothing.
+       */
+      updateFormValue() {
+        if (this.checked) {
+          super.updateFormValue();
+        } else {
+          this.internals.setFormValue(null);
+        }
+      }
+      shouldValidate(name) {
+        return super.shouldValidate(name) || name === "checked" || name === "required";
+      }
+      /**
+       * Sets the validity of all associated radio buttons.
+       * If any radio button is required, all associated are required as well.
+       */
+      validate() {
+        super.validate();
+        if (!this.associatedRadioButtons) {
+          return;
+        }
+        let required = false;
+        let checked = false;
+        for (const radio of this.associatedRadioButtons) {
+          required ||= radio.required;
+          checked ||= radio.checked;
+        }
+        if (required && !checked) {
+          this.associatedRadioButtons.forEach((r) => r.setValidityFlag("valueMissing", i18nSelectionRequired[this._languageController.current]));
+        } else {
+          this.associatedRadioButtons.forEach((r) => r.removeValidityFlag("valueMissing"));
+        }
+      }
+      /**
+       * Only a single radio should be focusable in the group. Defined as:
+       * - the checked radio;
+       * - the first non-disabled radio in DOM order;
+       */
+      updateFocusableRadios() {
+        if (!this.hasUpdated) {
+          return;
+        }
+        const radios = this._interactableGroupedRadios();
+        const checkedIndex = radios.findIndex((r) => r.checked && !r.disabled && !r.formDisabled);
+        const focusableIndex = checkedIndex !== -1 ? checkedIndex : radios.findIndex((r) => !r.disabled && !r.formDisabled);
+        if (focusableIndex !== -1) {
+          radios[focusableIndex].tabIndex = 0;
+          radios.splice(focusableIndex, 1);
+        }
+        radios.forEach((r) => r.removeAttribute("tabindex"));
+      }
+      async navigateByKeyboard(next) {
+        next.checked = true;
+        this.emitChangeEvents();
+        await next.updateComplete;
+        next.focus();
+      }
+      emitChangeEvents() {
+        this.dispatchEvent(new InputEvent("input", { bubbles: true, cancelable: true, composed: true }));
+        this.dispatchEvent(new Event("change", { bubbles: true }));
+      }
+      _synchronizeGroupState() {
+        if (this.checked) {
+          this._deselectGroupedRadios();
+        }
+        this.updateFocusableRadios();
+      }
+      /**
+       * Add `this` to the radioButton registry
+       */
+      _connectToRegistry() {
+        if (!this.name || isServer) {
+          return;
+        }
+        const root = this.form ?? this.getRootNode();
+        this._radioButtonGroupsMap = radioButtonRegistry.get(root);
+        if (!this._radioButtonGroupsMap) {
+          this._radioButtonGroupsMap = /* @__PURE__ */ new Map();
+          radioButtonRegistry.set(root, this._radioButtonGroupsMap);
+        }
+        this.associatedRadioButtons = this._radioButtonGroupsMap.get(this.name);
+        if (!this.associatedRadioButtons) {
+          this.associatedRadioButtons = /* @__PURE__ */ new Set();
+          this._radioButtonGroupsMap.set(this.name, this.associatedRadioButtons);
+        }
+        const entries = Array.from(this.associatedRadioButtons);
+        this.associatedRadioButtons.clear();
+        const index = entries.findIndex((r) => this.compareDocumentPosition(r) & Node.DOCUMENT_POSITION_FOLLOWING);
+        if (index !== -1) {
+          entries.splice(index, 0, this);
+        } else {
+          entries.push(this);
+        }
+        entries.forEach((r) => this.associatedRadioButtons.add(r));
+        this.validate();
+      }
+      /**
+       * Remove `this` from the radioButton registry and, if the group is empty, delete the entry from the groups Map
+       */
+      _disconnectFromRegistry() {
+        this.associatedRadioButtons?.delete(this);
+        if (this.associatedRadioButtons?.size === 0) {
+          this._radioButtonGroupsMap?.delete(this.name);
+        } else {
+          this.validate();
+        }
+        this.associatedRadioButtons = void 0;
+        this._radioButtonGroupsMap = void 0;
+      }
+      /**
+       * Return a list of 'interactable' grouped radios, ordered in DOM order
+       */
+      _interactableGroupedRadios() {
+        return Array.from(this.associatedRadioButtons ?? []).filter((el) => interactivityChecker.isVisible(el));
+      }
+      /**
+       * Deselect other radio of the same group
+       */
+      _deselectGroupedRadios() {
+        Array.from(this.associatedRadioButtons ?? []).filter((r) => r !== this).forEach((r) => r.checked = false);
+      }
+      async _handleArrowKeyDown(evt) {
+        if (!isArrowKeyPressed(evt)) {
+          return;
+        }
+        evt.preventDefault();
+        const enabledRadios = this._interactableGroupedRadios().filter((r) => !r.disabled && !r.formDisabled);
+        const current = enabledRadios.indexOf(this);
+        const nextIndex = getNextElementIndex(evt, current, enabledRadios.length);
+        await this.navigateByKeyboard(enabledRadios[nextIndex]);
+      }
+    }, (() => {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      _set_checked_decorators = [property({ type: Boolean })];
+      _set_name_decorators = [property()];
+      __esDecorate(_a, null, _set_checked_decorators, { kind: "setter", name: "checked", static: false, private: false, access: { has: (obj) => "checked" in obj, set: (obj, value) => {
+        obj.checked = value;
+      } }, metadata: _metadata }, null, _instanceExtraInitializers);
+      __esDecorate(_a, null, _set_name_decorators, { kind: "setter", name: "name", static: false, private: false, access: { has: (obj) => "name" in obj, set: (obj, value) => {
+        obj.name = value;
+      } }, metadata: _metadata }, null, _instanceExtraInitializers);
+      if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+    })(), _a.role = "radio", _a;
+  })();
+  return SbbFormAssociatedRadioButtonElement;
+};
+export {
+  SbbFormAssociatedRadioButtonMixin,
+  radioButtonRegistry
 };
-//#endregion
-export { SbbFormAssociatedRadioButtonMixin, radioButtonRegistry };
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"form-associated-radio-button-mixin.js","names":[],"sources":["../../../../../src/elements/core/mixins/form-associated-radio-button-mixin.ts"],"sourcesContent":["import { isServer, type LitElement, type PropertyValues } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { getNextElementIndex, interactivityChecker, isArrowKeyPressed } from '../a11y.ts';\nimport { SbbLanguageController } from '../controllers.ts';\nimport { i18nSelectionRequired } from '../i18n.ts';\n\nimport type { AbstractConstructor } from './constructor.ts';\nimport { SbbDisabledMixin } from './disabled-mixin.ts';\nimport {\n  SbbElementInternalsMixin,\n  type SbbElementInternalsMixinType,\n  type SbbElementInternalsConstructor,\n} from './element-internals-mixin.ts';\nimport {\n  type FormRestoreReason,\n  type FormRestoreState,\n  SbbFormAssociatedMixin,\n} from './form-associated-mixin.ts';\nimport { SbbRequiredMixin } from './required-mixin.ts';\n\n/**\n * A static registry that holds a collection of grouped `radio-buttons`.\n * Groups of radio buttons are local to the form they belong (or the `renderRoot` if they're not part of any form)\n * Multiple groups of radio with the same name can coexist (as long as they belong to a different form / renderRoot)\n * It is mainly used to support the standalone groups of radios.\n * @internal\n */\nexport const radioButtonRegistry = new WeakMap<\n  Node,\n  Map<string, Set<SbbFormAssociatedRadioButtonMixinType>>\n>();\n\nexport declare abstract class SbbFormAssociatedRadioButtonMixinType extends SbbDisabledMixin(\n  SbbRequiredMixin(SbbFormAssociatedMixin(SbbElementInternalsMixin(LitElement))),\n) {\n  public accessor checked: boolean;\n\n  protected associatedRadioButtons?: Set<SbbFormAssociatedRadioButtonMixinType>;\n\n  public formResetCallback(): void;\n  public formStateRestoreCallback(state: FormRestoreState | null, reason: FormRestoreReason): void;\n\n  protected updateFormValue(): void;\n  protected updateFocusableRadios(): void;\n  protected emitChangeEvents(): void;\n  protected navigateByKeyboard(radio: SbbFormAssociatedRadioButtonMixinType): Promise<void>;\n}\n\n/**\n * The SbbFormAssociatedRadioButtonMixin enables native form support for radio controls.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbFormAssociatedRadioButtonMixin = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbFormAssociatedRadioButtonMixinType> & T => {\n  // TODO(breaking-change): Remove SbbElementInternalsMixin and depend on SbbElement as base class instead of LitElement\n  const conditionalSuperClass = (superClass as unknown as Record<string, unknown>)['_$sbbElement$']\n    ? (superClass as unknown as AbstractConstructor<SbbElementInternalsMixinType> &\n        T &\n        SbbElementInternalsConstructor)\n    : SbbElementInternalsMixin(superClass);\n\n  abstract class SbbFormAssociatedRadioButtonElement\n    extends SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(conditionalSuperClass)))\n    implements Partial<SbbFormAssociatedRadioButtonMixinType>\n  {\n    public static override readonly role = 'radio';\n\n    /**\n     * Whether the radio button is checked.\n     */\n    @property({ type: Boolean })\n    public set checked(value: boolean) {\n      this._checked = !!value;\n\n      this.toggleState('checked', this.checked);\n      this.internals.ariaChecked = this.checked.toString();\n      this.updateFormValue();\n      this._synchronizeGroupState();\n    }\n    public get checked(): boolean {\n      return this._checked;\n    }\n    private _checked: boolean = false;\n\n    @property()\n    public override set name(value: string) {\n      super.name = value;\n\n      this._disconnectFromRegistry();\n      this._connectToRegistry();\n      this._synchronizeGroupState();\n    }\n    public override get name(): string {\n      return super.name;\n    }\n\n    /**\n     * Form type of element.\n     * @default 'radio'\n     */\n    public override get type(): string {\n      return 'radio';\n    }\n\n    /**\n     * Set of radio buttons that belongs to the same group of `this`.\n     * Assume them ordered in DOM order\n     */\n    protected associatedRadioButtons?: Set<SbbFormAssociatedRadioButtonElement>;\n    private _radioButtonGroupsMap?: Map<string, Set<SbbFormAssociatedRadioButtonMixinType>>;\n    private _languageController = new SbbLanguageController(this);\n\n    protected constructor() {\n      super();\n      this.addEventListener?.('keydown', (e) => this._handleArrowKeyDown(e));\n    }\n\n    public override connectedCallback(): void {\n      super.connectedCallback();\n      this._connectToRegistry();\n      this._synchronizeGroupState();\n    }\n\n    public override disconnectedCallback(): void {\n      super.disconnectedCallback();\n      this._disconnectFromRegistry();\n    }\n\n    /**\n     * Is called whenever the form is being reset.\n     * @internal\n     */\n    public override formResetCallback(): void {\n      this.checked = this.hasAttribute('checked');\n    }\n\n    /**\n     *  Called when the browser is trying to restore element’s state to state in which case\n     *  reason is \"restore\", or when the browser is trying to fulfill autofill on behalf of\n     *  user in which case reason is \"autocomplete\".\n     * @internal\n     */\n    public override formStateRestoreCallback(\n      state: FormRestoreState | null,\n      _reason: FormRestoreReason,\n    ): void {\n      if (typeof state === 'string' || state == null) {\n        this.checked = state === this.value;\n      } else if (state instanceof FormData) {\n        this._readFormData(state).then((data) => {\n          this.checked = data === this.value;\n        });\n      }\n    }\n\n    private async _readFormData(formData: FormData): Promise<unknown> {\n      const data = formData.get(this.name);\n      return data instanceof Blob ? JSON.parse(await data.text()) : data;\n    }\n\n    protected override willUpdate(changedProperties: PropertyValues<this>): void {\n      super.willUpdate(changedProperties);\n\n      if (changedProperties.has('disabled')) {\n        this.updateFocusableRadios();\n      }\n    }\n\n    protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n      super.firstUpdated(changedProperties);\n      this.updateFocusableRadios();\n    }\n\n    /**\n     * Called on `value` change\n     * If 'checked', update the value. Otherwise, do nothing.\n     */\n    protected override updateFormValue(): void {\n      if (this.checked) {\n        super.updateFormValue();\n      } else {\n        this.internals.setFormValue(null);\n      }\n    }\n\n    protected override shouldValidate(name: PropertyKey | undefined): boolean {\n      return super.shouldValidate(name) || name === 'checked' || name === 'required';\n    }\n\n    /**\n     * Sets the validity of all associated radio buttons.\n     * If any radio button is required, all associated are required as well.\n     */\n    protected override validate(): void {\n      super.validate();\n      if (!this.associatedRadioButtons) {\n        return;\n      }\n\n      let required = false;\n      let checked = false;\n      for (const radio of this.associatedRadioButtons) {\n        required ||= radio.required;\n        checked ||= radio.checked;\n      }\n\n      if (required && !checked) {\n        this.associatedRadioButtons.forEach((r) =>\n          r.setValidityFlag(\n            'valueMissing',\n            i18nSelectionRequired[this._languageController.current],\n          ),\n        );\n      } else {\n        this.associatedRadioButtons.forEach((r) => r.removeValidityFlag('valueMissing'));\n      }\n    }\n\n    /**\n     * Only a single radio should be focusable in the group. Defined as:\n     * - the checked radio;\n     * - the first non-disabled radio in DOM order;\n     */\n    protected updateFocusableRadios(): void {\n      if (!this.hasUpdated) {\n        return;\n      }\n      const radios = this._interactableGroupedRadios();\n      const checkedIndex = radios.findIndex((r) => r.checked && !r.disabled && !r.formDisabled);\n      const focusableIndex =\n        checkedIndex !== -1\n          ? checkedIndex\n          : radios.findIndex((r) => !r.disabled && !r.formDisabled); // Get the first focusable radio\n\n      if (focusableIndex !== -1) {\n        radios[focusableIndex].tabIndex = 0;\n        radios.splice(focusableIndex, 1);\n      }\n\n      // Reset tabIndex on other radios\n      radios.forEach((r) => r.removeAttribute('tabindex'));\n    }\n\n    protected async navigateByKeyboard(next: SbbFormAssociatedRadioButtonElement): Promise<void> {\n      next.checked = true;\n      this.emitChangeEvents();\n\n      await next.updateComplete;\n      next.focus();\n    }\n\n    protected emitChangeEvents(): void {\n      // Manually dispatch events to simulate a user interaction\n      this.dispatchEvent(\n        new InputEvent('input', { bubbles: true, cancelable: true, composed: true }),\n      );\n      this.dispatchEvent(new Event('change', { bubbles: true }));\n    }\n\n    private _synchronizeGroupState(): void {\n      if (this.checked) {\n        this._deselectGroupedRadios();\n      }\n      this.updateFocusableRadios();\n    }\n\n    /**\n     * Add `this` to the radioButton registry\n     */\n    private _connectToRegistry(): void {\n      if (!this.name || isServer) {\n        return;\n      }\n      const root = this.form ?? this.getRootNode();\n      this._radioButtonGroupsMap = radioButtonRegistry.get(root);\n\n      // Initialize the 'root' map entry\n      if (!this._radioButtonGroupsMap) {\n        this._radioButtonGroupsMap = new Map();\n        radioButtonRegistry.set(root, this._radioButtonGroupsMap);\n      }\n\n      this.associatedRadioButtons = this._radioButtonGroupsMap.get(\n        this.name,\n      ) as unknown as Set<SbbFormAssociatedRadioButtonElement>;\n\n      // Initialize the group set\n      if (!this.associatedRadioButtons) {\n        this.associatedRadioButtons = new Set();\n        this._radioButtonGroupsMap.set(\n          this.name,\n          this.associatedRadioButtons as unknown as Set<SbbFormAssociatedRadioButtonMixinType>,\n        );\n      }\n\n      // Insert the new radio into the set and sort following the DOM order.\n      // Since the order of a 'Set' is the insert order, we have to empty it and re-insert radios in order\n      const entries = Array.from(this.associatedRadioButtons);\n      this.associatedRadioButtons.clear();\n\n      // Find `this` position and insert it\n      const index = entries.findIndex(\n        (r) => this.compareDocumentPosition(r) & Node.DOCUMENT_POSITION_FOLLOWING,\n      );\n      if (index !== -1) {\n        entries.splice(index, 0, this);\n      } else {\n        entries.push(this);\n      }\n\n      // Repopulate the Set\n      entries.forEach((r) => this.associatedRadioButtons!.add(r));\n\n      this.validate();\n    }\n\n    /**\n     * Remove `this` from the radioButton registry and, if the group is empty, delete the entry from the groups Map\n     */\n    private _disconnectFromRegistry(): void {\n      this.associatedRadioButtons?.delete(this);\n\n      if (this.associatedRadioButtons?.size === 0) {\n        this._radioButtonGroupsMap?.delete(this.name);\n      } else {\n        this.validate();\n      }\n\n      this.associatedRadioButtons = undefined;\n      this._radioButtonGroupsMap = undefined;\n    }\n\n    /**\n     * Return a list of 'interactable' grouped radios, ordered in DOM order\n     */\n    private _interactableGroupedRadios(): SbbFormAssociatedRadioButtonElement[] {\n      return Array.from(this.associatedRadioButtons ?? []).filter((el) =>\n        interactivityChecker.isVisible(el),\n      );\n    }\n\n    /**\n     * Deselect other radio of the same group\n     */\n    private _deselectGroupedRadios(): void {\n      Array.from(this.associatedRadioButtons ?? [])\n        .filter((r) => r !== this)\n        .forEach((r) => (r.checked = false));\n    }\n\n    private async _handleArrowKeyDown(evt: KeyboardEvent): Promise<void> {\n      if (!isArrowKeyPressed(evt)) {\n        return;\n      }\n      evt.preventDefault();\n\n      const enabledRadios = this._interactableGroupedRadios().filter(\n        (r) => !r.disabled && !r.formDisabled,\n      );\n      const current: number = enabledRadios.indexOf(this);\n      const nextIndex: number = getNextElementIndex(evt, current, enabledRadios.length);\n\n      await this.navigateByKeyboard(enabledRadios[nextIndex]);\n    }\n  }\n\n  return SbbFormAssociatedRadioButtonElement as unknown as AbstractConstructor<SbbFormAssociatedRadioButtonMixinType> &\n    T;\n};\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"form-associated-radio-button-mixin.js","sources":["../../../../../src/elements/core/mixins/form-associated-radio-button-mixin.ts"],"sourcesContent":["import { isServer, type LitElement, type PropertyValues } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { getNextElementIndex, interactivityChecker, isArrowKeyPressed } from '../a11y.ts';\nimport { SbbLanguageController } from '../controllers.ts';\nimport { i18nSelectionRequired } from '../i18n.ts';\n\nimport type { AbstractConstructor } from './constructor.ts';\nimport { SbbDisabledMixin } from './disabled-mixin.ts';\nimport {\n  SbbElementInternalsMixin,\n  type SbbElementInternalsMixinType,\n  type SbbElementInternalsConstructor,\n} from './element-internals-mixin.ts';\nimport {\n  type FormRestoreReason,\n  type FormRestoreState,\n  SbbFormAssociatedMixin,\n} from './form-associated-mixin.ts';\nimport { SbbRequiredMixin } from './required-mixin.ts';\n\n/**\n * A static registry that holds a collection of grouped `radio-buttons`.\n * Groups of radio buttons are local to the form they belong (or the `renderRoot` if they're not part of any form)\n * Multiple groups of radio with the same name can coexist (as long as they belong to a different form / renderRoot)\n * It is mainly used to support the standalone groups of radios.\n * @internal\n */\nexport const radioButtonRegistry = new WeakMap<\n  Node,\n  Map<string, Set<SbbFormAssociatedRadioButtonMixinType>>\n>();\n\nexport declare abstract class SbbFormAssociatedRadioButtonMixinType extends SbbDisabledMixin(\n  SbbRequiredMixin(SbbFormAssociatedMixin(SbbElementInternalsMixin(LitElement))),\n) {\n  public accessor checked: boolean;\n\n  protected associatedRadioButtons?: Set<SbbFormAssociatedRadioButtonMixinType>;\n\n  public formResetCallback(): void;\n  public formStateRestoreCallback(state: FormRestoreState | null, reason: FormRestoreReason): void;\n\n  protected updateFormValue(): void;\n  protected updateFocusableRadios(): void;\n  protected emitChangeEvents(): void;\n  protected navigateByKeyboard(radio: SbbFormAssociatedRadioButtonMixinType): Promise<void>;\n}\n\n/**\n * The SbbFormAssociatedRadioButtonMixin enables native form support for radio controls.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbFormAssociatedRadioButtonMixin = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbFormAssociatedRadioButtonMixinType> & T => {\n  // TODO(breaking-change): Remove SbbElementInternalsMixin and depend on SbbElement as base class instead of LitElement\n  const conditionalSuperClass = (superClass as unknown as Record<string, unknown>)['_$sbbElement$']\n    ? (superClass as unknown as AbstractConstructor<SbbElementInternalsMixinType> &\n        T &\n        SbbElementInternalsConstructor)\n    : SbbElementInternalsMixin(superClass);\n\n  abstract class SbbFormAssociatedRadioButtonElement\n    extends SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(conditionalSuperClass)))\n    implements Partial<SbbFormAssociatedRadioButtonMixinType>\n  {\n    public static override readonly role = 'radio';\n\n    /**\n     * Whether the radio button is checked.\n     */\n    @property({ type: Boolean })\n    public set checked(value: boolean) {\n      this._checked = !!value;\n\n      this.toggleState('checked', this.checked);\n      this.internals.ariaChecked = this.checked.toString();\n      this.updateFormValue();\n      this._synchronizeGroupState();\n    }\n    public get checked(): boolean {\n      return this._checked;\n    }\n    private _checked: boolean = false;\n\n    @property()\n    public override set name(value: string) {\n      super.name = value;\n\n      this._disconnectFromRegistry();\n      this._connectToRegistry();\n      this._synchronizeGroupState();\n    }\n    public override get name(): string {\n      return super.name;\n    }\n\n    /**\n     * Form type of element.\n     * @default 'radio'\n     */\n    public override get type(): string {\n      return 'radio';\n    }\n\n    /**\n     * Set of radio buttons that belongs to the same group of `this`.\n     * Assume them ordered in DOM order\n     */\n    protected associatedRadioButtons?: Set<SbbFormAssociatedRadioButtonElement>;\n    private _radioButtonGroupsMap?: Map<string, Set<SbbFormAssociatedRadioButtonMixinType>>;\n    private _languageController = new SbbLanguageController(this);\n\n    protected constructor() {\n      super();\n      this.addEventListener?.('keydown', (e) => this._handleArrowKeyDown(e));\n    }\n\n    public override connectedCallback(): void {\n      super.connectedCallback();\n      this._connectToRegistry();\n      this._synchronizeGroupState();\n    }\n\n    public override disconnectedCallback(): void {\n      super.disconnectedCallback();\n      this._disconnectFromRegistry();\n    }\n\n    /**\n     * Is called whenever the form is being reset.\n     * @internal\n     */\n    public override formResetCallback(): void {\n      this.checked = this.hasAttribute('checked');\n    }\n\n    /**\n     *  Called when the browser is trying to restore element’s state to state in which case\n     *  reason is \"restore\", or when the browser is trying to fulfill autofill on behalf of\n     *  user in which case reason is \"autocomplete\".\n     * @internal\n     */\n    public override formStateRestoreCallback(\n      state: FormRestoreState | null,\n      _reason: FormRestoreReason,\n    ): void {\n      if (typeof state === 'string' || state == null) {\n        this.checked = state === this.value;\n      } else if (state instanceof FormData) {\n        this._readFormData(state).then((data) => {\n          this.checked = data === this.value;\n        });\n      }\n    }\n\n    private async _readFormData(formData: FormData): Promise<unknown> {\n      const data = formData.get(this.name);\n      return data instanceof Blob ? JSON.parse(await data.text()) : data;\n    }\n\n    protected override willUpdate(changedProperties: PropertyValues<this>): void {\n      super.willUpdate(changedProperties);\n\n      if (changedProperties.has('disabled')) {\n        this.updateFocusableRadios();\n      }\n    }\n\n    protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n      super.firstUpdated(changedProperties);\n      this.updateFocusableRadios();\n    }\n\n    /**\n     * Called on `value` change\n     * If 'checked', update the value. Otherwise, do nothing.\n     */\n    protected override updateFormValue(): void {\n      if (this.checked) {\n        super.updateFormValue();\n      } else {\n        this.internals.setFormValue(null);\n      }\n    }\n\n    protected override shouldValidate(name: PropertyKey | undefined): boolean {\n      return super.shouldValidate(name) || name === 'checked' || name === 'required';\n    }\n\n    /**\n     * Sets the validity of all associated radio buttons.\n     * If any radio button is required, all associated are required as well.\n     */\n    protected override validate(): void {\n      super.validate();\n      if (!this.associatedRadioButtons) {\n        return;\n      }\n\n      let required = false;\n      let checked = false;\n      for (const radio of this.associatedRadioButtons) {\n        required ||= radio.required;\n        checked ||= radio.checked;\n      }\n\n      if (required && !checked) {\n        this.associatedRadioButtons.forEach((r) =>\n          r.setValidityFlag(\n            'valueMissing',\n            i18nSelectionRequired[this._languageController.current],\n          ),\n        );\n      } else {\n        this.associatedRadioButtons.forEach((r) => r.removeValidityFlag('valueMissing'));\n      }\n    }\n\n    /**\n     * Only a single radio should be focusable in the group. Defined as:\n     * - the checked radio;\n     * - the first non-disabled radio in DOM order;\n     */\n    protected updateFocusableRadios(): void {\n      if (!this.hasUpdated) {\n        return;\n      }\n      const radios = this._interactableGroupedRadios();\n      const checkedIndex = radios.findIndex((r) => r.checked && !r.disabled && !r.formDisabled);\n      const focusableIndex =\n        checkedIndex !== -1\n          ? checkedIndex\n          : radios.findIndex((r) => !r.disabled && !r.formDisabled); // Get the first focusable radio\n\n      if (focusableIndex !== -1) {\n        radios[focusableIndex].tabIndex = 0;\n        radios.splice(focusableIndex, 1);\n      }\n\n      // Reset tabIndex on other radios\n      radios.forEach((r) => r.removeAttribute('tabindex'));\n    }\n\n    protected async navigateByKeyboard(next: SbbFormAssociatedRadioButtonElement): Promise<void> {\n      next.checked = true;\n      this.emitChangeEvents();\n\n      await next.updateComplete;\n      next.focus();\n    }\n\n    protected emitChangeEvents(): void {\n      // Manually dispatch events to simulate a user interaction\n      this.dispatchEvent(\n        new InputEvent('input', { bubbles: true, cancelable: true, composed: true }),\n      );\n      this.dispatchEvent(new Event('change', { bubbles: true }));\n    }\n\n    private _synchronizeGroupState(): void {\n      if (this.checked) {\n        this._deselectGroupedRadios();\n      }\n      this.updateFocusableRadios();\n    }\n\n    /**\n     * Add `this` to the radioButton registry\n     */\n    private _connectToRegistry(): void {\n      if (!this.name || isServer) {\n        return;\n      }\n      const root = this.form ?? this.getRootNode();\n      this._radioButtonGroupsMap = radioButtonRegistry.get(root);\n\n      // Initialize the 'root' map entry\n      if (!this._radioButtonGroupsMap) {\n        this._radioButtonGroupsMap = new Map();\n        radioButtonRegistry.set(root, this._radioButtonGroupsMap);\n      }\n\n      this.associatedRadioButtons = this._radioButtonGroupsMap.get(\n        this.name,\n      ) as unknown as Set<SbbFormAssociatedRadioButtonElement>;\n\n      // Initialize the group set\n      if (!this.associatedRadioButtons) {\n        this.associatedRadioButtons = new Set();\n        this._radioButtonGroupsMap.set(\n          this.name,\n          this.associatedRadioButtons as unknown as Set<SbbFormAssociatedRadioButtonMixinType>,\n        );\n      }\n\n      // Insert the new radio into the set and sort following the DOM order.\n      // Since the order of a 'Set' is the insert order, we have to empty it and re-insert radios in order\n      const entries = Array.from(this.associatedRadioButtons);\n      this.associatedRadioButtons.clear();\n\n      // Find `this` position and insert it\n      const index = entries.findIndex(\n        (r) => this.compareDocumentPosition(r) & Node.DOCUMENT_POSITION_FOLLOWING,\n      );\n      if (index !== -1) {\n        entries.splice(index, 0, this);\n      } else {\n        entries.push(this);\n      }\n\n      // Repopulate the Set\n      entries.forEach((r) => this.associatedRadioButtons!.add(r));\n\n      this.validate();\n    }\n\n    /**\n     * Remove `this` from the radioButton registry and, if the group is empty, delete the entry from the groups Map\n     */\n    private _disconnectFromRegistry(): void {\n      this.associatedRadioButtons?.delete(this);\n\n      if (this.associatedRadioButtons?.size === 0) {\n        this._radioButtonGroupsMap?.delete(this.name);\n      } else {\n        this.validate();\n      }\n\n      this.associatedRadioButtons = undefined;\n      this._radioButtonGroupsMap = undefined;\n    }\n\n    /**\n     * Return a list of 'interactable' grouped radios, ordered in DOM order\n     */\n    private _interactableGroupedRadios(): SbbFormAssociatedRadioButtonElement[] {\n      return Array.from(this.associatedRadioButtons ?? []).filter((el) =>\n        interactivityChecker.isVisible(el),\n      );\n    }\n\n    /**\n     * Deselect other radio of the same group\n     */\n    private _deselectGroupedRadios(): void {\n      Array.from(this.associatedRadioButtons ?? [])\n        .filter((r) => r !== this)\n        .forEach((r) => (r.checked = false));\n    }\n\n    private async _handleArrowKeyDown(evt: KeyboardEvent): Promise<void> {\n      if (!isArrowKeyPressed(evt)) {\n        return;\n      }\n      evt.preventDefault();\n\n      const enabledRadios = this._interactableGroupedRadios().filter(\n        (r) => !r.disabled && !r.formDisabled,\n      );\n      const current: number = enabledRadios.indexOf(this);\n      const nextIndex: number = getNextElementIndex(evt, current, enabledRadios.length);\n\n      await this.navigateByKeyboard(enabledRadios[nextIndex]);\n    }\n  }\n\n  return SbbFormAssociatedRadioButtonElement as unknown as AbstractConstructor<SbbFormAssociatedRadioButtonMixinType> &\n    T;\n};\n"],"names":[],"mappings":"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"}