@sbb-esta/lyne-elements-dev 4.7.0-dev.1773648103 → 4.7.0-dev.1773648656

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

@@ -1,148 +1,167 @@
+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 { defaultConverter } from "lit";
 import { property } from "lit/decorators.js";
-import { SbbLanguageController } from "../controllers.js";
 import { hostAttributes } from "../decorators.js";
 import { preventScrollOnSpacebarPress } from "../eventing.js";
+import { SbbLanguageController } from "../controllers.js";
 import { i18nCheckboxRequired } from "../i18n.js";
-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 SbbFormAssociatedCheckboxMixin = (superClass) => {
-  const conditionalSuperClass = superClass["_$sbbElement$"] ? superClass : SbbElementInternalsMixin(superClass);
-  let SbbFormAssociatedCheckboxElement = (() => {
-    var _a;
-    let _classDecorators = [hostAttributes({
-      tabindex: "0"
-    })];
-    let _classDescriptor;
-    let _classExtraInitializers = [];
-    let _classThis;
-    let _classSuper = SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(conditionalSuperClass)));
-    let _instanceExtraInitializers = [];
-    let _set_checked_decorators;
-    _a = class extends _classSuper {
-      /** Whether the checkbox is checked. */
-      set checked(value) {
-        const attributeSetter = typeof value === "object" ? value.attribute : false;
-        if (attributeSetter) {
-          value = value.value;
-        }
-        if (this.hasUpdated && !attributeSetter) {
-          this._attributeMutationBlocked = true;
-        }
-        this._checked = Boolean(value);
-        this.updateFormValue();
-      }
-      get checked() {
-        return this._checked;
-      }
-      /**
-       * Form type of element.
-       * @default 'checkbox'
-       */
-      get type() {
-        return "checkbox";
-      }
-      constructor() {
-        super();
-        this._attributeMutationBlocked = (__runInitializers(this, _instanceExtraInitializers), false);
-        this._languageController = new SbbLanguageController(this);
-        this._checked = false;
-        this._handleKeyboardInteraction = (event) => {
-          if (event.key === " ") {
-            this._handleUserInteraction();
-          }
-        };
-        this._handleUserInteraction = () => {
-          if (this.disabled) {
-            return;
-          }
-          this.withUserInteraction?.();
-          this.checked = !this.checked;
-          this._attributeMutationBlocked = true;
-          this.dispatchEvent(new InputEvent("input", { composed: true, bubbles: true }));
-          this.dispatchEvent(new Event("change", { bubbles: true }));
-        };
-        this.addEventListener?.("click", this._handleUserInteraction);
-        this.addEventListener?.("keydown", preventScrollOnSpacebarPress);
-        this.addEventListener?.("keyup", this._handleKeyboardInteraction);
-      }
-      attributeChangedCallback(name, old, value) {
-        if (name !== "checked" || !this._attributeMutationBlocked) {
-          super.attributeChangedCallback(name, old, value);
-        }
-      }
-      /**
-       * Is called whenever the form is being reset.
-       *
-       * @internal
-       */
-      formResetCallback() {
-        this.checked = this.hasAttribute("checked");
-        this._attributeMutationBlocked = false;
-      }
-      /**
-       *  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".
-       *  In the case of "restore", state is a string, File, or FormData object
-       *  previously set as the second argument to setFormValue.
-       *
-       * @internal
-       */
-      formStateRestoreCallback(state, _reason) {
-        if (state) {
-          this.checked = state === "true";
-        }
-      }
-      updateFormValue() {
-        if (this.checked) {
-          super.updateFormValue();
-        } else {
-          this.internals.setFormValue(null);
-        }
-      }
-      formState() {
-        return `${this.checked}`;
-      }
-      shouldValidate(name) {
-        return super.shouldValidate(name) || name === "checked" || name === "required";
-      }
-      validate() {
-        super.validate();
-        if (this.required && !this.checked) {
-          this.setValidityFlag("valueMissing", i18nCheckboxRequired[this._languageController.current]);
-        } else {
-          this.removeValidityFlag("valueMissing");
-        }
-      }
-    }, _classThis = _a, (() => {
-      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-      _set_checked_decorators = [property({
-        type: Boolean,
-        converter: {
-          ...defaultConverter,
-          // We need to pass information to the setter so that we know it was called by attribute change.
-          fromAttribute: (value, type) => {
-            const result = defaultConverter.fromAttribute?.(value, type);
-            return { value: result, attribute: true };
-          }
-        }
-      })];
-      __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(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-      _classThis = _classDescriptor.value;
-      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-    })(), _a.role = "checkbox", __runInitializers(_classThis, _classExtraInitializers), _a;
-    return _classThis;
-  })();
-  return SbbFormAssociatedCheckboxElement;
-};
-export {
-  SbbFormAssociatedCheckboxMixin
+//#region src/elements/core/mixins/form-associated-checkbox-mixin.ts
+/**
+* The FormAssociatedCheckboxMixin enables native form support for checkbox controls.
+*
+* Inherited classes MUST implement the ariaChecked state (ElementInternals) themselves.
+*/
+var SbbFormAssociatedCheckboxMixin = (superClass) => {
+	const conditionalSuperClass = superClass["_$sbbElement$"] ? superClass : SbbElementInternalsMixin(superClass);
+	return (() => {
+		let _classDecorators = [hostAttributes({ tabindex: "0" })];
+		let _classDescriptor;
+		let _classExtraInitializers = [];
+		let _classThis;
+		let _classSuper = SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(conditionalSuperClass)));
+		let _instanceExtraInitializers = [];
+		let _set_checked_decorators;
+		var SbbFormAssociatedCheckboxElement = class extends _classSuper {
+			static {
+				_classThis = this;
+			}
+			static {
+				const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+				_set_checked_decorators = [property({
+					type: Boolean,
+					converter: {
+						...defaultConverter,
+						fromAttribute: (value, type) => {
+							return {
+								value: defaultConverter.fromAttribute?.(value, type),
+								attribute: true
+							};
+						}
+					}
+				})];
+				__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(null, _classDescriptor = { value: _classThis }, _classDecorators, {
+					kind: "class",
+					name: _classThis.name,
+					metadata: _metadata
+				}, null, _classExtraInitializers);
+				SbbFormAssociatedCheckboxElement = _classThis = _classDescriptor.value;
+				if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, {
+					enumerable: true,
+					configurable: true,
+					writable: true,
+					value: _metadata
+				});
+			}
+			static {
+				this.role = "checkbox";
+			}
+			/** Whether the checkbox is checked. */
+			set checked(value) {
+				const attributeSetter = typeof value === "object" ? value.attribute : false;
+				if (attributeSetter) value = value.value;
+				if (this.hasUpdated && !attributeSetter) this._attributeMutationBlocked = true;
+				this._checked = Boolean(value);
+				this.updateFormValue();
+			}
+			get checked() {
+				return this._checked;
+			}
+			/**
+			* Form type of element.
+			* @default 'checkbox'
+			*/
+			get type() {
+				return "checkbox";
+			}
+			constructor() {
+				super();
+				this._attributeMutationBlocked = (__runInitializers(this, _instanceExtraInitializers), false);
+				this._languageController = new SbbLanguageController(this);
+				this._checked = false;
+				/** Method triggered on keyboard user interaction with checkbox. */
+				this._handleKeyboardInteraction = (event) => {
+					if (event.key === " ") this._handleUserInteraction();
+				};
+				/** Method triggered on user interaction with checkbox. */
+				this._handleUserInteraction = () => {
+					if (this.disabled) return;
+					this.withUserInteraction?.();
+					this.checked = !this.checked;
+					this._attributeMutationBlocked = true;
+					this.dispatchEvent(new InputEvent("input", {
+						composed: true,
+						bubbles: true
+					}));
+					this.dispatchEvent(new Event("change", { bubbles: true }));
+				};
+				this.addEventListener?.("click", this._handleUserInteraction);
+				this.addEventListener?.("keydown", preventScrollOnSpacebarPress);
+				this.addEventListener?.("keyup", this._handleKeyboardInteraction);
+			}
+			attributeChangedCallback(name, old, value) {
+				if (name !== "checked" || !this._attributeMutationBlocked) super.attributeChangedCallback(name, old, value);
+			}
+			/**
+			* Is called whenever the form is being reset.
+			*
+			* @internal
+			*/
+			formResetCallback() {
+				this.checked = this.hasAttribute("checked");
+				this._attributeMutationBlocked = false;
+			}
+			/**
+			*  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".
+			*  In the case of "restore", state is a string, File, or FormData object
+			*  previously set as the second argument to setFormValue.
+			*
+			* @internal
+			*/
+			formStateRestoreCallback(state, _reason) {
+				if (state) this.checked = state === "true";
+			}
+			updateFormValue() {
+				if (this.checked) super.updateFormValue();
+				else this.internals.setFormValue(null);
+			}
+			formState() {
+				return `${this.checked}`;
+			}
+			shouldValidate(name) {
+				return super.shouldValidate(name) || name === "checked" || name === "required";
+			}
+			validate() {
+				super.validate();
+				if (this.required && !this.checked) this.setValidityFlag("valueMissing", i18nCheckboxRequired[this._languageController.current]);
+				else this.removeValidityFlag("valueMissing");
+			}
+			static {
+				__runInitializers(_classThis, _classExtraInitializers);
+			}
+		};
+		return _classThis;
+	})();
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"form-associated-checkbox-mixin.js","sources":["../../../../../src/elements/core/mixins/form-associated-checkbox-mixin.ts"],"sourcesContent":["import { defaultConverter, type LitElement } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { SbbLanguageController } from '../controllers.ts';\nimport { hostAttributes } from '../decorators.ts';\nimport { preventScrollOnSpacebarPress } from '../eventing.ts';\nimport { i18nCheckboxRequired } 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  SbbFormAssociatedMixin,\n  type FormRestoreReason,\n  type FormRestoreState,\n} from './form-associated-mixin.ts';\nimport { SbbRequiredMixin } from './required-mixin.ts';\n\ninterface CheckedSetterValue {\n  value: boolean;\n  attribute: boolean;\n}\n\nexport declare abstract class SbbFormAssociatedCheckboxMixinType extends SbbDisabledMixin(\n  SbbRequiredMixin(SbbFormAssociatedMixin(SbbElementInternalsMixin(LitElement))),\n) {\n  public accessor checked: boolean;\n\n  public formResetCallback(): void;\n  public formStateRestoreCallback(state: FormRestoreState | null, reason: FormRestoreReason): void;\n\n  protected isRequiredExternally(): boolean;\n  protected withUserInteraction?(): void;\n  protected updateFormValue(): void;\n}\n\n/**\n * The FormAssociatedCheckboxMixin enables native form support for checkbox controls.\n *\n * Inherited classes MUST implement the ariaChecked state (ElementInternals) themselves.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbFormAssociatedCheckboxMixin = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbFormAssociatedCheckboxMixinType> & 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  @hostAttributes({\n    tabindex: '0',\n  })\n  abstract class SbbFormAssociatedCheckboxElement\n    extends SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(conditionalSuperClass)))\n    implements Partial<SbbFormAssociatedCheckboxMixinType>\n  {\n    public static override readonly role = 'checkbox';\n\n    private _attributeMutationBlocked = false;\n    private _languageController = new SbbLanguageController(this);\n\n    /** Whether the checkbox is checked. */\n    @property({\n      type: Boolean,\n      converter: {\n        ...defaultConverter,\n        // We need to pass information to the setter so that we know it was called by attribute change.\n        fromAttribute: (value: string | null, type?: unknown): CheckedSetterValue => {\n          const result = defaultConverter.fromAttribute?.(value, type);\n          return { value: result, attribute: true } as CheckedSetterValue;\n        },\n      },\n    })\n    public set checked(value: boolean) {\n      const attributeSetter =\n        typeof value === 'object' ? (value as unknown as CheckedSetterValue).attribute : false;\n      if (attributeSetter) {\n        value = (value as unknown as CheckedSetterValue).value;\n      }\n\n      // As soon as mutation was done not by setting attribute,\n      // we need to block syncing attribute.\n      if (this.hasUpdated && !attributeSetter) {\n        this._attributeMutationBlocked = true;\n      }\n      this._checked = Boolean(value);\n      this.updateFormValue();\n    }\n    public get checked(): boolean {\n      return this._checked;\n    }\n    private _checked: boolean = false;\n\n    /**\n     * Form type of element.\n     * @default 'checkbox'\n     */\n    public override get type(): string {\n      return 'checkbox';\n    }\n\n    protected constructor() {\n      super();\n      this.addEventListener?.('click', this._handleUserInteraction);\n      this.addEventListener?.('keydown', preventScrollOnSpacebarPress);\n      this.addEventListener?.('keyup', this._handleKeyboardInteraction);\n    }\n\n    public override attributeChangedCallback(\n      name: string,\n      old: string | null,\n      value: string | null,\n    ): void {\n      // Attribute should not be interpreted after programmatic or manual state change.\n      if (name !== 'checked' || !this._attributeMutationBlocked) {\n        super.attributeChangedCallback(name, old, value);\n      }\n    }\n\n    /**\n     * Is called whenever the form is being reset.\n     *\n     * @internal\n     */\n    public override formResetCallback(): void {\n      this.checked = this.hasAttribute('checked');\n      this._attributeMutationBlocked = false;\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     *  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 override formStateRestoreCallback(\n      state: FormRestoreState | null,\n      _reason: FormRestoreReason,\n    ): void {\n      if (state) {\n        this.checked = state === 'true';\n      }\n    }\n\n    /**\n     * Additional logic which is being executed when user\n     * interaction happens and state is not disabled.\n     */\n    protected withUserInteraction?(): void;\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 formState(): FormRestoreState {\n      return `${this.checked}`;\n    }\n\n    protected override shouldValidate(name: PropertyKey | undefined): boolean {\n      return super.shouldValidate(name) || name === 'checked' || name === 'required';\n    }\n\n    protected override validate(): void {\n      super.validate();\n      if (this.required && !this.checked) {\n        this.setValidityFlag(\n          'valueMissing',\n          i18nCheckboxRequired[this._languageController.current],\n        );\n      } else {\n        this.removeValidityFlag('valueMissing');\n      }\n    }\n\n    /** Method triggered on keyboard user interaction with checkbox. */\n    private _handleKeyboardInteraction = (event: KeyboardEvent): void => {\n      if (event.key === ' ') {\n        this._handleUserInteraction();\n      }\n    };\n\n    /** Method triggered on user interaction with checkbox. */\n    private _handleUserInteraction = (): void => {\n      if (this.disabled) {\n        return;\n      }\n      this.withUserInteraction?.();\n      this.checked = !this.checked;\n      this._attributeMutationBlocked = true;\n\n      this.dispatchEvent(new InputEvent('input', { composed: true, bubbles: true }));\n      this.dispatchEvent(new Event('change', { bubbles: true }));\n    };\n  }\n\n  return SbbFormAssociatedCheckboxElement as unknown as AbstractConstructor<SbbFormAssociatedCheckboxMixinType> &\n    T;\n};\n"],"names":[],"mappings":"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"}
+//#endregion
+export { SbbFormAssociatedCheckboxMixin };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"form-associated-checkbox-mixin.js","names":[],"sources":["../../../../../src/elements/core/mixins/form-associated-checkbox-mixin.ts"],"sourcesContent":["import { defaultConverter, type LitElement } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { SbbLanguageController } from '../controllers.ts';\nimport { hostAttributes } from '../decorators.ts';\nimport { preventScrollOnSpacebarPress } from '../eventing.ts';\nimport { i18nCheckboxRequired } 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  SbbFormAssociatedMixin,\n  type FormRestoreReason,\n  type FormRestoreState,\n} from './form-associated-mixin.ts';\nimport { SbbRequiredMixin } from './required-mixin.ts';\n\ninterface CheckedSetterValue {\n  value: boolean;\n  attribute: boolean;\n}\n\nexport declare abstract class SbbFormAssociatedCheckboxMixinType extends SbbDisabledMixin(\n  SbbRequiredMixin(SbbFormAssociatedMixin(SbbElementInternalsMixin(LitElement))),\n) {\n  public accessor checked: boolean;\n\n  public formResetCallback(): void;\n  public formStateRestoreCallback(state: FormRestoreState | null, reason: FormRestoreReason): void;\n\n  protected isRequiredExternally(): boolean;\n  protected withUserInteraction?(): void;\n  protected updateFormValue(): void;\n}\n\n/**\n * The FormAssociatedCheckboxMixin enables native form support for checkbox controls.\n *\n * Inherited classes MUST implement the ariaChecked state (ElementInternals) themselves.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbFormAssociatedCheckboxMixin = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbFormAssociatedCheckboxMixinType> & 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  @hostAttributes({\n    tabindex: '0',\n  })\n  abstract class SbbFormAssociatedCheckboxElement\n    extends SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(conditionalSuperClass)))\n    implements Partial<SbbFormAssociatedCheckboxMixinType>\n  {\n    public static override readonly role = 'checkbox';\n\n    private _attributeMutationBlocked = false;\n    private _languageController = new SbbLanguageController(this);\n\n    /** Whether the checkbox is checked. */\n    @property({\n      type: Boolean,\n      converter: {\n        ...defaultConverter,\n        // We need to pass information to the setter so that we know it was called by attribute change.\n        fromAttribute: (value: string | null, type?: unknown): CheckedSetterValue => {\n          const result = defaultConverter.fromAttribute?.(value, type);\n          return { value: result, attribute: true } as CheckedSetterValue;\n        },\n      },\n    })\n    public set checked(value: boolean) {\n      const attributeSetter =\n        typeof value === 'object' ? (value as unknown as CheckedSetterValue).attribute : false;\n      if (attributeSetter) {\n        value = (value as unknown as CheckedSetterValue).value;\n      }\n\n      // As soon as mutation was done not by setting attribute,\n      // we need to block syncing attribute.\n      if (this.hasUpdated && !attributeSetter) {\n        this._attributeMutationBlocked = true;\n      }\n      this._checked = Boolean(value);\n      this.updateFormValue();\n    }\n    public get checked(): boolean {\n      return this._checked;\n    }\n    private _checked: boolean = false;\n\n    /**\n     * Form type of element.\n     * @default 'checkbox'\n     */\n    public override get type(): string {\n      return 'checkbox';\n    }\n\n    protected constructor() {\n      super();\n      this.addEventListener?.('click', this._handleUserInteraction);\n      this.addEventListener?.('keydown', preventScrollOnSpacebarPress);\n      this.addEventListener?.('keyup', this._handleKeyboardInteraction);\n    }\n\n    public override attributeChangedCallback(\n      name: string,\n      old: string | null,\n      value: string | null,\n    ): void {\n      // Attribute should not be interpreted after programmatic or manual state change.\n      if (name !== 'checked' || !this._attributeMutationBlocked) {\n        super.attributeChangedCallback(name, old, value);\n      }\n    }\n\n    /**\n     * Is called whenever the form is being reset.\n     *\n     * @internal\n     */\n    public override formResetCallback(): void {\n      this.checked = this.hasAttribute('checked');\n      this._attributeMutationBlocked = false;\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     *  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 override formStateRestoreCallback(\n      state: FormRestoreState | null,\n      _reason: FormRestoreReason,\n    ): void {\n      if (state) {\n        this.checked = state === 'true';\n      }\n    }\n\n    /**\n     * Additional logic which is being executed when user\n     * interaction happens and state is not disabled.\n     */\n    protected withUserInteraction?(): void;\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 formState(): FormRestoreState {\n      return `${this.checked}`;\n    }\n\n    protected override shouldValidate(name: PropertyKey | undefined): boolean {\n      return super.shouldValidate(name) || name === 'checked' || name === 'required';\n    }\n\n    protected override validate(): void {\n      super.validate();\n      if (this.required && !this.checked) {\n        this.setValidityFlag(\n          'valueMissing',\n          i18nCheckboxRequired[this._languageController.current],\n        );\n      } else {\n        this.removeValidityFlag('valueMissing');\n      }\n    }\n\n    /** Method triggered on keyboard user interaction with checkbox. */\n    private _handleKeyboardInteraction = (event: KeyboardEvent): void => {\n      if (event.key === ' ') {\n        this._handleUserInteraction();\n      }\n    };\n\n    /** Method triggered on user interaction with checkbox. */\n    private _handleUserInteraction = (): void => {\n      if (this.disabled) {\n        return;\n      }\n      this.withUserInteraction?.();\n      this.checked = !this.checked;\n      this._attributeMutationBlocked = true;\n\n      this.dispatchEvent(new InputEvent('input', { composed: true, bubbles: true }));\n      this.dispatchEvent(new Event('change', { bubbles: true }));\n    };\n  }\n\n  return SbbFormAssociatedCheckboxElement as unknown as AbstractConstructor<SbbFormAssociatedCheckboxMixinType> &\n    T;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AA8CA,IAAa,kCACX,eAC+D;CAE/D,MAAM,wBAAyB,WAAkD,mBAC5E,aAGD,yBAAyB,WAAW;AA2JxC,eAtJ+C;0BAH9C,eAAe,EACd,UAAU,KACX,CAAC,CAAA;;;;oBAEQ,iBAAiB,iBAAiB,uBAAuB,sBAAsB,CAAC,CAAC;;;uDAAjF,YAAiF;;;;;;+BASxF,SAAS;KACR,MAAM;KACN,WAAW;MACT,GAAG;MAEH,gBAAgB,OAAsB,SAAsC;AAE1E,cAAO;QAAE,OADM,iBAAiB,gBAAgB,OAAO,KAAK;QACpC,WAAW;QAA4B;;;KAGpE,CAAC,CAAA;AACF,iBAAA,MAAA,MAAA,yBAAA;KAAA,MAAA;KAAA,MAAA;KAAA,QAAA;KAAA,SAAA;KAAA,QAAA;MAAA,MAAA,QAAA,aAAA;MAAA,MAAA,KAAA,UAAA;AAAA,WAAW,UAAO;;MAAA;KAAA,UAAA;KAAA,EAAA,MAAA,2BAAA;AArBpB,iBAAA,MAAA,mBAAA,EAAA,OAAA,YAAA,EAAA,kBAAA;KAAA,MAAA;KAAA,MAAA,WAAA;KAAA,UAAA;KAAA,EAAA,MAAA,wBAAA;;;;;;;;;;AAIkC,SAAA,OAAO;;;GAiBvC,IAAW,QAAQ,OAAc;IAC/B,MAAM,kBACJ,OAAO,UAAU,WAAY,MAAwC,YAAY;AACnF,QAAI,gBACF,SAAS,MAAwC;AAKnD,QAAI,KAAK,cAAc,CAAC,gBACtB,MAAK,4BAA4B;AAEnC,SAAK,WAAW,QAAQ,MAAM;AAC9B,SAAK,iBAAiB;;GAExB,IAAW,UAAO;AAChB,WAAO,KAAK;;;;;;GAQd,IAAoB,OAAI;AACtB,WAAO;;GAGT,cAAA;AACE,WAAO;AA5CD,SAAA,6BANK,kBAAA,MAAA,2BAAgC,EAMT;AAC5B,SAAA,sBAAsB,IAAI,sBAAsB,KAAK;AAgCrD,SAAA,WAAoB;;AA2FpB,SAAA,8BAA8B,UAA8B;AAClE,SAAI,MAAM,QAAQ,IAChB,MAAK,wBAAwB;;;AAKzB,SAAA,+BAAoC;AAC1C,SAAI,KAAK,SACP;AAEF,UAAK,uBAAuB;AAC5B,UAAK,UAAU,CAAC,KAAK;AACrB,UAAK,4BAA4B;AAEjC,UAAK,cAAc,IAAI,WAAW,SAAS;MAAE,UAAU;MAAM,SAAS;MAAM,CAAC,CAAC;AAC9E,UAAK,cAAc,IAAI,MAAM,UAAU,EAAE,SAAS,MAAM,CAAC,CAAC;;AA/F1D,SAAK,mBAAmB,SAAS,KAAK,uBAAuB;AAC7D,SAAK,mBAAmB,WAAW,6BAA6B;AAChE,SAAK,mBAAmB,SAAS,KAAK,2BAA2B;;GAGnD,yBACd,MACA,KACA,OAAoB;AAGpB,QAAI,SAAS,aAAa,CAAC,KAAK,0BAC9B,OAAM,yBAAyB,MAAM,KAAK,MAAM;;;;;;;GASpC,oBAAiB;AAC/B,SAAK,UAAU,KAAK,aAAa,UAAU;AAC3C,SAAK,4BAA4B;;;;;;;;;;;GAYnB,yBACd,OACA,SAA0B;AAE1B,QAAI,MACF,MAAK,UAAU,UAAU;;GAUV,kBAAe;AAChC,QAAI,KAAK,QACP,OAAM,iBAAiB;QAEvB,MAAK,UAAU,aAAa,KAAK;;GAIlB,YAAS;AAC1B,WAAO,GAAG,KAAK;;GAGE,eAAe,MAA6B;AAC7D,WAAO,MAAM,eAAe,KAAK,IAAI,SAAS,aAAa,SAAS;;GAGnD,WAAQ;AACzB,UAAM,UAAU;AAChB,QAAI,KAAK,YAAY,CAAC,KAAK,QACzB,MAAK,gBACH,gBACA,qBAAqB,KAAK,oBAAoB,SAC/C;QAED,MAAK,mBAAmB,eAAe;;;AA7H9B,sBAAA,YAAA,wBAAA"}