@sbb-esta/lyne-elements 4.7.0 → 4.8.1

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

@@ -1,286 +1,294 @@
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 import { __esDecorate, __runInitializers } from "tslib";
 import { property, state } from "lit/decorators.js";
 import { isWebkit } from "../dom.js";
-const validityKeys = {
-  badInput: false,
-  customError: false,
-  patternMismatch: false,
-  rangeOverflow: false,
-  rangeUnderflow: false,
-  stepMismatch: false,
-  tooLong: false,
-  tooShort: false,
-  typeMismatch: false,
-  valueMissing: false
+//#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;
+	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;
 }
-const SbbFormAssociatedMixin = (superClass) => {
-  let SbbFormAssociatedElement = (() => {
-    var _formDisabled_accessor_storage, _a;
-    let _classSuper = superClass;
-    let _instanceExtraInitializers = [];
-    let _set_name_decorators;
-    let _formDisabled_decorators;
-    let _formDisabled_initializers = [];
-    let _formDisabled_extraInitializers = [];
-    return _a = class extends _classSuper {
-      constructor(...args) {
-        super(...args);
-        __privateAdd(this, _formDisabled_accessor_storage);
-        this._validityStates = (__runInitializers(this, _instanceExtraInitializers), /* @__PURE__ */ new Map());
-        __privateSet(this, _formDisabled_accessor_storage, __runInitializers(this, _formDisabled_initializers, false));
-        __runInitializers(this, _formDisabled_extraInitializers);
-        this.addEventListener?.("invalid", (e) => e.preventDefault());
-      }
-      /**
-       * 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;
-      }
-      /** Whenever a surrounding form or fieldset is changing its disabled state. */
-      get formDisabled() {
-        return __privateGet(this, _formDisabled_accessor_storage);
-      }
-      set formDisabled(value) {
-        __privateSet(this, _formDisabled_accessor_storage, value);
-      }
-      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
-          });
-        }
-      }
-    }, _formDisabled_accessor_storage = new WeakMap(), (() => {
-      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-      _set_name_decorators = [property()];
-      _formDisabled_decorators = [state()];
-      __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);
-      __esDecorate(_a, 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(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-    })(), _a.formAssociated = true, _a;
-  })();
-  return SbbFormAssociatedElement;
-};
-export {
-  SbbFormAssociatedMixin
+/**
+* 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
+				});
+			}
+		};
+	})();
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"form-associated-mixin.js","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"],"names":[],"mappings":"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"}
+//#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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"}