@sbb-esta/lyne-elements 4.11.0 → 4.12.1

package/development/datepicker/datepicker/datepicker.component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"datepicker.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/datepicker/datepicker/datepicker.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAInB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,cAAc,EAEpB,MAAM,KAAK,CAAC;AAGb,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAOtD,OAAO,EAAE,KAAK,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AACvF,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAKzD,OAAO,mBAAmB,CAAC;;AAI3B;;;GAGG;AACH,qBAAa,oBAAoB,CAAC,CAAC,GAAG,IAAI,CACxC,SAAQ,yBACR,YAAW,sBAAsB,CAAC,CAAC,CAAC;IAEpC,gBAAgC,WAAW,EAAE,MAAM,CAAoB;IACvE,OAAuB,MAAM,EAAE,cAAc,CAAoD;IACjG,gBAAuB,sBAAsB,QAAQ;IAErD,gDAAgD;IAChD,SAEgB,IAAI,EAAE,OAAO,CAAS;IAEtC;;;;OAIG;IACH,SAEgB,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAQ;IAE5D,yEAAyE;IACzE,SAA4B,IAAI,EAAE,YAAY,CAAS;IAEvD,OAAO,CAAC,qBAAqB,CAAC,CAAkB;IAChD,OAAO,CAAC,YAAY,CAA4E;IAChG,OAAO,CAAC,SAAS,CAAmC;IACpD,OAAO,CAAC,MAAM,CAAS;;IAaP,iBAAiB,IAAI,IAAI;IAezB,aAAa,CAC3B,IAAI,CAAC,EAAE,WAAW,EAClB,QAAQ,CAAC,EAAE,OAAO,EAClB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,IAAI;cAkBY,YAAY,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAW9E,OAAO,CAAC,aAAa;cAmBF,aAAa,IAAI,cAAc;cAyB/B,MAAM,IAAI,cAAc;CAG5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,gBAAgB,EAAE,oBAAoB,CAAC;KACxC;CACF"}
+{"version":3,"file":"datepicker.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/datepicker/datepicker/datepicker.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAInB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,cAAc,EAEpB,MAAM,KAAK,CAAC;AAGb,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAOtD,OAAO,EAAE,KAAK,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AACvF,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAKzD,OAAO,mBAAmB,CAAC;;AAI3B;;;;;;GAMG;AACH,qBAAa,oBAAoB,CAAC,CAAC,GAAG,IAAI,CACxC,SAAQ,yBACR,YAAW,sBAAsB,CAAC,CAAC,CAAC;IAEpC,gBAAgC,WAAW,EAAE,MAAM,CAAoB;IACvE,OAAuB,MAAM,EAAE,cAAc,CAAoD;IACjG,gBAAuB,sBAAsB,QAAQ;IAErD,gDAAgD;IAChD,SAEgB,IAAI,EAAE,OAAO,CAAS;IAEtC;;;;OAIG;IACH,SAEgB,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAQ;IAE5D,yEAAyE;IACzE,SAA4B,IAAI,EAAE,YAAY,CAAS;IAEvD,OAAO,CAAC,qBAAqB,CAAC,CAAkB;IAChD,OAAO,CAAC,YAAY,CAA4E;IAChG,OAAO,CAAC,SAAS,CAAmC;IACpD,OAAO,CAAC,MAAM,CAAS;;IAaP,iBAAiB,IAAI,IAAI;IAezB,aAAa,CAC3B,IAAI,CAAC,EAAE,WAAW,EAClB,QAAQ,CAAC,EAAE,OAAO,EAClB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,IAAI;cAkBY,YAAY,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAW9E,OAAO,CAAC,aAAa;cAmBF,aAAa,IAAI,cAAc;cAyB/B,MAAM,IAAI,cAAc;CAG5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,gBAAgB,EAAE,oBAAoB,CAAC;KACxC;CACF"}

package/development/datepicker/datepicker/datepicker.component.js

@@ -1,2 +1,2 @@
-import { t as SbbDatepickerElement } from "../../datepicker.component-C8XQVo45.js";
+import { t as SbbDatepickerElement } from "../../datepicker.component-D2DxFng_.js";
 export { SbbDatepickerElement };

package/development/datepicker/datepicker.js

@@ -1,4 +1,4 @@
-import { t as SbbDatepickerElement } from "../datepicker.component-C8XQVo45.js";
+import { t as SbbDatepickerElement } from "../datepicker.component-D2DxFng_.js";
 //#region src/elements/datepicker/datepicker.ts
 /** @entrypoint */
 SbbDatepickerElement.define();

package/development/datepicker-button-CUPeoQgH.js

