@sbb-esta/lyne-elements-dev 0.0.0 → 4.0.0-dev.1775551720

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

@@ -0,0 +1,294 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { property, state } from "lit/decorators.js";
+import { isWebkit } from "../dom.js";
+//#region src/elements/core/mixins/form-associated-mixin.ts
+var validityKeys = {
+	badInput: false,
+	customError: false,
+	patternMismatch: false,
+	rangeOverflow: false,
+	rangeUnderflow: false,
+	stepMismatch: false,
+	tooLong: false,
+	tooShort: false,
+	typeMismatch: false,
+	valueMissing: false
+};
+if (typeof ValidityState === "undefined") {
+	const validityClass = class ValidityState {
+		get valid() {
+			return true;
+		}
+		constructor() {
+			throw new TypeError("Illegal constructor");
+		}
+	};
+	Object.entries(validityKeys).forEach(([key, value]) => Object.assign(validityClass.prototype, { get [key]() {
+		return value;
+	} }));
+	globalThis.ValidityState = validityClass;
+}
+/**
+* The FormAssociatedMixin enables native form support for custom controls.
+*/
+var SbbFormAssociatedMixin = (superClass) => {
+	return (() => {
+		let _classSuper = superClass;
+		let _instanceExtraInitializers = [];
+		let _set_name_decorators;
+		let _formDisabled_decorators;
+		let _formDisabled_initializers = [];
+		let _formDisabled_extraInitializers = [];
+		return class SbbFormAssociatedElement extends _classSuper {
+			static {
+				const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+				_set_name_decorators = [property()];
+				_formDisabled_decorators = [state()];
+				__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);
+				__esDecorate(this, null, _formDisabled_decorators, {
+					kind: "accessor",
+					name: "formDisabled",
+					static: false,
+					private: false,
+					access: {
+						has: (obj) => "formDisabled" in obj,
+						get: (obj) => obj.formDisabled,
+						set: (obj, value) => {
+							obj.formDisabled = value;
+						}
+					},
+					metadata: _metadata
+				}, _formDisabled_initializers, _formDisabled_extraInitializers);
+				if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+					enumerable: true,
+					configurable: true,
+					writable: true,
+					value: _metadata
+				});
+			}
+			static {
+				this.formAssociated = true;
+			}
+			/**
+			* Returns the form owner of this element.
+			*/
+			get form() {
+				return this.internals.form;
+			}
+			/**
+			* Name of the form element. Will be read from name attribute.
+			*
+			* @description Developer note: In this case updating the attribute must be synchronous.
+			* Due to this it is implemented as a getter/setter and the attributeChangedCallback() handles the diff check.
+			*/
+			set name(name) {
+				this.setAttribute("name", `${name}`);
+				this.updateFormValue();
+			}
+			get name() {
+				return this.getAttribute("name") ?? "";
+			}
+			/** @internal */
+			get type() {
+				return this.localName;
+			}
+			/**
+			* Returns the ValidityState object for this element.
+			*/
+			get validity() {
+				return this.internals.validity;
+			}
+			/**
+			* Returns the current error message, if available, which corresponds
+			* to the current validation state.
+			* Please note that only one message is returned at a time (e.g. if
+			* multiple validity states are invalid, only the chronologically first one
+			* is returned until it is fixed, at which point the next message might be
+			* returned, if it is still applicable). Also, a custom validity message
+			* (see below) has precedence over native validation messages.
+			*/
+			get validationMessage() {
+				return this.internals.validationMessage;
+			}
+			/**
+			* Returns true if this element will be validated
+			* when the form is submitted; false otherwise.
+			*/
+			get willValidate() {
+				return this.internals.willValidate;
+			}
+			#formDisabled_accessor_storage;
+			/** Whenever a surrounding form or fieldset is changing its disabled state. */
+			get formDisabled() {
+				return this.#formDisabled_accessor_storage;
+			}
+			set formDisabled(value) {
+				this.#formDisabled_accessor_storage = value;
+			}
+			constructor(...args) {
+				super(...args);
+				this._validityStates = (__runInitializers(this, _instanceExtraInitializers), /* @__PURE__ */ new Map());
+				this.#formDisabled_accessor_storage = __runInitializers(this, _formDisabled_initializers, false);
+				__runInitializers(this, _formDisabled_extraInitializers);
+				this.addEventListener?.("invalid", (e) => e.preventDefault());
+			}
+			attributeChangedCallback(name, old, value) {
+				if (name !== "name" || old !== value) super.attributeChangedCallback(name, old, value);
+			}
+			/**
+			* Returns true if this element has no validity problems; false otherwise.
+			* Fires an invalid event at the element in the latter case.
+			*/
+			checkValidity() {
+				return this.internals.checkValidity();
+			}
+			/**
+			* Returns true if this element has no validity problems; otherwise,
+			* returns false, fires an invalid event at the element,
+			* and (if the event isn't canceled) reports the problem to the user.
+			*/
+			reportValidity() {
+				return this.internals.reportValidity();
+			}
+			/**
+			* Sets the custom validity message for this element. Use the empty string
+			* to indicate that the element does not have a custom validity error.
+			*/
+			setCustomValidity(message) {
+				if (message) this.setValidityFlag("customError", message);
+				else this.removeValidityFlag("customError");
+			}
+			/**
+			* Is called whenever a surrounding fieldset changes disabled state.
+			*
+			* @internal
+			*/
+			formDisabledCallback(_disabled) {
+				this.formDisabled = this._hasDisabledAncestor();
+			}
+			_hasDisabledAncestor() {
+				let element = this.parentElement;
+				while (element) {
+					if (element.localName === "fieldset" && element.hasAttribute("disabled")) return true;
+					element = element.parentElement;
+				}
+				return false;
+			}
+			requestUpdate(name, oldValue, options) {
+				super.requestUpdate(name, oldValue, options);
+				if (name === "value") this.updateFormValue();
+				if (this.hasUpdated && this.shouldValidate(name)) this.validate();
+			}
+			firstUpdated(changedProperties) {
+				super.firstUpdated(changedProperties);
+				this.validate();
+			}
+			/**
+			* Should be called when form value is changed.
+			* Adapts and sets the formValue in the supported format (string | FormData | File | null)
+			* https://developer.mozilla.org/en-US/docs/Web/API/ElementInternals/setFormValue
+			*/
+			updateFormValue() {
+				let formValue;
+				const name = this.name ?? this.getAttribute("name");
+				if (typeof this.value === "string" || this.value == null) formValue = this.value;
+				else if (Array.isArray(this.value)) {
+					formValue = new FormData();
+					this.value.forEach((el) => {
+						formValue.append(name, typeof el === "string" ? el : new Blob([JSON.stringify(el)], { type: "application/json" }));
+					});
+				} else {
+					formValue = new FormData();
+					formValue.append(name, new Blob([JSON.stringify(this.value)], { type: "application/json" }));
+				}
+				this.internals.setFormValue(formValue, this.formState?.());
+			}
+			/**
+			* Marks this element as suffering from the constraint indicated by the
+			* flag argument and associates the given message to it.
+			* Note that only one message is displayed at a time and custom messages by
+			* consumers are always displayed before internal messages and internal
+			* messages are displayed in the order they were added.
+			* To set/define custom validity state flags, you need to extend the
+			* ValidityState prototype (and the CustomValidityState interface).
+			*
+			* @example
+			*
+			*   // The type of the custom validity state does not need to be boolean.
+			*   Object.assign(ValidityState.prototype, {
+			*     get myError(): boolean {
+			*       return false;
+			*     },
+			*   });
+			*
+			*   declare global {
+			*     interface CustomValidityState {
+			*       myError: boolean;
+			*     }
+			*   }
+			*/
+			setValidityFlag(flag, message, flagValue) {
+				flagValue ??= true;
+				const validityState = this._validityStates.get(flag);
+				if (!validityState || validityState.message !== message || validityState.flagValue !== flagValue) {
+					this._validityStates.set(flag, {
+						flagValue,
+						message
+					});
+					this._setInternalValidity();
+				}
+			}
+			/** Removes the validity state flag entry and updates validity state. */
+			removeValidityFlag(flag) {
+				if (this._validityStates.has(flag)) {
+					this._validityStates.delete(flag);
+					this._setInternalValidity();
+				}
+			}
+			/** To be called whenever the current element needs to be validated. */
+			validate() {}
+			/** Whether validation should be run on a property change with the given name. */
+			shouldValidate(name) {
+				return !name;
+			}
+			_setInternalValidity() {
+				let outputMessage = this._validityStates.get("customError")?.message;
+				const flags = {};
+				this._validityStates.forEach(({ flagValue, message }, flag) => {
+					flags[flag] = flagValue;
+					outputMessage ||= message;
+				});
+				const customFlags = Object.keys(ValidityState.prototype).filter((f) => !(f in validityKeys) && f !== "valid");
+				for (const flag of customFlags) {
+					const value = flag in flags ? flags[flag] : false;
+					Object.defineProperty(this.internals.validity, flag, {
+						value,
+						configurable: true
+					});
+					if (value) flags.customError = true;
+				}
+				this.internals.setValidity(flags, outputMessage);
+				if (isWebkit) Object.defineProperty(this.internals.validity, "customError", {
+					value: this._validityStates.has("customError") || !!flags.customError,
+					configurable: true
+				});
+			}
+		};
+	})();
+};
+//#endregion
+export { SbbFormAssociatedMixin };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"form-associated-mixin.js","names":[],"sources":["../../../../../src/elements/core/mixins/form-associated-mixin.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-empty-object-type */\nimport type { LitElement, PropertyDeclaration, PropertyValues } from 'lit';\nimport { property, state } from 'lit/decorators.js';\n\nimport { isWebkit } from '../dom.ts';\n\nimport type { AbstractConstructor } from './constructor.ts';\nimport type { SbbElementInternalsMixinType } from './element-internals-mixin.ts';\n\ndeclare global {\n  /**\n   * Defines custom validity state properties.\n   */\n  interface CustomValidityState {}\n  interface ValidityState extends CustomValidityState {}\n  interface ValidityStateFlags extends Partial<CustomValidityState> {}\n}\n\nconst validityKeys: Required<Omit<ValidityStateFlags, keyof CustomValidityState>> = {\n  badInput: false,\n  customError: false,\n  patternMismatch: false,\n  rangeOverflow: false,\n  rangeUnderflow: false,\n  stepMismatch: false,\n  tooLong: false,\n  tooShort: false,\n  typeMismatch: false,\n  valueMissing: false,\n};\n// We need ValidityState in the global context, as we check the prototype for\n// extensions. In environments where that is not the case (e.g. Node.js) we\n// patch it with a minimal shim.\nif (typeof ValidityState === 'undefined') {\n  const validityClass = class ValidityState {\n    public get valid(): boolean {\n      return true;\n    }\n    private constructor() {\n      throw new TypeError('Illegal constructor');\n    }\n  };\n  Object.entries(validityKeys).forEach(([key, value]) =>\n    Object.assign(validityClass.prototype, {\n      get [key](): boolean {\n        return value;\n      },\n    }),\n  );\n  globalThis.ValidityState = validityClass as unknown as typeof ValidityState;\n}\n\nexport declare abstract class SbbFormAssociatedMixinType {\n  public get form(): HTMLFormElement | null;\n  public accessor name: string;\n  public get type(): string;\n\n  public abstract accessor value: unknown;\n\n  public get validity(): ValidityState;\n  public get validationMessage(): string;\n  public get willValidate(): boolean;\n\n  protected formDisabled: boolean;\n\n  public checkValidity(): boolean;\n  public reportValidity(): boolean;\n  public setCustomValidity(message: string): void;\n\n  public formAssociatedCallback?(form: HTMLFormElement | null): void;\n  public formDisabledCallback(disabled: boolean): void;\n  public abstract formResetCallback(): void;\n  public abstract formStateRestoreCallback(\n    state: FormRestoreState | null,\n    reason: FormRestoreReason,\n  ): void;\n\n  protected updateFormValue(): void;\n  protected formState?(): FormRestoreState;\n  protected setValidityFlag<T extends keyof ValidityStateFlags>(\n    flag: T,\n    message: string,\n    flagValue?: ValidityStateFlags[T],\n  ): void;\n  protected removeValidityFlag<T extends keyof ValidityStateFlags>(flag: T): void;\n  protected validate(): void;\n  protected shouldValidate(name: PropertyKey | undefined): boolean;\n}\n\n/**\n * The FormAssociatedMixin enables native form support for custom controls.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbFormAssociatedMixin = <\n  T extends AbstractConstructor<LitElement & SbbElementInternalsMixinType>,\n>(\n  superClass: T,\n): AbstractConstructor<SbbFormAssociatedMixinType> & T => {\n  abstract class SbbFormAssociatedElement\n    extends superClass\n    implements Partial<SbbFormAssociatedMixinType>\n  {\n    public static formAssociated = true;\n\n    public abstract accessor value: unknown;\n\n    /**\n     * Returns the form owner of this element.\n     */\n    public get form(): HTMLFormElement | null {\n      return this.internals.form;\n    }\n\n    /**\n     * Name of the form element. Will be read from name attribute.\n     *\n     * @description Developer note: In this case updating the attribute must be synchronous.\n     * Due to this it is implemented as a getter/setter and the attributeChangedCallback() handles the diff check.\n     */\n    @property()\n    public set name(name: string) {\n      this.setAttribute('name', `${name}`);\n\n      // For `FormData` values, we have to manually update the fieldName key\n      this.updateFormValue();\n    }\n    public get name(): string {\n      return this.getAttribute('name') ?? '';\n    }\n\n    /** @internal */\n    public get type(): string {\n      return this.localName;\n    }\n\n    /**\n     * Returns the ValidityState object for this element.\n     */\n    public get validity(): ValidityState {\n      return this.internals.validity;\n    }\n\n    /**\n     * Returns the current error message, if available, which corresponds\n     * to the current validation state.\n     * Please note that only one message is returned at a time (e.g. if\n     * multiple validity states are invalid, only the chronologically first one\n     * is returned until it is fixed, at which point the next message might be\n     * returned, if it is still applicable). Also, a custom validity message\n     * (see below) has precedence over native validation messages.\n     */\n    public get validationMessage(): string {\n      return this.internals.validationMessage;\n    }\n\n    /**\n     * Returns true if this element will be validated\n     * when the form is submitted; false otherwise.\n     */\n    public get willValidate(): boolean {\n      return this.internals.willValidate;\n    }\n\n    private _validityStates = new Map<\n      keyof ValidityStateFlags,\n      { flagValue: unknown; message: string }\n    >();\n\n    /** Whenever a surrounding form or fieldset is changing its disabled state. */\n    @state() protected accessor formDisabled: boolean = false;\n\n    public constructor(...args: any[]) {\n      super(...args);\n      // We want to prevent the native browser validation message popover\n      // to be shown. This also prevents a bug in WebKit, which would not\n      // allow host as the validity anchor: https://bugs.webkit.org/show_bug.cgi?id=269832\n      this.addEventListener?.('invalid', (e) => e.preventDefault());\n    }\n\n    public override attributeChangedCallback(\n      name: string,\n      old: string | null,\n      value: string | null,\n    ): void {\n      if (name !== 'name' || old !== value) {\n        super.attributeChangedCallback(name, old, value);\n      }\n    }\n\n    /**\n     * Returns true if this element has no validity problems; false otherwise.\n     * Fires an invalid event at the element in the latter case.\n     */\n    public checkValidity(): boolean {\n      return this.internals.checkValidity();\n    }\n\n    /**\n     * Returns true if this element has no validity problems; otherwise,\n     * returns false, fires an invalid event at the element,\n     * and (if the event isn't canceled) reports the problem to the user.\n     */\n    public reportValidity(): boolean {\n      return this.internals.reportValidity();\n    }\n\n    /**\n     * Sets the custom validity message for this element. Use the empty string\n     * to indicate that the element does not have a custom validity error.\n     */\n    public setCustomValidity(message: string): void {\n      if (message) {\n        this.setValidityFlag('customError', message);\n      } else {\n        this.removeValidityFlag('customError');\n      }\n    }\n\n    /**\n     * Called when the associated form element changes.\n     * ElementInternals.form returns the associated from element.\n     *\n     * @internal\n     */\n    public formAssociatedCallback?(form: HTMLFormElement | null): void;\n\n    /**\n     * Is called whenever a surrounding fieldset changes disabled state.\n     *\n     * @internal\n     */\n    public formDisabledCallback(_disabled: boolean): void {\n      this.formDisabled = this._hasDisabledAncestor();\n    }\n\n    private _hasDisabledAncestor(): boolean {\n      // Check if any of the fieldset ancestors has the disabled attribute set.\n      let element: HTMLElement | null = this.parentElement;\n      while (element) {\n        if (element.localName === 'fieldset' && element.hasAttribute('disabled')) {\n          return true;\n        }\n        element = element.parentElement;\n      }\n      return false;\n    }\n\n    /**\n     * Is called whenever the form is being reset.\n     *\n     * @internal\n     */\n    public abstract formResetCallback(): void;\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     *  In the case of \"restore\", state is a string, File, or FormData object\n     *  previously set as the second argument to setFormValue.\n     *\n     * @internal\n     */\n    public abstract formStateRestoreCallback(\n      state: FormRestoreState | null,\n      reason: FormRestoreReason,\n    ): void;\n\n    public override requestUpdate(\n      name?: PropertyKey,\n      oldValue?: unknown,\n      options?: PropertyDeclaration,\n    ): void {\n      super.requestUpdate(name, oldValue, options);\n      if (name === 'value') {\n        this.updateFormValue();\n      }\n      if (this.hasUpdated && this.shouldValidate(name)) {\n        this.validate();\n      }\n    }\n\n    protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n      super.firstUpdated(changedProperties);\n      this.validate();\n    }\n\n    /**\n     * Should be called when form value is changed.\n     * Adapts and sets the formValue in the supported format (string | FormData | File | null)\n     * https://developer.mozilla.org/en-US/docs/Web/API/ElementInternals/setFormValue\n     */\n    protected updateFormValue(): void {\n      let formValue: FormData | string | null;\n      const name = this.name ?? this.getAttribute('name');\n\n      if (typeof this.value === 'string' || this.value == null) {\n        formValue = this.value as string | null;\n      } else if (Array.isArray(this.value)) {\n        formValue = new FormData();\n        this.value.forEach((el) => {\n          (formValue as FormData).append(\n            name,\n            typeof el === 'string'\n              ? el\n              : new Blob([JSON.stringify(el)], {\n                  type: 'application/json',\n                }),\n          );\n        });\n      } else {\n        formValue = new FormData();\n        formValue.append(\n          name,\n          new Blob([JSON.stringify(this.value)], {\n            type: 'application/json',\n          }),\n        );\n      }\n\n      // If the form state is undefined then form value will be copied to state.\n      this.internals.setFormValue(formValue, this.formState?.());\n    }\n\n    protected formState?(): FormRestoreState;\n\n    /**\n     * Marks this element as suffering from the constraint indicated by the\n     * flag argument and associates the given message to it.\n     * Note that only one message is displayed at a time and custom messages by\n     * consumers are always displayed before internal messages and internal\n     * messages are displayed in the order they were added.\n     * To set/define custom validity state flags, you need to extend the\n     * ValidityState prototype (and the CustomValidityState interface).\n     *\n     * @example\n     *\n     *   // The type of the custom validity state does not need to be boolean.\n     *   Object.assign(ValidityState.prototype, {\n     *     get myError(): boolean {\n     *       return false;\n     *     },\n     *   });\n     *\n     *   declare global {\n     *     interface CustomValidityState {\n     *       myError: boolean;\n     *     }\n     *   }\n     */\n    protected setValidityFlag<T extends keyof ValidityStateFlags>(\n      flag: T,\n      message: string,\n      flagValue?: ValidityStateFlags[T],\n    ): void {\n      flagValue ??= true;\n      const validityState = this._validityStates.get(flag);\n      if (\n        !validityState ||\n        validityState.message !== message ||\n        validityState.flagValue !== flagValue\n      ) {\n        this._validityStates.set(flag, { flagValue, message });\n        this._setInternalValidity();\n      }\n    }\n\n    /** Removes the validity state flag entry and updates validity state. */\n    protected removeValidityFlag<T extends keyof ValidityStateFlags>(flag: T): void {\n      if (this._validityStates.has(flag)) {\n        this._validityStates.delete(flag);\n        this._setInternalValidity();\n      }\n    }\n\n    /** To be called whenever the current element needs to be validated. */\n    protected validate(): void {}\n\n    /** Whether validation should be run on a property change with the given name. */\n    protected shouldValidate(name: PropertyKey | undefined): boolean {\n      return !name;\n    }\n\n    private _setInternalValidity(): void {\n      let outputMessage = this._validityStates.get('customError')?.message;\n      const flags: ValidityStateFlags = {};\n      this._validityStates.forEach(({ flagValue, message }, flag) => {\n        flags[flag] = flagValue as any;\n        outputMessage ||= message;\n      });\n\n      const customFlags = Object.keys(ValidityState.prototype).filter(\n        (f) => !(f in validityKeys) && f !== 'valid',\n      );\n      for (const flag of customFlags) {\n        const value = flag in flags ? flags[flag as keyof ValidityStateFlags] : false;\n        Object.defineProperty(this.internals.validity, flag, { value, configurable: true });\n        if (value) {\n          // If any custom errors are provided, we need to set customError to true,\n          // as this is the only custom error property browsers accept.\n          flags.customError = true;\n        }\n      }\n\n      this.internals.setValidity(flags, outputMessage);\n\n      // WebKit seems to always set customError to true, if any error is active.\n      // Due to this we patch the customError value manually.\n      if (isWebkit) {\n        Object.defineProperty(this.internals.validity, 'customError', {\n          value: this._validityStates.has('customError') || !!flags.customError,\n          configurable: true,\n        });\n      }\n    }\n  }\n  return SbbFormAssociatedElement as unknown as AbstractConstructor<SbbFormAssociatedMixinType> & T;\n};\n\n/**\n * A value to be restored for a component's form value. If a component's form\n * state is a `FormData` object, its entry list of name and values will be\n * provided.\n */\nexport type FormRestoreState = string | FormData | File;\n\n/**\n * The reason a form component is being restored for, either `'restore'` for\n * browser restoration or `'autocomplete'` for restoring user values.\n */\nexport type FormRestoreReason = 'restore' | 'autocomplete';\n"],"mappings":"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"}

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

