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

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

@@ -1,167 +1,148 @@
-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";
-//#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;
-	})();
+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
 };
-//#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"}
+//# 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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"}