@@ -0,0 +1,169 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, unsafeCSS } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbButtonBaseElement } from "./core/base-elements.js";
+import { idReference } from "./core/decorators.js";
+import { SbbNegativeMixin } from "./core/mixins.js";
+import { SbbLanguageController } from "./core/controllers.js";
+import { i18nToday } from "./core/i18n.js";
+import "./icon.js";
+import { readConfig } from "./core/config.js";
+import { defaultDateAdapter } from "./core/datetime.js";
+import { SbbDateInputElement } from "./date-input.js";
+//#endregion
+//#region src/elements/datepicker/common/datepicker-button.ts
+var datepickerButtonStyle = unsafeCSS(".sbb-action-base {\n  margin: auto;\n  -webkit-tap-highlight-color: transparent;\n}");
+/**
+* Base component for datepicker's buttons.
+*
+* @event {Event} change - The change event is fired on the datepicker's input 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.
+* @event {InputEvent} input - The input event fires on the datepicker's input when the value has been changed as a direct result of a user action.
+*/
+var SbbDatepickerButtonBase = (() => {
+	let _classSuper = SbbNegativeMixin(SbbButtonBaseElement);
+	let _input_decorators;
+	let _input_initializers = [];
+	let _input_extraInitializers = [];
+	return class SbbDatepickerButtonBase extends _classSuper {
+		constructor() {
+			super(...arguments);
+			this.#input_accessor_storage = __runInitializers(this, _input_initializers, null);
+			/** Whether the component is disabled due date-picker's input disabled. */
+			this._inputDisabled = (__runInitializers(this, _input_extraInitializers), true);
+			this.dateAdapter = readConfig().datetime?.dateAdapter ?? defaultDateAdapter;
+			this.language = new SbbLanguageController(this);
+		}
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_input_decorators = [idReference(), property()];
+			__esDecorate(this, null, _input_decorators, {
+				kind: "accessor",
+				name: "input",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "input" in obj,
+					get: (obj) => obj.input,
+					set: (obj, value) => {
+						obj.input = value;
+					}
+				},
+				metadata: _metadata
+			}, _input_initializers, _input_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.sbbDateInputAssociated = true;
+		}
+		#input_accessor_storage;
+		/**
+		* The associated date input element.
+		*
+		* For attribute usage, provide an id reference.
+		*/
+		get input() {
+			return this.#input_accessor_storage;
+		}
+		set input(value) {
+			this.#input_accessor_storage = value;
+		}
+		/** Whether this button is disabled. */
+		get disabled() {
+			return !!this._inputDisabled;
+		}
+		connectedCallback() {
+			super.connectedCallback();
+			this.toggleAttribute("disabled", this.disabled);
+			const formField = this.closest?.("sbb-form-field");
+			if (formField) {
+				customElements.upgrade?.(formField);
+				this.negative = formField.negative;
+				SbbDateInputElement.resolveAssociation(this);
+				this.slot ||= this._findSlotPosition();
+			}
+		}
+		requestUpdate(name, oldValue, options) {
+			super.requestUpdate(name, oldValue, options);
+			if (name === "input" && this.input !== oldValue) {
+				this._inputAbortController?.abort();
+				this._inputDisabled = true;
+				if (this.input) {
+					this._inputAbortController = new AbortController();
+					this.slot = this._findSlotPosition();
+					customElements.upgrade?.(this.input);
+					this._sync();
+					this.input.addEventListener("ɵchange", () => this._sync());
+				}
+				if (this.hasUpdated) this.toggleAttribute("disabled", this.disabled);
+			} else if (!name && this.hasUpdated && this.input) this._sync();
+		}
+		_findSlotPosition() {
+			return !this.input || this.compareDocumentPosition(this.input) & Node.DOCUMENT_POSITION_FOLLOWING ? "prefix" : "suffix";
+		}
+		_sync() {
+			this.syncDateInputState();
+			this.toggleAttribute("disabled", this.disabled);
+			if (this.disabled) this.removeAttribute("tabindex");
+			else this.setAttribute("tabindex", "0");
+		}
+		syncDateInputState() {
+			this._inputDisabled = this.input.disabled || this.input.readOnly;
+		}
+		renderTemplate() {
+			return html`<sbb-icon name=${this.iconName}></sbb-icon>`;
+		}
+	};
+})();
+var SbbDatepickerButton = class extends SbbDatepickerButtonBase {
+	get disabled() {
+		return this._disabled || super.disabled;
+	}
+	constructor() {
+		super();
+		/** Whether the component is disabled due date equals to boundary date. */
+		this._disabled = true;
+		this.addEventListener?.("click", () => this._handleClick());
+	}
+	/** @deprecated Use `getFollowingDate(date: T)` instead. */
+	findAvailableDate(_date) {
+		return this.getFollowingDate(_date);
+	}
+	_handleClick() {
+		if (!this.input || this.disabled) return;
+		const startingDate = this.input.valueAsDate ?? this.dateAdapter.today();
+		const date = this.getFollowingDate(startingDate);
+		if (this.dateAdapter.isValid(date) && this.dateAdapter.compareDate(date, startingDate) !== 0) {
+			this.input.valueAsDate = date;
+			this.input.dispatchEvent(new InputEvent("input", {
+				bubbles: true,
+				composed: true
+			}));
+			this.input.dispatchEvent(new Event("change", {
+				bubbles: true,
+				composed: true
+			}));
+			this.input.dispatchEvent(new Event("blur", { composed: true }));
+		}
+	}
+	syncDateInputState() {
+		super.syncDateInputState();
+		if (!this.dateAdapter.isValid(this.input.valueAsDate)) {
+			this._disabled = true;
+			this.internals.ariaLabel = this.i18nOffBoundaryDay[this.language.current];
+			return;
+		}
+		const date = this.getFollowingDate(this.input.valueAsDate);
+		this._disabled = !this.dateAdapter.isValid(date) || this.dateAdapter.compareDate(date, this.input.valueAsDate) === 0;
+		const currentDateString = this.dateAdapter.compareDate(this.dateAdapter.today(), this.input.valueAsDate) === 0 ? i18nToday[this.language.current].toLowerCase() : this.dateAdapter.getAccessibilityFormatDate(this.input.valueAsDate);
+		this.internals.ariaLabel = this.i18nSelectOffBoundaryDay(currentDateString)[this.language.current];
+	}
+};
+//#endregion
+export { SbbDatepickerButtonBase as n, datepickerButtonStyle as r, SbbDatepickerButton as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"datepicker-button-CUPeoQgH.js","names":[],"sources":["../../../src/elements/datepicker/common/datepicker-button.scss?inline","../../../src/elements/datepicker/common/datepicker-button.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n.sbb-action-base {\n  margin: auto;\n  -webkit-tap-highlight-color: transparent;\n}\n","import { html, unsafeCSS, type PropertyDeclaration, type TemplateResult } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { SbbButtonBaseElement } from '../../core/base-elements.ts';\nimport { readConfig } from '../../core/config.ts';\nimport { SbbLanguageController } from '../../core/controllers.ts';\nimport { type DateAdapter, defaultDateAdapter } from '../../core/datetime.ts';\nimport { idReference } from '../../core/decorators.ts';\nimport { i18nToday } from '../../core/i18n.ts';\nimport { SbbNegativeMixin } from '../../core/mixins.ts';\nimport { SbbDateInputElement, type SbbDateInputAssociated } from '../../date-input.ts';\n\nimport datepickerButtonStyleString from './datepicker-button.scss?inline';\n\nimport '../../icon.ts';\n\nexport const datepickerButtonStyle = unsafeCSS(datepickerButtonStyleString);\n\n/**\n * Base component for datepicker's buttons.\n *\n * @event {Event} change - The change event is fired on the datepicker's input 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 * @event {InputEvent} input - The input event fires on the datepicker's input when the value has been changed as a direct result of a user action.\n */\nexport abstract class SbbDatepickerButtonBase<T = Date>\n  extends SbbNegativeMixin(SbbButtonBaseElement)\n  implements SbbDateInputAssociated<T>\n{\n  public static readonly sbbDateInputAssociated = true;\n\n  /**\n   * The associated date input element.\n   *\n   * For attribute usage, provide an id reference.\n   */\n  @idReference()\n  @property()\n  public accessor input: SbbDateInputElement<T> | null = null;\n\n  /** Whether this button is disabled. */\n  public get disabled(): boolean {\n    return !!this._inputDisabled;\n  }\n\n  /** Whether the component is disabled due date-picker's input disabled. */\n  private _inputDisabled = true;\n\n  private _inputAbortController?: AbortController;\n\n  protected dateAdapter: DateAdapter<T> = readConfig().datetime?.dateAdapter ?? defaultDateAdapter;\n  protected language = new SbbLanguageController(this);\n  protected abstract iconName: string;\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    this.toggleAttribute('disabled', this.disabled);\n    const formField = this.closest?.('sbb-form-field');\n    if (formField) {\n      customElements.upgrade?.(formField);\n      this.negative = formField.negative;\n      SbbDateInputElement.resolveAssociation(this);\n      this.slot ||= this._findSlotPosition();\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 (name === 'input' && this.input !== oldValue) {\n      this._inputAbortController?.abort();\n      this._inputDisabled = true;\n      if (this.input) {\n        this._inputAbortController = new AbortController();\n        this.slot = this._findSlotPosition();\n        // The sbb-date-input instance must be upgraded in order\n        // for properties to be accessible.\n        customElements.upgrade?.(this.input);\n        this._sync();\n        this.input.addEventListener('ɵchange', () => this._sync());\n      }\n      if (this.hasUpdated) {\n        this.toggleAttribute('disabled', this.disabled);\n      }\n    } else if (!name && this.hasUpdated && this.input) {\n      // If language changes, we need to update related aria properties.\n      this._sync();\n    }\n  }\n\n  private _findSlotPosition(): string {\n    return !this.input ||\n      this.compareDocumentPosition(this.input) & Node.DOCUMENT_POSITION_FOLLOWING\n      ? 'prefix'\n      : 'suffix';\n  }\n\n  private _sync(): void {\n    this.syncDateInputState();\n    this.toggleAttribute('disabled', this.disabled);\n    if (this.disabled) {\n      this.removeAttribute('tabindex');\n    } else {\n      this.setAttribute('tabindex', '0');\n    }\n  }\n\n  protected syncDateInputState(): void {\n    this._inputDisabled = this.input!.disabled || this.input!.readOnly;\n  }\n\n  protected override renderTemplate(): TemplateResult {\n    return html`<sbb-icon name=${this.iconName}></sbb-icon>`;\n  }\n}\n\nexport abstract class SbbDatepickerButton<T = Date> extends SbbDatepickerButtonBase<T> {\n  /** Whether the component is disabled due date equals to boundary date. */\n  private _disabled = true;\n\n  protected abstract i18nOffBoundaryDay: Record<string, string>;\n  protected abstract i18nSelectOffBoundaryDay: (_currentDate: string) => Record<string, string>;\n\n  public override get disabled(): boolean {\n    return this._disabled || super.disabled;\n  }\n\n  public constructor() {\n    super();\n    this.addEventListener?.('click', () => this._handleClick());\n  }\n\n  /** @deprecated Use `getFollowingDate(date: T)` instead. */\n  protected findAvailableDate(_date: T): T | null {\n    return this.getFollowingDate(_date);\n  }\n\n  protected abstract getFollowingDate(_date: T): T | null;\n\n  private _handleClick(): void {\n    if (!this.input || this.disabled) {\n      return;\n    }\n    const startingDate: T = this.input.valueAsDate ?? this.dateAdapter.today();\n    const date = this.getFollowingDate(startingDate);\n    if (this.dateAdapter.isValid(date) && this.dateAdapter.compareDate(date, startingDate) !== 0) {\n      this.input.valueAsDate = date;\n      this.input.dispatchEvent(new InputEvent('input', { bubbles: true, composed: true }));\n      this.input.dispatchEvent(new Event('change', { bubbles: true, composed: true }));\n      // Emit blur event when value is changed programmatically to notify\n      // frameworks that rely on that event to update form status.\n      this.input.dispatchEvent(new Event('blur', { composed: true }));\n    }\n  }\n\n  protected override syncDateInputState(): void {\n    super.syncDateInputState();\n    if (!this.dateAdapter.isValid(this.input!.valueAsDate)) {\n      this._disabled = true;\n      this.internals.ariaLabel = this.i18nOffBoundaryDay[this.language.current];\n      return;\n    }\n\n    const date = this.getFollowingDate(this.input!.valueAsDate);\n    this._disabled =\n      !this.dateAdapter.isValid(date) ||\n      this.dateAdapter.compareDate(date, this.input!.valueAsDate) === 0;\n    const currentDateString =\n      this.dateAdapter.compareDate(this.dateAdapter.today(), this.input!.valueAsDate) === 0\n        ? i18nToday[this.language.current].toLowerCase()\n        : this.dateAdapter.getAccessibilityFormatDate(this.input!.valueAsDate);\n    this.internals.ariaLabel =\n      this.i18nSelectOffBoundaryDay(currentDateString)[this.language.current];\n  }\n}\n"],"mappings":"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"}

