@sbb-esta/lyne-elements-dev 4.7.0-dev.1773388991 → 4.7.0-dev.1773393164

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

@@ -1,2 +1,278 @@
-import { t as SbbDateInputElement } from "../date-input.component-CqsEOZfb.js";
-export { SbbDateInputElement };
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+import { __esDecorate, __runInitializers } from "tslib";
+import { css, isServer } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbElement } from "../core/base-elements.js";
+import { readConfig } from "../core/config.js";
+import { defaultDateAdapter } from "../core/datetime.js";
+import { plainDate, plainDateConverter } from "../core/decorators.js";
+import { i18nDatePickerPlaceholder, i18nDateInvalid, i18nDateMin, i18nDateMax } from "../core/i18n.js";
+import { SbbFormAssociatedInputMixin } from "../core/mixins.js";
+const style = css`:host {
+  display: inline-flex;
+  min-width: 9.375rem;
+  max-width: 100%;
+  cursor: text;
+  align-items: center;
+}
+@media (forced-colors: active) {
+  :host {
+    color: FieldText;
+  }
+}
+
+:host(:disabled) {
+  cursor: var(--sbb-cursor-default);
+}
+
+:host(:focus) {
+  text-overflow: initial !important;
+}
+
+:host(:empty)::after {
+  content: attr(placeholder);
+  color: var(--sbb-color-5);
+  -webkit-text-fill-color: var(--sbb-color-5);
+  opacity: 1;
+}
+@media (forced-colors: active) {
+  :host(:empty)::after {
+    color: GrayText;
+  }
+}`;
+Object.assign(ValidityState.prototype, {
+  get sbbDateFilter() {
+    return false;
+  }
+});
+let SbbDateInputElement = (() => {
+  var _min_accessor_storage, _max_accessor_storage, _weekdayStyle_accessor_storage, _a;
+  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 _a = class extends _classSuper {
+    constructor() {
+      super();
+      __privateAdd(this, _min_accessor_storage);
+      __privateAdd(this, _max_accessor_storage);
+      __privateAdd(this, _weekdayStyle_accessor_storage);
+      this._valueAsDate = __runInitializers(this, _instanceExtraInitializers);
+      __privateSet(this, _min_accessor_storage, __runInitializers(this, _min_initializers, null));
+      __privateSet(this, _max_accessor_storage, (__runInitializers(this, _min_extraInitializers), __runInitializers(this, _max_initializers, null)));
+      __privateSet(this, _weekdayStyle_accessor_storage, (__runInitializers(this, _max_extraInitializers), __runInitializers(this, _weekdayStyle_initializers, "short")));
+      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 });
+    }
+    /**
+     * 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.matches(":focus") && 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 (!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;
+    }
+    /**
+     * 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 __privateGet(this, _min_accessor_storage);
+    }
+    set min(value) {
+      __privateSet(this, _min_accessor_storage, value);
+    }
+    /**
+     * 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 __privateGet(this, _max_accessor_storage);
+    }
+    set max(value) {
+      __privateSet(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;
+    }
+    /**
+     * 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 __privateGet(this, _weekdayStyle_accessor_storage);
+    }
+    set weekdayStyle(value) {
+      __privateSet(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");
+    }
+    /**
+     * 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) {
+        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));
+    }
+  }, _min_accessor_storage = new WeakMap(), _max_accessor_storage = new WeakMap(), _weekdayStyle_accessor_storage = new WeakMap(), (() => {
+    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(_a, 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(_a, 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(_a, 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(_a, 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(_a, 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(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+  })(), _a.elementName = "sbb-date-input", _a.styles = style, _a;
+})();
+export {
+  SbbDateInputElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"date-input.component.js","sources":["../../../../src/elements/date-input/date-input.component.ts"],"sourcesContent":["import { type CSSResultGroup, isServer, type PropertyDeclaration } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { SbbElement } from '../core/base-elements.ts';\nimport { readConfig } from '../core/config.ts';\nimport { type DateAdapter, defaultDateAdapter } from '../core/datetime.ts';\nimport { plainDate, plainDateConverter } from '../core/decorators.ts';\nimport {\n  i18nDateInvalid,\n  i18nDateMax,\n  i18nDateMin,\n  i18nDatePickerPlaceholder,\n} from '../core/i18n.ts';\nimport { SbbFormAssociatedInputMixin } from '../core/mixins.ts';\nimport type { SbbDatepickerElement } from '../datepicker.ts';\n\nimport style from './date-input.scss?lit&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 = 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.matches(':focus') && 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 (!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"],"names":[],"mappings":"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"}

package/development/date-input.js

@@ -1,9 +1,6 @@
-import { t as SbbDateInputElement } from "./date-input.component-CqsEOZfb.js";
-import "./date-input.pure.js";
-//#region src/elements/date-input.ts
-/** @entrypoint */
+import { SbbDateInputElement } from "./date-input/date-input.component.js";
 SbbDateInputElement.define();
-//#endregion
-export { SbbDateInputElement };
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS1pbnB1dC5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZWxlbWVudHMvZGF0ZS1pbnB1dC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7IFNiYkRhdGVJbnB1dEVsZW1lbnQgfSBmcm9tICcuL2RhdGUtaW5wdXQucHVyZS50cyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vZGF0ZS1pbnB1dC5wdXJlLnRzJztcblxuU2JiRGF0ZUlucHV0RWxlbWVudC5kZWZpbmUoKTtcbiJdLCJtYXBwaW5ncyI6Ijs7OztBQUtBLG9CQUFvQixRQUFRIn0=
+export {
+  SbbDateInputElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS1pbnB1dC5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2VsZW1lbnRzL2RhdGUtaW5wdXQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqIEBlbnRyeXBvaW50ICovXG5pbXBvcnQgeyBTYmJEYXRlSW5wdXRFbGVtZW50IH0gZnJvbSAnLi9kYXRlLWlucHV0LnB1cmUudHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL2RhdGUtaW5wdXQucHVyZS50cyc7XG5cblNiYkRhdGVJbnB1dEVsZW1lbnQuZGVmaW5lKCk7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUtBLG9CQUFvQixPQUFBOyJ9

package/development/date-input.pure.js

@@ -1,2 +1,5 @@
-import { t as SbbDateInputElement } from "./date-input.component-CqsEOZfb.js";
-export { SbbDateInputElement };
+import { SbbDateInputElement } from "./date-input/date-input.component.js";
+export {
+  SbbDateInputElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS1pbnB1dC5wdXJlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjsifQ==

package/development/datepicker/common/datepicker-button.js

@@ -1,2 +1,155 @@
-import { n as SbbDatepickerButtonBase, r as datepicker_button_default, t as SbbDatepickerButton } from "../../datepicker-button-BORzfDaA.js";
-export { SbbDatepickerButton, SbbDatepickerButtonBase, datepicker_button_default as datepickerButtonStyle };
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+import { __runInitializers, __esDecorate } from "tslib";
+import { css, html } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbButtonBaseElement } from "../../core/base-elements.js";
+import { readConfig } from "../../core/config.js";
+import { SbbLanguageController } from "../../core/controllers.js";
+import { defaultDateAdapter } from "../../core/datetime.js";
+import { idReference } from "../../core/decorators.js";
+import { i18nToday } from "../../core/i18n.js";
+import { SbbNegativeMixin } from "../../core/mixins.js";
+import { SbbDateInputElement } from "../../date-input.js";
+import "../../icon.js";
+const datepickerButton = css`.sbb-action-base {
+  margin: auto;
+  -webkit-tap-highlight-color: transparent;
+}`;
+let SbbDatepickerButtonBase = (() => {
+  var _input_accessor_storage, _a;
+  let _classSuper = SbbNegativeMixin(SbbButtonBaseElement);
+  let _input_decorators;
+  let _input_initializers = [];
+  let _input_extraInitializers = [];
+  return _a = class extends _classSuper {
+    constructor() {
+      super(...arguments);
+      __privateAdd(this, _input_accessor_storage);
+      __privateSet(this, _input_accessor_storage, __runInitializers(this, _input_initializers, null));
+      this._inputDisabled = (__runInitializers(this, _input_extraInitializers), true);
+      this.dateAdapter = readConfig().datetime?.dateAdapter ?? defaultDateAdapter;
+      this.language = new SbbLanguageController(this);
+    }
+    /**
+     * The associated date input element.
+     *
+     * For attribute usage, provide an id reference.
+     */
+    get input() {
+      return __privateGet(this, _input_accessor_storage);
+    }
+    set input(value) {
+      __privateSet(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>`;
+    }
+  }, _input_accessor_storage = new WeakMap(), (() => {
+    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+    _input_decorators = [idReference(), property()];
+    __esDecorate(_a, 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(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+  })(), _a.sbbDateInputAssociated = true, _a;
+})();
+class SbbDatepickerButton extends SbbDatepickerButtonBase {
+  get disabled() {
+    return this._disabled || super.disabled;
+  }
+  constructor() {
+    super();
+    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];
+  }
+}
+export {
+  SbbDatepickerButton,
+  SbbDatepickerButtonBase,
+  datepickerButton as datepickerButtonStyle
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"datepicker-button.js","sources":["../../../../../src/elements/datepicker/common/datepicker-button.ts"],"sourcesContent":["import { html, 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 '../../icon.ts';\n\nexport { default as datepickerButtonStyle } from './datepicker-button.scss?lit&inline';\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"],"names":[],"mappings":"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"}

package/development/datepicker/common.js

@@ -1,8 +1,9 @@
-import { n as SbbDatepickerButtonBase, r as datepicker_button_default, t as SbbDatepickerButton } from "../datepicker-button-BORzfDaA.js";
-//#region src/elements/datepicker/common.ts
+import { SbbDatepickerButton, SbbDatepickerButtonBase, datepickerButtonStyle } from "./common/datepicker-button.js";
 console.warn(`The entrypoint '@sbb-esta/elements/datepicker/common.js' has been deprecated.
 Use either '@sbb-esta/elements/datepicker.js' or '@sbb-esta/elements/datepicker.pure.js' instead.`);
-//#endregion
-export { SbbDatepickerButton, SbbDatepickerButtonBase, datepicker_button_default as datepickerButtonStyle };
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9uLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9lbGVtZW50cy9kYXRlcGlja2VyL2NvbW1vbi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmV4cG9ydCAqIGZyb20gJy4vY29tbW9uL2RhdGVwaWNrZXItYnV0dG9uLnRzJztcblxuY29uc29sZS53YXJuKGBUaGUgZW50cnlwb2ludCAnQHNiYi1lc3RhL2VsZW1lbnRzL2RhdGVwaWNrZXIvY29tbW9uLmpzJyBoYXMgYmVlbiBkZXByZWNhdGVkLlxuVXNlIGVpdGhlciAnQHNiYi1lc3RhL2VsZW1lbnRzL2RhdGVwaWNrZXIuanMnIG9yICdAc2JiLWVzdGEvZWxlbWVudHMvZGF0ZXBpY2tlci5wdXJlLmpzJyBpbnN0ZWFkLmApO1xuIl0sIm1hcHBpbmdzIjoiOztBQUdBLFFBQVEsS0FBSzttR0FDc0YifQ==
+export {
+  SbbDatepickerButton,
+  SbbDatepickerButtonBase,
+  datepickerButtonStyle
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9uLmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZWxlbWVudHMvZGF0ZXBpY2tlci9jb21tb24udHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqIEBlbnRyeXBvaW50ICovXG5leHBvcnQgKiBmcm9tICcuL2NvbW1vbi9kYXRlcGlja2VyLWJ1dHRvbi50cyc7XG5cbmNvbnNvbGUud2FybihgVGhlIGVudHJ5cG9pbnQgJ0BzYmItZXN0YS9lbGVtZW50cy9kYXRlcGlja2VyL2NvbW1vbi5qcycgaGFzIGJlZW4gZGVwcmVjYXRlZC5cblVzZSBlaXRoZXIgJ0BzYmItZXN0YS9lbGVtZW50cy9kYXRlcGlja2VyLmpzJyBvciAnQHNiYi1lc3RhL2VsZW1lbnRzL2RhdGVwaWNrZXIucHVyZS5qcycgaW5zdGVhZC5gKTtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBR0EsUUFBUSxLQUFLO0FBQUEsa0dBQ3FGOyJ9