@sbb-esta/lyne-elements-dev 5.0.0-next.3-dev.1780293128 → 5.0.0-next.3-dev.1780308310

package/development/date-input.component-DMNqiZ6l.js

@@ -0,0 +1,302 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { isServer, unsafeCSS } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbElement, SbbFormAssociatedInputMixin, defaultDateAdapter, i18nDateInvalid, i18nDateMax, i18nDateMin, i18nDatePickerPlaceholder, plainDate, plainDateConverter, readConfig } from "./core.js";
+//#region src/elements/date-input/date-input.scss?inline
+var date_input_default = ":host {\n  display: inline-flex;\n  min-width: 9.375rem;\n  max-width: 100%;\n  cursor: text;\n  align-items: center;\n  font-weight: normal;\n}\n@media (forced-colors: active) {\n  :host {\n    color: FieldText;\n  }\n}\n\n:host(:disabled) {\n  cursor: var(--sbb-cursor-default);\n}\n\n:host(:focus) {\n  text-overflow: initial !important;\n}\n\n:host(:empty)::after {\n  content: attr(placeholder);\n  color: var(--sbb-color-5);\n  -webkit-text-fill-color: var(--sbb-color-5);\n  opacity: 1;\n}\n@media (forced-colors: active) {\n  :host(:empty)::after {\n    color: GrayText;\n  }\n}";
+//#endregion
+//#region src/elements/date-input/date-input.component.ts
+Object.assign(ValidityState.prototype, { get sbbDateFilter() {
+	return false;
+} });
+/**
+* Custom input for a date.
+*/
+var SbbDateInputElement = (() => {
+	let _classSuper = SbbFormAssociatedInputMixin(SbbElement);
+	let _instanceExtraInitializers = [];
+	let _set_valueAsDate_decorators;
+	let _min_decorators;
+	let _min_initializers = [];
+	let _min_extraInitializers = [];
+	let _max_decorators;
+	let _max_initializers = [];
+	let _max_extraInitializers = [];
+	let _set_dateFilter_decorators;
+	let _weekdayStyle_decorators;
+	let _weekdayStyle_initializers = [];
+	let _weekdayStyle_extraInitializers = [];
+	return class SbbDateInputElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_set_valueAsDate_decorators = [property({ attribute: false })];
+			_min_decorators = [plainDate(), property({
+				converter: plainDateConverter,
+				reflect: true
+			})];
+			_max_decorators = [plainDate(), property({
+				converter: plainDateConverter,
+				reflect: true
+			})];
+			_set_dateFilter_decorators = [property({ attribute: false })];
+			_weekdayStyle_decorators = [property({ attribute: "weekday-style" })];
+			__esDecorate(this, null, _set_valueAsDate_decorators, {
+				kind: "setter",
+				name: "valueAsDate",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "valueAsDate" in obj,
+					set: (obj, value) => {
+						obj.valueAsDate = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _min_decorators, {
+				kind: "accessor",
+				name: "min",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "min" in obj,
+					get: (obj) => obj.min,
+					set: (obj, value) => {
+						obj.min = value;
+					}
+				},
+				metadata: _metadata
+			}, _min_initializers, _min_extraInitializers);
+			__esDecorate(this, null, _max_decorators, {
+				kind: "accessor",
+				name: "max",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "max" in obj,
+					get: (obj) => obj.max,
+					set: (obj, value) => {
+						obj.max = value;
+					}
+				},
+				metadata: _metadata
+			}, _max_initializers, _max_extraInitializers);
+			__esDecorate(this, null, _set_dateFilter_decorators, {
+				kind: "setter",
+				name: "dateFilter",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "dateFilter" in obj,
+					set: (obj, value) => {
+						obj.dateFilter = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _weekdayStyle_decorators, {
+				kind: "accessor",
+				name: "weekdayStyle",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "weekdayStyle" in obj,
+					get: (obj) => obj.weekdayStyle,
+					set: (obj, value) => {
+						obj.weekdayStyle = value;
+					}
+				},
+				metadata: _metadata
+			}, _weekdayStyle_initializers, _weekdayStyle_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-date-input";
+		}
+		static {
+			this.styles = [unsafeCSS(date_input_default)];
+		}
+		/**
+		* The value of the date input. Reflects the current text value
+		* of this input.
+		* The attribute `value` Accepts ISO8601 formatted values, which will be
+		* formatted according to the current locale.
+		*/
+		set value(value) {
+			this._tryParseValue(value);
+			if (!isServer && !this.isSelected() && this.valueAsDate !== null) value = this._formatDate();
+			super.value = value;
+		}
+		get value() {
+			return super.value ?? "";
+		}
+		/** Formats the current input's value as date. */
+		set valueAsDate(value) {
+			value = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+			if (this.isSelected() && (value === null || this._dateAdapter.sameDate(value, this._dateAdapter.parse(this.value)))) {} else if (!value) {
+				this._valueAsDate = null;
+				this._valueCache = ["", null];
+				this.value = "";
+			} else if (!this._dateAdapter.isDateInstance(this._valueAsDate) || this._dateAdapter.compareDate(this._valueAsDate, value) !== 0) {
+				this._valueAsDate = this._dateAdapter.createDate(this._dateAdapter.getYear(value), this._dateAdapter.getMonth(value), this._dateAdapter.getDate(value));
+				const stringValue = this._formatDate();
+				this._valueCache = [stringValue, this._valueAsDate];
+				this.value = stringValue;
+			}
+		}
+		get valueAsDate() {
+			return this._valueAsDate ? this._dateAdapter.clone(this._valueAsDate) : null;
+		}
+		#min_accessor_storage;
+		/**
+		* The minimum valid date. Accepts a date object or null.
+		* Accepts an ISO8601 formatted string (e.g. 2024-12-24) as attribute.
+		*/
+		get min() {
+			return this.#min_accessor_storage;
+		}
+		set min(value) {
+			this.#min_accessor_storage = value;
+		}
+		#max_accessor_storage;
+		/**
+		* The maximum valid date. Accepts a date object or null.
+		* Accepts an ISO8601 formatted string (e.g. 2024-12-24) as attribute.
+		*/
+		get max() {
+			return this.#max_accessor_storage;
+		}
+		set max(value) {
+			this.#max_accessor_storage = value;
+		}
+		/**
+		* A function used to filter out dates.
+		* It is strongly recommended to use min and max dates alongside
+		* this filter.
+		*/
+		set dateFilter(value) {
+			this._dateFilter = value;
+		}
+		get dateFilter() {
+			return this._dateFilter;
+		}
+		#weekdayStyle_accessor_storage;
+		/**
+		* How to format the displayed date.
+		* `short`: Two letter abbreviation of the week day (e.g. Fr).
+		* `none`: The weekday is not displayed.
+		*/
+		get weekdayStyle() {
+			return this.#weekdayStyle_accessor_storage;
+		}
+		set weekdayStyle(value) {
+			this.#weekdayStyle_accessor_storage = value;
+		}
+		/**
+		* Gets the associated datepicker, if any.
+		* The sbb-date-input and the sbb-datepicker are assumed to be in the same parent container.
+		*/
+		get datepicker() {
+			return this.parentElement.querySelector("sbb-datepicker");
+		}
+		constructor() {
+			super();
+			this._valueAsDate = __runInitializers(this, _instanceExtraInitializers);
+			this.#min_accessor_storage = __runInitializers(this, _min_initializers, null);
+			this.#max_accessor_storage = (__runInitializers(this, _min_extraInitializers), __runInitializers(this, _max_initializers, null));
+			this.#weekdayStyle_accessor_storage = (__runInitializers(this, _max_extraInitializers), __runInitializers(this, _weekdayStyle_initializers, "short"));
+			/**
+			* Stores the last string and parsed date object value to prevent repeated
+			* parsing of the string value.
+			*/
+			this._valueCache = __runInitializers(this, _weekdayStyle_extraInitializers);
+			this._dateAdapter = readConfig().datetime?.dateAdapter ?? defaultDateAdapter;
+			this._placeholderMutable = false;
+			this._dateFilter = () => true;
+			this.addEventListener?.("change", () => this._updateValueDateFormat(), { capture: true });
+		}
+		/**
+		* Attempts to resolve the associated date input with the given element.
+		*/
+		static resolveAssociation(host) {
+			if (host.hasAttribute("input") || host.input) return;
+			const input = host.closest("sbb-form-field")?.querySelector("sbb-date-input");
+			if (input) host.input = input;
+		}
+		connectedCallback() {
+			super.connectedCallback();
+			if (!this.placeholder) {
+				this._placeholderMutable = true;
+				this.placeholder = i18nDatePickerPlaceholder[this.language.current];
+			}
+			for (const child of Array.from(this.closest("sbb-form-field")?.children ?? [])) {
+				customElements.upgrade?.(child);
+				if (child.constructor.sbbDateInputAssociated && !child.hasAttribute("input") && !child.input) child.input = this;
+			}
+		}
+		requestUpdate(name, oldValue, options) {
+			super.requestUpdate(name, oldValue, options);
+			if (this.hasUpdated && !name) {
+				this._updateValueDateFormat();
+				if (this._placeholderMutable) this.placeholder = i18nDatePickerPlaceholder[this.language.current];
+			} else if (name === "weekdayStyle") this._updateValueDateFormat();
+			if (this.isConnected)
+ /** @internal */
+			this.dispatchEvent(new Event("ɵchange"));
+		}
+		updateFormValue() {
+			this._tryParseValue();
+			const formValue = this.valueAsDate !== null ? this._dateAdapter.toIso8601(this.valueAsDate) : null;
+			this.internals.setFormValue(formValue, this.value);
+		}
+		_tryParseValue(value = this.value) {
+			if (this._valueCache?.[0] !== value) {
+				this._valueAsDate = this._dateAdapter.parse(value);
+				this._valueCache = [value, this._valueAsDate];
+			}
+		}
+		_updateValueDateFormat() {
+			if (this.valueAsDate) {
+				const formattedDate = this._formatDate();
+				if (this.value !== formattedDate) super.value = formattedDate;
+			}
+		}
+		_formatDate() {
+			return this._dateAdapter.format(this.valueAsDate, { weekdayStyle: this.weekdayStyle });
+		}
+		shouldValidate(name) {
+			return super.shouldValidate(name) || [
+				"valueAsDate",
+				"min",
+				"max",
+				"dateFilter"
+			].includes(name);
+		}
+		validate() {
+			super.validate();
+			if (!this.value) this._removeValidityErrors();
+			else if (!this._dateAdapter.isValid(this.valueAsDate)) this.setValidityFlag("badInput", i18nDateInvalid[this.language.current]);
+			else if (this._dateAdapter.isValid(this.min) && this._dateAdapter.compareDate(this.min, this.valueAsDate) > 0) this.setValidityFlag("rangeUnderflow", i18nDateMin(this._dateAdapter.format(this.min, { weekdayStyle: "none" }))[this.language.current]);
+			else if (this._dateAdapter.isValid(this.max) && this._dateAdapter.compareDate(this.valueAsDate, this.max) > 0) this.setValidityFlag("rangeOverflow", i18nDateMax(this._dateAdapter.format(this.max, { weekdayStyle: "none" }))[this.language.current]);
+			else if (this.dateFilter && !this.dateFilter(this.valueAsDate)) this.setValidityFlag("sbbDateFilter", i18nDateInvalid[this.language.current]);
+			else this._removeValidityErrors();
+		}
+		_removeValidityErrors() {
+			[
+				"badInput",
+				"rangeUnderflow",
+				"rangeOverflow",
+				"sbbDateFilter"
+			].forEach((f) => this.removeValidityFlag(f));
+		}
+	};
+})();
+//#endregion
+export { SbbDateInputElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"date-input.component-DMNqiZ6l.js","names":[],"sources":["../../../src/elements/date-input/date-input.scss?inline","../../../src/elements/date-input/date-input.component.ts"],"sourcesContent":["@use '../core/styles' as sbb;\n\n:host {\n  display: inline-flex;\n\n  // With sbb-form-field[width=\"collapsed\"], the default min width of a\n  // an inline element is basically nothing (except potentially the placeholder).\n  // Due to this, we set a minimum width of the date input element.\n  min-width: #{sbb.px-to-rem-build(150)};\n  max-width: 100%;\n  cursor: text;\n  align-items: center;\n  font-weight: normal;\n\n  @media (forced-colors: active) {\n    color: FieldText;\n  }\n}\n\n:host(:disabled) {\n  cursor: var(--sbb-cursor-default);\n}\n\n:host(:focus) {\n  text-overflow: initial !important;\n}\n\n:host(:empty)::after {\n  content: attr(placeholder);\n  @include sbb.placeholder;\n  @media (forced-colors: active) {\n    color: GrayText;\n  }\n}\n","import { type CSSResultGroup, isServer, type PropertyDeclaration, unsafeCSS } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport {\n  type DateAdapter,\n  defaultDateAdapter,\n  i18nDateInvalid,\n  i18nDateMax,\n  i18nDateMin,\n  i18nDatePickerPlaceholder,\n  plainDate,\n  plainDateConverter,\n  readConfig,\n  SbbElement,\n  SbbFormAssociatedInputMixin,\n} from '../core.ts';\nimport type { SbbDatepickerElement } from '../datepicker.pure.ts';\n\nimport style from './date-input.scss?inline';\n\n// As documented in form-associated-mixin.ts, we extend the prototype of\n// ValidityState with custom error states for the date input.\nObject.assign(ValidityState.prototype, {\n  get sbbDateFilter(): boolean {\n    return false;\n  },\n});\n\n/**\n * Interface for elements that can be associated with a date input.\n * Implementing classes must also have a static property `sbbDateInputAssociated` set to `true`.\n */\nexport interface SbbDateInputAssociated<T> {\n  input: SbbDateInputElement<T> | null;\n}\n\n/**\n * Custom input for a date.\n */\nexport class SbbDateInputElement<T = Date> extends SbbFormAssociatedInputMixin(SbbElement) {\n  public static override readonly elementName: string = 'sbb-date-input';\n  public static override styles: CSSResultGroup = [unsafeCSS(style)];\n\n  /**\n   * The value of the date input. Reflects the current text value\n   * of this input.\n   * The attribute `value` Accepts ISO8601 formatted values, which will be\n   * formatted according to the current locale.\n   */\n  public override set value(value: string) {\n    this._tryParseValue(value);\n    // As long as this element has focus we delay automatically updating\n    // the value with the formatted string of the parsed date.\n    if (!isServer && !this.isSelected() && this.valueAsDate !== null) {\n      value = this._formatDate();\n    }\n    super.value = value;\n  }\n  public override get value(): string {\n    return super.value ?? '';\n  }\n\n  /** Formats the current input's value as date. */\n  @property({ attribute: false })\n  public set valueAsDate(value: T | null) {\n    value = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    if (\n      this.isSelected() &&\n      (value === null || this._dateAdapter.sameDate(value, this._dateAdapter.parse(this.value)))\n    ) {\n      // Do nothing, as the user is currently editing the value and the parsed\n      // date is the same as the current value.\n      // This can also happen with Angular Forms Signals, as it currently\n      // continuously invokes writeValue, which assigns to this setter.\n    } else if (!value) {\n      this._valueAsDate = null;\n      this._valueCache = ['', null];\n      this.value = '';\n    } else if (\n      !this._dateAdapter.isDateInstance(this._valueAsDate) ||\n      this._dateAdapter.compareDate(this._valueAsDate!, value!) !== 0\n    ) {\n      // Align with the native date input, as it copies the value of\n      // the given date without the time and does not retain the\n      // original instance.\n      this._valueAsDate = this._dateAdapter.createDate(\n        this._dateAdapter.getYear(value),\n        this._dateAdapter.getMonth(value),\n        this._dateAdapter.getDate(value),\n      );\n      const stringValue = this._formatDate();\n      this._valueCache = [stringValue, this._valueAsDate];\n      this.value = stringValue;\n    }\n  }\n  public get valueAsDate(): T | null {\n    // We should never return the internal date object directly, as it\n    // could be manipulated outside of this class.\n    return this._valueAsDate ? this._dateAdapter.clone(this._valueAsDate) : null;\n  }\n  private _valueAsDate?: T | null;\n\n  /**\n   * The minimum valid date. Accepts a date object or null.\n   * Accepts an ISO8601 formatted string (e.g. 2024-12-24) as attribute.\n   */\n  @plainDate()\n  @property({ converter: plainDateConverter, reflect: true })\n  public accessor min: T | null = null;\n\n  /**\n   * The maximum valid date. Accepts a date object or null.\n   * Accepts an ISO8601 formatted string (e.g. 2024-12-24) as attribute.\n   */\n  @plainDate()\n  @property({ converter: plainDateConverter, reflect: true })\n  public accessor max: T | null = null;\n\n  /**\n   * A function used to filter out dates.\n   * It is strongly recommended to use min and max dates alongside\n   * this filter.\n   */\n  @property({ attribute: false })\n  public set dateFilter(value: (date: T | null) => boolean) {\n    this._dateFilter = value;\n  }\n  public get dateFilter(): (date: T | null) => boolean {\n    return this._dateFilter;\n  }\n\n  /**\n   * How to format the displayed date.\n   * `short`: Two letter abbreviation of the week day (e.g. Fr).\n   * `none`: The weekday is not displayed.\n   */\n  @property({ attribute: 'weekday-style' })\n  public accessor weekdayStyle: 'short' | 'none' = 'short';\n\n  /**\n   * Stores the last string and parsed date object value to prevent repeated\n   * parsing of the string value.\n   */\n  private _valueCache?: [string, T | null];\n  private _dateAdapter: DateAdapter<T> = readConfig().datetime?.dateAdapter ?? defaultDateAdapter;\n  private _placeholderMutable = false;\n\n  /**\n   * Gets the associated datepicker, if any.\n   * The sbb-date-input and the sbb-datepicker are assumed to be in the same parent container.\n   */\n  public get datepicker(): SbbDatepickerElement<T> | null {\n    return this.parentElement!.querySelector<SbbDatepickerElement<T>>('sbb-datepicker');\n  }\n\n  public constructor() {\n    super();\n    this.addEventListener?.('change', () => this._updateValueDateFormat(), { capture: true });\n  }\n\n  /**\n   * Attempts to resolve the associated date input with the given element.\n   */\n  public static resolveAssociation<T>(host: HTMLElement & SbbDateInputAssociated<T>): void {\n    if (host.hasAttribute('input') || host.input) {\n      return;\n    }\n\n    const input = host\n      .closest('sbb-form-field')\n      ?.querySelector<SbbDateInputElement<T>>('sbb-date-input');\n    if (input) {\n      host.input = input;\n    }\n  }\n\n  private _dateFilter: (date: T | null) => boolean = () => true;\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    if (!this.placeholder) {\n      this._placeholderMutable = true;\n      this.placeholder = i18nDatePickerPlaceholder[this.language.current];\n    }\n    for (const child of Array.from(this.closest('sbb-form-field')?.children ?? [])) {\n      // Elements must be upgraded in order for the constructor to be accessible.\n      customElements.upgrade?.(child);\n      if (\n        (child.constructor as { sbbDateInputAssociated?: boolean }).sbbDateInputAssociated &&\n        !child.hasAttribute('input') &&\n        !(child as Partial<SbbDateInputAssociated<T>>).input\n      ) {\n        (child as Partial<SbbDateInputAssociated<T>>).input = 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 (this.hasUpdated && !name) {\n      this._updateValueDateFormat();\n      if (this._placeholderMutable) {\n        this.placeholder = i18nDatePickerPlaceholder[this.language.current];\n      }\n    } else if (name === 'weekdayStyle') {\n      this._updateValueDateFormat();\n    }\n    if (this.isConnected) {\n      // Used to notify associated components to update state\n      /** @internal */\n      this.dispatchEvent(new Event('ɵchange'));\n    }\n  }\n\n  protected override updateFormValue(): void {\n    this._tryParseValue();\n    const formValue =\n      this.valueAsDate !== null ? this._dateAdapter.toIso8601(this.valueAsDate) : null;\n    this.internals.setFormValue(formValue, this.value);\n  }\n\n  private _tryParseValue(value = this.value): void {\n    if (this._valueCache?.[0] !== value) {\n      this._valueAsDate = this._dateAdapter.parse(value);\n      this._valueCache = [value, this._valueAsDate];\n    }\n  }\n\n  private _updateValueDateFormat(): void {\n    if (this.valueAsDate) {\n      const formattedDate = this._formatDate();\n      if (this.value !== formattedDate) {\n        super.value = formattedDate;\n      }\n    }\n  }\n\n  private _formatDate(): string {\n    return this._dateAdapter.format(this.valueAsDate, { weekdayStyle: this.weekdayStyle });\n  }\n\n  protected override shouldValidate(name: PropertyKey | undefined): boolean {\n    return (\n      super.shouldValidate(name) ||\n      ['valueAsDate', 'min', 'max', 'dateFilter'].includes(name as string)\n    );\n  }\n\n  protected override validate(): void {\n    super.validate();\n    if (!this.value) {\n      this._removeValidityErrors();\n    } else if (!this._dateAdapter.isValid(this.valueAsDate)) {\n      this.setValidityFlag('badInput', i18nDateInvalid[this.language.current]);\n    } else if (\n      this._dateAdapter.isValid(this.min) &&\n      this._dateAdapter.compareDate(this.min, this.valueAsDate) > 0\n    ) {\n      this.setValidityFlag(\n        'rangeUnderflow',\n        i18nDateMin(this._dateAdapter.format(this.min, { weekdayStyle: 'none' }))[\n          this.language.current\n        ],\n      );\n    } else if (\n      this._dateAdapter.isValid(this.max) &&\n      this._dateAdapter.compareDate(this.valueAsDate, this.max) > 0\n    ) {\n      this.setValidityFlag(\n        'rangeOverflow',\n        i18nDateMax(this._dateAdapter.format(this.max, { weekdayStyle: 'none' }))[\n          this.language.current\n        ],\n      );\n    } else if (this.dateFilter && !this.dateFilter(this.valueAsDate)) {\n      this.setValidityFlag('sbbDateFilter', i18nDateInvalid[this.language.current]);\n    } else {\n      this._removeValidityErrors();\n    }\n  }\n\n  private _removeValidityErrors(): void {\n    (['badInput', 'rangeUnderflow', 'rangeOverflow', 'sbbDateFilter'] as const).forEach((f) =>\n      this.removeValidityFlag(f),\n    );\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-date-input': SbbDateInputElement;\n  }\n\n  interface CustomValidityState {\n    sbbDateFilter: boolean;\n  }\n}\n"],"mappings":"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"}