package/development/datepicker.component-D2DxFng_.js

@@ -0,0 +1,216 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, isServer, nothing, unsafeCSS } from "lit";
+import { property } from "lit/decorators.js";
+import { forceType, idReference } from "./core/decorators.js";
+import { SbbUpdateSchedulerMixin } from "./core/mixins.js";
+import { SbbLanguageController } from "./core/controllers.js";
+import { i18nDateChangedTo } from "./core/i18n.js";
+import { readConfig } from "./core/config.js";
+import { defaultDateAdapter } from "./core/datetime.js";
+import { SbbDateInputElement } from "./date-input.js";
+import { SbbPopoverBaseElement } from "./popover.js";
+import "./calendar.js";
+//#region src/elements/datepicker/datepicker/datepicker.scss?inline
+var datepicker_default = "#status-container {\n  border: 0;\n  clip-path: rect(0 0 0 0);\n  height: 1px;\n  margin: -1px;\n  overflow: hidden;\n  padding: 0;\n  position: absolute;\n  white-space: nowrap;\n  width: 1px;\n}";
+//#endregion
+//#region src/elements/datepicker/datepicker/datepicker.component.ts
+var nextId = 0;
+/**
+* A datepicker component that allows users to select a date from a calendar view.
+*
+* @event {CustomEvent<T>} dateselected - Event emitted on date selection.
+* @event {Event} change - The change event is fired on the datepicker's input 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.
+* @event {InputEvent} input - The input event fires  on the datepicker's input when the value has been changed as a direct result of a user action.
+*/
+var SbbDatepickerElement = (() => {
+	let _classSuper = SbbUpdateSchedulerMixin(SbbPopoverBaseElement);
+	let _wide_decorators;
+	let _wide_initializers = [];
+	let _wide_extraInitializers = [];
+	let _input_decorators;
+	let _input_initializers = [];
+	let _input_extraInitializers = [];
+	let _view_decorators;
+	let _view_initializers = [];
+	let _view_extraInitializers = [];
+	return class SbbDatepickerElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_wide_decorators = [forceType(), property({ type: Boolean })];
+			_input_decorators = [idReference(), property()];
+			_view_decorators = [property()];
+			__esDecorate(this, null, _wide_decorators, {
+				kind: "accessor",
+				name: "wide",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "wide" in obj,
+					get: (obj) => obj.wide,
+					set: (obj, value) => {
+						obj.wide = value;
+					}
+				},
+				metadata: _metadata
+			}, _wide_initializers, _wide_extraInitializers);
+			__esDecorate(this, null, _input_decorators, {
+				kind: "accessor",
+				name: "input",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "input" in obj,
+					get: (obj) => obj.input,
+					set: (obj, value) => {
+						obj.input = value;
+					}
+				},
+				metadata: _metadata
+			}, _input_initializers, _input_extraInitializers);
+			__esDecorate(this, null, _view_decorators, {
+				kind: "accessor",
+				name: "view",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "view" in obj,
+					get: (obj) => obj.view,
+					set: (obj, value) => {
+						obj.view = value;
+					}
+				},
+				metadata: _metadata
+			}, _view_initializers, _view_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-datepicker";
+		}
+		static {
+			this.styles = [SbbPopoverBaseElement.styles, unsafeCSS(datepicker_default)];
+		}
+		static {
+			this.sbbDateInputAssociated = true;
+		}
+		#wide_accessor_storage;
+		/** If set to true, two months are displayed. */
+		get wide() {
+			return this.#wide_accessor_storage;
+		}
+		set wide(value) {
+			this.#wide_accessor_storage = value;
+		}
+		#input_accessor_storage;
+		/**
+		* Reference to the sbb-date-input instance or the native input connected to the datepicker.
+		*
+		* For attribute usage, provide an id reference.
+		*/
+		get input() {
+			return this.#input_accessor_storage;
+		}
+		set input(value) {
+			this.#input_accessor_storage = value;
+		}
+		#view_accessor_storage;
+		/** The initial view of calendar which should be displayed on opening. */
+		get view() {
+			return this.#view_accessor_storage;
+		}
+		set view(value) {
+			this.#view_accessor_storage = value;
+		}
+		constructor() {
+			super();
+			this.#wide_accessor_storage = __runInitializers(this, _wide_initializers, false);
+			this.#input_accessor_storage = (__runInitializers(this, _wide_extraInitializers), __runInitializers(this, _input_initializers, null));
+			this.#view_accessor_storage = (__runInitializers(this, _input_extraInitializers), __runInitializers(this, _view_initializers, "day"));
+			this._inputAbortController = __runInitializers(this, _view_extraInitializers);
+			this._dateAdapter = readConfig().datetime?.dateAdapter ?? defaultDateAdapter;
+			this._language = new SbbLanguageController(this);
+			this._ready = false;
+			this.startUpdate();
+			this.addEventListener(SbbPopoverBaseElement.events.beforeopen, () => {
+				this.shadowRoot?.querySelector("sbb-calendar")?.resetPosition?.();
+			});
+			if (!isServer && this.hydrationRequired) this.hydrationComplete.then(() => this.requestUpdate());
+		}
+		connectedCallback() {
+			this.id ||= `sbb-datepicker-${++nextId}`;
+			super.connectedCallback();
+			const formField = this.closest?.("sbb-form-field");
+			if (formField) {
+				SbbDateInputElement.resolveAssociation(this);
+				const toggle = formField.querySelector("sbb-datepicker-toggle");
+				if (toggle && !toggle.hasAttribute("datepicker")) toggle.datepicker ??= this;
+			}
+		}
+		requestUpdate(name, oldValue, options) {
+			super.requestUpdate(name, oldValue, options);
+			if (name === "input" && this.input !== oldValue) {
+				this._inputAbortController?.abort();
+				if (this.input) {
+					const { signal } = this._inputAbortController = new AbortController();
+					this.input?.addEventListener("ɵchange", () => {
+						super.requestUpdate();
+						this._updateStatus();
+					}, { signal });
+				}
+			}
+		}
+		firstUpdated(changedProperties) {
+			super.firstUpdated(changedProperties);
+			setTimeout(() => {
+				this._ready = true;
+				this.requestUpdate();
+				this.completeUpdate();
+			});
+		}
+		_updateStatus() {
+			const status = this.shadowRoot?.getElementById("status-container");
+			if (!status) return;
+			const text = this._dateAdapter.isValid(this.input?.valueAsDate) ? `${i18nDateChangedTo[this._language.current]} ${this._dateAdapter.format(this.input.valueAsDate, { weekdayStyle: "long" })}` : "";
+			if (status.textContent !== text) status.textContent = text;
+		}
+		renderContent() {
+			return html`
+      <p id="status-container" role="status"></p>
+      <sbb-calendar
+        .view=${this.view}
+        .min=${this.input?.min ?? null}
+        .max=${this.input?.max ?? null}
+        .dateFilter=${this.input?.dateFilter ?? null}
+        .selected=${this.input?.valueAsDate ?? null}
+        ?wide=${this.wide}
+        @dateselected=${(d) => {
+				if (this.input) {
+					this.input.valueAsDate = d.detail;
+					this.input.dispatchEvent(new InputEvent("input", {
+						bubbles: true,
+						composed: true
+					}));
+					this.input.dispatchEvent(new Event("change", {
+						bubbles: true,
+						composed: true
+					}));
+					this.input.dispatchEvent(new Event("blur", { composed: true }));
+					this.close();
+				}
+			}}
+      ></sbb-calendar>
+    `;
+		}
+		render() {
+			return isServer || this.hydrationRequired || !this._ready ? html`${nothing}` : super.render();
+		}
+	};
+})();
+//#endregion
+export { SbbDatepickerElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"datepicker.component-D2DxFng_.js","names":[],"sources":["../../../src/elements/datepicker/datepicker/datepicker.scss?inline","../../../src/elements/datepicker/datepicker/datepicker.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n#status-container {\n  @include sbb.screen-reader-only;\n}\n","import {\n  type CSSResultGroup,\n  html,\n  isServer,\n  nothing,\n  type PropertyDeclaration,\n  type PropertyValues,\n  type TemplateResult,\n  unsafeCSS,\n} from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport type { CalendarView } from '../../calendar.ts';\nimport { readConfig } from '../../core/config.ts';\nimport { SbbLanguageController } from '../../core/controllers.ts';\nimport { type DateAdapter, defaultDateAdapter } from '../../core/datetime.ts';\nimport { forceType, idReference } from '../../core/decorators.ts';\nimport { i18nDateChangedTo } from '../../core/i18n.ts';\nimport { SbbUpdateSchedulerMixin } from '../../core/mixins.ts';\nimport { type SbbDateInputAssociated, SbbDateInputElement } from '../../date-input.ts';\nimport { SbbPopoverBaseElement } from '../../popover.ts';\nimport type { SbbDatepickerToggleElement } from '../datepicker-toggle/datepicker-toggle.component.ts';\n\nimport style from './datepicker.scss?inline';\n\nimport '../../calendar.ts';\n\nlet nextId = 0;\n\n/**\n * A datepicker component that allows users to select a date from a calendar view.\n *\n * @event {CustomEvent<T>} dateselected - Event emitted on date selection.\n * @event {Event} change - The change event is fired on the datepicker's input 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 * @event {InputEvent} input - The input event fires  on the datepicker's input when the value has been changed as a direct result of a user action.\n */\nexport class SbbDatepickerElement<T = Date>\n  extends SbbUpdateSchedulerMixin(SbbPopoverBaseElement)\n  implements SbbDateInputAssociated<T>\n{\n  public static override readonly elementName: string = 'sbb-datepicker';\n  public static override styles: CSSResultGroup = [SbbPopoverBaseElement.styles, unsafeCSS(style)];\n  public static readonly sbbDateInputAssociated = true;\n\n  /** If set to true, two months are displayed. */\n  @forceType()\n  @property({ type: Boolean })\n  public accessor wide: boolean = false;\n\n  /**\n   * Reference to the sbb-date-input instance or the native input connected to the datepicker.\n   *\n   * For attribute usage, provide an id reference.\n   */\n  @idReference()\n  @property()\n  public accessor input: SbbDateInputElement<T> | null = null;\n\n  /** The initial view of calendar which should be displayed on opening. */\n  @property() public accessor view: CalendarView = 'day';\n\n  private _inputAbortController?: AbortController;\n  private _dateAdapter: DateAdapter<T> = readConfig().datetime?.dateAdapter ?? defaultDateAdapter;\n  private _language = new SbbLanguageController(this);\n  private _ready = false;\n\n  public constructor() {\n    super();\n    this.startUpdate();\n    this.addEventListener(SbbPopoverBaseElement.events.beforeopen, () => {\n      this.shadowRoot?.querySelector('sbb-calendar')?.resetPosition?.();\n    });\n    if (!isServer && this.hydrationRequired) {\n      this.hydrationComplete.then(() => this.requestUpdate());\n    }\n  }\n\n  public override connectedCallback(): void {\n    this.id ||= `sbb-datepicker-${++nextId}`;\n    super.connectedCallback();\n\n    const formField = this.closest?.('sbb-form-field');\n    if (formField) {\n      SbbDateInputElement.resolveAssociation(this);\n      const toggle =\n        formField.querySelector<SbbDatepickerToggleElement<T>>('sbb-datepicker-toggle');\n      if (toggle && !toggle.hasAttribute('datepicker')) {\n        toggle.datepicker ??= this;\n      }\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 (name === 'input' && this.input !== oldValue) {\n      this._inputAbortController?.abort();\n      if (this.input) {\n        const { signal } = (this._inputAbortController = new AbortController());\n        this.input?.addEventListener(\n          'ɵchange',\n          () => {\n            super.requestUpdate();\n            this._updateStatus();\n          },\n          { signal },\n        );\n      }\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n    setTimeout(() => {\n      // We want to delay the rendering of the calendar to avoid a slow initial render.\n      // The slow render can be a problem if a large amount of datepickers are rendered at once.\n      this._ready = true;\n      this.requestUpdate();\n      this.completeUpdate();\n    });\n  }\n\n  private _updateStatus(): void {\n    const status = this.shadowRoot?.getElementById('status-container');\n    if (!status) {\n      return;\n    }\n\n    const text = this._dateAdapter.isValid(this.input?.valueAsDate)\n      ? `${i18nDateChangedTo[this._language.current]} ${this._dateAdapter.format(\n          this.input!.valueAsDate,\n          {\n            weekdayStyle: 'long',\n          },\n        )}`\n      : '';\n    if (status.textContent !== text) {\n      status.textContent = text;\n    }\n  }\n\n  protected override renderContent(): TemplateResult {\n    return html`\n      <p id=\"status-container\" role=\"status\"></p>\n      <sbb-calendar\n        .view=${this.view}\n        .min=${this.input?.min ?? null}\n        .max=${this.input?.max ?? null}\n        .dateFilter=${this.input?.dateFilter ?? null}\n        .selected=${this.input?.valueAsDate ?? null}\n        ?wide=${this.wide}\n        @dateselected=${(d: CustomEvent<T>) => {\n          if (this.input) {\n            this.input.valueAsDate = d.detail;\n            this.input.dispatchEvent(new InputEvent('input', { bubbles: true, composed: true }));\n            this.input.dispatchEvent(new Event('change', { bubbles: true, composed: true }));\n            // Emit blur event when value is changed programmatically to notify\n            // frameworks that rely on that event to update form status.\n            this.input.dispatchEvent(new Event('blur', { composed: true }));\n            this.close();\n          }\n        }}\n      ></sbb-calendar>\n    `;\n  }\n\n  protected override render(): TemplateResult {\n    return isServer || this.hydrationRequired || !this._ready ? html`${nothing}` : super.render();\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-datepicker': SbbDatepickerElement;\n  }\n}\n"],"mappings":"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"}