@@ -0,0 +1,29 @@
+import { LitElement } from 'lit';
+import { AbstractConstructor } from './constructor.ts';
+import { SbbElementInternalsMixinType, SbbElementInternalsConstructor } from './element-internals-mixin.ts';
+import { FormRestoreReason, FormRestoreState } from './form-associated-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
+ */
+export declare const radioButtonRegistry: WeakMap<Node, Map<string, Set<SbbFormAssociatedRadioButtonMixinType>>>;
+declare const SbbFormAssociatedRadioButtonMixinType_base: AbstractConstructor<import('./disabled-mixin.ts').SbbDisabledMixinType> & AbstractConstructor<import('./required-mixin.ts').SbbRequiredMixinType> & AbstractConstructor<import('./form-associated-mixin.ts').SbbFormAssociatedMixinType> & AbstractConstructor<SbbElementInternalsMixinType> & typeof LitElement & SbbElementInternalsConstructor;
+export declare abstract class SbbFormAssociatedRadioButtonMixinType extends SbbFormAssociatedRadioButtonMixinType_base {
+    accessor checked: boolean;
+    protected associatedRadioButtons?: Set<SbbFormAssociatedRadioButtonMixinType>;
+    formResetCallback(): void;
+    formStateRestoreCallback(state: FormRestoreState | null, reason: FormRestoreReason): void;
+    protected updateFormValue(): void;
+    protected updateFocusableRadios(): void;
+    protected emitChangeEvents(): void;
+    protected navigateByKeyboard(radio: SbbFormAssociatedRadioButtonMixinType): Promise<void>;
+}
+/**
+ * The SbbFormAssociatedRadioButtonMixin enables native form support for radio controls.
+ */
+export declare const SbbFormAssociatedRadioButtonMixin: <T extends AbstractConstructor<LitElement>>(superClass: T) => AbstractConstructor<SbbFormAssociatedRadioButtonMixinType> & T;
+export {};
+//# sourceMappingURL=form-associated-radio-button-mixin.d.ts.map