package/development/date-input.js

@@ -1,4 +1,4 @@
-import { t as SbbDateInputElement } from "./date-input.component-Cy7m1ocL.js";
+import { t as SbbDateInputElement } from "./date-input.component-DMNqiZ6l.js";
 import "./date-input.pure.js";
 //#region src/elements/date-input.ts
 /** @entrypoint */

package/development/date-input.pure.js

@@ -1,2 +1,2 @@
-import { t as SbbDateInputElement } from "./date-input.component-Cy7m1ocL.js";
+import { t as SbbDateInputElement } from "./date-input.component-DMNqiZ6l.js";
 export { SbbDateInputElement };

package/development/time-input/time-input.component.d.ts

@@ -14,7 +14,7 @@ export declare class SbbTimeInputElement extends SbbTimeInputElement_base {
     set value(value: string);
     get value(): string;
     /** Formats the current input's value as date. */
-    set valueAsDate(date: Date | null);
+    set valueAsDate(value: Date | null);
     get valueAsDate(): Date | null;
     private _valueAsTime?;
     /**
@@ -30,6 +30,8 @@ export declare class SbbTimeInputElement extends SbbTimeInputElement_base {
     private _tryParseValue;
     /** Validate input against the defined RegExps. */
     private _parseValue;
+    private _toTime;
+    private _isSameTime;
     private _updateValueDateFormat;
     private _formatTime;
     protected preparePastedText(text: string): string;

package/development/time-input/time-input.component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"time-input.component.d.ts","sourceRoot":"","sources":["../../../../src/elements/time-input/time-input.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAuB,MAAM,KAAK,CAAC;AAG/D,OAAO,EAKL,UAAU,EAIX,MAAM,YAAY,CAAC;;AAcpB;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,wBAAuC;IAC9E,gBAAgC,WAAW,EAAE,MAAM,CAAoB;IACvE,OAAuB,MAAM,EAAE,cAAc,CAAsB;IAEnE;;;OAGG;IACH,IAAoB,KAAK,CAAC,KAAK,EAAE,MAAM,EAYtC;IACD,IAAoB,KAAK,IAAI,MAAM,CAElC;IAED,iDAAiD;IACjD,IACW,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,EAcvC;IACD,IAAW,WAAW,IAAI,IAAI,GAAG,IAAI,CASpC;IACD,OAAO,CAAC,YAAY,CAAC,CAAc;IAEnC;;;OAGG;IACH,OAAO,CAAC,WAAW,CAAC,CAAwB;IAE5C,OAAO,CAAC,SAAS,CAAmC;;IAWpC,iBAAiB,IAAI,IAAI;IAMzB,oBAAoB,IAAI,IAAI;cAIzB,eAAe,IAAI,IAAI;IAM1C,OAAO,CAAC,cAAc;IAOtB,kDAAkD;IAClD,OAAO,CAAC,WAAW;IAgBnB,OAAO,CAAC,sBAAsB;IAS9B,OAAO,CAAC,WAAW;cAUA,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;cAMvC,cAAc,CAAC,IAAI,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO;cAOtD,QAAQ,IAAI,IAAI;IAanC,OAAO,CAAC,qBAAqB;IAI7B,uFAAuF;IACvF,OAAO,CAAC,YAAY;IAIpB,qDAAqD;IACrD,OAAO,CAAC,kBAAkB;IAgC1B,OAAO,CAAC,aAAa;CAItB;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,gBAAgB,EAAE,mBAAmB,CAAC;KACvC;CACF"}
+{"version":3,"file":"time-input.component.d.ts","sourceRoot":"","sources":["../../../../src/elements/time-input/time-input.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAuB,MAAM,KAAK,CAAC;AAG/D,OAAO,EAKL,UAAU,EAIX,MAAM,YAAY,CAAC;;AAcpB;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,wBAAuC;IAC9E,gBAAgC,WAAW,EAAE,MAAM,CAAoB;IACvE,OAAuB,MAAM,EAAE,cAAc,CAAsB;IAEnE;;;OAGG;IACH,IAAoB,KAAK,CAAC,KAAK,EAAE,MAAM,EAYtC;IACD,IAAoB,KAAK,IAAI,MAAM,CAElC;IAED,iDAAiD;IACjD,IACW,WAAW,CAAC,KAAK,EAAE,IAAI,GAAG,IAAI,EAoBxC;IACD,IAAW,WAAW,IAAI,IAAI,GAAG,IAAI,CASpC;IACD,OAAO,CAAC,YAAY,CAAC,CAAc;IAEnC;;;OAGG;IACH,OAAO,CAAC,WAAW,CAAC,CAAwB;IAE5C,OAAO,CAAC,SAAS,CAAmC;;IAWpC,iBAAiB,IAAI,IAAI;IAMzB,oBAAoB,IAAI,IAAI;cAIzB,eAAe,IAAI,IAAI;IAM1C,OAAO,CAAC,cAAc;IAOtB,kDAAkD;IAClD,OAAO,CAAC,WAAW;IAgBnB,OAAO,CAAC,OAAO;IAMf,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,sBAAsB;IAS9B,OAAO,CAAC,WAAW;cAUA,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;cAMvC,cAAc,CAAC,IAAI,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO;cAOtD,QAAQ,IAAI,IAAI;IAanC,OAAO,CAAC,qBAAqB;IAI7B,uFAAuF;IACvF,OAAO,CAAC,YAAY;IAIpB,qDAAqD;IACrD,OAAO,CAAC,kBAAkB;IAgC1B,OAAO,CAAC,aAAa;CAItB;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,gBAAgB,EAAE,mBAAmB,CAAC;KACvC;CACF"}

package/development/time-input/time-input.component.js

@@ -1,2 +1,2 @@
-import { t as SbbTimeInputElement } from "../time-input.component-CGPW3RCw.js";
+import { t as SbbTimeInputElement } from "../time-input.component-Cdd1dzcG.js";
 export { SbbTimeInputElement };

package/development/time-input.component-Cdd1dzcG.js

@@ -0,0 +1,194 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { isServer, unsafeCSS } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbElement, SbbFormAssociatedInputMixin, SbbLanguageController, i18nTimeInputChange, i18nTimeInvalid, i18nTimeMax, i18nTimeMaxLength, sbbLiveAnnouncer } from "./core.js";
+//#region src/elements/time-input/time-input.scss?inline
+var time_input_default = ":host {\n  display: inline-flex;\n  min-width: var(--sbb-time-input-max-width);\n  max-width: var(--sbb-time-input-max-width);\n  cursor: text;\n  align-items: center;\n  font-weight: normal;\n}\n@media (forced-colors: active) {\n  :host {\n    color: FieldText;\n  }\n}\n\n:host(:disabled) {\n  cursor: var(--sbb-cursor-default);\n}\n\n:host(:focus) {\n  text-overflow: initial !important;\n}\n\n:host(:empty)::after {\n  content: attr(placeholder);\n  color: var(--sbb-color-5);\n  -webkit-text-fill-color: var(--sbb-color-5);\n  opacity: 1;\n}\n@media (forced-colors: active) {\n  :host(:empty)::after {\n    color: GrayText;\n  }\n}";
+//#endregion
+//#region src/elements/time-input/time-input.component.ts
+var REGEX_ALLOWED_CHARACTERS = /[0-9.:,\-;_hH]/;
+var REGEX_DISALLOWED_CHARACTERS = /[^0-9.:,\-;_hH]/g;
+var REGEX_GROUPS_WITHOUT_COLON = /^([0-9]{1,2})([0-9]{2})$/;
+var REGEX_GROUPS_WITH_COLON = /^([0-9]{1,2})?[.:,\-;_hH]?([0-9]{1,2})?$/;
+/**
+* Custom input for a time.
+*/
+var SbbTimeInputElement = (() => {
+	let _classSuper = SbbFormAssociatedInputMixin(SbbElement);
+	let _instanceExtraInitializers = [];
+	let _set_valueAsDate_decorators;
+	return class SbbTimeInputElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_set_valueAsDate_decorators = [property({ attribute: false })];
+			__esDecorate(this, null, _set_valueAsDate_decorators, {
+				kind: "setter",
+				name: "valueAsDate",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "valueAsDate" in obj,
+					set: (obj, value) => {
+						obj.valueAsDate = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-time-input";
+		}
+		static {
+			this.styles = [unsafeCSS(time_input_default)];
+		}
+		/**
+		* The value of the time input. Reflects the current text value
+		* of this input.
+		*/
+		set value(value) {
+			value = typeof value === "string" ? value.replace(REGEX_DISALLOWED_CHARACTERS, "").substring(0, 5) : "";
+			this._tryParseValue(value);
+			if (!isServer && !this.isSelected() && this.valueAsDate !== null) value = this._formatTime();
+			super.value = value;
+		}
+		get value() {
+			return super.value ?? "";
+		}
+		/** Formats the current input's value as date. */
+		set valueAsDate(value) {
+			const time = this._toTime(value);
+			if (this.isSelected() && (time === null || this._isSameTime(time, this._parseValue(this.value)))) {} else if (time) {
+				this._valueAsTime = time;
+				const formattedValue = this._formatTime();
+				if (this.value !== formattedValue) this.value = formattedValue;
+			} else {
+				this._valueAsTime = null;
+				this.value = "";
+			}
+		}
+		get valueAsDate() {
+			if (this._valueAsTime && this._isTimeValid(this._valueAsTime)) {
+				const date = /* @__PURE__ */ new Date(0);
+				date.setHours(this._valueAsTime.hours);
+				date.setMinutes(this._valueAsTime.minutes);
+				return date;
+			} else return null;
+		}
+		constructor() {
+			super();
+			this._valueAsTime = __runInitializers(this, _instanceExtraInitializers);
+			this._language = new SbbLanguageController(this);
+			this.addEventListener?.("change", () => this._updateValueDateFormat(), { capture: true });
+			this.addEventListener?.("change", () => sbbLiveAnnouncer.announce(i18nTimeInputChange(this.value)[this._language.current]));
+			this.addEventListener?.("keydown", (event) => this._preventCharInsert(event));
+		}
+		connectedCallback() {
+			super.connectedCallback();
+			this.inputMode ||= "numeric";
+			this.placeholder ||= "HH:MM";
+		}
+		disconnectedCallback() {
+			super.disconnectedCallback();
+		}
+		updateFormValue() {
+			this._tryParseValue();
+			const formValue = this.valueAsDate !== null ? this._formatTime() : null;
+			this.internals.setFormValue(formValue, this.value);
+		}
+		_tryParseValue(value = this.value) {
+			if (this._valueCache?.[0] !== value) {
+				this._valueAsTime = this._parseValue(value);
+				this._valueCache = [value, this._valueAsTime ?? null];
+			}
+		}
+		/** Validate input against the defined RegExps. */
+		_parseValue(value) {
+			const trimmedValue = value?.trim();
+			if (!trimmedValue) return null;
+			const match = trimmedValue.match(REGEX_GROUPS_WITHOUT_COLON) ?? trimmedValue.match(REGEX_GROUPS_WITH_COLON);
+			if (match) return {
+				hours: +match[1] || 0,
+				minutes: +match[2] || 0
+			};
+			return null;
+		}
+		_toTime(value) {
+			return value instanceof Date && !isNaN(value.valueOf()) ? {
+				hours: value.getHours(),
+				minutes: value.getMinutes()
+			} : null;
+		}
+		_isSameTime(time1, time2) {
+			return !!(time1 == time2 || time1 && time2 && time1.hours === time2.hours && time1.minutes === time2.minutes);
+		}
+		_updateValueDateFormat() {
+			if (this.valueAsDate) {
+				const formattedDate = this._formatTime();
+				if (this.value !== formattedDate) super.value = formattedDate;
+			}
+		}
+		_formatTime() {
+			const value = this.valueAsDate;
+			if (!value) return "";
+			return `${String(value.getHours()).padStart(2, "0")}:${String(value.getMinutes()).padStart(2, "0")}`;
+		}
+		preparePastedText(text) {
+			return text.replace(REGEX_DISALLOWED_CHARACTERS, "").substring(0, 5 - (this.textContent?.length ?? 0));
+		}
+		shouldValidate(name) {
+			return super.shouldValidate(name) || [
+				"valueAsDate",
+				"min",
+				"max",
+				"dateFilter"
+			].includes(name);
+		}
+		validate() {
+			super.validate();
+			if (!this.value) this._removeValidityErrors();
+			else if (!this._valueAsTime) this.setValidityFlag("badInput", i18nTimeInvalid[this.language.current]);
+			else if (!this._isTimeValid(this._valueAsTime)) this.setValidityFlag("rangeOverflow", i18nTimeMax[this.language.current]);
+			else this._removeValidityErrors();
+		}
+		_removeValidityErrors() {
+			["badInput", "rangeOverflow"].forEach((f) => this.removeValidityFlag(f));
+		}
+		/** Checks if values of hours and minutes are possible, to avoid non-existent times. */
+		_isTimeValid(time) {
+			return time.hours < 24 && time.minutes < 60;
+		}
+		/**  Only allow typing numbers and separator keys. */
+		_preventCharInsert(event) {
+			if (event.ctrlKey || event.altKey || event.metaKey || [
+				"Backspace",
+				"Tab",
+				"Enter",
+				"ArrowUp",
+				"ArrowDown",
+				"ArrowLeft",
+				"ArrowRight",
+				"Home",
+				"End",
+				"PageUp",
+				"PageDown",
+				"Delete"
+			].includes(event.key) || REGEX_ALLOWED_CHARACTERS.test(event.key) && (this.value.length < 5 || this._hasSelection())) return;
+			event.preventDefault();
+			if (this.value.length >= 5) sbbLiveAnnouncer.announce(i18nTimeMaxLength[this._language.current]);
+		}
+		_hasSelection() {
+			const range = window.getSelection()?.getRangeAt(0);
+			return !!range && range.startOffset !== range.endOffset;
+		}
+	};
+})();
+//#endregion
+export { SbbTimeInputElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"time-input.component-Cdd1dzcG.js","names":[],"sources":["../../../src/elements/time-input/time-input.scss?inline","../../../src/elements/time-input/time-input.component.ts"],"sourcesContent":["@use '../core/styles' as sbb;\n\n:host {\n  display: inline-flex;\n\n  // With sbb-form-field[width=\"collapsed\"], the default min width of a\n  // an inline element is basically nothing (except potentially the placeholder).\n  // Due to this, we set a minimum width for the time input element.\n  // We also cannot use width, as the form field overwrites that property.\n  min-width: var(--sbb-time-input-max-width);\n\n  // The time input also has a very specific dimension, so we also set the maximum width.\n  max-width: var(--sbb-time-input-max-width);\n  cursor: text;\n  align-items: center;\n  font-weight: normal;\n\n  @media (forced-colors: active) {\n    color: FieldText;\n  }\n}\n\n:host(:disabled) {\n  cursor: var(--sbb-cursor-default);\n}\n\n:host(:focus) {\n  text-overflow: initial !important;\n}\n\n:host(:empty)::after {\n  content: attr(placeholder);\n  @include sbb.placeholder;\n  @media (forced-colors: active) {\n    color: GrayText;\n  }\n}\n","import { type CSSResultGroup, isServer, unsafeCSS } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport {\n  i18nTimeInputChange,\n  i18nTimeInvalid,\n  i18nTimeMax,\n  i18nTimeMaxLength,\n  SbbElement,\n  SbbFormAssociatedInputMixin,\n  SbbLanguageController,\n  sbbLiveAnnouncer,\n} from '../core.ts';\n\nimport style from './time-input.scss?inline';\n\nconst REGEX_ALLOWED_CHARACTERS = /[0-9.:,\\-;_hH]/;\nconst REGEX_DISALLOWED_CHARACTERS = /[^0-9.:,\\-;_hH]/g;\nconst REGEX_GROUPS_WITHOUT_COLON = /^([0-9]{1,2})([0-9]{2})$/;\nconst REGEX_GROUPS_WITH_COLON = /^([0-9]{1,2})?[.:,\\-;_hH]?([0-9]{1,2})?$/;\n\ninterface Time {\n  hours: number;\n  minutes: number;\n}\n\n/**\n * Custom input for a time.\n */\nexport class SbbTimeInputElement extends SbbFormAssociatedInputMixin(SbbElement) {\n  public static override readonly elementName: string = 'sbb-time-input';\n  public static override styles: CSSResultGroup = [unsafeCSS(style)];\n\n  /**\n   * The value of the time input. Reflects the current text value\n   * of this input.\n   */\n  public override set value(value: string) {\n    value =\n      typeof value === 'string'\n        ? value.replace(REGEX_DISALLOWED_CHARACTERS, '').substring(0, 5)\n        : '';\n    this._tryParseValue(value);\n    // As long as this element has focus we delay automatically updating\n    // the value with the formatted string of the parsed date.\n    if (!isServer && !this.isSelected() && this.valueAsDate !== null) {\n      value = this._formatTime();\n    }\n    super.value = value;\n  }\n  public override get value(): string {\n    return super.value ?? '';\n  }\n\n  /** Formats the current input's value as date. */\n  @property({ attribute: false })\n  public set valueAsDate(value: Date | null) {\n    const time = this._toTime(value);\n    if (\n      this.isSelected() &&\n      (time === null || this._isSameTime(time, this._parseValue(this.value)))\n    ) {\n      // Do nothing, as the user is currently editing the value and the parsed\n      // time is the same as the current value.\n      // This can also happen with Angular Forms Signals, as it currently\n      // continuously invokes writeValue, which assigns to this setter.\n    } else if (time) {\n      this._valueAsTime = time;\n      const formattedValue = this._formatTime();\n      if (this.value !== formattedValue) {\n        this.value = formattedValue;\n      }\n    } else {\n      this._valueAsTime = null;\n      this.value = '';\n    }\n  }\n  public get valueAsDate(): Date | null {\n    if (this._valueAsTime && this._isTimeValid(this._valueAsTime)) {\n      const date = new Date(0);\n      date.setHours(this._valueAsTime.hours);\n      date.setMinutes(this._valueAsTime.minutes);\n      return date;\n    } else {\n      return null;\n    }\n  }\n  private _valueAsTime?: Time | null;\n\n  /**\n   * Stores the last string and parsed date object value to prevent repeated\n   * parsing of the string value.\n   */\n  private _valueCache?: [string, Time | null];\n\n  private _language = new SbbLanguageController(this);\n\n  public constructor() {\n    super();\n    this.addEventListener?.('change', () => this._updateValueDateFormat(), { capture: true });\n    this.addEventListener?.('change', () =>\n      sbbLiveAnnouncer.announce(i18nTimeInputChange(this.value)[this._language.current]),\n    );\n    this.addEventListener?.('keydown', (event) => this._preventCharInsert(event));\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    this.inputMode ||= 'numeric';\n    this.placeholder ||= 'HH:MM';\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n  }\n\n  protected override updateFormValue(): void {\n    this._tryParseValue();\n    const formValue = this.valueAsDate !== null ? this._formatTime() : null;\n    this.internals.setFormValue(formValue, this.value);\n  }\n\n  private _tryParseValue(value = this.value): void {\n    if (this._valueCache?.[0] !== value) {\n      this._valueAsTime = this._parseValue(value);\n      this._valueCache = [value, this._valueAsTime ?? null];\n    }\n  }\n\n  /** Validate input against the defined RegExps. */\n  private _parseValue(value: string | undefined): Time | null {\n    const trimmedValue = value?.trim();\n    if (!trimmedValue) {\n      return null;\n    }\n\n    // Special case: the input is 3 or 4 digits; split like: AB?:CD\n    const match =\n      trimmedValue.match(REGEX_GROUPS_WITHOUT_COLON) ?? trimmedValue.match(REGEX_GROUPS_WITH_COLON);\n    if (match) {\n      return { hours: +match[1] || 0, minutes: +match[2] || 0 };\n    }\n\n    return null;\n  }\n\n  private _toTime(value: Date | null): Time | null {\n    return value instanceof Date && !isNaN(value.valueOf())\n      ? { hours: value.getHours(), minutes: value.getMinutes() }\n      : null;\n  }\n\n  private _isSameTime(time1: Time | null, time2: Time | null): boolean {\n    return !!(\n      time1 == time2 ||\n      (time1 && time2 && time1.hours === time2.hours && time1.minutes === time2.minutes)\n    );\n  }\n\n  private _updateValueDateFormat(): void {\n    if (this.valueAsDate) {\n      const formattedDate = this._formatTime();\n      if (this.value !== formattedDate) {\n        super.value = formattedDate;\n      }\n    }\n  }\n\n  private _formatTime(): string {\n    const value = this.valueAsDate;\n    if (!value) {\n      return '';\n    }\n    const hours = String(value.getHours()).padStart(2, '0');\n    const minutes = String(value.getMinutes()).padStart(2, '0');\n    return `${hours}:${minutes}`;\n  }\n\n  protected override preparePastedText(text: string): string {\n    return text\n      .replace(REGEX_DISALLOWED_CHARACTERS, '')\n      .substring(0, 5 - (this.textContent?.length ?? 0));\n  }\n\n  protected override shouldValidate(name: PropertyKey | undefined): boolean {\n    return (\n      super.shouldValidate(name) ||\n      ['valueAsDate', 'min', 'max', 'dateFilter'].includes(name as string)\n    );\n  }\n\n  protected override validate(): void {\n    super.validate();\n    if (!this.value) {\n      this._removeValidityErrors();\n    } else if (!this._valueAsTime) {\n      this.setValidityFlag('badInput', i18nTimeInvalid[this.language.current]);\n    } else if (!this._isTimeValid(this._valueAsTime)) {\n      this.setValidityFlag('rangeOverflow', i18nTimeMax[this.language.current]);\n    } else {\n      this._removeValidityErrors();\n    }\n  }\n\n  private _removeValidityErrors(): void {\n    (['badInput', 'rangeOverflow'] as const).forEach((f) => this.removeValidityFlag(f));\n  }\n\n  /** Checks if values of hours and minutes are possible, to avoid non-existent times. */\n  private _isTimeValid(time: Time): boolean {\n    return time.hours < 24 && time.minutes < 60;\n  }\n\n  /**  Only allow typing numbers and separator keys. */\n  private _preventCharInsert(event: KeyboardEvent): void {\n    const alwaysAllowed = [\n      'Backspace',\n      'Tab',\n      'Enter',\n      'ArrowUp',\n      'ArrowDown',\n      'ArrowLeft',\n      'ArrowRight',\n      'Home',\n      'End',\n      'PageUp',\n      'PageDown',\n      'Delete',\n    ];\n\n    if (\n      event.ctrlKey ||\n      event.altKey ||\n      event.metaKey ||\n      alwaysAllowed.includes(event.key) ||\n      (REGEX_ALLOWED_CHARACTERS.test(event.key) && (this.value.length < 5 || this._hasSelection()))\n    ) {\n      return;\n    }\n\n    event.preventDefault();\n    if (this.value.length >= 5) {\n      sbbLiveAnnouncer.announce(i18nTimeMaxLength[this._language.current]);\n    }\n  }\n\n  private _hasSelection(): boolean {\n    const range = window.getSelection()?.getRangeAt(0);\n    return !!range && range.startOffset !== range.endOffset;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-time-input': SbbTimeInputElement;\n  }\n}\n"],"mappings":"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"}

package/development/time-input.js

@@ -1,4 +1,4 @@
-import { t as SbbTimeInputElement } from "./time-input.component-CGPW3RCw.js";
+import { t as SbbTimeInputElement } from "./time-input.component-Cdd1dzcG.js";
 import "./time-input.pure.js";
 //#region src/elements/time-input.ts
 /** @entrypoint */

package/development/time-input.pure.js

@@ -1,2 +1,2 @@
-import { t as SbbTimeInputElement } from "./time-input.component-CGPW3RCw.js";
+import { t as SbbTimeInputElement } from "./time-input.component-Cdd1dzcG.js";
 export { SbbTimeInputElement };

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@sbb-esta/lyne-elements-dev",
-  "version": "5.0.0-next.3-dev.1780293128",
+  "version": "5.0.0-next.3-dev.1780308310",
   "description": "Lyne Design System",
   "keywords": [
     "design system",
     "web components",
     "lit",
-    "https://github.com/sbb-design-systems/lyne-components/commit/3c261cb2488cbbf23e11a0ed60594fc7624520ca"
+    "https://github.com/sbb-design-systems/lyne-components/commit/91a12a1b6938ede80e293d4805eb1543ddd7fe3c"
   ],
   "type": "module",
   "exports": {

package/time-input/time-input.component.js

@@ -1,2 +1,2 @@
-import { t as e } from "../time-input.component-DTMCclRN.js";
+import { t as e } from "../time-input.component-j2vUlNKx.js";
 export { e as SbbTimeInputElement };