package/development/datepicker.js

@@ -1,8 +1,8 @@
-import { n as SbbDatepickerButtonBase, r as datepickerButtonStyle, t as SbbDatepickerButton } from "./datepicker-button-CANzGO5m.js";
+import { n as SbbDatepickerButtonBase, r as datepickerButtonStyle, t as SbbDatepickerButton } from "./datepicker-button-CUPeoQgH.js";
 import { SbbDatepickerNextDayElement } from "./datepicker/datepicker-next-day/datepicker-next-day.component.js";
 import { SbbDatepickerPreviousDayElement } from "./datepicker/datepicker-previous-day/datepicker-previous-day.component.js";
 import { SbbDatepickerToggleElement } from "./datepicker/datepicker-toggle/datepicker-toggle.component.js";
-import { t as SbbDatepickerElement } from "./datepicker.component-C8XQVo45.js";
+import { t as SbbDatepickerElement } from "./datepicker.component-D2DxFng_.js";
 import "./datepicker.pure.js";
 //#region src/elements/datepicker.ts
 /** @entrypoint */

package/development/datepicker.pure.js

@@ -1,6 +1,6 @@
-import { n as SbbDatepickerButtonBase, r as datepickerButtonStyle, t as SbbDatepickerButton } from "./datepicker-button-CANzGO5m.js";
+import { n as SbbDatepickerButtonBase, r as datepickerButtonStyle, t as SbbDatepickerButton } from "./datepicker-button-CUPeoQgH.js";
 import { SbbDatepickerNextDayElement } from "./datepicker/datepicker-next-day/datepicker-next-day.component.js";
 import { SbbDatepickerPreviousDayElement } from "./datepicker/datepicker-previous-day/datepicker-previous-day.component.js";
 import { SbbDatepickerToggleElement } from "./datepicker/datepicker-toggle/datepicker-toggle.component.js";
