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

package/development/core/base-elements/button-base-element.js

@@ -0,0 +1,254 @@
+import { SbbActionBaseElement } from "./action-base-element.js";
+import { __esDecorate, __runInitializers } from "tslib";
+import { isServer } from "lit";
+import { property } from "lit/decorators.js";
+import { forceType, hostAttributes } from "../decorators.js";
+import { isEventPrevented } from "../eventing.js";
+import { SbbFormAssociatedMixin } from "../mixins.js";
+//#region src/elements/core/base-elements/button-base-element.ts
+/** Button base class. */
+var SbbButtonLikeBaseElement = (() => {
+	let _classDecorators = [hostAttributes({ tabindex: "0" })];
+	let _classDescriptor;
+	let _classExtraInitializers = [];
+	let _classThis;
+	let _classSuper = SbbFormAssociatedMixin(SbbActionBaseElement);
+	var SbbButtonLikeBaseElement = class extends _classSuper {
+		static {
+			_classThis = this;
+		}
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			__esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, {
+				kind: "class",
+				name: _classThis.name,
+				metadata: _metadata
+			}, null, _classExtraInitializers);
+			SbbButtonLikeBaseElement = _classThis = _classDescriptor.value;
+			if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.role = "button";
+		}
+		constructor() {
+			super();
+			/**
+			* Prevents scrolling from pressing Space, when the event target is an action element.
+			* Also sets active state.
+			* @param event The origin event.
+			*/
+			this._preventScrollOnSpaceKeydown = (event) => {
+				if (event.key === " ") {
+					event.preventDefault();
+					this.internals.states.add("active");
+				}
+			};
+			this._removeActiveMarker = () => {
+				this.internals.states.delete("active");
+			};
+			/**
+			* Dispatches a 'click' PointerEvent if the original keyboard event is a 'Space' press.
+			* As verified with the native button, when 'Space' is pressed, a 'click' event is dispatched
+			* after the 'keyup' event.
+			* @param event The origin event.
+			*/
+			this._dispatchClickEventOnSpaceKeyup = (event) => {
+				if (event.key === " ") {
+					this._removeActiveMarker();
+					this._dispatchClickEvent(event);
+				}
+			};
+			this._dispatchClickEvent = (event) => {
+				const { altKey, ctrlKey, metaKey, shiftKey } = event;
+				event.target.dispatchEvent(new PointerEvent("click", {
+					bubbles: true,
+					cancelable: true,
+					composed: true,
+					pointerId: -1,
+					pointerType: "",
+					altKey,
+					ctrlKey,
+					metaKey,
+					shiftKey
+				}));
+			};
+			this.internals.states.add("button");
+			if (!isServer) {
+				this.setupBaseEventHandlers();
+				const passiveOptions = { passive: true };
+				this.addEventListener("keydown", this._preventScrollOnSpaceKeydown);
+				this.addEventListener("keyup", this._dispatchClickEventOnSpaceKeyup, passiveOptions);
+				this.addEventListener("blur", this._removeActiveMarker, passiveOptions);
+				this.addEventListener("keypress", (event) => {
+					if (event.key === "Enter" || event.key === "\n") this._dispatchClickEvent(event);
+				}, passiveOptions);
+			}
+		}
+		attributeChangedCallback(name, old, value) {
+			if (!["name", "value"].includes(name) || old !== value) super.attributeChangedCallback(name, old, value);
+		}
+		static {
+			__runInitializers(_classThis, _classExtraInitializers);
+		}
+	};
+	return _classThis;
+})();
+/** Button base class. */
+var SbbButtonBaseElement = (() => {
+	let _classSuper = SbbButtonLikeBaseElement;
+	let _instanceExtraInitializers = [];
+	let _value_decorators;
+	let _value_initializers = [];
+	let _value_extraInitializers = [];
+	let _set_type_decorators;
+	let _set_form_decorators;
+	return class SbbButtonBaseElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_value_decorators = [forceType(), property()];
+			_set_type_decorators = [property()];
+			_set_form_decorators = [property()];
+			__esDecorate(this, null, _value_decorators, {
+				kind: "accessor",
+				name: "value",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "value" in obj,
+					get: (obj) => obj.value,
+					set: (obj, value) => {
+						obj.value = value;
+					}
+				},
+				metadata: _metadata
+			}, _value_initializers, _value_extraInitializers);
+			__esDecorate(this, null, _set_type_decorators, {
+				kind: "setter",
+				name: "type",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "type" in obj,
+					set: (obj, value) => {
+						obj.type = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _set_form_decorators, {
+				kind: "setter",
+				name: "form",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "form" in obj,
+					set: (obj, value) => {
+						obj.form = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		#value_accessor_storage;
+		/** Value of the form element. */
+		get value() {
+			return this.#value_accessor_storage;
+		}
+		set value(value) {
+			this.#value_accessor_storage = value;
+		}
+		/**
+		* The type attribute to use for the button.
+		* @default 'button'
+		*/
+		set type(name) {
+			this.setAttribute("type", `${name}`);
+		}
+		get type() {
+			return this.getAttribute("type") ?? "button";
+		}
+		/** The `<form>` element to associate the button with. */
+		set form(value) {
+			this._formId = value;
+			this.form?.addEventListener("keydown", this._formKeyDown, { capture: true });
+		}
+		get form() {
+			return this._formId ? this.getRootNode?.()?.getElementById?.(this._formId) ?? null : this.internals.form;
+		}
+		constructor() {
+			super();
+			this._elementsOnWhichEnterPressTriggersSubmit = (__runInitializers(this, _instanceExtraInitializers), [
+				"input",
+				"sbb-date-input",
+				"sbb-time-input"
+			]);
+			this.#value_accessor_storage = __runInitializers(this, _value_initializers, "");
+			this._formId = (__runInitializers(this, _value_extraInitializers), "");
+			this._handleButtonClick = async (event) => {
+				if (this.type === "button" || await isEventPrevented(event)) return;
+				const form = this.form;
+				if (!form) return;
+				else if (this.type === "submit") this._requestSubmit(form);
+				else if (this.type === "reset") form.reset();
+			};
+			this._formKeyDown = (event) => {
+				const form = this.form;
+				if (this.type === "submit" && form && (event.key === "Enter" || event.key === "\n") && this._elementsOnWhichEnterPressTriggersSubmit.includes(event.target?.localName) && event.isTrusted) {
+					event.stopImmediatePropagation();
+					event.preventDefault();
+					if (event.composedPath()[0].dispatchEvent(new KeyboardEvent(event.type, event)) && !this.matches(":disabled")) this._requestSubmit(form);
+				}
+			};
+			this.addEventListener("click", this._handleButtonClick);
+		}
+		connectedCallback() {
+			super.connectedCallback();
+			this.form?.addEventListener("keydown", this._formKeyDown, { capture: true });
+		}
+		disconnectedCallback() {
+			super.disconnectedCallback();
+			this.form?.removeEventListener("keydown", this._formKeyDown, { capture: true });
+		}
+		_requestSubmit(form) {
+			const submitButtonClone = document.createElement("button");
+			submitButtonClone.inert = true;
+			submitButtonClone.hidden = true;
+			submitButtonClone.name = this.name;
+			submitButtonClone.value = this.value ?? "";
+			form.append(submitButtonClone);
+			form.requestSubmit(submitButtonClone);
+			submitButtonClone.remove();
+		}
+		/**
+		* Intentionally empty, as buttons are not targeted by form reset
+		* @internal
+		*/
+		formResetCallback() {}
+		/**
+		* Intentionally empty, as buttons are not targeted by form restore
+		* @internal
+		*/
+		formStateRestoreCallback(_state, _reason) {}
+		/**
+		* Intentionally empty, as button does not write its data in form.
+		* The data is only applied on submit button click as submitter of requestSubmit();
+		* @internal
+		*/
+		updateFormValue() {}
+	};
+})();
+//#endregion
+export { SbbButtonBaseElement, SbbButtonLikeBaseElement };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"button-base-element.js","names":[],"sources":["../../../../../src/elements/core/base-elements/button-base-element.ts"],"sourcesContent":["import { isServer } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { forceType, hostAttributes } from '../decorators.ts';\nimport { isEventPrevented } from '../eventing.ts';\nimport {\n  type FormRestoreReason,\n  type FormRestoreState,\n  SbbFormAssociatedMixin,\n} from '../mixins.ts';\n\nimport { SbbActionBaseElement } from './action-base-element.ts';\n\n/** Enumeration for type attribute in <button> HTML tag. */\nexport type SbbButtonType = 'button' | 'reset' | 'submit';\n\n/** Button base class. */\nexport\n@hostAttributes({\n  tabindex: '0',\n})\nabstract class SbbButtonLikeBaseElement extends SbbFormAssociatedMixin(SbbActionBaseElement) {\n  public static override readonly role: ElementInternals['role'] = 'button';\n\n  public constructor() {\n    super();\n    this.internals.states.add('button');\n\n    if (!isServer) {\n      this.setupBaseEventHandlers();\n\n      const passiveOptions = { passive: true };\n      this.addEventListener('keydown', this._preventScrollOnSpaceKeydown);\n      this.addEventListener('keyup', this._dispatchClickEventOnSpaceKeyup, passiveOptions);\n      this.addEventListener('blur', this._removeActiveMarker, passiveOptions);\n      this.addEventListener(\n        'keypress',\n        (event: KeyboardEvent): void => {\n          if (event.key === 'Enter' || event.key === '\\n') {\n            this._dispatchClickEvent(event);\n          }\n        },\n        passiveOptions,\n      );\n    }\n  }\n\n  /**\n   * Prevents scrolling from pressing Space, when the event target is an action element.\n   * Also sets active state.\n   * @param event The origin event.\n   */\n  private _preventScrollOnSpaceKeydown = (event: KeyboardEvent): void => {\n    if (event.key === ' ') {\n      event.preventDefault();\n      this.internals.states.add('active');\n    }\n  };\n\n  private _removeActiveMarker = (): void => {\n    this.internals.states.delete('active');\n  };\n\n  /**\n   * Dispatches a 'click' PointerEvent if the original keyboard event is a 'Space' press.\n   * As verified with the native button, when 'Space' is pressed, a 'click' event is dispatched\n   * after the 'keyup' event.\n   * @param event The origin event.\n   */\n  private _dispatchClickEventOnSpaceKeyup = (event: KeyboardEvent): void => {\n    if (event.key === ' ') {\n      this._removeActiveMarker();\n      this._dispatchClickEvent(event);\n    }\n  };\n\n  private _dispatchClickEvent = (event: KeyboardEvent): void => {\n    const { altKey, ctrlKey, metaKey, shiftKey } = event;\n    (event.target as Element).dispatchEvent(\n      new PointerEvent('click', {\n        bubbles: true,\n        cancelable: true,\n        composed: true,\n        pointerId: -1,\n        pointerType: '',\n        altKey,\n        ctrlKey,\n        metaKey,\n        shiftKey,\n      }),\n    );\n  };\n\n  public override attributeChangedCallback(\n    name: string,\n    old: string | null,\n    value: string | null,\n  ): void {\n    if (!['name', 'value'].includes(name) || old !== value) {\n      super.attributeChangedCallback(name, old, value);\n    }\n  }\n}\n\n/** Button base class. */\nexport abstract class SbbButtonBaseElement extends SbbButtonLikeBaseElement {\n  private readonly _elementsOnWhichEnterPressTriggersSubmit = [\n    'input',\n    'sbb-date-input',\n    'sbb-time-input',\n  ];\n\n  /** Value of the form element. */\n  @forceType()\n  @property()\n  public accessor value: string = '';\n\n  /**\n   * The type attribute to use for the button.\n   * @default 'button'\n   */\n  @property()\n  public override set type(name: SbbButtonType) {\n    this.setAttribute('type', `${name}`);\n  }\n  public override get type(): SbbButtonType {\n    return (this.getAttribute('type') as SbbButtonType) ?? 'button';\n  }\n\n  /** The `<form>` element to associate the button with. */\n  @property()\n  public override set form(value: string) {\n    this._formId = value;\n    this.form?.addEventListener('keydown', this._formKeyDown, { capture: true });\n  }\n  public override get form(): HTMLFormElement | null {\n    // Use querySelector with form and id selector, as the form property must\n    // reference a valid <form> element\n    return this._formId\n      ? (((this.getRootNode?.() as DocumentFragment | null)?.getElementById?.(\n          this._formId,\n        ) as HTMLFormElement) ?? null)\n      : this.internals.form;\n  }\n  private _formId: string = '';\n\n  public constructor() {\n    super();\n\n    this.addEventListener('click', this._handleButtonClick);\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n\n    this.form?.addEventListener('keydown', this._formKeyDown, { capture: true });\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n\n    this.form?.removeEventListener('keydown', this._formKeyDown, { capture: true });\n  }\n\n  private _handleButtonClick = async (event: MouseEvent): Promise<void> => {\n    if (this.type === 'button' || (await isEventPrevented(event))) {\n      return;\n    }\n\n    const form = this.form;\n    if (!form) {\n      return;\n    } else if (this.type === 'submit') {\n      this._requestSubmit(form);\n    } else if (this.type === 'reset') {\n      form.reset();\n    }\n  };\n\n  private _requestSubmit(form: HTMLFormElement): void {\n    // `form.requestSubmit(element);` seems not to work for CustomElements, so the `element` parameter has been removed;\n    // TODO: Check if solved in any way, see https://github.com/WICG/webcomponents/issues/814#issuecomment-1218452137\n    // We use the workaround described in the github issue by cloning the submit button and pass this one as an argument.\n\n    const submitButtonClone = document.createElement('button');\n    submitButtonClone.inert = true;\n    submitButtonClone.hidden = true;\n    submitButtonClone.name = this.name;\n    submitButtonClone.value = this.value ?? '';\n\n    form.append(submitButtonClone);\n    form.requestSubmit(submitButtonClone);\n    submitButtonClone.remove();\n  }\n\n  private _formKeyDown = (event: KeyboardEvent): void => {\n    const form = this.form;\n    if (\n      this.type === 'submit' &&\n      form &&\n      (event.key === 'Enter' || event.key === '\\n') &&\n      this._elementsOnWhichEnterPressTriggersSubmit.includes(\n        (event.target as HTMLElement)?.localName,\n      ) &&\n      event.isTrusted\n    ) {\n      // In the case where there is only one form element, an enter press submits the form.\n      // In the case where we only have one input and this button as a submit button,\n      // we need to prevent the default functionality of submitting the form because\n      // while this button should be recognized as a submit element, that is not natively the case,\n      // and therefore we manually handle this case here.\n      // If this button is not disabled we will then request a submit further down below.\n      event.stopImmediatePropagation();\n      event.preventDefault();\n\n      const eventOrigin = event.composedPath()[0];\n\n      if (\n        eventOrigin.dispatchEvent(new KeyboardEvent(event.type, event)) &&\n        !this.matches(':disabled')\n      ) {\n        this._requestSubmit(form);\n      }\n    }\n  };\n\n  /**\n   * Intentionally empty, as buttons are not targeted by form reset\n   * @internal\n   */\n  public override formResetCallback(): void {}\n\n  /**\n   * Intentionally empty, as buttons are not targeted by form restore\n   * @internal\n   */\n  public override formStateRestoreCallback(\n    _state: FormRestoreState | null,\n    _reason: FormRestoreReason,\n  ): void {}\n\n  /**\n   * Intentionally empty, as button does not write its data in form.\n   * The data is only applied on submit button click as submitter of requestSubmit();\n   * @internal\n   */\n  protected override updateFormValue(): void {}\n}\n"],"mappings":";;;;;;;;;IAqBe,kCAAwB;yBAHtC,eAAe,EACd,UAAU,KACX,CAAC,CAAA;;;;mBAC8C,uBAAuB,qBAAqB;8CAA5C,YAA4C;;;;;;AAA5F,gBAAA,MAAA,mBAAA,EAAA,OAAA,YAAA,EAAA,kBAAA;IAAA,MAAA;IAAA,MAAA,WAAA;IAAA,UAAA;IAAA,EAAA,MAAA,wBAAA;;;;;;;;;;AACkC,QAAA,OAAiC;;EAEjE,cAAA;AACE,UAAO;;;;;;AA2BD,QAAA,gCAAgC,UAA8B;AACpE,QAAI,MAAM,QAAQ,KAAK;AACrB,WAAM,gBAAgB;AACtB,UAAK,UAAU,OAAO,IAAI,SAAS;;;AAI/B,QAAA,4BAAiC;AACvC,SAAK,UAAU,OAAO,OAAO,SAAS;;;;;;;;AAShC,QAAA,mCAAmC,UAA8B;AACvE,QAAI,MAAM,QAAQ,KAAK;AACrB,UAAK,qBAAqB;AAC1B,UAAK,oBAAoB,MAAM;;;AAI3B,QAAA,uBAAuB,UAA8B;IAC3D,MAAM,EAAE,QAAQ,SAAS,SAAS,aAAa;AAC9C,UAAM,OAAmB,cACxB,IAAI,aAAa,SAAS;KACxB,SAAS;KACT,YAAY;KACZ,UAAU;KACV,WAAW;KACX,aAAa;KACb;KACA;KACA;KACA;KACD,CAAC,CACH;;AAhED,QAAK,UAAU,OAAO,IAAI,SAAS;AAEnC,OAAI,CAAC,UAAU;AACb,SAAK,wBAAwB;IAE7B,MAAM,iBAAiB,EAAE,SAAS,MAAM;AACxC,SAAK,iBAAiB,WAAW,KAAK,6BAA6B;AACnE,SAAK,iBAAiB,SAAS,KAAK,iCAAiC,eAAe;AACpF,SAAK,iBAAiB,QAAQ,KAAK,qBAAqB,eAAe;AACvE,SAAK,iBACH,aACC,UAA8B;AAC7B,SAAI,MAAM,QAAQ,WAAW,MAAM,QAAQ,KACzC,MAAK,oBAAoB,MAAM;OAGnC,eACD;;;EAkDW,yBACd,MACA,KACA,OAAoB;AAEpB,OAAI,CAAC,CAAC,QAAQ,QAAQ,CAAC,SAAS,KAAK,IAAI,QAAQ,MAC/C,OAAM,yBAAyB,MAAM,KAAK,MAAM;;;AA9EvC,qBAAA,YAAA,wBAAA;;;;;;IAoFO,8BAAoB;mBAAS;;;;;;;cAA7B,6BAA6B,YAAwB;;;wBAQxE,WAAW,EACX,UAAU,CAAA;2BAOV,UAAU,CAAA;2BASV,UAAU,CAAA;AAfX,gBAAA,MAAA,MAAA,mBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,WAAA;KAAA,MAAA,QAAA,IAAgB;KAAK,MAAA,KAAA,UAAA;AAAA,UAAL,QAAK;;KAAA;IAAA,UAAA;IAAA,EAAA,qBAAA,yBAAA;AAOrB,gBAAA,MAAA,MAAA,sBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,UAAA;KAAA,MAAA,KAAA,UAAA;AAAA,UAAoB,OAAI;;KAAA;IAAA,UAAA;IAAA,EAAA,MAAA,2BAAA;AASxB,gBAAA,MAAA,MAAA,sBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,UAAA;KAAA,MAAA,KAAA,UAAA;AAAA,UAAoB,OAAI;;KAAA;IAAA,UAAA;IAAA,EAAA,MAAA,2BAAA;;;;;;;;EAhBxB;;EAAA,IAAgB,QAAK;AAAA,UAAA,MAAA;;EAArB,IAAgB,MAAK,OAAA;AAAA,SAAA,yBAAA;;;;;;EAOrB,IAAoB,KAAK,MAAmB;AAC1C,QAAK,aAAa,QAAQ,GAAG,OAAO;;EAEtC,IAAoB,OAAI;AACtB,UAAQ,KAAK,aAAa,OAAyB,IAAI;;;EAKzD,IAAoB,KAAK,OAAa;AACpC,QAAK,UAAU;AACf,QAAK,MAAM,iBAAiB,WAAW,KAAK,cAAc,EAAE,SAAS,MAAM,CAAC;;EAE9E,IAAoB,OAAI;AAGtB,UAAO,KAAK,UACL,KAAK,eAA2C,EAAE,iBACnD,KAAK,QACc,IAAI,OACzB,KAAK,UAAU;;EAIrB,cAAA;AACE,UAAO;AAzCQ,QAAA,4CADG,kBAAA,MAAA,2BAAoB,EACoB;IAC1D;IACA;IACA;IACD;AAKe,SAAA,yBAAA,kBAAA,MAAA,qBAAgB,GAAE;AA6B1B,QAAA,WAAO,kBAAA,MAAA,yBAAA,EAAW;AAoBlB,QAAA,qBAAqB,OAAO,UAAoC;AACtE,QAAI,KAAK,SAAS,YAAa,MAAM,iBAAiB,MAAM,CAC1D;IAGF,MAAM,OAAO,KAAK;AAClB,QAAI,CAAC,KACH;aACS,KAAK,SAAS,SACvB,MAAK,eAAe,KAAK;aAChB,KAAK,SAAS,QACvB,MAAK,OAAO;;AAoBR,QAAA,gBAAgB,UAA8B;IACpD,MAAM,OAAO,KAAK;AAClB,QACE,KAAK,SAAS,YACd,SACC,MAAM,QAAQ,WAAW,MAAM,QAAQ,SACxC,KAAK,yCAAyC,SAC3C,MAAM,QAAwB,UAChC,IACD,MAAM,WACN;AAOA,WAAM,0BAA0B;AAChC,WAAM,gBAAgB;AAItB,SAFoB,MAAM,cAAc,CAAC,GAG3B,cAAc,IAAI,cAAc,MAAM,MAAM,MAAM,CAAC,IAC/D,CAAC,KAAK,QAAQ,YAAY,CAE1B,MAAK,eAAe,KAAK;;;AAxE7B,QAAK,iBAAiB,SAAS,KAAK,mBAAmB;;EAGzC,oBAAiB;AAC/B,SAAM,mBAAmB;AAEzB,QAAK,MAAM,iBAAiB,WAAW,KAAK,cAAc,EAAE,SAAS,MAAM,CAAC;;EAG9D,uBAAoB;AAClC,SAAM,sBAAsB;AAE5B,QAAK,MAAM,oBAAoB,WAAW,KAAK,cAAc,EAAE,SAAS,MAAM,CAAC;;EAkBzE,eAAe,MAAqB;GAK1C,MAAM,oBAAoB,SAAS,cAAc,SAAS;AAC1D,qBAAkB,QAAQ;AAC1B,qBAAkB,SAAS;AAC3B,qBAAkB,OAAO,KAAK;AAC9B,qBAAkB,QAAQ,KAAK,SAAS;AAExC,QAAK,OAAO,kBAAkB;AAC9B,QAAK,cAAc,kBAAkB;AACrC,qBAAkB,QAAQ;;;;;;EAsCZ,oBAAiB;;;;;EAMjB,yBACd,QACA,SAA0B;;;;;;EAQT,kBAAe"}

package/development/core/base-elements/element.d.ts

@@ -0,0 +1,59 @@
+import { LitElement, PropertyDeclaration, ReactiveController } from 'lit';
+export interface SbbPropertyValues {
+    oldValue?: unknown;
+    value?: unknown;
+}
+export interface SbbReactiveController extends ReactiveController {
+    hostPropertyUpdate?(name: PropertyKey, values?: SbbPropertyValues, options?: PropertyDeclaration): void;
+}
+declare const SbbElement_base: import('../mixins.ts').AbstractConstructor<import('../mixins/hydration-mixin.ts').SbbHydrationMixinType> & import('../mixins.ts').AbstractConstructor<import('../mixins/element-internals-mixin.ts').SbbElementInternalsMixinType> & typeof LitElement & import('../mixins/element-internals-mixin.ts').SbbElementInternalsConstructor;
+/**
+ * A base class for all SBB elements.
+ */
+export declare class SbbElement extends SbbElement_base {
+    static ['_$sbbElement$']: boolean;
+    static readonly elementName: string;
+    private _controllers?;
+    /**
+     * Register the custom element to the specified CustomElementRegistry.
+     * If none is provided, defaults to the global `customElements` registry.
+     * @param customElementRegistry Optional CustomElementRegistry to register this element to.
+     *   Defaults to the global `customElements` instance.
+     */
+    static define(customElementRegistry?: CustomElementRegistry): void;
+    /**
+     * Registers a `ReactiveController` to participate in the element's reactive
+     * update cycle. The element automatically calls into any registered
+     * controllers during its lifecycle callbacks.
+     *
+     * If the element is connected when `addController()` is called, the
+     * controller's `hostConnected()` callback will be immediately called.
+     */
+    addController(controller: SbbReactiveController): void;
+    /**
+     * Removes a `ReactiveController` from the element.
+     */
+    removeController(controller: SbbReactiveController): void;
+    /**
+     * Requests an update which is processed asynchronously. This should be called
+     * when an element should update based on some state not triggered by setting
+     * a reactive property. In this case, pass no arguments. It should also be
+     * called when manually implementing a property setter. In this case, pass the
+     * property `name` and `oldValue` to ensure that any configured property
+     * options are honored.
+     *
+     * @param name name of requesting property
+     * @param oldValue old value of requesting property
+     * @param options property options to use instead of the previously
+     *     configured options
+     * @param useNewValue if true, the newValue argument is used instead of
+     *     reading the property value. This is important to use if the reactive
+     *     property is a standard private accessor, as opposed to a plain
+     *     property, since private members can't be dynamically read by name.
+     * @param newValue the new value of the property. This is only used if
+     *     `useNewValue` is true.
+     */
+    requestUpdate(name?: PropertyKey, oldValue?: unknown, options?: PropertyDeclaration, useNewValue?: boolean, newValue?: unknown): void;
+}
+export {};
+//# sourceMappingURL=element.d.ts.map

package/development/core/base-elements/element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/base-elements/element.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,mBAAmB,EAAE,KAAK,kBAAkB,EAAE,MAAM,KAAK,CAAC;AAKpF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,qBAAsB,SAAQ,kBAAkB;IAC/D,kBAAkB,CAAC,CACjB,IAAI,EAAE,WAAW,EACjB,MAAM,CAAC,EAAE,iBAAiB,EAC1B,OAAO,CAAC,EAAE,mBAAmB,GAC5B,IAAI,CAAC;CACT;;AAED;;GAEG;AAEH,qBAAa,UAAW,SAAQ,eAAuD;IACrF,OAAc,CAAC,eAAe,CAAC,UAAQ;IACvC,gBAAuB,WAAW,EAAE,MAAM,CAAC;IAE3C,OAAO,CAAC,YAAY,CAAC,CAA6B;IAElD;;;;;OAKG;WACW,MAAM,CAAC,qBAAqB,GAAE,qBAAsC,GAAG,IAAI;IAoBzF;;;;;;;OAOG;IACa,aAAa,CAAC,UAAU,EAAE,qBAAqB,GAAG,IAAI;IAKtE;;OAEG;IACa,gBAAgB,CAAC,UAAU,EAAE,qBAAqB,GAAG,IAAI;IAKzE;;;;;;;;;;;;;;;;;;OAkBG;IACa,aAAa,CAC3B,IAAI,CAAC,EAAE,WAAW,EAClB,QAAQ,CAAC,EAAE,OAAO,EAClB,OAAO,CAAC,EAAE,mBAAmB,EAC7B,WAAW,CAAC,EAAE,OAAO,EACrB,QAAQ,CAAC,EAAE,OAAO,GACjB,IAAI;CAYR"}

package/development/core/base-elements/element.js

@@ -0,0 +1,77 @@
+import { LitElement } from "lit";
+import { SbbElementInternalsMixin } from "../mixins/element-internals-mixin.js";
+import { SbbHydrationMixin } from "../mixins/hydration-mixin.js";
+//#region src/elements/core/base-elements/element.ts
+/**
+* A base class for all SBB elements.
+*/
+var SbbElement = class extends SbbHydrationMixin(SbbElementInternalsMixin(LitElement)) {
+	static {
+		this["_$sbbElement$"] = true;
+	}
+	/**
+	* Register the custom element to the specified CustomElementRegistry.
+	* If none is provided, defaults to the global `customElements` registry.
+	* @param customElementRegistry Optional CustomElementRegistry to register this element to.
+	*   Defaults to the global `customElements` instance.
+	*/
+	static define(customElementRegistry = customElements) {
+		if (!this.elementName) throw new Error(`The static property "elementName" is not defined on ${this.name}. Please define it to register the custom element.`);
+		if (!customElementRegistry.get(this.elementName)) {
+			customElementRegistry.define(this.elementName, this);
+			this.finalize();
+		}
+	}
+	/**
+	* Registers a `ReactiveController` to participate in the element's reactive
+	* update cycle. The element automatically calls into any registered
+	* controllers during its lifecycle callbacks.
+	*
+	* If the element is connected when `addController()` is called, the
+	* controller's `hostConnected()` callback will be immediately called.
+	*/
+	addController(controller) {
+		super.addController(controller);
+		(this._controllers ??= /* @__PURE__ */ new Set()).add(controller);
+	}
+	/**
+	* Removes a `ReactiveController` from the element.
+	*/
+	removeController(controller) {
+		super.removeController(controller);
+		this._controllers?.delete(controller);
+	}
+	/**
+	* Requests an update which is processed asynchronously. This should be called
+	* when an element should update based on some state not triggered by setting
+	* a reactive property. In this case, pass no arguments. It should also be
+	* called when manually implementing a property setter. In this case, pass the
+	* property `name` and `oldValue` to ensure that any configured property
+	* options are honored.
+	*
+	* @param name name of requesting property
+	* @param oldValue old value of requesting property
+	* @param options property options to use instead of the previously
+	*     configured options
+	* @param useNewValue if true, the newValue argument is used instead of
+	*     reading the property value. This is important to use if the reactive
+	*     property is a standard private accessor, as opposed to a plain
+	*     property, since private members can't be dynamically read by name.
+	* @param newValue the new value of the property. This is only used if
+	*     `useNewValue` is true.
+	*/
+	requestUpdate(name, oldValue, options, useNewValue, newValue) {
+		super.requestUpdate(name, oldValue, options, useNewValue, newValue);
+		if (name) {
+			const values = {
+				oldValue,
+				value: useNewValue ? newValue : this[name]
+			};
+			this._controllers?.forEach((controller) => controller.hostPropertyUpdate?.(name, values, options));
+		}
+	}
+};
+//#endregion
+export { SbbElement };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/core/base-elements/link-base-element.d.ts

@@ -0,0 +1,34 @@
+import { TemplateResult } from 'lit';
+import { SbbLanguageController } from '../controllers.ts';
+import { SbbActionBaseElement } from './action-base-element.ts';
+/** Enumeration for 'target' attribute in <a> HTML tag. */
+export type LinkTargetType = '_blank' | '_self' | '_parent' | '_top';
+/** Link base class. */
+export declare abstract class SbbLinkBaseElement extends SbbActionBaseElement {
+    /** The href value you want to link to. */
+    accessor href: string;
+    /** Where to display the linked URL. */
+    accessor target: LinkTargetType | string;
+    /** The relationship of the linked URL as space-separated link types. */
+    accessor rel: string;
+    /** Whether the browser will show the download dialog on click. */
+    accessor download: boolean;
+    /** This will be forwarded as aria-label to the inner anchor element. */
+    accessor accessibilityLabel: string;
+    /** This will be forwarded as aria-current to the inner anchor element. */
+    accessor accessibilityCurrent: string;
+    protected language: SbbLanguageController;
+    protected readonly anchorRole: string | null;
+    constructor();
+    /** @internal */
+    focus(options?: FocusOptions | undefined): void;
+    /** @internal */
+    blur(): void;
+    /** @internal */
+    click(): void;
+    private _evaluateRelAttribute;
+    /** Default render method for link-like components. Can be overridden if the LinkRenderVariables are not needed. */
+    protected render(): TemplateResult;
+    protected renderLink(renderContent: TemplateResult): TemplateResult;
+}
+//# sourceMappingURL=link-base-element.d.ts.map

package/development/core/base-elements/link-base-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link-base-element.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/base-elements/link-base-element.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAGnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAI1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAEhE,0DAA0D;AAC1D,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAErE,uBAAuB;AACvB,8BAAsB,kBAAmB,SAAQ,oBAAoB;IACnE,0CAA0C;IAC1C,SAEgB,IAAI,EAAE,MAAM,CAAM;IAElC,uCAAuC;IACvC,SAEgB,MAAM,EAAE,cAAc,GAAG,MAAM,CAAM;IAErD,wEAAwE;IACxE,SAEgB,GAAG,EAAE,MAAM,CAAM;IAEjC,kEAAkE;IAClE,SAEgB,QAAQ,EAAE,OAAO,CAAS;IAE1C,wEAAwE;IACxE,SAEgB,kBAAkB,EAAE,MAAM,CAAM;IAEhD,0EAA0E;IAC1E,SAEgB,oBAAoB,EAAE,MAAM,CAAM;IAElD,SAAS,CAAC,QAAQ,wBAAmC;IACrD,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAQ;;IAUpD,gBAAgB;IACA,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,SAAS,GAAG,IAAI;IAI/D,gBAAgB;IACA,IAAI,IAAI,IAAI;IAI5B,gBAAgB;IACA,KAAK,IAAI,IAAI;IAI7B,OAAO,CAAC,qBAAqB,CAE3B;IAEF,mHAAmH;cAChG,MAAM,IAAI,cAAc;IAI3C,SAAS,CAAC,UAAU,CAAC,aAAa,EAAE,cAAc,GAAG,cAAc;CAyBpE"}