package/development/core/mixins/form-associated-radio-button-mixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form-associated-radio-button-mixin.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/mixins/form-associated-radio-button-mixin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,UAAU,EAAuB,MAAM,KAAK,CAAC;AAOrE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAE5D,OAAO,EAEL,KAAK,4BAA4B,EACjC,KAAK,8BAA8B,EACpC,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EAEtB,MAAM,4BAA4B,CAAC;AAGpC;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,wEAG7B,CAAC;;AAEJ,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,qCAAsC,SAAQ,0CAE3E;IACC,SAAgB,OAAO,EAAE,OAAO,CAAC;IAEjC,SAAS,CAAC,sBAAsB,CAAC,EAAE,GAAG,CAAC,qCAAqC,CAAC,CAAC;IAEvE,iBAAiB,IAAI,IAAI;IACzB,wBAAwB,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI,EAAE,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAEhG,SAAS,CAAC,eAAe,IAAI,IAAI;IACjC,SAAS,CAAC,qBAAqB,IAAI,IAAI;IACvC,SAAS,CAAC,gBAAgB,IAAI,IAAI;IAClC,SAAS,CAAC,kBAAkB,CAAC,KAAK,EAAE,qCAAqC,GAAG,OAAO,CAAC,IAAI,CAAC;CAC1F;AAED;;GAEG;AAEH,eAAO,MAAM,iCAAiC,GAAI,CAAC,SAAS,mBAAmB,CAAC,UAAU,CAAC,EACzF,YAAY,CAAC,KACZ,mBAAmB,CAAC,qCAAqC,CAAC,GAAG,CA2T/D,CAAC"}