@sbb-esta/lyne-elements 2.7.1 → 2.9.0

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

@@ -0,0 +1,427 @@
+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, isServer, LitElement, html } from "lit";
+import { customElement, property, state } from "lit/decorators.js";
+import { readConfig } from "../../core/config.js";
+import { SbbIdReferenceController, SbbLanguageController } from "../../core/controllers.js";
+import { defaultDateAdapter } from "../../core/datetime.js";
+import { forceType } from "../../core/decorators.js";
+import { findReferencedElement } from "../../core/dom.js";
+import { EventEmitter, forwardEvent } from "../../core/eventing.js";
+import { i18nDatePickerPlaceholder, i18nDateChangedTo } from "../../core/i18n.js";
+import { SbbDatepickerAssociationHostController } from "../common.js";
+const style = css`:host {
+  border: 0;
+  clip: rect(0 0 0 0);
+  height: 1px;
+  margin: -1px;
+  overflow: hidden;
+  padding: 0;
+  position: absolute;
+  white-space: nowrap;
+  width: 1px;
+}`;
+function getDatePicker(element, trigger) {
+  var _a, _b;
+  if (!trigger) {
+    return (_b = (_a = element.closest) == null ? void 0 : _a.call(element, "sbb-form-field")) == null ? void 0 : _b.querySelector("sbb-datepicker");
+  }
+  return findReferencedElement(trigger);
+}
+const datepickerControlRegisteredEventFactory = () => new CustomEvent("datepickerControlRegistered", {
+  bubbles: false,
+  composed: true
+});
+let nextId = 0;
+let warningLogged = false;
+const isDateInput = (element) => (element == null ? void 0 : element.localName) === "sbb-date-input";
+let SbbDatepickerElement = (() => {
+  var _wide_accessor_storage, _input_accessor_storage, __inputElement_accessor_storage, _a;
+  let _classDecorators = [customElement("sbb-datepicker")];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = LitElement;
+  let _instanceExtraInitializers = [];
+  let _wide_decorators;
+  let _wide_initializers = [];
+  let _wide_extraInitializers = [];
+  let _set_dateFilter_decorators;
+  let _input_decorators;
+  let _input_initializers = [];
+  let _input_extraInitializers = [];
+  let _set_now_decorators;
+  let _set_valueAsDate_decorators;
+  let __inputElement_decorators;
+  let __inputElement_initializers = [];
+  let __inputElement_extraInitializers = [];
+  var SbbDatepickerElement2 = (_a = class extends _classSuper {
+    constructor() {
+      var _a2;
+      super(...arguments);
+      __privateAdd(this, _wide_accessor_storage);
+      __privateAdd(this, _input_accessor_storage);
+      __privateAdd(this, __inputElement_accessor_storage);
+      __privateSet(this, _wide_accessor_storage, (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _wide_initializers, false)));
+      this._dateFilter = __runInitializers(this, _wide_extraInitializers);
+      __privateSet(this, _input_accessor_storage, __runInitializers(this, _input_initializers, null));
+      this._now = __runInitializers(this, _input_extraInitializers);
+      __privateSet(this, __inputElement_accessor_storage, __runInitializers(this, __inputElement_initializers, null));
+      this._change = (__runInitializers(this, __inputElement_extraInitializers), new EventEmitter(this, SbbDatepickerElement2.events.change, {
+        bubbles: true
+      }));
+      this._inputUpdated = new EventEmitter(this, SbbDatepickerElement2.events.inputUpdated, { bubbles: true, cancelable: true });
+      this._datePickerUpdated = new EventEmitter(this, SbbDatepickerElement2.events.datePickerUpdated, {
+        bubbles: true,
+        cancelable: true
+      });
+      this._validationChange = new EventEmitter(this, SbbDatepickerElement2.events.validationChange);
+      this._inputElementPlaceholderMutable = false;
+      this._inputIdReferenceController = new SbbIdReferenceController(this, "input");
+      this._inputObserver = !isServer ? new MutationObserver((mutationsList) => {
+        var _a3;
+        this._emitInputUpdated();
+        (_a3 = this._associationController) == null ? void 0 : _a3.updateControls();
+        if (this.inputElement && !isDateInput(this.inputElement) && (mutationsList == null ? void 0 : mutationsList.some((e) => e.attributeName === "value"))) {
+          const value = this.inputElement.getAttribute("value");
+          this.valueAsDate = this._dateAdapter.parse(value, this.now) ?? value;
+        }
+      }) : null;
+      this._dateAdapter = ((_a2 = readConfig().datetime) == null ? void 0 : _a2.dateAdapter) ?? defaultDateAdapter;
+      this._language = new SbbLanguageController(this);
+      this._associationController = new SbbDatepickerAssociationHostController(this);
+    }
+    /** If set to true, two months are displayed. */
+    get wide() {
+      return __privateGet(this, _wide_accessor_storage);
+    }
+    set wide(value) {
+      __privateSet(this, _wide_accessor_storage, value);
+    }
+    /**
+     * A function used to filter out dates.
+     * @deprecated Use dateFilter from SbbDateInputElement.
+     */
+    set dateFilter(value) {
+      this._dateFilter = value;
+    }
+    get dateFilter() {
+      return this._dateFilter ?? (isDateInput(this.inputElement) ? this.inputElement.dateFilter : null) ?? (() => true);
+    }
+    // TODO: Replace HTMLElement by HTMLInputElement | SbbDateInputElement
+    /**
+     * Reference of the sbb-date-input instance or the native input connected to the datepicker.
+     * If given a string, it will be treated as an id reference and an attempt is
+     * made to be resolved for the containing document fragment.
+     * If given a HTMLElement instance, it will be used as is.
+     */
+    get input() {
+      return __privateGet(this, _input_accessor_storage);
+    }
+    set input(value) {
+      __privateSet(this, _input_accessor_storage, value);
+    }
+    /**
+     * A configured date which acts as the current date instead of the real current date.
+     * Recommended for testing purposes.
+     */
+    set now(value) {
+      this._now = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+    }
+    get now() {
+      return this._now ?? this._dateAdapter.today();
+    }
+    /**
+     * The currently selected date as a Date or custom date provider instance.
+     * @deprecated Use valueAsDate from SbbDateInputElement.
+     */
+    set valueAsDate(value) {
+      if (isDateInput(this.inputElement)) {
+        this.inputElement.valueAsDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+        return;
+      }
+      this._valueAsDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+      if (this._tryApplyFormatToInput()) {
+        this.inputElement.dispatchEvent(new Event("blur", { composed: true }));
+      }
+    }
+    get valueAsDate() {
+      if (isDateInput(this.inputElement)) {
+        return this.inputElement.valueAsDate;
+      }
+      return this._valueAsDate ?? null;
+    }
+    /** The resolved associated input element, as defined by `input`. */
+    get inputElement() {
+      return this._inputElement;
+    }
+    get _inputElement() {
+      return __privateGet(this, __inputElement_accessor_storage);
+    }
+    set _inputElement(value) {
+      __privateSet(this, __inputElement_accessor_storage, value);
+    }
+    connectedCallback() {
+      super.connectedCallback();
+      this.id || (this.id = `sbb-datepicker-${++nextId}`);
+      this._configureInputElement();
+    }
+    requestUpdate(name, oldValue, options) {
+      super.requestUpdate(name, oldValue, options);
+      if (this.hasUpdated && !name && this.inputElement) {
+        if (this._inputElementPlaceholderMutable) {
+          this.inputElement.placeholder = i18nDatePickerPlaceholder[this._language.current];
+        }
+        if (this.valueAsDate) {
+          this.inputElement.value = this._dateAdapter.format(this.valueAsDate);
+        }
+      }
+      if (!isServer && (!name || name === "input") && this.hasUpdated) {
+        this._configureInputElement();
+      }
+    }
+    willUpdate(changedProperties) {
+      super.willUpdate(changedProperties);
+      if (changedProperties.has("wide") || changedProperties.has("dateFilter") || changedProperties.has("now")) {
+        this._associationController.updateControls();
+        this._datePickerUpdated.emit();
+      }
+      if (changedProperties.has("valueAsDate")) {
+        this._setAriaLiveMessage();
+      }
+    }
+    disconnectedCallback() {
+      var _a2, _b;
+      super.disconnectedCallback();
+      (_a2 = this._inputObserver) == null ? void 0 : _a2.disconnect();
+      (_b = this._inputAbortController) == null ? void 0 : _b.abort();
+      this._inputElement = null;
+    }
+    firstUpdated(changedProperties) {
+      super.firstUpdated(changedProperties);
+      this._setAriaLiveMessage();
+    }
+    /**
+     * @internal
+     * Whether a custom now is configured.
+     */
+    hasCustomNow() {
+      return !!this._now;
+    }
+    _configureInputElement() {
+      var _a2, _b, _c, _d, _e, _f;
+      const inputElement = this.input instanceof HTMLInputElement || this.input instanceof HTMLElement && isDateInput(this.input) ? this.input : this._inputIdReferenceController.find() ?? ((_b = (_a2 = this.closest) == null ? void 0 : _a2.call(this, "sbb-form-field")) == null ? void 0 : _b.querySelector("input,sbb-date-input")) ?? null;
+      if (inputElement === this.inputElement) {
+        return;
+      }
+      (_c = this._inputAbortController) == null ? void 0 : _c.abort();
+      (_d = this._inputObserver) == null ? void 0 : _d.disconnect();
+      this._inputElement = inputElement;
+      if (!this.inputElement) {
+        return;
+      }
+      const isNativeInput = !isDateInput(this.inputElement);
+      if (isNativeInput && true && !warningLogged) {
+        warningLogged = true;
+        console.warn("Using <sbb-datepicker> with a native <input> is deprecated. Use a <sbb-date-input> instead of <input>.");
+      }
+      this._inputAbortController = new AbortController();
+      (_e = this._inputObserver) == null ? void 0 : _e.observe(this.inputElement, {
+        attributeFilter: ["disabled", "readonly", "min", "max", "value"]
+      });
+      if (isNativeInput) {
+        this._inputElementPlaceholderMutable = !this.inputElement.placeholder;
+        this.inputElement.type = "text";
+        if (this._inputElementPlaceholderMutable) {
+          this.inputElement.placeholder = i18nDatePickerPlaceholder[this._language.current];
+        }
+      }
+      const options = { signal: this._inputAbortController.signal };
+      this.inputElement.addEventListener("input", (e) => {
+        forwardEvent(e, this);
+        this._parseInput();
+      }, options);
+      this.inputElement.addEventListener("change", () => this._handleInputChange(), options);
+      this.inputElement.addEventListener("ɵchange", () => {
+        var _a3;
+        return (_a3 = this._associationController) == null ? void 0 : _a3.updateControls();
+      }, options);
+      this._parseInput(true);
+      this._tryApplyFormatToInput();
+      this._validateDate();
+      this._emitInputUpdated();
+      (_f = this._associationController) == null ? void 0 : _f.updateControls();
+    }
+    _emitInputUpdated() {
+      const { disabled, readOnly: readonly, min: minValue, max: maxValue } = this.inputElement ?? {};
+      const min = minValue && typeof minValue !== "string" ? this._dateAdapter.toIso8601(minValue) : minValue;
+      const max = maxValue && typeof maxValue !== "string" ? this._dateAdapter.toIso8601(maxValue) : maxValue;
+      this._inputUpdated.emit({ disabled, readonly, min, max });
+    }
+    _handleInputChange() {
+      var _a2;
+      if (this._tryApplyFormatToInput()) {
+        return;
+      }
+      this._validateDate();
+      this._setAriaLiveMessage();
+      this._change.emit();
+      (_a2 = this._associationController) == null ? void 0 : _a2.updateControls();
+    }
+    _tryApplyFormatToInput() {
+      if (!this.inputElement || isDateInput(this.inputElement)) {
+        return false;
+      }
+      const formattedDate = this.valueAsDate ? this._dateAdapter.format(this.valueAsDate) : "";
+      if (formattedDate && this.inputElement.value !== formattedDate) {
+        const setValue = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value").set;
+        setValue.call(this.inputElement, formattedDate);
+        this.inputElement.dispatchEvent(new InputEvent("input", { bubbles: true, composed: true }));
+        this.inputElement.dispatchEvent(new Event("change", { bubbles: true, composed: true }));
+        return true;
+      }
+      return false;
+    }
+    _validateDate() {
+      if (!this.inputElement) {
+        return;
+      }
+      const isEmptyOrValid = !this.inputElement.value || this._isDateAvailable();
+      const wasValid = !this.inputElement.hasAttribute("data-sbb-invalid");
+      this.inputElement.toggleAttribute("data-sbb-invalid", !isEmptyOrValid);
+      if (wasValid !== isEmptyOrValid) {
+        this._validationChange.emit({ valid: isEmptyOrValid });
+      }
+    }
+    _parseInput(deserializeAsFallback = false) {
+      if (isDateInput(this.inputElement)) {
+        return;
+      }
+      const value = this.inputElement.value;
+      this._valueAsDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.parse(value, this.now));
+      if (deserializeAsFallback && !this._valueAsDate) {
+        this._valueAsDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+      }
+    }
+    _setAriaLiveMessage() {
+      var _a2, _b;
+      const containerElement = (_b = (_a2 = this.shadowRoot) == null ? void 0 : _a2.querySelector) == null ? void 0 : _b.call(_a2, "#status-container");
+      if (!containerElement) {
+        return;
+      } else if (!this.valueAsDate) {
+        containerElement.innerText = "";
+      } else {
+        const date = this._dateAdapter.format(this.valueAsDate, { weekdayStyle: "long" });
+        containerElement.innerText = `${i18nDateChangedTo[this._language.current]} ${date}`;
+      }
+    }
+    render() {
+      return html`<p id="status-container" role="status"></p>`;
+    }
+    /**
+     * Calculates the first available date before the given one,
+     * considering the SbbDatepickerElement `dateFilter` property and `min` parameter (e.g. from the self-named input's attribute).
+     * @param date The starting date for calculations.
+     */
+    findPreviousAvailableDate(date) {
+      var _a2;
+      const previousDate = this._findAvailableDate(date, -1);
+      const dateMin = this._dateAdapter.deserialize((_a2 = this.inputElement) == null ? void 0 : _a2.min);
+      if (!dateMin || this._dateAdapter.isValid(dateMin) && this._dateAdapter.compareDate(previousDate, dateMin) >= 0) {
+        return previousDate;
+      }
+      return date;
+    }
+    /**
+     * Calculates the first available date after the given one,
+     * considering the SbbDatepickerElement `dateFilter` property and `max` parameter (e.g. from the self-named input's attribute).
+     * @param date The starting date for calculations.
+     */
+    findNextAvailableDate(date) {
+      var _a2;
+      const nextDate = this._findAvailableDate(date, 1);
+      const dateMax = this._dateAdapter.deserialize((_a2 = this.inputElement) == null ? void 0 : _a2.max);
+      if (!dateMax || this._dateAdapter.isValid(dateMax) && this._dateAdapter.compareDate(nextDate, dateMax) <= 0) {
+        return nextDate;
+      }
+      return date;
+    }
+    /**
+     * Returns the first available date before or after a given one, considering the `dateFilter` property.
+     * @param date The starting date for calculations.
+     * @param delta The number of days to add/subtract from the starting one.
+     */
+    _findAvailableDate(date, delta) {
+      let availableDate = this._dateAdapter.addCalendarDays(date, delta);
+      if (this.dateFilter) {
+        while (!this.dateFilter(availableDate)) {
+          availableDate = this._dateAdapter.addCalendarDays(availableDate, delta);
+        }
+      }
+      return availableDate;
+    }
+    /**
+     * Checks if valueAsDate is valid, considering the SbbDatepickerElement `dateFilter` property
+     * and `min` and `max` parameters (e.g. from the self-named input's attributes).
+     */
+    _isDateAvailable() {
+      var _a2, _b, _c;
+      if (!this.valueAsDate) {
+        return false;
+      }
+      const dateMin = this._dateAdapter.deserialize((_a2 = this.inputElement) == null ? void 0 : _a2.min);
+      const dateMax = this._dateAdapter.deserialize((_b = this.inputElement) == null ? void 0 : _b.max);
+      if (this._dateAdapter.isValid(dateMin) && this._dateAdapter.compareDate(this.valueAsDate, dateMin) < 0 || this._dateAdapter.isValid(dateMax) && this._dateAdapter.compareDate(this.valueAsDate, dateMax) > 0) {
+        return false;
+      }
+      return ((_c = this.dateFilter) == null ? void 0 : _c.call(this, this.valueAsDate)) ?? true;
+    }
+  }, _wide_accessor_storage = new WeakMap(), _input_accessor_storage = new WeakMap(), __inputElement_accessor_storage = new WeakMap(), _classThis = _a, (() => {
+    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+    _wide_decorators = [forceType(), property({ type: Boolean })];
+    _set_dateFilter_decorators = [property({ attribute: false })];
+    _input_decorators = [property()];
+    _set_now_decorators = [property()];
+    _set_valueAsDate_decorators = [property({ attribute: false })];
+    __inputElement_decorators = [state()];
+    __esDecorate(_a, 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(_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, _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(_a, null, _set_now_decorators, { kind: "setter", name: "now", static: false, private: false, access: { has: (obj) => "now" in obj, set: (obj, value) => {
+      obj.now = value;
+    } }, metadata: _metadata }, null, _instanceExtraInitializers);
+    __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, __inputElement_decorators, { kind: "accessor", name: "_inputElement", static: false, private: false, access: { has: (obj) => "_inputElement" in obj, get: (obj) => obj._inputElement, set: (obj, value) => {
+      obj._inputElement = value;
+    } }, metadata: _metadata }, __inputElement_initializers, __inputElement_extraInitializers);
+    __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+    SbbDatepickerElement2 = _classThis = _classDescriptor.value;
+    if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+  })(), _a.styles = style, _a.events = {
+    change: "change",
+    inputUpdated: "inputUpdated",
+    datePickerUpdated: "datePickerUpdated",
+    validationChange: "validationChange"
+  }, __runInitializers(_classThis, _classExtraInitializers), _a);
+  return SbbDatepickerElement2 = _classThis;
+})();
+export {
+  SbbDatepickerElement,
+  datepickerControlRegisteredEventFactory,
+  getDatePicker
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"datepicker.component.js","sources":["../../../../../src/elements/datepicker/datepicker/datepicker.component.ts"],"sourcesContent":["import {\n  type CSSResultGroup,\n  html,\n  isServer,\n  LitElement,\n  type PropertyDeclaration,\n  type PropertyValues,\n  type TemplateResult,\n} from 'lit';\nimport { customElement, property, state } from 'lit/decorators.js';\n\nimport { readConfig } from '../../core/config.js';\nimport { SbbIdReferenceController, SbbLanguageController } from '../../core/controllers.js';\nimport { type DateAdapter, defaultDateAdapter } from '../../core/datetime.js';\nimport { forceType } from '../../core/decorators.js';\nimport { findReferencedElement } from '../../core/dom.js';\nimport { EventEmitter, forwardEvent } from '../../core/eventing.js';\nimport { i18nDateChangedTo, i18nDatePickerPlaceholder } from '../../core/i18n.js';\nimport type { SbbDateLike, SbbValidationChangeEvent } from '../../core/interfaces.js';\nimport type { SbbDateInputElement } from '../../date-input.js';\nimport { SbbDatepickerAssociationHostController, type SbbDatepickerButton } from '../common.js';\nimport type { SbbDatepickerToggleElement } from '../datepicker-toggle.js';\n\nimport style from './datepicker.scss?lit&inline';\n\nexport interface SbbInputUpdateEvent {\n  disabled?: boolean;\n  readonly?: boolean;\n  min?: string | number;\n  max?: string | number;\n}\n\n/**\n * Given a SbbDatepickerPreviousDayElement, a SbbDatepickerNextDayElement or a SbbDatepickerToggleElement component,\n * it returns the related SbbDatepickerElement reference, if exists.\n * @param element The element potentially connected to the SbbDatepickerElement.\n * @param trigger The id or the reference of the SbbDatePicker.\n * @deprecated No longer in use. Will be removed with next major version.\n */\nexport function getDatePicker<T = Date>(\n  element: SbbDatepickerButton<T> | SbbDatepickerToggleElement<T>,\n  trigger?: string | HTMLElement,\n): SbbDatepickerElement<T> | null | undefined {\n  if (!trigger) {\n    return element\n      .closest?.('sbb-form-field')\n      ?.querySelector<SbbDatepickerElement<T>>('sbb-datepicker');\n  }\n\n  return findReferencedElement<SbbDatepickerElement<T>>(trigger);\n}\n\n/**\n * @deprecated No longer in use.\n */\nexport const datepickerControlRegisteredEventFactory = (): CustomEvent =>\n  new CustomEvent('datepickerControlRegistered', {\n    bubbles: false,\n    composed: true,\n  });\n\nlet nextId = 0;\nlet warningLogged = false;\nconst isDateInput = <T>(\n  element: HTMLElement | HTMLInputElement | SbbDateInputElement<T> | null,\n): element is SbbDateInputElement<T> => element?.localName === 'sbb-date-input';\n\n/**\n * Combined with a native input, it displays the input's value as a formatted date.\n *\n * @event {CustomEvent<void>} change - Notifies that the connected input has changes.\n * @event {CustomEvent<void>} input - Notifies that the connected input fired the input event.\n * @event {CustomEvent<SbbInputUpdateEvent>} inputUpdated - Notifies that the attributes of the input connected to the datepicker have changes.\n * @event {CustomEvent<void>} datePickerUpdated - Notifies that the attributes of the datepicker have changes.\n * @event {CustomEvent<SbbValidationChangeEvent>} validationChange - Emits whenever the internal validation state changes.\n */\nexport\n@customElement('sbb-datepicker')\nclass SbbDatepickerElement<T = Date> extends LitElement {\n  public static override styles: CSSResultGroup = style;\n  public static readonly events = {\n    change: 'change',\n    inputUpdated: 'inputUpdated',\n    datePickerUpdated: 'datePickerUpdated',\n    validationChange: 'validationChange',\n  } as const;\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   * A function used to filter out dates.\n   * @deprecated Use dateFilter from SbbDateInputElement.\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 (\n      this._dateFilter ??\n      (isDateInput(this.inputElement) ? this.inputElement.dateFilter : null) ??\n      (() => true)\n    );\n  }\n  private _dateFilter?: (date: T | null) => boolean;\n\n  // TODO: Replace HTMLElement by HTMLInputElement | SbbDateInputElement\n  /**\n   * Reference of the sbb-date-input instance or the native input connected to the datepicker.\n   * If given a string, it will be treated as an id reference and an attempt is\n   * made to be resolved for the containing document fragment.\n   * If given a HTMLElement instance, it will be used as is.\n   */\n  @property()\n  public accessor input: string | HTMLElement | null = null;\n\n  /**\n   * A configured date which acts as the current date instead of the real current date.\n   * Recommended for testing purposes.\n   */\n  @property()\n  public set now(value: SbbDateLike<T> | null) {\n    this._now = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n  }\n  public get now(): T {\n    return this._now ?? this._dateAdapter.today();\n  }\n  private _now?: T | null;\n\n  /**\n   * The currently selected date as a Date or custom date provider instance.\n   * @deprecated Use valueAsDate from SbbDateInputElement.\n   */\n  @property({ attribute: false })\n  public set valueAsDate(value: SbbDateLike<T> | null) {\n    if (isDateInput(this.inputElement)) {\n      this.inputElement.valueAsDate = this._dateAdapter.getValidDateOrNull(\n        this._dateAdapter.deserialize(value),\n      );\n      return;\n    }\n\n    this._valueAsDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    if (this._tryApplyFormatToInput()) {\n      // Emit blur event when value is changed programmatically to notify\n      // frameworks that rely on that event to update form status.\n      this.inputElement!.dispatchEvent(new Event('blur', { composed: true }));\n    }\n  }\n  public get valueAsDate(): T | null {\n    if (isDateInput(this.inputElement)) {\n      return this.inputElement.valueAsDate;\n    }\n\n    return this._valueAsDate ?? null;\n  }\n  private _valueAsDate?: T | null;\n\n  /** The resolved associated input element, as defined by `input`. */\n  public get inputElement(): HTMLInputElement | SbbDateInputElement<T> | null {\n    return this._inputElement;\n  }\n  @state() private accessor _inputElement: HTMLInputElement | SbbDateInputElement<T> | null = null;\n\n  /** Notifies that the connected input has changes. */\n  private _change: EventEmitter = new EventEmitter(this, SbbDatepickerElement.events.change, {\n    bubbles: true,\n  });\n\n  /** Notifies that the attributes of the input connected to the datepicker have changes. */\n  private _inputUpdated: EventEmitter<SbbInputUpdateEvent> = new EventEmitter(\n    this,\n    SbbDatepickerElement.events.inputUpdated,\n    { bubbles: true, cancelable: true },\n  );\n\n  /** Notifies that the attributes of the datepicker have changes. */\n  private _datePickerUpdated: EventEmitter = new EventEmitter(\n    this,\n    SbbDatepickerElement.events.datePickerUpdated,\n    {\n      bubbles: true,\n      cancelable: true,\n    },\n  );\n\n  /** Emits whenever the internal validation state changes. */\n  private _validationChange: EventEmitter<SbbValidationChangeEvent> = new EventEmitter(\n    this,\n    SbbDatepickerElement.events.validationChange,\n  );\n\n  private _inputElementPlaceholderMutable = false;\n\n  private _inputAbortController!: AbortController;\n  private _inputIdReferenceController = new SbbIdReferenceController(this, 'input');\n\n  private _inputObserver = !isServer\n    ? new MutationObserver((mutationsList) => {\n        this._emitInputUpdated();\n        this._associationController?.updateControls();\n        // TODO: Decide whether to remove this logic by adding a value property to the datepicker.\n        if (\n          this.inputElement &&\n          !isDateInput(this.inputElement) &&\n          mutationsList?.some((e) => e.attributeName === 'value')\n        ) {\n          const value = this.inputElement.getAttribute('value');\n          this.valueAsDate = this._dateAdapter.parse(value, this.now) ?? value;\n        }\n      })\n    : null;\n\n  private _dateAdapter: DateAdapter<T> = readConfig().datetime?.dateAdapter ?? defaultDateAdapter;\n\n  private _language = new SbbLanguageController(this);\n  private _associationController = new SbbDatepickerAssociationHostController(this);\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n\n    this.id ||= `sbb-datepicker-${++nextId}`;\n    this._configureInputElement();\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 && this.inputElement) {\n      if (this._inputElementPlaceholderMutable) {\n        this.inputElement.placeholder = i18nDatePickerPlaceholder[this._language.current];\n      }\n      if (this.valueAsDate) {\n        this.inputElement.value = this._dateAdapter.format(this.valueAsDate);\n      }\n    }\n    if (!isServer && (!name || name === 'input') && this.hasUpdated) {\n      this._configureInputElement();\n    }\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (\n      changedProperties.has('wide') ||\n      changedProperties.has('dateFilter') ||\n      changedProperties.has('now')\n    ) {\n      this._associationController.updateControls();\n      this._datePickerUpdated.emit();\n    }\n    if (changedProperties.has('valueAsDate')) {\n      this._setAriaLiveMessage();\n    }\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._inputObserver?.disconnect();\n    this._inputAbortController?.abort();\n    this._inputElement = null;\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n    this._setAriaLiveMessage();\n  }\n\n  /**\n   * @internal\n   * Whether a custom now is configured.\n   */\n  public hasCustomNow(): boolean {\n    return !!this._now;\n  }\n\n  private _configureInputElement(): void {\n    const inputElement =\n      this.input instanceof HTMLInputElement ||\n      (this.input instanceof HTMLElement && isDateInput<T>(this.input))\n        ? this.input\n        : ((this._inputIdReferenceController.find() as HTMLInputElement | null) ??\n          this.closest?.('sbb-form-field')?.querySelector<HTMLInputElement>(\n            'input,sbb-date-input',\n          ) ??\n          null);\n    if (inputElement === this.inputElement) {\n      return;\n    }\n\n    this._inputAbortController?.abort();\n    this._inputObserver?.disconnect();\n    this._inputElement = inputElement;\n\n    if (!this.inputElement) {\n      return;\n    }\n\n    const isNativeInput = !isDateInput(this.inputElement);\n    if (isNativeInput && import.meta.env.DEV && !warningLogged) {\n      warningLogged = true;\n      console.warn(\n        'Using <sbb-datepicker> with a native <input> is deprecated. Use a <sbb-date-input> instead of <input>.',\n      );\n    }\n\n    this._inputAbortController = new AbortController();\n    this._inputObserver?.observe(this.inputElement, {\n      attributeFilter: ['disabled', 'readonly', 'min', 'max', 'value'],\n    });\n\n    if (isNativeInput) {\n      this._inputElementPlaceholderMutable = !this.inputElement.placeholder;\n      this.inputElement.type = 'text';\n      if (this._inputElementPlaceholderMutable) {\n        this.inputElement.placeholder = i18nDatePickerPlaceholder[this._language.current];\n      }\n    }\n\n    const options: AddEventListenerOptions = { signal: this._inputAbortController.signal };\n    this.inputElement.addEventListener(\n      'input',\n      (e) => {\n        forwardEvent(e, this);\n        this._parseInput();\n      },\n      options,\n    );\n    this.inputElement.addEventListener('change', () => this._handleInputChange(), options);\n    this.inputElement.addEventListener(\n      'ɵchange',\n      () => this._associationController?.updateControls(),\n      options,\n    );\n    this._parseInput(true);\n    this._tryApplyFormatToInput();\n    this._validateDate();\n    this._emitInputUpdated();\n    this._associationController?.updateControls();\n  }\n\n  private _emitInputUpdated(): void {\n    const { disabled, readOnly: readonly, min: minValue, max: maxValue } = this.inputElement ?? {};\n    const min = (\n      minValue && typeof minValue !== 'string' ? this._dateAdapter.toIso8601(minValue) : minValue\n    ) as string | undefined;\n    const max = (\n      maxValue && typeof maxValue !== 'string' ? this._dateAdapter.toIso8601(maxValue) : maxValue\n    ) as string | undefined;\n    this._inputUpdated.emit({ disabled, readonly, min, max });\n  }\n\n  private _handleInputChange(): void {\n    if (this._tryApplyFormatToInput()) {\n      return;\n    }\n    this._validateDate();\n    this._setAriaLiveMessage();\n    this._change.emit();\n    this._associationController?.updateControls();\n  }\n\n  private _tryApplyFormatToInput(): boolean {\n    if (!this.inputElement || isDateInput(this.inputElement)) {\n      return false;\n    }\n\n    const formattedDate = this.valueAsDate ? this._dateAdapter.format(this.valueAsDate!) : '';\n    if (formattedDate && this.inputElement.value !== formattedDate) {\n      // In order to support React onChange event, we have to get the setter and call it.\n      // https://github.com/facebook/react/issues/11600#issuecomment-345813130\n      const setValue = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')!.set!;\n      setValue.call(this.inputElement, formattedDate);\n\n      this.inputElement.dispatchEvent(new InputEvent('input', { bubbles: true, composed: true }));\n      this.inputElement.dispatchEvent(new Event('change', { bubbles: true, composed: true }));\n      return true;\n    }\n\n    return false;\n  }\n\n  private _validateDate(): void {\n    if (!this.inputElement) {\n      return;\n    }\n\n    const isEmptyOrValid = !this.inputElement.value || this._isDateAvailable();\n    const wasValid = !this.inputElement.hasAttribute('data-sbb-invalid');\n    this.inputElement.toggleAttribute('data-sbb-invalid', !isEmptyOrValid);\n    if (wasValid !== isEmptyOrValid) {\n      this._validationChange.emit({ valid: isEmptyOrValid });\n    }\n  }\n\n  private _parseInput(deserializeAsFallback = false): void {\n    if (isDateInput(this.inputElement)) {\n      return;\n    }\n\n    const value = this.inputElement!.value;\n    // We are assigning directly to the private backing property of valueAsDate\n    // as we don't want to trigger a blur event during this time.\n    this._valueAsDate = this._dateAdapter.getValidDateOrNull(\n      this._dateAdapter.parse(value, this.now),\n    );\n    if (deserializeAsFallback && !this._valueAsDate) {\n      this._valueAsDate = this._dateAdapter.getValidDateOrNull(\n        this._dateAdapter.deserialize(value),\n      );\n    }\n  }\n\n  private _setAriaLiveMessage(): void {\n    const containerElement: HTMLParagraphElement | null | undefined =\n      this.shadowRoot?.querySelector?.<HTMLParagraphElement>('#status-container');\n\n    if (!containerElement) {\n      return;\n    } else if (!this.valueAsDate) {\n      containerElement.innerText = '';\n    } else {\n      const date = this._dateAdapter.format(this.valueAsDate, { weekdayStyle: 'long' });\n      containerElement.innerText = `${i18nDateChangedTo[this._language.current]} ${date}`;\n    }\n  }\n\n  protected override render(): TemplateResult {\n    return html`<p id=\"status-container\" role=\"status\"></p>`;\n  }\n\n  /**\n   * Calculates the first available date before the given one,\n   * considering the SbbDatepickerElement `dateFilter` property and `min` parameter (e.g. from the self-named input's attribute).\n   * @param date The starting date for calculations.\n   */\n  public findPreviousAvailableDate(date: T): T {\n    const previousDate = this._findAvailableDate(date, -1);\n    const dateMin = this._dateAdapter.deserialize(this.inputElement?.min);\n\n    if (\n      !dateMin ||\n      (this._dateAdapter.isValid(dateMin) &&\n        this._dateAdapter.compareDate(previousDate, dateMin) >= 0)\n    ) {\n      return previousDate;\n    }\n    return date;\n  }\n\n  /**\n   * Calculates the first available date after the given one,\n   * considering the SbbDatepickerElement `dateFilter` property and `max` parameter (e.g. from the self-named input's attribute).\n   * @param date The starting date for calculations.\n   */\n  public findNextAvailableDate(date: T): T {\n    const nextDate = this._findAvailableDate(date, 1);\n    const dateMax = this._dateAdapter.deserialize(this.inputElement?.max);\n\n    if (\n      !dateMax ||\n      (this._dateAdapter.isValid(dateMax) && this._dateAdapter.compareDate(nextDate, dateMax) <= 0)\n    ) {\n      return nextDate;\n    }\n    return date;\n  }\n\n  /**\n   * Returns the first available date before or after a given one, considering the `dateFilter` property.\n   * @param date The starting date for calculations.\n   * @param delta The number of days to add/subtract from the starting one.\n   */\n  private _findAvailableDate(date: T, delta: number): T {\n    let availableDate = this._dateAdapter.addCalendarDays(date, delta);\n\n    if (this.dateFilter) {\n      while (!this.dateFilter(availableDate)) {\n        availableDate = this._dateAdapter.addCalendarDays(availableDate, delta);\n      }\n    }\n\n    return availableDate;\n  }\n\n  /**\n   * Checks if valueAsDate is valid, considering the SbbDatepickerElement `dateFilter` property\n   * and `min` and `max` parameters (e.g. from the self-named input's attributes).\n   */\n  private _isDateAvailable(): boolean {\n    if (!this.valueAsDate) {\n      return false;\n    }\n\n    const dateMin = this._dateAdapter.deserialize(this.inputElement?.min);\n    const dateMax = this._dateAdapter.deserialize(this.inputElement?.max);\n\n    if (\n      (this._dateAdapter.isValid(dateMin) &&\n        this._dateAdapter.compareDate(this.valueAsDate, dateMin!) < 0) ||\n      (this._dateAdapter.isValid(dateMax) &&\n        this._dateAdapter.compareDate(this.valueAsDate, dateMax!) > 0)\n    ) {\n      return false;\n    }\n\n    return this.dateFilter?.(this.valueAsDate) ?? true;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-datepicker': SbbDatepickerElement;\n  }\n\n  interface GlobalEventHandlersEventMap {\n    inputUpdated: CustomEvent<SbbInputUpdateEvent>;\n  }\n}\n"],"names":["SbbDatepickerElement","_a"],"mappings":"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"}

