@sbb-esta/lyne-elements-dev 0.0.0 → 4.5.1-dev.1771859294

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

@@ -0,0 +1,319 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { isServer, html } from "lit";
+import { property, eventOptions } from "lit/decorators.js";
+import { sbbInputModalityDetector } from "../a11y.js";
+import { SbbLanguageController, SbbMediaQueryPointerCoarse } from "../controllers.js";
+import { isWebkit, isBlink } from "../dom.js";
+import { i18nInputRequired } from "../i18n.js";
+import { SbbDisabledMixin } from "./disabled-mixin.js";
+import { SbbElementInternalsMixin } from "./element-internals-mixin.js";
+import { SbbFormAssociatedMixin } from "./form-associated-mixin.js";
+import { SbbReadonlyMixin } from "./readonly-mixin.js";
+import { SbbRequiredMixin } from "./required-mixin.js";
+const checkPlaintextOnlySupport = () => {
+  if (isServer) {
+    return false;
+  }
+  const div = document.createElement("div");
+  div.setAttribute("contenteditable", "PLAINTEXT-ONLY");
+  return div.contentEditable === "plaintext-only";
+};
+const plaintextOnlySupported = checkPlaintextOnlySupport();
+const SbbFormAssociatedInputMixin = (superClass) => {
+  let SbbFormAssociatedInputElement = (() => {
+    var _a;
+    let _classSuper = SbbReadonlyMixin(SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(SbbElementInternalsMixin(superClass)))));
+    let _instanceExtraInitializers = [];
+    let _set_value_decorators;
+    let _set_placeholder_decorators;
+    let __cleanChildren_decorators;
+    return _a = class extends _classSuper {
+      /**
+       * Form type of element.
+       * @default 'text'
+       */
+      get type() {
+        return "text";
+      }
+      /**
+       * The value of the input. Reflects the current text value of this input.
+       */
+      set value(value) {
+        this._value = this._cleanText(value);
+        if (this.hasUpdated) {
+          this._assignValue(this._value);
+        }
+        this.dispatchEvent(new Event("displayvaluechange", { bubbles: true, composed: true }));
+      }
+      get value() {
+        return this._value ?? "";
+      }
+      set placeholder(value) {
+        if (value) {
+          this.setAttribute("placeholder", value);
+        } else {
+          this.removeAttribute("placeholder");
+        }
+        this.internals.ariaPlaceholder = value ? value : null;
+      }
+      get placeholder() {
+        return this.getAttribute("placeholder") ?? "";
+      }
+      constructor() {
+        super();
+        this._shouldEmitChange = (__runInitializers(this, _instanceExtraInitializers), false);
+        this._shouldTriggerSubmit = false;
+        this.language = new SbbLanguageController(this);
+        this._value = "";
+        this.addEventListener?.("input", () => {
+          const oldValue = this._value;
+          this._value = this._cleanText(this.textContent ?? "");
+          this.requestUpdate("value", oldValue);
+          this.internals.states.add("interacted");
+          this._shouldEmitChange = true;
+        }, { capture: true });
+        this.addEventListener?.("change", () => this._shouldEmitChange = false, { capture: true });
+        this.addEventListener?.("keydown", (event) => {
+          if (this._requiresEmptyPatch()) {
+            this._assignValue("");
+          }
+          if ((event.key === "Enter" || event.key === "\n") && event.isTrusted) {
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            this._shouldTriggerSubmit = this.dispatchEvent(new KeyboardEvent("keydown", event));
+          } else if (isWebkit && this.value && (event.key === "Backspace" || event.key === "Delete") && event.isTrusted) {
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            if (!this.dispatchEvent(new KeyboardEvent("keydown", event))) {
+              return;
+            }
+            const selectedRange = window.getSelection()?.getRangeAt(0);
+            if (!selectedRange) {
+              return;
+            }
+            if (selectedRange.startOffset !== selectedRange.endOffset) {
+              selectedRange.deleteContents();
+              this._dispatchInputEvent();
+            } else if (event.key === "Backspace" && selectedRange.startOffset > 0) {
+              selectedRange.setStart(selectedRange.startContainer, selectedRange.startOffset - 1);
+              selectedRange.deleteContents();
+              this._dispatchInputEvent();
+            } else if (event.key === "Delete" && selectedRange.endOffset < this.value.length) {
+              selectedRange.setEnd(selectedRange.endContainer, selectedRange.endOffset + 1);
+              selectedRange.deleteContents();
+              this._dispatchInputEvent();
+            }
+          }
+        }, { capture: true });
+        this.addEventListener?.("keyup", (event) => {
+          if (event.key === "Enter" || event.key === "\n") {
+            this._emitChangeIfNecessary();
+            if (this._shouldTriggerSubmit) {
+              this._shouldTriggerSubmit = false;
+              this.form?.requestSubmit();
+            }
+          } else if (this._requiresEmptyPatch()) {
+            this._setCursorAt(0);
+          }
+        }, { capture: true });
+        this.addEventListener?.("paste", (e) => {
+          e.preventDefault();
+          if (this._requiresEmptyPatch()) {
+            this._assignValue("");
+          }
+          const text = this._cleanText(e.clipboardData?.getData("text/plain") ?? "");
+          const selectedRange = window.getSelection()?.getRangeAt(0);
+          if (!selectedRange || !text) {
+            return;
+          }
+          selectedRange.deleteContents();
+          selectedRange.insertNode(document.createTextNode(this.preparePastedText(text)));
+          selectedRange.setStart(selectedRange.endContainer, selectedRange.endOffset);
+          this._dispatchInputEvent();
+        });
+        this.addEventListener?.("focus", () => {
+          if (sbbInputModalityDetector.mostRecentModality === "keyboard") {
+            window.getSelection()?.selectAllChildren(this);
+          }
+        });
+        this.addEventListener?.("touchend", () => {
+          if (this._requiresEmptyPatch()) {
+            this._assignValue("&nbsp;");
+            this._setCursorAt(0);
+          }
+        });
+        this.addEventListener?.("click", () => {
+          if (this._requiresEmptyPatch() && sbbInputModalityDetector.mostRecentModality === "touch") {
+            this._setCursorAt(0);
+          }
+        });
+        this.addEventListener?.("blur", () => {
+          window.getSelection()?.removeAllRanges();
+          if (this.value === "") {
+            this._assignValue("");
+          }
+          this._emitChangeIfNecessary();
+          this.scrollLeft = 0;
+        }, { capture: true });
+      }
+      isDisabledExternally() {
+        return this.formDisabled;
+      }
+      connectedCallback() {
+        super.connectedCallback();
+        this.internals.ariaMultiLine = "false";
+        this._updateContenteditable();
+        this._assignValue(this.value);
+      }
+      focus(options) {
+        super.focus(options);
+        if (this._canSelect()) {
+          const selection = window.getSelection();
+          if (!selection) {
+            return;
+          }
+          const range = selection.rangeCount > 0 ? selection.getRangeAt(0) : null;
+          if (range && range.startOffset !== 0) {
+            return;
+          }
+          this._setCursorAt(this.textContent.length);
+        }
+      }
+      attributeChangedCallback(name, old, value) {
+        if (name !== "value" || !this.internals.states.has("interacted")) {
+          super.attributeChangedCallback(name, old, value);
+        }
+      }
+      /**
+       * Is called whenever the form is being reset.
+       *
+       * @internal
+       */
+      formResetCallback() {
+        this.internals.states.delete("interacted");
+        this.value = this.getAttribute("value") ?? "";
+      }
+      /**
+       *  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 && typeof state === "string") {
+          this.value = state;
+        }
+      }
+      /**
+       * Makes the selection equal to the current object.
+       *
+       * @link https://developer.mozilla.org/docs/Web/API/HTMLInputElement/select
+       */
+      select() {
+        window.getSelection()?.selectAllChildren(this);
+      }
+      firstUpdated(changedProperties) {
+        super.firstUpdated(changedProperties);
+        if (this.value && !this.innerHTML.length) {
+          this._assignValue(this.value);
+        }
+      }
+      requestUpdate(name, oldValue, options) {
+        super.requestUpdate(name, oldValue, options);
+        if (this.isConnected && (name === "disabled" || name === "formDisabled" || name === "readOnly")) {
+          this._updateContenteditable();
+        }
+      }
+      shouldValidate(name) {
+        return super.shouldValidate(name) || name === "value" || name === "required";
+      }
+      validate() {
+        super.validate();
+        if (this.required && !this.value) {
+          this.setValidityFlag("valueMissing", i18nInputRequired[this.language.current]);
+        } else {
+          this.removeValidityFlag("valueMissing");
+        }
+      }
+      preparePastedText(text) {
+        return text;
+      }
+      _requiresEmptyPatch() {
+        return isServer ? false : isBlink && this.value === "" && window.matchMedia(SbbMediaQueryPointerCoarse).matches;
+      }
+      _assignValue(value) {
+        this.innerHTML = value;
+      }
+      _setCursorAt(position) {
+        const selection = window.getSelection();
+        if (!selection) {
+          return;
+        }
+        const range = document.createRange();
+        range.setStart(this.firstChild, position);
+        range.collapse(true);
+        selection.removeAllRanges();
+        selection.addRange(range);
+      }
+      _cleanText(value) {
+        return value === null ? "" : `${value}`.replace(/[\n\r]+/g, "");
+      }
+      _dispatchInputEvent() {
+        this.dispatchEvent(new InputEvent("input", { bubbles: true, composed: true }));
+      }
+      _cleanChildren() {
+        if (this.childElementCount) {
+          for (const element of this.children) {
+            element.remove();
+          }
+        }
+      }
+      _updateContenteditable() {
+        if (!isServer && this.isConnected) {
+          this.internals.ariaReadOnly = this.readOnly ? "true" : null;
+          this.internals.ariaDisabled = this.disabled ? "true" : null;
+          const value = this.disabled || this.readOnly ? "false" : plaintextOnlySupported ? "plaintext-only" : "true";
+          this.setAttribute("contenteditable", value);
+          if (this.readOnly) {
+            this.setAttribute("tabindex", "0");
+          } else {
+            this.removeAttribute("tabindex");
+          }
+        }
+      }
+      _emitChangeIfNecessary() {
+        if (this._shouldEmitChange) {
+          this._shouldEmitChange = false;
+          this.dispatchEvent(new Event("change", { bubbles: true }));
+        }
+      }
+      _canSelect() {
+        return !isServer && !this.disabled && !this.readOnly && !!this.value;
+      }
+      render() {
+        return html`<slot @slotchange=${this._cleanChildren}></slot>`;
+      }
+    }, (() => {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      _set_value_decorators = [property()];
+      _set_placeholder_decorators = [property({ attribute: false })];
+      __cleanChildren_decorators = [eventOptions({ passive: true })];
+      __esDecorate(_a, null, _set_value_decorators, { kind: "setter", name: "value", static: false, private: false, access: { has: (obj) => "value" in obj, set: (obj, value) => {
+        obj.value = value;
+      } }, metadata: _metadata }, null, _instanceExtraInitializers);
+      __esDecorate(_a, null, _set_placeholder_decorators, { kind: "setter", name: "placeholder", static: false, private: false, access: { has: (obj) => "placeholder" in obj, set: (obj, value) => {
+        obj.placeholder = value;
+      } }, metadata: _metadata }, null, _instanceExtraInitializers);
+      __esDecorate(_a, null, __cleanChildren_decorators, { kind: "method", name: "_cleanChildren", static: false, private: false, access: { has: (obj) => "_cleanChildren" in obj, get: (obj) => obj._cleanChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
+      if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+    })(), _a.role = "textbox", _a.formFieldAssociated = true, _a;
+  })();
+  return SbbFormAssociatedInputElement;
+};
+export {
+  SbbFormAssociatedInputMixin
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"form-associated-input-mixin.js","sources":["../../../../../src/elements/core/mixins/form-associated-input-mixin.ts"],"sourcesContent":["import {\n  html,\n  isServer,\n  type LitElement,\n  type PropertyDeclaration,\n  type PropertyValues,\n} from 'lit';\nimport { eventOptions, property } from 'lit/decorators.js';\n\nimport { sbbInputModalityDetector } from '../a11y.ts';\nimport { SbbLanguageController, SbbMediaQueryPointerCoarse } from '../controllers.ts';\nimport { isBlink, isWebkit } from '../dom.ts';\nimport { i18nInputRequired } from '../i18n.ts';\n\nimport type { AbstractConstructor } from './constructor.ts';\nimport { SbbDisabledMixin } from './disabled-mixin.ts';\nimport { SbbElementInternalsMixin } from './element-internals-mixin.ts';\nimport {\n  type FormRestoreReason,\n  type FormRestoreState,\n  SbbFormAssociatedMixin,\n} from './form-associated-mixin.ts';\nimport { SbbReadonlyMixin } from './readonly-mixin.ts';\nimport { SbbRequiredMixin } from './required-mixin.ts';\n\nexport declare abstract class SbbFormAssociatedInputMixinType extends SbbRequiredMixin(\n  SbbFormAssociatedMixin(SbbElementInternalsMixin(LitElement)),\n) {\n  public static readonly formFieldAssociated = true;\n\n  public set value(value: string);\n  public get value(): string;\n\n  public set disabled(value: boolean);\n  public get disabled(): boolean;\n\n  public set readOnly(value: boolean);\n  public get readOnly(): boolean;\n\n  public set placeholder(value: string);\n  public get placeholder(): string;\n\n  /**\n   * Makes the selection equal to the current object.\n   *\n   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/select)\n   */\n  public select(): void;\n\n  public formResetCallback(): void;\n  public formStateRestoreCallback(state: FormRestoreState | null, reason: FormRestoreReason): void;\n\n  protected preparePastedText(text: string): string;\n  protected language: SbbLanguageController;\n}\n\nconst checkPlaintextOnlySupport = (): boolean => {\n  if (isServer) {\n    return false;\n  }\n\n  const div = document.createElement('div');\n  div.setAttribute('contenteditable', 'PLAINTEXT-ONLY');\n\n  // If plaintext-only is supported, the attribute value is\n  // returned as lower-case from the property access.\n  return div.contentEditable === 'plaintext-only';\n};\nconst plaintextOnlySupported = checkPlaintextOnlySupport();\n\n/**\n * The SbbFormAssociatedInputMixin enables native form support for text input controls.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbFormAssociatedInputMixin = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbFormAssociatedInputMixinType> & T => {\n  abstract class SbbFormAssociatedInputElement\n    extends SbbReadonlyMixin(\n      SbbDisabledMixin(\n        SbbRequiredMixin(SbbFormAssociatedMixin(SbbElementInternalsMixin(superClass))),\n      ),\n    )\n    implements Partial<SbbFormAssociatedInputMixinType>\n  {\n    public static override readonly role = 'textbox';\n    public static readonly formFieldAssociated = true;\n\n    /**\n     * An element with contenteditable will not emit a change event. To achieve parity\n     * with a native text input, we need to track whether a change event should be\n     * emitted.\n     */\n    private _shouldEmitChange = false;\n    /**\n     * A native text input attempts to submit the form when pressing Enter.\n     * This can be prevented by calling preventDefault on the keydown event.\n     * We track whether to request submit, which should occur before the keyup\n     * event.\n     */\n    private _shouldTriggerSubmit = false;\n\n    protected language = new SbbLanguageController(this);\n\n    /**\n     * Form type of element.\n     * @default 'text'\n     */\n    public override get type(): string {\n      return 'text';\n    }\n\n    /**\n     * The value of the input. Reflects the current text value of this input.\n     */\n    @property()\n    public set value(value: string) {\n      this._value = this._cleanText(value);\n      if (this.hasUpdated) {\n        this._assignValue(this._value);\n      }\n      /** @internal */\n      this.dispatchEvent(new Event('displayvaluechange', { bubbles: true, composed: true }));\n    }\n    public get value(): string {\n      return this._value ?? '';\n    }\n    private _value: string = '';\n\n    @property({ attribute: false })\n    public set placeholder(value: string) {\n      if (value) {\n        this.setAttribute('placeholder', value);\n      } else {\n        this.removeAttribute('placeholder');\n      }\n      this.internals.ariaPlaceholder = value ? value : null;\n    }\n    public get placeholder(): string {\n      return this.getAttribute('placeholder') ?? '';\n    }\n\n    protected constructor() {\n      super();\n      // We primarily use capture event listeners, as we want\n      // our listeners to occur before consumer event listeners.\n      this.addEventListener?.(\n        'input',\n        () => {\n          const oldValue = this._value;\n          this._value = this._cleanText(this.textContent ?? '');\n          this.requestUpdate('value', oldValue);\n          this.internals.states.add('interacted');\n          this._shouldEmitChange = true;\n        },\n        { capture: true },\n      );\n      this.addEventListener?.('change', () => (this._shouldEmitChange = false), { capture: true });\n      this.addEventListener?.(\n        'keydown',\n        (event) => {\n          if (this._requiresEmptyPatch()) {\n            this._assignValue('');\n          }\n          // We prevent recursive events by checking the original event for isTrusted\n          // which is false for manually dispatched events (which we dispatch below).\n          if ((event.key === 'Enter' || event.key === '\\n') && event.isTrusted) {\n            event.preventDefault();\n            event.stopImmediatePropagation();\n            this._shouldTriggerSubmit = this.dispatchEvent(new KeyboardEvent('keydown', event));\n          } else if (\n            isWebkit &&\n            this.value &&\n            (event.key === 'Backspace' || event.key === 'Delete') &&\n            event.isTrusted\n          ) {\n            // In Webkit pressing Backspace or Delete completely removes all the content\n            // if contenteditable is set on a web component host.\n            // We have to replicate the normal delete behavior.\n            event.preventDefault();\n            event.stopImmediatePropagation();\n\n            if (!this.dispatchEvent(new KeyboardEvent('keydown', event))) {\n              return;\n            }\n\n            const selectedRange = window.getSelection()?.getRangeAt(0);\n            if (!selectedRange) {\n              return;\n            }\n\n            if (selectedRange.startOffset !== selectedRange.endOffset) {\n              // If a text range is selected, then delete this range\n              selectedRange.deleteContents();\n              this._dispatchInputEvent();\n            } else if (event.key === 'Backspace' && selectedRange.startOffset > 0) {\n              // When pressing Backspace, we select the previous character from\n              // the current cursor position and delete it.\n              selectedRange.setStart(selectedRange.startContainer, selectedRange.startOffset - 1);\n              selectedRange.deleteContents();\n              this._dispatchInputEvent();\n            } else if (event.key === 'Delete' && selectedRange.endOffset < this.value.length) {\n              // When pressing Delete, we select the next character from\n              // the current cursor position and delete it.\n              selectedRange.setEnd(selectedRange.endContainer, selectedRange.endOffset + 1);\n              selectedRange.deleteContents();\n              this._dispatchInputEvent();\n            }\n          }\n        },\n        { capture: true },\n      );\n      this.addEventListener?.(\n        'keyup',\n        (event) => {\n          if (event.key === 'Enter' || event.key === '\\n') {\n            this._emitChangeIfNecessary();\n            if (this._shouldTriggerSubmit) {\n              this._shouldTriggerSubmit = false;\n              this.form?.requestSubmit();\n            }\n          } else if (this._requiresEmptyPatch()) {\n            this._setCursorAt(0);\n          }\n        },\n        { capture: true },\n      );\n      // contenteditable allows pasting rich content into its host.\n      // We prevent this by listening to the paste event and\n      // extracting the plain text from the pasted content\n      // and inserting it into the selected range (cursor position\n      // or selection).\n      this.addEventListener?.('paste', (e) => {\n        e.preventDefault();\n        if (this._requiresEmptyPatch()) {\n          this._assignValue('');\n        }\n\n        const text = this._cleanText(e.clipboardData?.getData('text/plain') ?? '');\n        const selectedRange = window.getSelection()?.getRangeAt(0);\n        if (!selectedRange || !text) {\n          return;\n        }\n\n        selectedRange.deleteContents();\n        selectedRange.insertNode(document.createTextNode(this.preparePastedText(text)));\n        selectedRange.setStart(selectedRange.endContainer, selectedRange.endOffset);\n        this._dispatchInputEvent();\n      });\n      // When focusing a text input via keyboard, the text content should be selected.\n      this.addEventListener?.('focus', () => {\n        if (sbbInputModalityDetector.mostRecentModality === 'keyboard') {\n          // TODO: This does not seem to work in Firefox with readonly.\n          window.getSelection()?.selectAllChildren(this);\n        }\n      });\n      this.addEventListener?.('touchend', () => {\n        if (this._requiresEmptyPatch()) {\n          this._assignValue('&nbsp;');\n          this._setCursorAt(0);\n        }\n      });\n      this.addEventListener?.('click', () => {\n        if (this._requiresEmptyPatch() && sbbInputModalityDetector.mostRecentModality === 'touch') {\n          this._setCursorAt(0);\n        }\n      });\n\n      // On blur the native text input scrolls the text to the start of the text.\n      // We mimic that by resetting the scroll position.\n      // We also unset any selection to align with the native text input.\n      this.addEventListener?.(\n        'blur',\n        () => {\n          window.getSelection()?.removeAllRanges();\n          if (this.value === '') {\n            this._assignValue('');\n          }\n          this._emitChangeIfNecessary();\n          this.scrollLeft = 0;\n        },\n        { capture: true },\n      );\n    }\n\n    protected override isDisabledExternally(): boolean {\n      return this.formDisabled;\n    }\n\n    public override connectedCallback(): void {\n      super.connectedCallback();\n      this.internals.ariaMultiLine = 'false';\n      this._updateContenteditable();\n\n      // We want to replace any content by just the text content.\n      this._assignValue(this.value);\n    }\n\n    public override focus(options?: FocusOptions): void {\n      super.focus(options);\n      // By default, when calling focus on an input element, the cursor is placed\n      // at the end of the input text. However, with contenteditable, the cursor\n      // is placed at the beginning, so we move it to the end, if that is the case.\n      if (this._canSelect()) {\n        const selection = window.getSelection();\n        if (!selection) {\n          return;\n        }\n        const range = selection.rangeCount > 0 ? selection.getRangeAt(0) : null;\n        if (range && range.startOffset !== 0) {\n          return;\n        }\n\n        this._setCursorAt(this.textContent!.length);\n      }\n    }\n\n    public override attributeChangedCallback(\n      name: string,\n      old: string | null,\n      value: string | null,\n    ): void {\n      /**\n       * The native text input changes the value property when the value attribute is\n       * changed under the condition that no input event has occurred since creation\n       * or the last form reset.\n       */\n      if (name !== 'value' || !this.internals.states.has('interacted')) {\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.internals.states.delete('interacted');\n      this.value = this.getAttribute('value') ?? '';\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 && typeof state === 'string') {\n        this.value = state;\n      }\n    }\n\n    /**\n     * Makes the selection equal to the current object.\n     *\n     * @link https://developer.mozilla.org/docs/Web/API/HTMLInputElement/select\n     */\n    public select(): void {\n      window.getSelection()?.selectAllChildren(this);\n    }\n\n    protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n      super.firstUpdated(changedProperties);\n\n      // If the value was assigned before firstUpdate, we have to\n      // write it the document to be visually seen\n      if (this.value && !this.innerHTML.length) {\n        this._assignValue(this.value);\n      }\n    }\n\n    public override requestUpdate(\n      name?: PropertyKey,\n      oldValue?: unknown,\n      options?: PropertyDeclaration,\n    ): void {\n      super.requestUpdate(name, oldValue, options);\n      if (\n        this.isConnected &&\n        (name === 'disabled' || name === 'formDisabled' || name === 'readOnly')\n      ) {\n        this._updateContenteditable();\n      }\n    }\n\n    protected override shouldValidate(name: PropertyKey | undefined): boolean {\n      return super.shouldValidate(name) || name === 'value' || name === 'required';\n    }\n\n    protected override validate(): void {\n      super.validate();\n      if (this.required && !this.value) {\n        this.setValidityFlag('valueMissing', i18nInputRequired[this.language.current]);\n      } else {\n        this.removeValidityFlag('valueMissing');\n      }\n    }\n\n    protected preparePastedText(text: string): string {\n      return text;\n    }\n\n    private _requiresEmptyPatch(): boolean {\n      // In Blink, a contenteditable element with empty content will crash\n      // upon receiving focus, when in Mobile mode.\n      // To prevent this, we patch the empty state by inserting a non-breaking space.\n      return isServer\n        ? false\n        : isBlink && this.value === '' && window.matchMedia(SbbMediaQueryPointerCoarse).matches;\n    }\n\n    private _assignValue(value: string): void {\n      this.innerHTML = value;\n    }\n\n    private _setCursorAt(position: number): void {\n      const selection = window.getSelection();\n      if (!selection) {\n        return;\n      }\n\n      const range = document.createRange();\n      range.setStart(this.firstChild!, position);\n      range.collapse(true);\n      selection.removeAllRanges();\n      selection.addRange(range);\n    }\n\n    private _cleanText(value: string): string {\n      // The native text input removes all newline characters if passed to the value property\n      return value === null ? '' : `${value}`.replace(/[\\n\\r]+/g, '');\n    }\n\n    private _dispatchInputEvent(): void {\n      /** The input event fires when the value has been changed as a direct result of a user action. */\n      this.dispatchEvent(new InputEvent('input', { bubbles: true, composed: true }));\n    }\n\n    @eventOptions({ passive: true })\n    private _cleanChildren(): void {\n      if (this.childElementCount) {\n        for (const element of this.children) {\n          element.remove();\n        }\n      }\n    }\n\n    private _updateContenteditable(): void {\n      if (!isServer && this.isConnected) {\n        this.internals.ariaReadOnly = this.readOnly ? 'true' : null;\n        this.internals.ariaDisabled = this.disabled ? 'true' : null;\n        // TODO(2026): Firefox supports plaintext-only since version 136 (March 2025).\n        // Until this is part of our baseline, we should feature check to enable it.\n        const value =\n          this.disabled || this.readOnly\n            ? 'false'\n            : plaintextOnlySupported\n              ? 'plaintext-only'\n              : 'true';\n        this.setAttribute('contenteditable', value);\n        // In the readonly case, we disable contenteditable, but it still\n        // needs to be focusable. We achieve this by setting tabindex in that case.\n        if (this.readOnly) {\n          this.setAttribute('tabindex', '0');\n        } else {\n          this.removeAttribute('tabindex');\n        }\n      }\n    }\n\n    private _emitChangeIfNecessary(): void {\n      if (this._shouldEmitChange) {\n        this._shouldEmitChange = false;\n        /** The change event is fired when the user modifies the element's value. Unlike the input event, the change event is not necessarily fired for each alteration to an element's value. */\n        this.dispatchEvent(new Event('change', { bubbles: true }));\n      }\n    }\n\n    private _canSelect(): boolean {\n      return !isServer && !this.disabled && !this.readOnly && !!this.value;\n    }\n\n    protected override render(): unknown {\n      return html`<slot @slotchange=${this._cleanChildren}></slot>`;\n    }\n  }\n\n  return SbbFormAssociatedInputElement as unknown as AbstractConstructor<SbbFormAssociatedInputMixinType> &\n    T;\n};\n"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,53 @@
+import { LitElement } from 'lit';
+import { AbstractConstructor } from './constructor.ts';
+import { SbbElementInternalsMixinType } from './element-internals-mixin.ts';
+declare global {
+    /**
+     * Defines custom validity state properties.
+     */
+    interface CustomValidityState {
+    }
+    interface ValidityState extends CustomValidityState {
+    }
+    interface ValidityStateFlags extends Partial<CustomValidityState> {
+    }
+}
+export declare abstract class SbbFormAssociatedMixinType {
+    get form(): HTMLFormElement | null;
+    accessor name: string;
+    get type(): string;
+    abstract accessor value: unknown;
+    get validity(): ValidityState;
+    get validationMessage(): string;
+    get willValidate(): boolean;
+    protected formDisabled: boolean;
+    checkValidity(): boolean;
+    reportValidity(): boolean;
+    setCustomValidity(message: string): void;
+    formAssociatedCallback?(form: HTMLFormElement | null): void;
+    formDisabledCallback(disabled: boolean): void;
+    abstract formResetCallback(): void;
+    abstract formStateRestoreCallback(state: FormRestoreState | null, reason: FormRestoreReason): void;
+    protected updateFormValue(): void;
+    protected formState?(): FormRestoreState;
+    protected setValidityFlag<T extends keyof ValidityStateFlags>(flag: T, message: string, flagValue?: ValidityStateFlags[T]): void;
+    protected removeValidityFlag<T extends keyof ValidityStateFlags>(flag: T): void;
+    protected validate(): void;
+    protected shouldValidate(name: PropertyKey | undefined): boolean;
+}
+/**
+ * The FormAssociatedMixin enables native form support for custom controls.
+ */
+export declare const SbbFormAssociatedMixin: <T extends AbstractConstructor<LitElement & SbbElementInternalsMixinType>>(superClass: T) => AbstractConstructor<SbbFormAssociatedMixinType> & T;
+/**
+ * A value to be restored for a component's form value. If a component's form
+ * state is a `FormData` object, its entry list of name and values will be
+ * provided.
+ */
+export type FormRestoreState = string | FormData | File;
+/**
+ * The reason a form component is being restored for, either `'restore'` for
+ * browser restoration or `'autocomplete'` for restoring user values.
+ */
+export type FormRestoreReason = 'restore' | 'autocomplete';
+//# sourceMappingURL=form-associated-mixin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"form-associated-mixin.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/mixins/form-associated-mixin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAuC,MAAM,KAAK,CAAC;AAK3E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,8BAA8B,CAAC;AAEjF,OAAO,CAAC,MAAM,CAAC;IACb;;OAEG;IACH,UAAU,mBAAmB;KAAG;IAChC,UAAU,aAAc,SAAQ,mBAAmB;KAAG;IACtD,UAAU,kBAAmB,SAAQ,OAAO,CAAC,mBAAmB,CAAC;KAAG;CACrE;AAoCD,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,0BAA0B;IACtD,IAAW,IAAI,IAAI,eAAe,GAAG,IAAI,CAAC;IAC1C,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,IAAW,IAAI,IAAI,MAAM,CAAC;IAE1B,kBAAyB,KAAK,EAAE,OAAO,CAAC;IAExC,IAAW,QAAQ,IAAI,aAAa,CAAC;IACrC,IAAW,iBAAiB,IAAI,MAAM,CAAC;IACvC,IAAW,YAAY,IAAI,OAAO,CAAC;IAEnC,SAAS,CAAC,YAAY,EAAE,OAAO,CAAC;IAEzB,aAAa,IAAI,OAAO;IACxB,cAAc,IAAI,OAAO;IACzB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAExC,sBAAsB,CAAC,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,GAAG,IAAI;IAC3D,oBAAoB,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI;aACpC,iBAAiB,IAAI,IAAI;aACzB,wBAAwB,CACtC,KAAK,EAAE,gBAAgB,GAAG,IAAI,EAC9B,MAAM,EAAE,iBAAiB,GACxB,IAAI;IAEP,SAAS,CAAC,eAAe,IAAI,IAAI;IACjC,SAAS,CAAC,SAAS,CAAC,IAAI,gBAAgB;IACxC,SAAS,CAAC,eAAe,CAAC,CAAC,SAAS,MAAM,kBAAkB,EAC1D,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAChC,IAAI;IACP,SAAS,CAAC,kBAAkB,CAAC,CAAC,SAAS,MAAM,kBAAkB,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI;IAC/E,SAAS,CAAC,QAAQ,IAAI,IAAI;IAC1B,SAAS,CAAC,cAAc,CAAC,IAAI,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO;CACjE;AAED;;GAEG;AAEH,eAAO,MAAM,sBAAsB,GACjC,CAAC,SAAS,mBAAmB,CAAC,UAAU,GAAG,4BAA4B,CAAC,EAExE,YAAY,CAAC,KACZ,mBAAmB,CAAC,0BAA0B,CAAC,GAAG,CAgUpD,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,QAAQ,GAAG,IAAI,CAAC;AAExD;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,cAAc,CAAC"}