-import { t as SbbDatepickerElement } from "./datepicker.component-C8XQVo45.js";
+import { t as SbbDatepickerElement } from "./datepicker.component-D2DxFng_.js";
 export { SbbDatepickerButton, SbbDatepickerButtonBase, SbbDatepickerElement, SbbDatepickerNextDayElement, SbbDatepickerPreviousDayElement, SbbDatepickerToggleElement, datepickerButtonStyle };

package/development/error.component-OBpWoVRL.js

@@ -0,0 +1,55 @@
+import { html, unsafeCSS } from "lit";
+import { SbbElement } from "./core/base-elements.js";
+import { SbbNegativeMixin } from "./core/mixins.js";
+import { boxSizingStyles } from "./core/styles.js";
+//#region src/elements/form-field/error/error.scss?inline
+var error_default = ":host {\n  --_sbb-error-height: calc(var(--sbb-typo-line-height-text) * 1em);\n  --sbb-icon-svg-width: var(--sbb-error-icon-size);\n  --sbb-icon-svg-height: var(--sbb-error-icon-size);\n  display: flex;\n  align-items: flex-start;\n  color: var(--sbb-error-color);\n  min-height: var(--_sbb-error-height);\n  font-size: var(--sbb-error-font-size);\n  line-height: var(--sbb-typo-line-height-text);\n  letter-spacing: var(--sbb-typo-letter-spacing-text);\n}\n@media (forced-colors: active) {\n  :host {\n    --sbb-error-color: LinkText !important;\n  }\n}\n\n:host([negative]) {\n  --sbb-error-color: var(--sbb-color-red85);\n}\n\n.error__icon {\n  display: flex;\n  align-items: center;\n  height: var(--_sbb-error-height);\n  margin-inline-end: var(--sbb-spacing-fixed-1x);\n}\n\n.error-content {\n  line-height: var(--sbb-typo-line-height-text);\n  vertical-align: text-top;\n}\n\n.error__icon-svg {\n  stroke: currentcolor;\n  height: var(--_sbb-error-height);\n}";
+//#endregion
+//#region src/elements/form-field/error/error.component.ts
+/**
+* It displays an error message in the `sbb-form-field`.
+*
+* @slot - Use this slot to display the error message.
+* @slot icon - Use this slot to override the default error icon.
+*/
+var SbbErrorElement = class extends SbbNegativeMixin(SbbElement) {
+	static {
+		this.elementName = "sbb-error";
+	}
+	static {
+		this.styles = [boxSizingStyles, unsafeCSS(error_default)];
+	}
+	connectedCallback() {
+		super.connectedCallback();
+		const formField = this.closest?.("sbb-form-field");
+		if (formField) this.negative = formField.hasAttribute("negative");
+	}
+	render() {
+		return html`
+      <span class="error__icon">
+        <slot name="icon">
+          <svg
+            class="error__icon-svg"
+            aria-hidden="true"
+            width="14"
+            height="14"
+            viewBox="0 0 14 14"
+            fill="none"
+            xmlns="http://www.w3.org/2000/svg"
+          >
+            <line x1="7" y1="3" x2="7" y2="8.5" />
+            <line x1="7" y1="10" x2="7" y2="11" />
+            <circle cx="7" cy="7" r="6.5" />
+          </svg>
+        </slot>
+      </span>
+      <span class="error-content">
+        <slot></slot>
+      </span>
+    `;
+	}
+};
+//#endregion
+export { SbbErrorElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/expansion-panel/expansion-panel-header/expansion-panel-header.component.js

@@ -1,2 +1,2 @@
-import { t as SbbExpansionPanelHeaderElement } from "../../expansion-panel-header.component-Bw4uROTe.js";
+import { t as SbbExpansionPanelHeaderElement } from "../../expansion-panel-header.component-C1xRGcAN.js";
 export { SbbExpansionPanelHeaderElement };

package/development/expansion-panel/expansion-panel-header.js

@@ -1,4 +1,4 @@
-import { t as SbbExpansionPanelHeaderElement } from "../expansion-panel-header.component-Bw4uROTe.js";
+import { t as SbbExpansionPanelHeaderElement } from "../expansion-panel-header.component-C1xRGcAN.js";
 //#region src/elements/expansion-panel/expansion-panel-header.ts
 /** @entrypoint */
 SbbExpansionPanelHeaderElement.define();