package/development/datepicker/datepicker-next-day/datepicker-next-day.component.d.ts

@@ -0,0 +1,18 @@
+import { CSSResultGroup } from 'lit';
+import { SbbDatepickerButton } from '../common.js';
+/**
+ * Combined with a `sbb-datepicker`, it can be used to move the date ahead.
+ */
+export declare class SbbDatepickerNextDayElement<T = Date> extends SbbDatepickerButton<T> {
+    static styles: CSSResultGroup;
+    protected iconName: string;
+    protected i18nOffBoundaryDay: Record<string, string>;
+    protected i18nSelectOffBoundaryDay: (currentDate: string) => Record<string, string>;
+    protected findAvailableDate(date: T): T;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-datepicker-next-day': SbbDatepickerNextDayElement;
+    }
+}
+//# sourceMappingURL=datepicker-next-day.component.d.ts.map

package/development/datepicker/datepicker-next-day/datepicker-next-day.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datepicker-next-day.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/datepicker/datepicker-next-day/datepicker-next-day.component.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAK1C,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAInD;;GAEG;AACH,qBAKM,2BAA2B,CAAC,CAAC,GAAG,IAAI,CAAE,SAAQ,mBAAmB,CAAC,CAAC,CAAC;IACxE,OAAuB,MAAM,EAAE,cAAc,CAAS;IAEtD,SAAS,CAAC,QAAQ,EAAE,MAAM,CAA+B;IACzD,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAe;IACnE,SAAS,CAAC,wBAAwB,kDAAqB;IAEvD,SAAS,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC;CAIxC;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,yBAAyB,EAAE,2BAA2B,CAAC;KACxD;CACF"}