@sbb-esta/lyne-elements 2.7.1 → 2.9.0

package/development/calendar/calendar.component.js

@@ -0,0 +1,1547 @@
+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, LitElement, isServer, nothing, html } from "lit";
+import { customElement, property, state } from "lit/decorators.js";
+import { classMap } from "lit/directives/class-map.js";
+import { sbbInputModalityDetector, isArrowKeyOrPageKeysPressed } from "../core/a11y.js";
+import { readConfig } from "../core/config.js";
+import { SbbLanguageController, SbbMediaMatcherController, SbbMediaQueryBreakpointMediumAndAbove } from "../core/controllers.js";
+import { defaultDateAdapter, YEARS_PER_PAGE, DAYS_PER_ROW, MONTHS_PER_ROW, YEARS_PER_ROW, MONTHS_PER_PAGE } from "../core/datetime.js";
+import { forceType } from "../core/decorators.js";
+import { EventEmitter } from "../core/eventing.js";
+import { i18nPreviousMonth, i18nNextMonth, i18nYearMonthSelection, i18nPreviousYear, i18nNextYear, i18nCalendarDateSelection, i18nPreviousYearRange, i18nNextYearRange } from "../core/i18n.js";
+import { SbbHydrationMixin } from "../core/mixins.js";
+import "../button/secondary-button.js";
+import "../icon.js";
+import "../screen-reader-only.js";
+const style = css`*,
+::before,
+::after {
+  box-sizing: border-box;
+}
+
+:host {
+  display: block;
+  width: max-content;
+  --sbb-calendar-cell-size: 2.5rem;
+  --sbb-calendar-hover-shift: 0.0625rem;
+  --sbb-calendar-wide-cell-size: 4.375rem;
+  --sbb-calendar-cell-disabled-color: var(--sbb-color-granite);
+  --sbb-calendar-header-color: var(--sbb-color-granite);
+  --sbb-calendar-cell-background-color: transparent;
+  --sbb-calendar-cell-padding: 0.125rem;
+  --sbb-calendar-cell-color: var(--sbb-color-charcoal);
+  --sbb-calendar-cell-selected-color: var(--sbb-color-white);
+  --sbb-calendar-cell-selected-background-color: var(--sbb-color-charcoal);
+  --sbb-calendar-cell-disabled-height: 0.09375rem;
+  --sbb-calendar-cell-disabled-width: 1.59375rem;
+  --sbb-calendar-cell-transition-duration: var(
+    --sbb-disable-animation-duration,
+    var(--sbb-animation-duration-2x)
+  );
+  --sbb-calendar-cell-transition-easing-function: var(--sbb-animation-easing);
+  --sbb-calendar-tables-gap: var(--sbb-spacing-fixed-10x);
+  --sbb-calendar-table-animation-shift: 0.00625rem;
+  --sbb-calendar-table-animation-duration: 0.1ms;
+  --sbb-calendar-table-column-spaces: 12;
+  --sbb-calendar-control-view-change-height: 2.75rem;
+  --sbb-calendar-control-view-change-color: var(--sbb-color-charcoal);
+  --sbb-calendar-control-view-change-background: var(--sbb-color-white);
+}
+@media (min-width: calc(22.5rem)) {
+  :host {
+    --sbb-calendar-cell-size: 2.75rem;
+    --sbb-calendar-wide-cell-size: 4.8125rem;
+    --sbb-calendar-control-view-change-height: 3rem;
+  }
+}
+
+.sbb-calendar__wrapper {
+  width: 100%;
+  display: block;
+  transition-duration: var(--sbb-calendar-cell-transition-duration);
+}
+
+.sbb-calendar__controls {
+  width: 100%;
+  display: inline-flex;
+  align-items: center;
+  gap: var(--sbb-spacing-fixed-2x);
+  margin-block-end: var(--sbb-spacing-fixed-4x);
+}
+
+.sbb-calendar__controls-month {
+  width: 100%;
+  display: flex;
+  gap: var(--sbb-calendar-tables-gap);
+}
+
+#sbb-calendar__controls-previous,
+#sbb-calendar__controls-next {
+  -webkit-tap-highlight-color: transparent;
+}
+
+.sbb-calendar__controls-change-date {
+  -webkit-appearance: none;
+  -moz-appearance: none;
+  box-sizing: border-box;
+  margin: 0;
+  outline: none;
+  border: none;
+  border-radius: 0;
+  padding: 0;
+  background: none;
+  -webkit-tap-highlight-color: transparent;
+  color: inherit;
+  --sbb-text-font-size: var(--sbb-font-size-text-s);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-body-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-body-text);
+  font-size: var(--sbb-text-font-size);
+  display: flex;
+  align-items: center;
+  margin: auto;
+  height: var(--sbb-calendar-control-view-change-height);
+  text-transform: capitalize;
+  cursor: pointer;
+  padding-inline: var(--sbb-spacing-fixed-5x) var(--sbb-spacing-fixed-2x);
+  border-radius: var(--sbb-border-radius-infinity);
+  background-color: var(--sbb-calendar-control-view-change-background);
+  color: var(--sbb-calendar-control-view-change-color);
+  transition-duration: var(--sbb-calendar-cell-transition-duration);
+  transition-timing-function: var(--sbb-calendar-cell-transition-easing-function);
+  transition-property: background-color, padding-block-end;
+}
+.sbb-calendar__controls-change-date:disabled {
+  --sbb-calendar-control-view-change-background: var(--sbb-color-milk);
+  --sbb-calendar-control-view-change-color: var(--sbb-calendar-cell-disabled-color);
+  cursor: unset;
+}
+.sbb-calendar__controls-change-date:focus-visible {
+  outline-offset: var(--sbb-focus-outline-offset);
+  outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);
+  outline-offset: var(--sbb-spacing-fixed-1x);
+}
+@media (any-hover: hover) {
+  .sbb-calendar__controls-change-date:not(:active, :disabled):hover {
+    padding-block-end: var(--sbb-calendar-hover-shift);
+  }
+}
+.sbb-calendar__controls-change-date:not(:disabled):active {
+  --sbb-calendar-control-view-change-background: var(--sbb-color-milk);
+}
+
+.sbb-calendar__table-month-view,
+.sbb-calendar__table-year-view {
+  --sbb-calendar-table-column-spaces: 6;
+}
+
+.sbb-calendar__table-container {
+  display: flex;
+  gap: var(--sbb-calendar-tables-gap);
+  margin-inline: var(--sbb-calendar-margin);
+  --sbb-calendar-min-width: calc(7 * var(--sbb-calendar-cell-size));
+  --sbb-calendar-overflow: calc(100% - var(--sbb-calendar-min-width));
+  --sbb-calendar-start-offset: min(
+    0px,
+    -1 * (var(--sbb-calendar-overflow) / var(--sbb-calendar-table-column-spaces))
+  );
+  --sbb-calendar-margin: var(--sbb-calendar-start-offset);
+}
+:host([data-wide]) .sbb-calendar__table-container {
+  --sbb-calendar-min-width: calc(
+    2 * 7 * var(--sbb-calendar-cell-size) + var(--sbb-calendar-tables-gap)
+  );
+  --sbb-calendar-margin: calc(0.5 * var(--sbb-calendar-start-offset));
+}
+:host([orientation=vertical]) .sbb-calendar__table-container {
+  min-width: var(--sbb-calendar-min-width);
+  --sbb-calendar-start-offset: 0;
+}
+:host([orientation=vertical][data-wide]) .sbb-calendar__table-container {
+  --sbb-calendar-min-width: calc(
+    13 * var(--sbb-calendar-cell-size) + var(--sbb-calendar-tables-gap)
+  );
+}
+
+.sbb-calendar__table {
+  width: 100%;
+  border-collapse: collapse;
+  height: max-content;
+  animation-name: show;
+  animation-duration: var(--sbb-calendar-table-animation-duration);
+}
+.sbb-calendar__table.sbb-calendar__table-hide {
+  --sbb-calendar-cell-transition-duration: 0ms;
+  animation-name: hide;
+  animation-duration: var(--sbb-calendar-table-animation-duration);
+}
+:host(:not([data-wide])) .sbb-calendar__table {
+  min-width: 100%;
+}
+
+.sbb-calendar__table-header {
+  --sbb-text-font-size: var(--sbb-font-size-text-xs);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-body-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-body-text);
+  font-size: var(--sbb-text-font-size);
+  color: var(--sbb-calendar-header-color);
+  width: var(--sbb-calendar-cell-size);
+  padding: 0;
+  text-align: center;
+}
+:host([orientation=horizontal]) .sbb-calendar__table-header {
+  padding-block-end: var(--sbb-spacing-fixed-4x);
+}
+:host([orientation=vertical]) .sbb-calendar__table-header {
+  padding-inline-end: var(--sbb-spacing-fixed-1x);
+}
+
+.sbb-calendar__table-data {
+  position: relative;
+  padding: 0;
+  text-align: center;
+}
+
+.sbb-calendar__cell {
+  -webkit-appearance: none;
+  -moz-appearance: none;
+  box-sizing: border-box;
+  margin: 0;
+  outline: none;
+  border: none;
+  border-radius: 0;
+  padding: 0;
+  background: none;
+  -webkit-tap-highlight-color: transparent;
+  color: inherit;
+  --sbb-text-font-size: var(--sbb-font-size-text-s);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-body-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-body-text);
+  font-size: var(--sbb-text-font-size);
+  height: var(--sbb-calendar-cell-size);
+  color: var(--sbb-calendar-cell-color);
+  cursor: pointer;
+  position: relative;
+  z-index: 0;
+}
+.sbb-calendar__cell::before {
+  content: "";
+  position: absolute;
+  inset: var(--sbb-calendar-cell-padding);
+  background-color: var(--sbb-calendar-cell-background-color);
+  border-radius: 50%;
+  z-index: -1;
+  transition-duration: var(--sbb-calendar-cell-transition-duration);
+  transition-timing-function: var(--sbb-calendar-cell-transition-easing-function);
+  transition-property: background-color;
+}
+@media (any-hover: hover) {
+  .sbb-calendar__cell:not(.sbb-calendar__selected, :active, :disabled):hover {
+    --sbb-calendar-cell-background-color: var(--sbb-color-milk);
+    padding-block-end: var(--sbb-calendar-hover-shift);
+  }
+}
+@media (any-hover: hover) and (forced-colors: active) {
+  .sbb-calendar__cell:not(.sbb-calendar__selected, :active, :disabled):hover::before {
+    outline-offset: var(--sbb-focus-outline-offset);
+    outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);
+    --sbb-focus-outline-style: initial;
+  }
+}
+.sbb-calendar__cell:disabled {
+  --sbb-calendar-cell-color: var(--sbb-calendar-cell-disabled-color);
+  cursor: unset;
+}
+.sbb-calendar__cell:focus-visible::before {
+  outline-offset: var(--sbb-focus-outline-offset);
+  outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);
+}
+.sbb-calendar__cell:not(.sbb-calendar__selected, :disabled):active {
+  --sbb-calendar-cell-background-color: var(--sbb-color-cloud);
+}
+@media (forced-colors: active) {
+  .sbb-calendar__cell:not(.sbb-calendar__selected, :disabled):active::before {
+    outline-offset: var(--sbb-focus-outline-offset);
+    outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);
+    --sbb-focus-outline-style: initial;
+  }
+}
+
+.sbb-calendar__day {
+  border-radius: 50%;
+  width: var(--sbb-calendar-cell-size);
+}
+.sbb-calendar__day::before {
+  border-radius: 50%;
+}
+
+.sbb-calendar__pill {
+  width: var(--sbb-calendar-wide-cell-size);
+  border-radius: var(--sbb-border-radius-infinity);
+}
+.sbb-calendar__pill::before {
+  border-radius: var(--sbb-border-radius-infinity);
+}
+
+.sbb-calendar__crossed-out::after {
+  content: "";
+  height: var(--sbb-calendar-cell-disabled-height);
+  width: var(--sbb-calendar-cell-disabled-width);
+  position: absolute;
+  background-color: var(--sbb-calendar-cell-disabled-color);
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%) rotate(-45deg);
+}
+
+.sbb-calendar__cell-current {
+  --sbb-text-font-size: var(--sbb-font-size-text-s);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-body-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-body-text);
+  font-size: var(--sbb-text-font-size);
+  font-weight: bold;
+}
+
+.sbb-calendar__selected {
+  --sbb-calendar-cell-color: var(--sbb-calendar-cell-selected-color);
+  --sbb-calendar-cell-background-color: var(--sbb-calendar-cell-selected-background-color);
+}
+@media (forced-colors: active) {
+  .sbb-calendar__selected {
+    --sbb-calendar-cell-background-color: ButtonText !important;
+  }
+}
+
+@keyframes show {
+  from {
+    opacity: 0;
+    transform: translateY(var(--sbb-calendar-table-animation-shift));
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0%);
+  }
+}
+@keyframes hide {
+  from {
+    opacity: 1;
+    transform: translateY(0%);
+  }
+  to {
+    opacity: 0;
+    transform: translateY(var(--sbb-calendar-table-animation-shift));
+  }
+}`;
+let SbbCalendarElement = (() => {
+  var _wide_accessor_storage, _view_accessor_storage, _dateFilter_accessor_storage, _orientation_accessor_storage, __activeDate_accessor_storage, __selected_accessor_storage, __calendarView_accessor_storage, __initialized_accessor_storage, _a;
+  let _classDecorators = [customElement("sbb-calendar")];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = SbbHydrationMixin(LitElement);
+  let _instanceExtraInitializers = [];
+  let _wide_decorators;
+  let _wide_initializers = [];
+  let _wide_extraInitializers = [];
+  let _view_decorators;
+  let _view_initializers = [];
+  let _view_extraInitializers = [];
+  let _set_min_decorators;
+  let _set_max_decorators;
+  let _set_now_decorators;
+  let _set_selected_decorators;
+  let _dateFilter_decorators;
+  let _dateFilter_initializers = [];
+  let _dateFilter_extraInitializers = [];
+  let _orientation_decorators;
+  let _orientation_initializers = [];
+  let _orientation_extraInitializers = [];
+  let __activeDate_decorators;
+  let __activeDate_initializers = [];
+  let __activeDate_extraInitializers = [];
+  let __selected_decorators;
+  let __selected_initializers = [];
+  let __selected_extraInitializers = [];
+  let _set__wide_decorators;
+  let __calendarView_decorators;
+  let __calendarView_initializers = [];
+  let __calendarView_extraInitializers = [];
+  let __initialized_decorators;
+  let __initialized_initializers = [];
+  let __initialized_extraInitializers = [];
+  var SbbCalendarElement2 = (_a = class extends _classSuper {
+    constructor() {
+      var _a2;
+      super();
+      __privateAdd(this, _wide_accessor_storage);
+      __privateAdd(this, _view_accessor_storage);
+      __privateAdd(this, _dateFilter_accessor_storage);
+      __privateAdd(this, _orientation_accessor_storage);
+      __privateAdd(this, __activeDate_accessor_storage);
+      __privateAdd(this, __selected_accessor_storage);
+      __privateAdd(this, __calendarView_accessor_storage);
+      __privateAdd(this, __initialized_accessor_storage);
+      __privateSet(this, _wide_accessor_storage, (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _wide_initializers, false)));
+      __privateSet(this, _view_accessor_storage, (__runInitializers(this, _wide_extraInitializers), __runInitializers(this, _view_initializers, "day")));
+      this._min = __runInitializers(this, _view_extraInitializers);
+      this._now = null;
+      __privateSet(this, _dateFilter_accessor_storage, __runInitializers(this, _dateFilter_initializers, null));
+      __privateSet(this, _orientation_accessor_storage, (__runInitializers(this, _dateFilter_extraInitializers), __runInitializers(this, _orientation_initializers, "horizontal")));
+      this._dateAdapter = (__runInitializers(this, _orientation_extraInitializers), ((_a2 = readConfig().datetime) == null ? void 0 : _a2.dateAdapter) ?? defaultDateAdapter);
+      this._dateSelected = new EventEmitter(this, SbbCalendarElement2.events.dateSelected);
+      __privateSet(this, __activeDate_accessor_storage, __runInitializers(this, __activeDate_initializers, this.now));
+      __privateSet(this, __selected_accessor_storage, (__runInitializers(this, __activeDate_extraInitializers), __runInitializers(this, __selected_initializers, void 0)));
+      __privateSet(this, __calendarView_accessor_storage, (__runInitializers(this, __selected_extraInitializers), __runInitializers(this, __calendarView_initializers, "day")));
+      this._nextCalendarView = (__runInitializers(this, __calendarView_extraInitializers), "day");
+      this._keyboardNavigationDayViewParameters = {
+        firstDayInView: null,
+        lastDayInView: null,
+        firstMonthOffset: 0,
+        firstMonthLength: 0,
+        secondMonthOffset: 0
+      };
+      this._weeks = [];
+      this._monthNames = this._dateAdapter.getMonthNames("long");
+      this._resetFocus = false;
+      __privateSet(this, __initialized_accessor_storage, __runInitializers(this, __initialized_initializers, false));
+      this._language = (__runInitializers(this, __initialized_extraInitializers), new SbbLanguageController(this).withHandler(() => {
+        this._monthNames = this._dateAdapter.getMonthNames("long");
+        this._createMonthRows();
+      }));
+      this._mediaMatcher = new SbbMediaMatcherController(this, {
+        [SbbMediaQueryBreakpointMediumAndAbove]: () => this._init()
+      });
+      this._createMonthRows();
+      this._setWeekdays();
+    }
+    /** 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);
+    }
+    /** The initial view of the calendar which should be displayed on opening. */
+    get view() {
+      return __privateGet(this, _view_accessor_storage);
+    }
+    set view(value) {
+      __privateSet(this, _view_accessor_storage, value);
+    }
+    /** The minimum valid date. Takes T Object, ISOString, and Unix Timestamp (number of seconds since Jan 1, 1970). */
+    set min(value) {
+      this._min = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+    }
+    get min() {
+      return this._min ?? null;
+    }
+    /** The maximum valid date. Takes T Object, ISOString, and Unix Timestamp (number of seconds since Jan 1, 1970). */
+    set max(value) {
+      this._max = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+    }
+    get max() {
+      return this._max ?? null;
+    }
+    /** 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 selected date. Takes T Object, ISOString, and Unix Timestamp (number of seconds since Jan 1, 1970). */
+    set selected(value) {
+      this._selectedDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+      if (!!this._selectedDate && (!this._isDayInRange(this._dateAdapter.toIso8601(this._selectedDate)) || this._dateFilter(this._selectedDate))) {
+        this._selected = this._dateAdapter.toIso8601(this._selectedDate);
+      } else {
+        this._selected = void 0;
+      }
+    }
+    get selected() {
+      return this._selectedDate ?? null;
+    }
+    /** A function used to filter out dates. */
+    get dateFilter() {
+      return __privateGet(this, _dateFilter_accessor_storage);
+    }
+    set dateFilter(value) {
+      __privateSet(this, _dateFilter_accessor_storage, value);
+    }
+    /** The orientation of days in the calendar. */
+    get orientation() {
+      return __privateGet(this, _orientation_accessor_storage);
+    }
+    set orientation(value) {
+      __privateSet(this, _orientation_accessor_storage, value);
+    }
+    /** The currently active date. */
+    get _activeDate() {
+      return __privateGet(this, __activeDate_accessor_storage);
+    }
+    set _activeDate(value) {
+      __privateSet(this, __activeDate_accessor_storage, value);
+    }
+    /** The selected date as ISOString. */
+    get _selected() {
+      return __privateGet(this, __selected_accessor_storage);
+    }
+    set _selected(value) {
+      __privateSet(this, __selected_accessor_storage, value);
+    }
+    /** The current wide property considering property value and breakpoints. From zero to small `wide` has always to be false. */
+    set _wide(wide) {
+      this.toggleAttribute("data-wide", wide);
+    }
+    get _wide() {
+      return this.hasAttribute("data-wide");
+    }
+    get _calendarView() {
+      return __privateGet(this, __calendarView_accessor_storage);
+    }
+    set _calendarView(value) {
+      __privateSet(this, __calendarView_accessor_storage, value);
+    }
+    /** A list of buttons corresponding to days, months or years depending on the view. */
+    get _cells() {
+      return Array.from(this.shadowRoot.querySelectorAll(".sbb-calendar__cell") ?? []);
+    }
+    get _initialized() {
+      return __privateGet(this, __initialized_accessor_storage);
+    }
+    set _initialized(value) {
+      __privateSet(this, __initialized_accessor_storage, value);
+    }
+    _dateFilter(date) {
+      var _a2;
+      return ((_a2 = this.dateFilter) == null ? void 0 : _a2.call(this, date)) ?? true;
+    }
+    /** Resets the active month according to the new state of the calendar. */
+    resetPosition() {
+      this._resetCalendarView();
+      this._init();
+    }
+    connectedCallback() {
+      super.connectedCallback();
+      this.resetPosition();
+      this.focus = () => {
+        this._resetFocus = true;
+        this._focusCell();
+      };
+    }
+    willUpdate(changedProperties) {
+      super.willUpdate(changedProperties);
+      if (!this._initialized) {
+        return;
+      }
+      if (changedProperties.has("wide") || changedProperties.has("orientation")) {
+        this.resetPosition();
+      }
+      if (changedProperties.has("view")) {
+        this._setChosenYear();
+        this._chosenMonth = void 0;
+        this._nextCalendarView = this._calendarView = this.view;
+      }
+    }
+    updated(changedProperties) {
+      super.updated(changedProperties);
+      this._setTabIndex();
+      if (sbbInputModalityDetector.mostRecentModality === "keyboard") {
+        this._focusCell();
+      }
+    }
+    /** Initializes the component. */
+    _init(activeDate) {
+      if (isServer) {
+        return;
+      } else if (this.hydrationRequired) {
+        this.hydrationComplete.then(() => this._init());
+        return;
+      }
+      if (activeDate) {
+        this._assignActiveDate(activeDate);
+      }
+      this._wide = (this._mediaMatcher.matches(SbbMediaQueryBreakpointMediumAndAbove) ?? false) && this.wide;
+      this._weeks = this._createWeekRows(this._activeDate);
+      this._years = this._createYearRows();
+      this._nextMonthWeeks = [[]];
+      this._nextMonthYears = [[]];
+      if (this._wide) {
+        const nextMonthDate = this._dateAdapter.addCalendarMonths(this._activeDate, 1);
+        this._nextMonthWeeks = this._createWeekRows(nextMonthDate, true);
+        this._nextMonthYears = this._createYearRows(YEARS_PER_PAGE);
+      }
+      this._initialized = true;
+    }
+    /** Focuses on a day cell prioritizing the selected day, the current day, and lastly, the first selectable day. */
+    _focusCell() {
+      var _a2;
+      if (this._resetFocus) {
+        (_a2 = this._getFirstFocusable()) == null ? void 0 : _a2.focus();
+        this._resetFocus = false;
+      }
+    }
+    /** Creates the array of weekdays. */
+    _setWeekdays() {
+      const narrowWeekdays = this._dateAdapter.getDayOfWeekNames("narrow");
+      const longWeekdays = this._dateAdapter.getDayOfWeekNames("long");
+      const weekdays = longWeekdays.map((long, i) => ({
+        long,
+        narrow: narrowWeekdays[i]
+      }));
+      const firstDayOfWeek = this._dateAdapter.getFirstDayOfWeek();
+      this._weekdays = weekdays.slice(firstDayOfWeek).concat(weekdays.slice(0, firstDayOfWeek));
+    }
+    /** Creates the rows for each week and sets the parameters used in keyboard navigation. */
+    _createWeekRows(value, isSecondMonthInView = false) {
+      const dateNames = this._dateAdapter.getDateNames();
+      const daysInMonth = this._dateAdapter.getNumDaysInMonth(value);
+      const weekOffset = this._dateAdapter.getFirstWeekOffset(value);
+      if (!isSecondMonthInView) {
+        this._keyboardNavigationDayViewParameters.firstMonthLength = daysInMonth;
+        this._keyboardNavigationDayViewParameters.firstMonthOffset = weekOffset;
+        this._keyboardNavigationDayViewParameters.firstDayInView = this._dateAdapter.toIso8601(this._dateAdapter.createDate(this._dateAdapter.getYear(value), this._dateAdapter.getMonth(value), 1));
+        this._keyboardNavigationDayViewParameters.lastDayInView = this._dateAdapter.toIso8601(this._dateAdapter.createDate(this._dateAdapter.getYear(value), this._dateAdapter.getMonth(value), daysInMonth));
+      } else {
+        this._keyboardNavigationDayViewParameters.secondMonthOffset = weekOffset;
+        this._keyboardNavigationDayViewParameters.lastDayInView = this._dateAdapter.toIso8601(this._dateAdapter.createDate(this._dateAdapter.getYear(value), this._dateAdapter.getMonth(value), daysInMonth));
+      }
+      return this.orientation === "horizontal" ? this._createWeekRowsHorizontal(value, dateNames, daysInMonth, weekOffset) : this._createWeekRowsVertical(value, dateNames, daysInMonth, weekOffset);
+    }
+    /**
+     * Creates the rows for each week in orientation='horizontal'.
+     *
+     * Iterates through the days of the months, creates a Day object for each and pushes it into and array.
+     * Each seven days (considering the offset at the beginning of the month) restarts from an empty array.
+     *
+     * The result is a matrix in which every row is a week (or part of it, considering offset).
+     */
+    _createWeekRowsHorizontal(value, dateNames, daysInMonth, weekOffset) {
+      const weeks = [[]];
+      for (let i = 0, cell = weekOffset; i < daysInMonth; i++, cell++) {
+        if (cell === DAYS_PER_ROW) {
+          weeks.push([]);
+          cell = 0;
+        }
+        const date = this._dateAdapter.createDate(this._dateAdapter.getYear(value), this._dateAdapter.getMonth(value), i + 1);
+        weeks[weeks.length - 1].push({
+          value: this._dateAdapter.toIso8601(date),
+          dateValue: date,
+          dayValue: dateNames[i],
+          monthValue: String(this._dateAdapter.getMonth(date)),
+          yearValue: String(this._dateAdapter.getYear(date))
+        });
+      }
+      return weeks;
+    }
+    /**
+     * Creates the rows for each week in orientation='vertical'.
+     *
+     * Creates a matrix with seven empty rows.
+     * Iterates through the days of the months, creates a Day object for each
+     * and pushes it into the correct array considering the offset at the beginning of the month.
+     * Each seven days (including offset) restarts from the first.
+     *
+     * The result is a matrix in which every row is a set of weekdays, so:
+     * - row 0: all the Mondays;
+     * - row 1: all the Tuesdays;
+     * - ...
+     * - row 7: all the Sundays.
+     */
+    _createWeekRowsVertical(value, dateNames, daysInMonth, weekOffset) {
+      const weeks = Array.from({ length: DAYS_PER_ROW }, () => []);
+      for (let i = 0, cell = weekOffset; i < daysInMonth; i++, cell++) {
+        if (cell === DAYS_PER_ROW) {
+          cell = 0;
+        }
+        const date = this._dateAdapter.createDate(this._dateAdapter.getYear(value), this._dateAdapter.getMonth(value), i + 1);
+        weeks[cell].push({
+          value: this._dateAdapter.toIso8601(date),
+          dateValue: date,
+          dayValue: dateNames[i],
+          monthValue: String(this._dateAdapter.getMonth(date)),
+          yearValue: String(this._dateAdapter.getYear(date))
+        });
+      }
+      return weeks;
+    }
+    /** Creates the rows for the month selection view. */
+    _createMonthRows() {
+      const shortNames = this._dateAdapter.getMonthNames("short");
+      const months = new Array(12).fill(null).map((_, i) => ({
+        value: shortNames[i],
+        longValue: this._monthNames[i],
+        monthValue: i + 1
+      }));
+      const rows = 12 / MONTHS_PER_ROW;
+      const monthArray = [];
+      for (let i = 0; i < rows; i++) {
+        monthArray.push(months.slice(MONTHS_PER_ROW * i, MONTHS_PER_ROW * (i + 1)));
+      }
+      this._months = monthArray;
+    }
+    /** Creates the rows for the year selection view. */
+    _createYearRows(offset = 0) {
+      const startValueYearView = this._getStartValueYearView();
+      const allYears = new Array(YEARS_PER_PAGE).fill(0).map((_, i) => startValueYearView + offset + i);
+      const rows = YEARS_PER_PAGE / YEARS_PER_ROW;
+      const yearArray = [];
+      for (let i = 0; i < rows; i++) {
+        yearArray.push(allYears.slice(YEARS_PER_ROW * i, YEARS_PER_ROW * (i + 1)));
+      }
+      return yearArray;
+    }
+    /**
+     * Calculates the first year that will be shown in the year selection panel.
+     * If `minDate` and `maxDate` are both null, the starting year is calculated as
+     * the multiple of YEARS_PER_PAGE closest to and less than activeDate,
+     * e.g., with `YEARS_PER_PAGE` = 24 and `activeDate` = 2020, the function will return 2016 (24 * 83),
+     * while with `activeDate` = 2000, the function will return 1992 (24 * 82).
+     * If `minDate` is not null, it returns the corresponding year; if `maxDate` is not null,
+     * it returns the corresponding year minus `YEARS_PER_PAGE`, so that the `maxDate` is the last rendered year.
+     * If both are not null, `maxDate` has priority over `minDate`.
+     */
+    _getStartValueYearView() {
+      let startingYear = 0;
+      if (this.max) {
+        startingYear = this._dateAdapter.getYear(this.max) - YEARS_PER_PAGE + 1;
+      } else if (this.min) {
+        startingYear = this._dateAdapter.getYear(this.min);
+      }
+      const activeYear = this._dateAdapter.getYear(this._activeDate);
+      return activeYear - ((activeYear - startingYear) % YEARS_PER_PAGE + YEARS_PER_PAGE) % YEARS_PER_PAGE;
+    }
+    /** Checks if date is within the min-max range. */
+    _isDayInRange(date) {
+      if (!this.min && !this.max) {
+        return true;
+      }
+      const isBeforeMin = this._dateAdapter.isValid(this.min) && this._dateAdapter.compareDate(this.min, this._dateAdapter.deserialize(date)) > 0;
+      const isAfterMax = this._dateAdapter.isValid(this.max) && this._dateAdapter.compareDate(this.max, this._dateAdapter.deserialize(date)) < 0;
+      return !(isBeforeMin || isAfterMax);
+    }
+    /** Checks if date is within the min-max range in month view. */
+    _isMonthInRange(month, year) {
+      if (!this.min && !this.max) {
+        return true;
+      }
+      const isBeforeMin = this._dateAdapter.isValid(this.min) && (year < this._dateAdapter.getYear(this.min) || year === this._dateAdapter.getYear(this.min) && month < this._dateAdapter.getMonth(this.min));
+      const isAfterMax = this._dateAdapter.isValid(this.max) && (year > this._dateAdapter.getYear(this.max) || year === this._dateAdapter.getYear(this.max) && month > this._dateAdapter.getMonth(this.max));
+      return !(isBeforeMin || isAfterMax);
+    }
+    /** Checks if date is within the min-max range in year view. */
+    _isYearInRange(year) {
+      if (!this.min && !this.max) {
+        return true;
+      }
+      const isBeforeMin = this._dateAdapter.isValid(this.min) && this._dateAdapter.getYear(this.min) > year;
+      const isAfterMax = this._dateAdapter.isValid(this.max) && this._dateAdapter.getYear(this.max) < year;
+      return !(isBeforeMin || isAfterMax);
+    }
+    // Implementation adapted from https://github.com/angular/components/blob/main/src/material/datepicker/year-view.ts#L366
+    _isMonthFilteredOut(month, year) {
+      if (!this.dateFilter) {
+        return true;
+      }
+      const firstOfMonth = this._dateAdapter.createDate(year, month, 1);
+      for (let date = firstOfMonth; this._dateAdapter.getMonth(date) == month; date = this._dateAdapter.addCalendarDays(date, 1)) {
+        if (this.dateFilter(date)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    // Implementation adapted from https://github.com/angular/components/blob/main/src/material/datepicker/multi-year-view.ts#L351
+    _isYearFilteredOut(year) {
+      if (!this.dateFilter) {
+        return true;
+      }
+      const firstOfYear = this._dateAdapter.createDate(year, 1, 1);
+      for (let date = firstOfYear; this._dateAdapter.getYear(date) == year; date = this._dateAdapter.addCalendarDays(date, 1)) {
+        if (this.dateFilter(date)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    /** Emits the selected date and sets it internally. */
+    _selectDate(day) {
+      this._chosenMonth = void 0;
+      this._setChosenYear();
+      if (this._selected !== day) {
+        this._selected = day;
+        this._dateSelected.emit(this._dateAdapter.deserialize(day));
+      }
+    }
+    _setChosenYear() {
+      if (this.view === "month") {
+        this._chosenYear = this._dateAdapter.getYear(this._dateAdapter.deserialize(this._selected) ?? this.selected ?? this.now);
+      } else {
+        this._chosenYear = void 0;
+      }
+    }
+    _assignActiveDate(date) {
+      if (this.min && this._dateAdapter.compareDate(this.min, date) > 0) {
+        this._activeDate = this.min;
+        return;
+      }
+      if (this.max && this._dateAdapter.compareDate(this.max, date) < 0) {
+        this._activeDate = this.max;
+        return;
+      }
+      this._activeDate = date;
+    }
+    /** Goes to the month identified by the shift. */
+    _goToDifferentMonth(months) {
+      this._init(this._dateAdapter.addCalendarMonths(this._activeDate, months));
+    }
+    _goToDifferentYear(years) {
+      this._chosenYear += years;
+      this._activeDate = this._dateAdapter.createDate(this._chosenYear, this._dateAdapter.getMonth(this._activeDate), this._dateAdapter.getDate(this._activeDate));
+      this._init();
+    }
+    _goToDifferentYearRange(years) {
+      this._init(this._dateAdapter.addCalendarYears(this._activeDate, years));
+    }
+    _prevDisabled(prevDate) {
+      if (!this.min) {
+        return false;
+      }
+      return this._dateAdapter.compareDate(prevDate, this.min) < 0;
+    }
+    _nextDisabled(nextDate) {
+      if (!this.max) {
+        return false;
+      }
+      return this._dateAdapter.compareDate(nextDate, this.max) > 0;
+    }
+    /** Checks if the "previous month" button should be disabled. */
+    _previousMonthDisabled() {
+      const prevMonth = this._dateAdapter.addCalendarDays(this._activeDate, this._dateAdapter.getDate(this._activeDate) * -1);
+      return this._prevDisabled(prevMonth);
+    }
+    /** Checks if the "next month" button should be disabled. */
+    _nextMonthDisabled() {
+      let nextMonth = this._dateAdapter.addCalendarMonths(this._activeDate, this._wide ? 2 : 1);
+      nextMonth = this._dateAdapter.createDate(this._dateAdapter.getYear(nextMonth), this._dateAdapter.getMonth(nextMonth), 1);
+      return this._nextDisabled(nextMonth);
+    }
+    /** Checks if the "previous year" button should be disabled. */
+    _previousYearDisabled() {
+      const prevYear = this._dateAdapter.createDate(this._dateAdapter.getYear(this._activeDate) - 1, 12, 31);
+      return this._prevDisabled(prevYear);
+    }
+    /** Checks if the "next year" button should be disabled. */
+    _nextYearDisabled() {
+      const nextYear = this._dateAdapter.createDate(this._dateAdapter.getYear(this._activeDate) + (this._wide ? 2 : 1), 1, 1);
+      return this._nextDisabled(nextYear);
+    }
+    /** Checks if the "previous year" button should be disabled in year view. */
+    _previousYearRangeDisabled() {
+      const prevYear = this._dateAdapter.createDate(this._years[0][0] - 1, 12, 31);
+      return this._prevDisabled(prevYear);
+    }
+    /** Checks if the "next year" button should be disabled in year view. */
+    _nextYearRangeDisabled() {
+      const years = this._wide ? this._nextMonthYears : this._years;
+      const lastYearRange = years[years.length - 1];
+      const lastYear = lastYearRange[lastYearRange.length - 1];
+      const nextYear = this._dateAdapter.createDate(lastYear + 1, 1, 1);
+      return this._nextDisabled(nextYear);
+    }
+    _handleTableBlur(eventTarget) {
+      if ((eventTarget == null ? void 0 : eventTarget.localName) !== "button") {
+        this._setTabIndex();
+      }
+    }
+    _setTabIndex() {
+      Array.from(this.shadowRoot.querySelectorAll('.sbb-calendar__cell[tabindex="0"]') ?? []).forEach((day) => day.tabIndex = -1);
+      const firstFocusable = this._getFirstFocusable();
+      if (firstFocusable) {
+        firstFocusable.tabIndex = 0;
+      }
+    }
+    /** Get the element in the calendar to assign focus. */
+    _getFirstFocusable() {
+      const active = this._selected ? this._dateAdapter.deserialize(this._selected) : this.now;
+      let firstFocusable = this.shadowRoot.querySelector(".sbb-calendar__selected") ?? this.shadowRoot.querySelector(`[value="${this._dateAdapter.toIso8601(active)}"]`) ?? this.shadowRoot.querySelector(`[data-month="${this._dateAdapter.getMonth(active)}"]`) ?? this.shadowRoot.querySelector(`[data-year="${this._dateAdapter.getYear(active)}"]`);
+      if (!firstFocusable || (firstFocusable == null ? void 0 : firstFocusable.disabled)) {
+        firstFocusable = this._calendarView === "day" ? this._getFirstFocusableDay() : this.shadowRoot.querySelector(".sbb-calendar__cell:not([disabled])");
+      }
+      return firstFocusable || null;
+    }
+    /**
+     * In `day` view in `vertical` orientation,
+     * if the first of the month is not a Monday, it is not the first rendered element in the table,
+     * so `this.shadowRoot!.querySelector('.sbb-calendar__cell:not([disabled])')` will return a wrong value.
+     *
+     * To solve this, the element with the lowest `value` is taken (ISO String are ordered).
+     */
+    _getFirstFocusableDay() {
+      const daysInView = Array.from(this.shadowRoot.querySelectorAll(".sbb-calendar__cell:not([disabled])"));
+      if (!daysInView || daysInView.length === 0) {
+        return null;
+      } else {
+        const firstElement = daysInView.map((e) => e.value).sort()[0];
+        return this.shadowRoot.querySelector(`.sbb-calendar__cell[value="${firstElement}"]`);
+      }
+    }
+    _handleKeyboardEvent(event, day) {
+      if (isArrowKeyOrPageKeysPressed(event)) {
+        event.preventDefault();
+      }
+      const cells = this._cells;
+      const index = cells.findIndex((e) => e === event.target);
+      let nextEl;
+      if (day) {
+        nextEl = this._navigateByKeyboardDayView(event, index, cells, day);
+      } else {
+        nextEl = this._navigateByKeyboard(event, index, cells);
+      }
+      const activeEl = this.shadowRoot.activeElement;
+      if (nextEl !== activeEl) {
+        nextEl.tabIndex = 0;
+        nextEl == null ? void 0 : nextEl.focus();
+        activeEl.tabIndex = -1;
+      }
+    }
+    _navigateByKeyboardDayView(evt, index, cells, day) {
+      const arrowsOffset = this.orientation === "horizontal" ? { leftRight: 1, upDown: DAYS_PER_ROW } : { leftRight: DAYS_PER_ROW, upDown: 1 };
+      const offsetForVertical = index < this._keyboardNavigationDayViewParameters.firstMonthLength ? this._keyboardNavigationDayViewParameters.firstMonthOffset : this._keyboardNavigationDayViewParameters.secondMonthOffset;
+      switch (evt.key) {
+        case "ArrowUp":
+          return this._findDayArrows(cells, index, day.dateValue, -arrowsOffset.upDown);
+        case "ArrowDown":
+          return this._findDayArrows(cells, index, day.dateValue, arrowsOffset.upDown);
+        case "ArrowLeft":
+          return this._findDayArrows(cells, index, day.dateValue, -arrowsOffset.leftRight);
+        case "ArrowRight":
+          return this._findDayArrows(cells, index, day.dateValue, arrowsOffset.leftRight);
+        case "PageUp": {
+          if (this.orientation === "horizontal") {
+            const firstOfWeek = +day.dayValue % DAYS_PER_ROW || DAYS_PER_ROW;
+            const delta = firstOfWeek - +day.dayValue;
+            return this._findDayPageUpDown(cells, index, day, delta, arrowsOffset.upDown);
+          } else {
+            const weekNumber = Math.ceil((+day.dayValue + offsetForVertical) / DAYS_PER_ROW);
+            const firstOfWeek = (weekNumber - 1) * DAYS_PER_ROW - offsetForVertical + 1;
+            const delta = firstOfWeek - +day.dayValue;
+            return this._findDayPageUpDown(cells, index, day, delta, arrowsOffset.upDown);
+          }
+        }
+        case "PageDown": {
+          if (this.orientation === "horizontal") {
+            const monthInBounds = +day.monthValue + 1 > 12 ? 1 : +day.monthValue + 1;
+            const yearInBounds = +day.monthValue + 1 > 12 ? +day.yearValue + 1 : +day.yearValue;
+            const firstNextMonth = this._dateAdapter.createDate(yearInBounds, monthInBounds, 1);
+            const lastOfMonth = this._dateAdapter.getDate(this._dateAdapter.addCalendarDays(firstNextMonth, -1));
+            const delta = Math.trunc((lastOfMonth - +day.dayValue) / DAYS_PER_ROW) * DAYS_PER_ROW;
+            return this._findDayPageUpDown(cells, index, day, delta, -arrowsOffset.upDown);
+          } else {
+            const weekNumber = Math.ceil((+day.dayValue + offsetForVertical) / DAYS_PER_ROW);
+            const lastOfWeek = weekNumber * DAYS_PER_ROW - offsetForVertical;
+            const delta = lastOfWeek - +day.dayValue;
+            return this._findDayPageUpDown(cells, index, day, delta, -arrowsOffset.upDown);
+          }
+        }
+        case "Home": {
+          return this._findDayFirst(cells, index, day, 1);
+        }
+        case "End": {
+          const monthInBounds = +day.monthValue + 1 > 12 ? 1 : +day.monthValue + 1;
+          const yearInBounds = +day.monthValue + 1 > 12 ? +day.yearValue + 1 : +day.yearValue;
+          const firstNextMonth = this._dateAdapter.createDate(yearInBounds, monthInBounds, 1);
+          return this._findDayLast(cells, index, firstNextMonth);
+        }
+        default:
+          return cells[index];
+      }
+    }
+    _isDayOutOfView(date) {
+      return date < this._keyboardNavigationDayViewParameters.firstDayInView || date > this._keyboardNavigationDayViewParameters.lastDayInView;
+    }
+    _findDayArrows(cells, index, date, delta) {
+      const newDateValue = this._dateAdapter.toIso8601(this._dateAdapter.addCalendarDays(date, delta));
+      if (this._isDayOutOfView(newDateValue)) {
+        return cells[index];
+      }
+      const nextCell = cells.find((e) => e.value === newDateValue);
+      if (!nextCell || nextCell.disabled) {
+        return this._findDayArrows(cells, index, this._dateAdapter.deserialize(newDateValue), delta);
+      }
+      return nextCell;
+    }
+    _findDayPageUpDown(cells, index, day, delta, deltaIfDisabled) {
+      const newDateValue = this._dateAdapter.toIso8601(this._dateAdapter.addCalendarDays(day.dateValue, delta));
+      if (this._isDayOutOfView(newDateValue)) {
+        return cells[index];
+      }
+      const nextCell = cells.find((e) => e.value === newDateValue);
+      if (!nextCell || nextCell.disabled) {
+        return this._findDayPageUpDown(cells, index, day, delta + deltaIfDisabled, deltaIfDisabled);
+      }
+      return nextCell;
+    }
+    _findDayFirst(cells, index, day, date) {
+      const newDateValue = this._dateAdapter.toIso8601(this._dateAdapter.createDate(+day.yearValue, +day.monthValue, date));
+      if (this._isDayOutOfView(newDateValue)) {
+        return cells[index];
+      }
+      const nextCell = cells.find((e) => e.value === newDateValue);
+      if (!nextCell || nextCell.disabled) {
+        return this._findDayFirst(cells, index, day, date + 1);
+      }
+      return nextCell;
+    }
+    _findDayLast(cells, index, firstNextMonth) {
+      const newDateValue = this._dateAdapter.toIso8601(this._dateAdapter.addCalendarDays(firstNextMonth, -1));
+      if (this._isDayOutOfView(newDateValue)) {
+        return cells[index];
+      }
+      const nextCell = cells.find((e) => e.value === newDateValue);
+      if (!nextCell || nextCell.disabled) {
+        return this._findDayLast(cells, index, this._dateAdapter.deserialize(newDateValue));
+      }
+      return nextCell;
+    }
+    /**
+     * Gets the index of the element to move to, based on a list of elements (which can be potentially disabled),
+     * the keyboard input and the position of the current element in the list.
+     * In the day view, the `day?: Day` parameter is mandatory for calculation,
+     * while in month and year view it's not due to the fixed amount of rendered cells.
+     */
+    _navigateByKeyboard(evt, index, cells) {
+      const { elementIndexForWideMode, offsetForWideMode, lastElementIndexForWideMode, verticalOffset } = this._calculateParametersForKeyboardNavigation(index, this._calendarView === "year");
+      switch (evt.key) {
+        case "ArrowUp":
+          return this._findNext(cells, index, -verticalOffset);
+        case "ArrowDown":
+          return this._findNext(cells, index, verticalOffset);
+        case "ArrowLeft":
+          return this._findNext(cells, index, -1);
+        case "ArrowRight":
+          return this._findNext(cells, index, 1);
+        case "Home":
+          return this._findFirst(cells, offsetForWideMode);
+        case "PageUp":
+          return this._findFirstOnColumn(cells, elementIndexForWideMode, offsetForWideMode, verticalOffset);
+        case "PageDown":
+          return this._findLastOnColumn(cells, index, lastElementIndexForWideMode, verticalOffset);
+        case "End":
+          return this._findLast(cells, lastElementIndexForWideMode - 1);
+        default:
+          return cells[index];
+      }
+    }
+    /**
+     * Calculates the parameters needed in keyboard navigation in year and month view.
+     * @param index The starting element's index in the cell array.
+     * @param isYearView Whether the displayed `view` is the year one.
+     */
+    _calculateParametersForKeyboardNavigation(index, isYearView) {
+      const elementsPerPage = isYearView ? YEARS_PER_PAGE : MONTHS_PER_PAGE;
+      const offset = Math.trunc(index / elementsPerPage) * elementsPerPage;
+      const indexInView = offset === 0 ? index : index - elementsPerPage;
+      return {
+        verticalOffset: isYearView ? YEARS_PER_ROW : MONTHS_PER_ROW,
+        elementIndexForWideMode: indexInView,
+        offsetForWideMode: index - indexInView,
+        lastElementIndexForWideMode: offset === 0 ? elementsPerPage : elementsPerPage * 2
+      };
+    }
+    /**
+     * Gets the next element of the provided array starting from `index` by adding `delta`.
+     * If the found element is disabled, it continues adding `delta` until it finds an enabled one in the array bounds.
+     */
+    _findNext(days, index, delta) {
+      var _a2;
+      let nextIndex = index + delta;
+      while (nextIndex < days.length && ((_a2 = days[nextIndex]) == null ? void 0 : _a2.disabled)) {
+        nextIndex += delta;
+      }
+      return days[nextIndex] ?? days[index];
+    }
+    /** Find the first enabled element in the provided array. */
+    _findFirst(days, firstOfCurrentMonth) {
+      return !days[firstOfCurrentMonth].disabled ? days[firstOfCurrentMonth] : this._findNext(days, firstOfCurrentMonth, 1);
+    }
+    /** Find the last enabled element in the provided array. */
+    _findLast(days, lastOfCurrentMonth) {
+      return !days[lastOfCurrentMonth].disabled ? days[lastOfCurrentMonth] : this._findNext(days, lastOfCurrentMonth, -1);
+    }
+    /** Find the first enabled element in the same column of the provided array. */
+    _findFirstOnColumn(days, index, offset, verticalOffset) {
+      const nextIndex = index % verticalOffset + offset;
+      return !days[nextIndex].disabled ? days[nextIndex] : this._findNext(days, nextIndex, verticalOffset);
+    }
+    /** Find the last enabled element in the same column of the provided array. */
+    _findLastOnColumn(days, index, offset, verticalOffset) {
+      const nextIndex = index + Math.trunc((offset - index - 1) / verticalOffset) * verticalOffset;
+      return !days[nextIndex].disabled ? days[nextIndex] : this._findNext(days, nextIndex, -verticalOffset);
+    }
+    _resetCalendarView(initTransition = false) {
+      this._resetFocus = true;
+      this._activeDate = this.selected ?? this.now;
+      this._setChosenYear();
+      this._chosenMonth = void 0;
+      this._nextCalendarView = this._calendarView = this.view;
+      if (initTransition) {
+        this._startTableTransition();
+      }
+    }
+    /** Render the view for the day selection. */
+    _renderDayView() {
+      const nextMonthActiveDate = this._wide ? this._dateAdapter.addCalendarMonths(this._activeDate, 1) : void 0;
+      return html`
+      <div class="sbb-calendar__controls">
+        ${this._getArrow("left", () => this._goToDifferentMonth(-1), i18nPreviousMonth[this._language.current], this._previousMonthDisabled())}
+        <div class="sbb-calendar__controls-month">
+          ${this._createLabelForDayView(this._activeDate)}
+          ${this._wide ? this._createLabelForDayView(nextMonthActiveDate) : nothing}
+          <sbb-screen-reader-only role="status">
+            ${this._createAriaLabelForDayView(this._activeDate, nextMonthActiveDate)}
+          </sbb-screen-reader-only>
+        </div>
+        ${this._getArrow("right", () => this._goToDifferentMonth(1), i18nNextMonth[this._language.current], this._nextMonthDisabled())}
+      </div>
+      <div class="sbb-calendar__table-container sbb-calendar__table-day-view">
+        ${this.orientation === "horizontal" ? html`
+              ${this._createDayTable(this._weeks)}
+              ${this._wide ? this._createDayTable(this._nextMonthWeeks) : nothing}
+            ` : html`
+              ${this._createDayTableVertical(this._weeks)}
+              ${this._wide ? this._createDayTableVertical(this._nextMonthWeeks, nextMonthActiveDate) : nothing}
+            `}
+      </div>
+    `;
+    }
+    /** Creates the label with the month for the daily view. */
+    _createLabelForDayView(d) {
+      const monthLabel = `${this._monthNames[this._dateAdapter.getMonth(d) - 1]} ${this._dateAdapter.getYear(d)}`;
+      return html`
+      <button
+        type="button"
+        class="sbb-calendar__date-selection sbb-calendar__controls-change-date"
+        aria-label="${i18nYearMonthSelection[this._language.current]} ${monthLabel}"
+        @click=${() => {
+        this._resetFocus = true;
+        this._nextCalendarView = "year";
+        this._startTableTransition();
+      }}
+      >
+        ${monthLabel}
+        <sbb-icon name="chevron-small-down-small"></sbb-icon>
+      </button>
+    `;
+    }
+    /** Creates the aria-label for the daily view. */
+    _createAriaLabelForDayView(...dates) {
+      let monthLabel = "";
+      for (const d of dates) {
+        if (d) {
+          monthLabel += `${this._monthNames[this._dateAdapter.getMonth(d) - 1]} ${this._dateAdapter.getYear(d)} `;
+        }
+      }
+      return monthLabel;
+    }
+    /** Creates the calendar table for the daily view. */
+    _createDayTable(weeks) {
+      const today = this._dateAdapter.toIso8601(this.now);
+      return html`
+      <table
+        class="sbb-calendar__table"
+        @focusout=${(event) => this._handleTableBlur(event.relatedTarget)}
+        @animationend=${(e) => this._tableAnimationEnd(e)}
+      >
+        <thead class="sbb-calendar__table-header">
+          <tr class="sbb-calendar__table-header-row">
+            ${this._weekdays.map((day) => html`
+                <th class="sbb-calendar__table-header">
+                  <sbb-screen-reader-only>${day.long}</sbb-screen-reader-only>
+                  <span aria-hidden="true">${day.narrow}</span>
+                </th>
+              `)}
+          </tr>
+        </thead>
+        <tbody class="sbb-calendar__table-body">
+          ${weeks.map((week, rowIndex) => {
+        const firstRowOffset = DAYS_PER_ROW - week.length;
+        if (rowIndex === 0 && firstRowOffset) {
+          return html`
+                <tr>
+                  ${[...Array(firstRowOffset).keys()].map(() => html`<td class="sbb-calendar__table-data"></td>`)}
+                  ${this._createDayCells(week, today)}
+                </tr>
+              `;
+        }
+        return html`<tr>
+              ${this._createDayCells(week, today)}
+            </tr>`;
+      })}
+        </tbody>
+      </table>
+    `;
+    }
+    /* Creates the table in orientation='vertical'. */
+    _createDayTableVertical(weeks, nextMonthActiveDate) {
+      const today = this._dateAdapter.toIso8601(this.now);
+      const weekOffset = this._dateAdapter.getFirstWeekOffset(nextMonthActiveDate ?? this._activeDate);
+      return html`
+      <table
+        class="sbb-calendar__table"
+        @focusout=${(event) => this._handleTableBlur(event.relatedTarget)}
+        @animationend=${(e) => this._tableAnimationEnd(e)}
+      >
+        <tbody class="sbb-calendar__table-body">
+          ${weeks.map((week, rowIndex) => {
+        const weekday = this._weekdays[rowIndex];
+        return html`
+              <tr>
+                ${!nextMonthActiveDate ? html` <td class="sbb-calendar__table-header">
+                      <sbb-screen-reader-only>${weekday.long}</sbb-screen-reader-only>
+                      <span aria-hidden="true">${weekday.narrow}</span>
+                    </td>` : nothing}
+                ${rowIndex < weekOffset ? html`<td class="sbb-calendar__table-data"></td>` : nothing}
+                ${this._createDayCells(week, today)}
+              </tr>
+            `;
+      })}
+        </tbody>
+      </table>
+    `;
+    }
+    /** Creates the cells for the daily view. */
+    _createDayCells(week, today) {
+      return week.map((day) => {
+        const isOutOfRange = !this._isDayInRange(day.value);
+        const isFilteredOut = !this._dateFilter(this._dateAdapter.deserialize(day.value));
+        const selected = !!this._selected && day.value === this._selected;
+        const isToday = day.value === today;
+        return html`
+        <td
+          class=${classMap({
+          "sbb-calendar__table-data": true,
+          "sbb-calendar__table-data-selected": selected
+        })}
+        >
+          <button
+            class=${classMap({
+          "sbb-calendar__cell": true,
+          "sbb-calendar__day": true,
+          "sbb-calendar__cell-current": isToday,
+          "sbb-calendar__selected": selected,
+          "sbb-calendar__crossed-out": !isOutOfRange && isFilteredOut
+        })}
+            @click=${() => this._selectDate(day.value)}
+            ?disabled=${isOutOfRange || isFilteredOut}
+            value=${day.value}
+            type="button"
+            aria-label=${this._dateAdapter.getAccessibilityFormatDate(day.value)}
+            aria-pressed=${selected}
+            aria-disabled=${isOutOfRange || isFilteredOut}
+            aria-current=${isToday ? "date" : nothing}
+            tabindex="-1"
+            @keydown=${(evt) => this._handleKeyboardEvent(evt, day)}
+            sbb-popover-close
+          >
+            ${day.dayValue}
+          </button>
+        </td>
+      `;
+      });
+    }
+    /** Render the view for the month selection. */
+    _renderMonthView() {
+      return html`
+      <div class="sbb-calendar__controls">
+        ${this._getArrow("left", () => this._goToDifferentYear(-1), i18nPreviousYear[this._language.current], this._previousYearDisabled())}
+        <div class="sbb-calendar__controls-month">${this._createLabelForMonthView()}</div>
+        ${this._getArrow("right", () => this._goToDifferentYear(1), i18nNextYear[this._language.current], this._nextYearDisabled())}
+      </div>
+      <div class="sbb-calendar__table-container sbb-calendar__table-month-view">
+        ${this._createMonthTable(this._months, this._chosenYear)}
+        ${this._wide ? this._createMonthTable(this._months, this._chosenYear + 1) : nothing}
+      </div>
+    `;
+    }
+    /** Creates the label with the year for the monthly view. */
+    _createLabelForMonthView() {
+      return html` <button
+        type="button"
+        id="sbb-calendar__month-selection"
+        class="sbb-calendar__controls-change-date"
+        aria-label=${`${i18nCalendarDateSelection[this._language.current]} ${this._chosenYear}`}
+        @click=${() => this._resetCalendarView(true)}
+      >
+        ${this._chosenYear} ${this._wide ? ` - ${this._chosenYear + 1}` : nothing}
+        <sbb-icon name="chevron-small-up-small"></sbb-icon>
+      </button>
+      <sbb-screen-reader-only role="status"> ${this._chosenYear} </sbb-screen-reader-only>`;
+    }
+    /** Creates the table for the month selection view. */
+    _createMonthTable(months, year) {
+      return html`
+      <table
+        class="sbb-calendar__table"
+        @animationend=${(e) => this._tableAnimationEnd(e)}
+      >
+        ${this._wide ? html`<thead class="sbb-calendar__table-header" aria-hidden="true">
+              <tr class="sbb-calendar__table-header-row">
+                <th class="sbb-calendar__table-header" colspan=${MONTHS_PER_ROW}>${year}</th>
+              </tr>
+            </thead>` : nothing}
+        <tbody class="sbb-calendar__table-body">
+          ${months.map((row) => html`
+              <tr>
+                ${row.map((month) => {
+        const isOutOfRange = !this._isMonthInRange(month.monthValue, year);
+        const isFilteredOut = !this._isMonthFilteredOut(month.monthValue, year);
+        const selectedMonth = this._selected ? this._dateAdapter.getMonth(this._dateAdapter.deserialize(this._selected)) : void 0;
+        const selectedYear = this._selected ? this._dateAdapter.getYear(this._dateAdapter.deserialize(this._selected)) : void 0;
+        const selected = !!this._selected && year === selectedYear && month.monthValue === selectedMonth;
+        const isCurrentMonth = year === this._dateAdapter.getYear(this.now) && this._dateAdapter.getMonth(this.now) === month.monthValue;
+        return html` <td
+                    class=${classMap({
+          "sbb-calendar__table-data": true,
+          "sbb-calendar__table-month": true
+        })}
+                  >
+                    <button
+                      class=${classMap({
+          "sbb-calendar__cell": true,
+          "sbb-calendar__pill": true,
+          "sbb-calendar__cell-current": isCurrentMonth,
+          "sbb-calendar__crossed-out": !isOutOfRange && isFilteredOut,
+          "sbb-calendar__selected": selected
+        })}
+                      @click=${() => this._onMonthSelection(month.monthValue, year)}
+                      ?disabled=${isOutOfRange || isFilteredOut}
+                      aria-label=${`${month.longValue} ${year}`}
+                      aria-pressed=${selected}
+                      aria-disabled=${String(isOutOfRange || isFilteredOut)}
+                      tabindex="-1"
+                      data-month=${month.monthValue || nothing}
+                      @keydown=${(evt) => this._handleKeyboardEvent(evt)}
+                    >
+                      ${month.value}
+                    </button>
+                  </td>`;
+      })}
+              </tr>
+            `)}
+        </tbody>
+      </table>
+    `;
+    }
+    /** Select the month and change the view to day selection. */
+    _onMonthSelection(month, year) {
+      this._chosenMonth = month;
+      this._nextCalendarView = "day";
+      this._init(this._dateAdapter.createDate(year, this._chosenMonth, this._dateAdapter.getDate(this._activeDate)));
+      this._startTableTransition();
+    }
+    /** Render the view for the year selection. */
+    _renderYearView() {
+      return html`
+      <div class="sbb-calendar__controls">
+        ${this._getArrow("left", () => this._goToDifferentYearRange(-YEARS_PER_PAGE), i18nPreviousYearRange(YEARS_PER_PAGE)[this._language.current], this._previousYearRangeDisabled())}
+        <div class="sbb-calendar__controls-month">${this._createLabelForYearView()}</div>
+        ${this._getArrow("right", () => this._goToDifferentYearRange(YEARS_PER_PAGE), i18nNextYearRange(YEARS_PER_PAGE)[this._language.current], this._nextYearRangeDisabled())}
+      </div>
+      <div class="sbb-calendar__table-container sbb-calendar__table-year-view">
+        ${this._createYearTable(this._years)}
+        ${this._wide ? this._createYearTable(this._nextMonthYears, true) : nothing}
+      </div>
+    `;
+    }
+    /** Creates the button arrow for all the views. */
+    _getArrow(direction, click, ariaLabel, disabled) {
+      return html`<sbb-secondary-button
+      size="m"
+      icon-name="chevron-small-${direction}-small"
+      aria-label=${ariaLabel}
+      @click=${click}
+      ?disabled=${disabled}
+      id="sbb-calendar__controls-${direction === "left" ? "previous" : "next"}"
+    ></sbb-secondary-button>`;
+    }
+    /** Creates the label with the year range for the yearly view. */
+    _createLabelForYearView() {
+      const firstYear = this._years.flat()[0];
+      const lastYearArray = (this._wide ? this._nextMonthYears : this._years).flat();
+      const lastYear = lastYearArray[lastYearArray.length - 1];
+      const yearLabel = `${firstYear} - ${lastYear}`;
+      return html`
+      <button
+        type="button"
+        id="sbb-calendar__year-selection"
+        class="sbb-calendar__controls-change-date"
+        aria-label="${i18nCalendarDateSelection[this._language.current]} ${yearLabel}"
+        @click=${() => this._resetCalendarView(true)}
+      >
+        ${yearLabel}
+        <sbb-icon name="chevron-small-up-small"></sbb-icon>
+      </button>
+      <sbb-screen-reader-only role="status"> ${yearLabel} </sbb-screen-reader-only>
+    `;
+    }
+    /** Creates the table for the year selection view. */
+    _createYearTable(years, shiftRight = false) {
+      const now = this.now;
+      return html` <table
+      class="sbb-calendar__table"
+      @animationend=${(e) => this._tableAnimationEnd(e)}
+    >
+      <tbody class="sbb-calendar__table-body">
+        ${years.map((row) => html` <tr>
+              ${row.map((year) => {
+        const isOutOfRange = !this._isYearInRange(year);
+        const isFilteredOut = !this._isYearFilteredOut(year);
+        const selectedYear = this._selected ? this._dateAdapter.getYear(this._dateAdapter.deserialize(this._selected)) : void 0;
+        const selected = !!this._selected && year === selectedYear;
+        const isCurrentYear = this._dateAdapter.getYear(now) === year;
+        return html` <td class="sbb-calendar__table-data sbb-calendar__table-year">
+                  <button
+                    class=${classMap({
+          "sbb-calendar__cell": true,
+          "sbb-calendar__pill": true,
+          "sbb-calendar__cell-current": isCurrentYear,
+          "sbb-calendar__crossed-out": !isOutOfRange && isFilteredOut,
+          "sbb-calendar__selected": selected
+        })}
+                    @click=${() => this._onYearSelection(year, shiftRight)}
+                    ?disabled=${isOutOfRange || isFilteredOut}
+                    aria-label=${year}
+                    aria-pressed=${selected}
+                    aria-disabled=${String(isOutOfRange || isFilteredOut)}
+                    tabindex="-1"
+                    data-year=${year || nothing}
+                    @keydown=${(evt) => this._handleKeyboardEvent(evt)}
+                  >
+                    ${year}
+                  </button>
+                </td>`;
+      })}
+            </tr>`)}
+      </tbody>
+    </table>`;
+    }
+    /** Select the year and change the view to month selection. */
+    _onYearSelection(year, rightSide) {
+      this._chosenYear = rightSide ? year - 1 : year;
+      this._nextCalendarView = "month";
+      this._assignActiveDate(this._dateAdapter.createDate(this._chosenYear, this._dateAdapter.getMonth(this._activeDate), this._dateAdapter.getDate(this._activeDate)));
+      this._startTableTransition();
+    }
+    _getView() {
+      if (isServer || this.hydrationRequired) {
+        return html`${nothing}`;
+      }
+      switch (this._calendarView) {
+        case "year":
+          return this._renderYearView();
+        case "month":
+          return this._renderMonthView();
+        case "day":
+        default:
+          return this._renderDayView();
+      }
+    }
+    _tableAnimationEnd(event) {
+      const table = event.target;
+      if (event.animationName === "hide") {
+        table.classList.remove("sbb-calendar__table-hide");
+        this._resetFocus = true;
+        this._calendarView = this._nextCalendarView;
+      } else if (event.animationName === "show") {
+        this.removeAttribute("data-transition");
+      }
+    }
+    _startTableTransition() {
+      var _a2, _b;
+      this.toggleAttribute("data-transition", true);
+      (_b = (_a2 = this.shadowRoot) == null ? void 0 : _a2.querySelectorAll("table")) == null ? void 0 : _b.forEach((e) => e.classList.toggle("sbb-calendar__table-hide"));
+    }
+    render() {
+      return html`<div class="sbb-calendar__wrapper">${this._getView()}</div>`;
+    }
+  }, _wide_accessor_storage = new WeakMap(), _view_accessor_storage = new WeakMap(), _dateFilter_accessor_storage = new WeakMap(), _orientation_accessor_storage = new WeakMap(), __activeDate_accessor_storage = new WeakMap(), __selected_accessor_storage = new WeakMap(), __calendarView_accessor_storage = new WeakMap(), __initialized_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 })];
+    _view_decorators = [property()];
+    _set_min_decorators = [property()];
+    _set_max_decorators = [property()];
+    _set_now_decorators = [property()];
+    _set_selected_decorators = [property()];
+    _dateFilter_decorators = [property({ attribute: "date-filter" })];
+    _orientation_decorators = [property({ reflect: true })];
+    __activeDate_decorators = [state()];
+    __selected_decorators = [state()];
+    _set__wide_decorators = [state()];
+    __calendarView_decorators = [state()];
+    __initialized_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, _view_decorators, { kind: "accessor", name: "view", static: false, private: false, access: { has: (obj) => "view" in obj, get: (obj) => obj.view, set: (obj, value) => {
+      obj.view = value;
+    } }, metadata: _metadata }, _view_initializers, _view_extraInitializers);
+    __esDecorate(_a, null, _set_min_decorators, { kind: "setter", name: "min", static: false, private: false, access: { has: (obj) => "min" in obj, set: (obj, value) => {
+      obj.min = value;
+    } }, metadata: _metadata }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _set_max_decorators, { kind: "setter", name: "max", static: false, private: false, access: { has: (obj) => "max" in obj, set: (obj, value) => {
+      obj.max = value;
+    } }, metadata: _metadata }, null, _instanceExtraInitializers);
+    __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_selected_decorators, { kind: "setter", name: "selected", static: false, private: false, access: { has: (obj) => "selected" in obj, set: (obj, value) => {
+      obj.selected = value;
+    } }, metadata: _metadata }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _dateFilter_decorators, { kind: "accessor", name: "dateFilter", static: false, private: false, access: { has: (obj) => "dateFilter" in obj, get: (obj) => obj.dateFilter, set: (obj, value) => {
+      obj.dateFilter = value;
+    } }, metadata: _metadata }, _dateFilter_initializers, _dateFilter_extraInitializers);
+    __esDecorate(_a, null, _orientation_decorators, { kind: "accessor", name: "orientation", static: false, private: false, access: { has: (obj) => "orientation" in obj, get: (obj) => obj.orientation, set: (obj, value) => {
+      obj.orientation = value;
+    } }, metadata: _metadata }, _orientation_initializers, _orientation_extraInitializers);
+    __esDecorate(_a, null, __activeDate_decorators, { kind: "accessor", name: "_activeDate", static: false, private: false, access: { has: (obj) => "_activeDate" in obj, get: (obj) => obj._activeDate, set: (obj, value) => {
+      obj._activeDate = value;
+    } }, metadata: _metadata }, __activeDate_initializers, __activeDate_extraInitializers);
+    __esDecorate(_a, null, __selected_decorators, { kind: "accessor", name: "_selected", static: false, private: false, access: { has: (obj) => "_selected" in obj, get: (obj) => obj._selected, set: (obj, value) => {
+      obj._selected = value;
+    } }, metadata: _metadata }, __selected_initializers, __selected_extraInitializers);
+    __esDecorate(_a, null, _set__wide_decorators, { kind: "setter", name: "_wide", static: false, private: false, access: { has: (obj) => "_wide" in obj, set: (obj, value) => {
+      obj._wide = value;
+    } }, metadata: _metadata }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, __calendarView_decorators, { kind: "accessor", name: "_calendarView", static: false, private: false, access: { has: (obj) => "_calendarView" in obj, get: (obj) => obj._calendarView, set: (obj, value) => {
+      obj._calendarView = value;
+    } }, metadata: _metadata }, __calendarView_initializers, __calendarView_extraInitializers);
+    __esDecorate(_a, null, __initialized_decorators, { kind: "accessor", name: "_initialized", static: false, private: false, access: { has: (obj) => "_initialized" in obj, get: (obj) => obj._initialized, set: (obj, value) => {
+      obj._initialized = value;
+    } }, metadata: _metadata }, __initialized_initializers, __initialized_extraInitializers);
+    __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+    SbbCalendarElement2 = _classThis = _classDescriptor.value;
+    if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+  })(), _a.styles = style, _a.events = {
+    dateSelected: "dateSelected"
+  }, __runInitializers(_classThis, _classExtraInitializers), _a);
+  return SbbCalendarElement2 = _classThis;
+})();
+export {
+  SbbCalendarElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"calendar.component.js","sources":["../../../../src/elements/calendar/calendar.component.ts"],"sourcesContent":["import {\n  type CSSResultGroup,\n  html,\n  isServer,\n  LitElement,\n  nothing,\n  type PropertyValues,\n  type TemplateResult,\n} from 'lit';\nimport { customElement, property, state } from 'lit/decorators.js';\nimport { classMap } from 'lit/directives/class-map.js';\n\nimport { isArrowKeyOrPageKeysPressed, sbbInputModalityDetector } from '../core/a11y.js';\nimport { readConfig } from '../core/config.js';\nimport {\n  SbbLanguageController,\n  SbbMediaMatcherController,\n  SbbMediaQueryBreakpointMediumAndAbove,\n} from '../core/controllers.js';\nimport type { DateAdapter } from '../core/datetime.js';\nimport {\n  DAYS_PER_ROW,\n  defaultDateAdapter,\n  MONTHS_PER_PAGE,\n  MONTHS_PER_ROW,\n  YEARS_PER_PAGE,\n  YEARS_PER_ROW,\n} from '../core/datetime.js';\nimport { forceType } from '../core/decorators.js';\nimport { EventEmitter } from '../core/eventing.js';\nimport {\n  i18nCalendarDateSelection,\n  i18nNextMonth,\n  i18nNextYear,\n  i18nNextYearRange,\n  i18nPreviousMonth,\n  i18nPreviousYear,\n  i18nPreviousYearRange,\n  i18nYearMonthSelection,\n} from '../core/i18n.js';\nimport type { SbbDateLike } from '../core/interfaces.js';\nimport { SbbHydrationMixin } from '../core/mixins.js';\n\nimport style from './calendar.scss?lit&inline';\n\nimport '../button/secondary-button.js';\nimport '../icon.js';\nimport '../screen-reader-only.js';\n\n/**\n * Parameters needed in year and month views to correctly calculate the next element in keyboard navigation.\n *\n * The cell's index and the element's index in its month / year batch must be distinguished:\n * the first is the index of the element in the array of all the rendered cells, while the second is the index of the element relative to its table.\n * In non-wide mode, the wto are the same, while in wide mode the cell's index can go from 0 to 47 for years and from 0 to 23 for months,\n * while the element index goes from 0 to, respectively, 23 and 11.\n */\ninterface CalendarKeyboardNavigationMonthYearViewsParameters {\n  /** The element index within its year or month range. */\n  elementIndexForWideMode: number;\n  /** In wide mode, the index of the first element in the second panel, or, alternatively, the number of elements in the first panel. */\n  offsetForWideMode: number;\n  /** The index of the last element within the element's month (or year range). */\n  lastElementIndexForWideMode: number;\n  /** The number of cells displayed in a single row, depending on the rendered view. */\n  verticalOffset: number;\n}\n\n/**\n * Parameters needed in day view to correctly calculate the next element in keyboard navigation.\n *\n * In orientation='vertical', it's not possible to rely on any array/index to calculate the element to navigate to,\n * so calculations on dates must be done, which should consider view boundaries, offsets and month's length.\n */\ninterface CalendarKeyboardNavigationDayViewParameters {\n  /** The first day rendered. */\n  firstDayInView: string | null;\n  /** The last day rendered. It depends on the 'wide' value. */\n  lastDayInView: string | null;\n  /** The offset from the first day of the week (Monday) of the first rendered month. */\n  firstMonthOffset: number;\n  /** The number of days in the first rendered month. */\n  firstMonthLength: number;\n  /** The offset from the first day of the week (Monday) of the second rendered month. If wide is false, it's equal to zero. */\n  secondMonthOffset: number;\n}\n\nexport interface Day<T = Date> {\n  value: string;\n  dayValue: string;\n  monthValue: string;\n  yearValue: string;\n  dateValue?: T;\n}\n\nexport interface Month {\n  value: string;\n  longValue: string;\n  monthValue: number;\n}\n\nexport interface Weekday {\n  long: string;\n  narrow: string;\n}\n\nexport type CalendarView = 'day' | 'month' | 'year';\n\n/**\n * It displays a calendar which allows to choose a date.\n *\n * @event {CustomEvent<T>} dateSelected - Event emitted on date selection.\n */\nexport\n@customElement('sbb-calendar')\nclass SbbCalendarElement<T = Date> extends SbbHydrationMixin(LitElement) {\n  public static override styles: CSSResultGroup = style;\n  public static readonly events = {\n    dateSelected: 'dateSelected',\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  /** The initial view of the calendar which should be displayed on opening. */\n  @property() public accessor view: CalendarView = 'day';\n\n  /** The minimum valid date. Takes T Object, ISOString, and Unix Timestamp (number of seconds since Jan 1, 1970). */\n  @property()\n  public set min(value: SbbDateLike<T> | null) {\n    this._min = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n  }\n  public get min(): T | null {\n    return this._min ?? null;\n  }\n  private _min?: T | null;\n\n  /** The maximum valid date. Takes T Object, ISOString, and Unix Timestamp (number of seconds since Jan 1, 1970). */\n  @property()\n  public set max(value: SbbDateLike<T> | null) {\n    this._max = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n  }\n  public get max(): T | null {\n    return this._max ?? null;\n  }\n  private _max?: T | null;\n\n  /** A configured date which acts as the current date instead of the real current date. Recommended for testing purposes. */\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 = null;\n\n  /** The selected date. Takes T Object, ISOString, and Unix Timestamp (number of seconds since Jan 1, 1970). */\n  @property()\n  public set selected(value: SbbDateLike<T> | null) {\n    this._selectedDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    if (\n      !!this._selectedDate &&\n      (!this._isDayInRange(this._dateAdapter.toIso8601(this._selectedDate)) ||\n        this._dateFilter(this._selectedDate))\n    ) {\n      this._selected = this._dateAdapter.toIso8601(this._selectedDate);\n    } else {\n      this._selected = undefined;\n    }\n  }\n  public get selected(): T | null {\n    return this._selectedDate ?? null;\n  }\n  private _selectedDate?: T | null;\n\n  /** A function used to filter out dates. */\n  @property({ attribute: 'date-filter' })\n  public accessor dateFilter: ((date: T | null) => boolean) | null = null;\n\n  /** The orientation of days in the calendar. */\n  @property({ reflect: true }) public accessor orientation: 'horizontal' | 'vertical' =\n    'horizontal';\n\n  private _dateAdapter: DateAdapter<T> = readConfig().datetime?.dateAdapter ?? defaultDateAdapter;\n\n  /** Event emitted on date selection. */\n  private _dateSelected: EventEmitter<T> = new EventEmitter(\n    this,\n    SbbCalendarElement.events.dateSelected,\n  );\n\n  /** The currently active date. */\n  @state() private accessor _activeDate: T = this.now;\n\n  /** The selected date as ISOString. */\n  @state() private accessor _selected: string | undefined;\n\n  /** The current wide property considering property value and breakpoints. From zero to small `wide` has always to be false. */\n  @state()\n  private set _wide(wide: boolean) {\n    this.toggleAttribute('data-wide', wide);\n  }\n  private get _wide(): boolean {\n    return this.hasAttribute('data-wide');\n  }\n\n  @state() private accessor _calendarView: CalendarView = 'day';\n\n  private _nextCalendarView: CalendarView = 'day';\n\n  /** Information about the rendered day view; used in keyboard navigation. */\n  private _keyboardNavigationDayViewParameters: CalendarKeyboardNavigationDayViewParameters = {\n    firstDayInView: null,\n    lastDayInView: null,\n    firstMonthOffset: 0,\n    firstMonthLength: 0,\n    secondMonthOffset: 0,\n  };\n\n  /** A list of days, in two formats (long and single char). */\n  private _weekdays!: Weekday[];\n\n  /** Grid of calendar cells representing the dates of the month. */\n  private _weeks: Day<T>[][] = [];\n\n  /** Grid of calendar cells representing months. */\n  private _months!: Month[][];\n\n  /** Grid of calendar cells representing years. */\n  private _years!: number[][];\n\n  /** Grid of calendar cells representing years for the wide view. */\n  private _nextMonthYears!: number[][];\n\n  /** Grid of calendar cells representing the dates of the next month. */\n  private _nextMonthWeeks!: Day<T>[][];\n\n  /** An array containing all the month names in the current language. */\n  private _monthNames: string[] = this._dateAdapter.getMonthNames('long');\n\n  /** A list of buttons corresponding to days, months or years depending on the view. */\n  private get _cells(): HTMLButtonElement[] {\n    return Array.from(\n      this.shadowRoot!.querySelectorAll('.sbb-calendar__cell') ?? [],\n    ) as HTMLButtonElement[];\n  }\n\n  /** The chosen year in the year selection view. */\n  private _chosenYear?: number;\n\n  /** The chosen month in the year selection view. */\n  private _chosenMonth?: number;\n\n  /** Whether the focus should be reset on focusCell. */\n  private _resetFocus = false;\n\n  @state()\n  private accessor _initialized = false;\n\n  private _language = new SbbLanguageController(this).withHandler(() => {\n    this._monthNames = this._dateAdapter.getMonthNames('long');\n    this._createMonthRows();\n  });\n  private _mediaMatcher = new SbbMediaMatcherController(this, {\n    [SbbMediaQueryBreakpointMediumAndAbove]: () => this._init(),\n  });\n\n  public constructor() {\n    super();\n    this._createMonthRows();\n    this._setWeekdays();\n  }\n\n  private _dateFilter(date: T): boolean {\n    return this.dateFilter?.(date) ?? true;\n  }\n\n  /** Resets the active month according to the new state of the calendar. */\n  public resetPosition(): void {\n    this._resetCalendarView();\n    this._init();\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    this.resetPosition();\n    this.focus = () => {\n      this._resetFocus = true;\n      this._focusCell();\n    };\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (!this._initialized) {\n      return;\n    }\n\n    if (changedProperties.has('wide') || changedProperties.has('orientation')) {\n      this.resetPosition();\n    }\n\n    if (changedProperties.has('view')) {\n      this._setChosenYear();\n      this._chosenMonth = undefined;\n      this._nextCalendarView = this._calendarView = this.view;\n    }\n  }\n\n  protected override updated(changedProperties: PropertyValues<this>): void {\n    super.updated(changedProperties);\n    // The calendar needs to calculate tab-indexes on first render,\n    // and every time a date is selected or the month view changes.\n    this._setTabIndex();\n    // When changing view to year/month, the tabindex is changed, but the focused element is not,\n    // so if the navigation is done via keyboard, there's the need\n    // to call the `_focusCell()` method explicitly to correctly set the focus.\n    if (sbbInputModalityDetector.mostRecentModality === 'keyboard') {\n      this._focusCell();\n    }\n  }\n\n  /** Initializes the component. */\n  private _init(activeDate?: T): void {\n    // Due to its complexity, the calendar is only initialized on client side\n    if (isServer) {\n      return;\n    } else if (this.hydrationRequired) {\n      this.hydrationComplete.then(() => this._init());\n      return;\n    }\n\n    if (activeDate) {\n      this._assignActiveDate(activeDate);\n    }\n    this._wide =\n      (this._mediaMatcher.matches(SbbMediaQueryBreakpointMediumAndAbove) ?? false) && this.wide;\n    this._weeks = this._createWeekRows(this._activeDate);\n    this._years = this._createYearRows();\n    this._nextMonthWeeks = [[]];\n    this._nextMonthYears = [[]];\n    if (this._wide) {\n      const nextMonthDate = this._dateAdapter.addCalendarMonths(this._activeDate, 1);\n      this._nextMonthWeeks = this._createWeekRows(nextMonthDate, true);\n      this._nextMonthYears = this._createYearRows(YEARS_PER_PAGE);\n    }\n    this._initialized = true;\n  }\n\n  /** Focuses on a day cell prioritizing the selected day, the current day, and lastly, the first selectable day. */\n  private _focusCell(): void {\n    if (this._resetFocus) {\n      this._getFirstFocusable()?.focus();\n      this._resetFocus = false;\n    }\n  }\n\n  /** Creates the array of weekdays. */\n  private _setWeekdays(): void {\n    const narrowWeekdays: string[] = this._dateAdapter.getDayOfWeekNames('narrow');\n    const longWeekdays: string[] = this._dateAdapter.getDayOfWeekNames('long');\n    const weekdays: Weekday[] = longWeekdays.map((long: string, i: number) => ({\n      long,\n      narrow: narrowWeekdays[i],\n    }));\n\n    // Rotates the labels for days of the week based on the configured first day of the week.\n    const firstDayOfWeek: number = this._dateAdapter.getFirstDayOfWeek();\n    this._weekdays = weekdays.slice(firstDayOfWeek).concat(weekdays.slice(0, firstDayOfWeek));\n  }\n\n  /** Creates the rows for each week and sets the parameters used in keyboard navigation. */\n  private _createWeekRows(value: T, isSecondMonthInView = false): Day<T>[][] {\n    const dateNames: string[] = this._dateAdapter.getDateNames();\n    const daysInMonth: number = this._dateAdapter.getNumDaysInMonth(value);\n    const weekOffset: number = this._dateAdapter.getFirstWeekOffset(value);\n    if (!isSecondMonthInView) {\n      this._keyboardNavigationDayViewParameters.firstMonthLength = daysInMonth;\n      this._keyboardNavigationDayViewParameters.firstMonthOffset = weekOffset;\n      this._keyboardNavigationDayViewParameters.firstDayInView = this._dateAdapter.toIso8601(\n        this._dateAdapter.createDate(\n          this._dateAdapter.getYear(value),\n          this._dateAdapter.getMonth(value),\n          1,\n        ),\n      );\n      this._keyboardNavigationDayViewParameters.lastDayInView = this._dateAdapter.toIso8601(\n        this._dateAdapter.createDate(\n          this._dateAdapter.getYear(value),\n          this._dateAdapter.getMonth(value),\n          daysInMonth,\n        ),\n      );\n    } else {\n      this._keyboardNavigationDayViewParameters.secondMonthOffset = weekOffset;\n      this._keyboardNavigationDayViewParameters.lastDayInView = this._dateAdapter.toIso8601(\n        this._dateAdapter.createDate(\n          this._dateAdapter.getYear(value),\n          this._dateAdapter.getMonth(value),\n          daysInMonth,\n        ),\n      );\n    }\n    return this.orientation === 'horizontal'\n      ? this._createWeekRowsHorizontal(value, dateNames, daysInMonth, weekOffset)\n      : this._createWeekRowsVertical(value, dateNames, daysInMonth, weekOffset);\n  }\n\n  /**\n   * Creates the rows for each week in orientation='horizontal'.\n   *\n   * Iterates through the days of the months, creates a Day object for each and pushes it into and array.\n   * Each seven days (considering the offset at the beginning of the month) restarts from an empty array.\n   *\n   * The result is a matrix in which every row is a week (or part of it, considering offset).\n   */\n  private _createWeekRowsHorizontal(\n    value: T,\n    dateNames: string[],\n    daysInMonth: number,\n    weekOffset: number,\n  ): Day<T>[][] {\n    const weeks: Day<T>[][] = [[]];\n    for (let i = 0, cell = weekOffset; i < daysInMonth; i++, cell++) {\n      if (cell === DAYS_PER_ROW) {\n        weeks.push([]);\n        cell = 0;\n      }\n      const date = this._dateAdapter.createDate(\n        this._dateAdapter.getYear(value),\n        this._dateAdapter.getMonth(value),\n        i + 1,\n      )!;\n      weeks[weeks.length - 1].push({\n        value: this._dateAdapter.toIso8601(date),\n        dateValue: date,\n        dayValue: dateNames[i],\n        monthValue: String(this._dateAdapter.getMonth(date)),\n        yearValue: String(this._dateAdapter.getYear(date)),\n      });\n    }\n    return weeks;\n  }\n\n  /**\n   * Creates the rows for each week in orientation='vertical'.\n   *\n   * Creates a matrix with seven empty rows.\n   * Iterates through the days of the months, creates a Day object for each\n   * and pushes it into the correct array considering the offset at the beginning of the month.\n   * Each seven days (including offset) restarts from the first.\n   *\n   * The result is a matrix in which every row is a set of weekdays, so:\n   * - row 0: all the Mondays;\n   * - row 1: all the Tuesdays;\n   * - ...\n   * - row 7: all the Sundays.\n   */\n  private _createWeekRowsVertical(\n    value: T,\n    dateNames: string[],\n    daysInMonth: number,\n    weekOffset: number,\n  ): Day<T>[][] {\n    const weeks: Day<T>[][] = Array.from({ length: DAYS_PER_ROW }, () => []);\n    for (let i = 0, cell = weekOffset; i < daysInMonth; i++, cell++) {\n      if (cell === DAYS_PER_ROW) {\n        cell = 0;\n      }\n      const date = this._dateAdapter.createDate(\n        this._dateAdapter.getYear(value),\n        this._dateAdapter.getMonth(value),\n        i + 1,\n      )!;\n      weeks[cell].push({\n        value: this._dateAdapter.toIso8601(date),\n        dateValue: date,\n        dayValue: dateNames[i],\n        monthValue: String(this._dateAdapter.getMonth(date)),\n        yearValue: String(this._dateAdapter.getYear(date)),\n      });\n    }\n    return weeks;\n  }\n\n  /** Creates the rows for the month selection view. */\n  private _createMonthRows(): void {\n    const shortNames: string[] = this._dateAdapter.getMonthNames('short');\n    const months: Month[] = new Array(12).fill(null).map(\n      (_, i: number): Month => ({\n        value: shortNames[i],\n        longValue: this._monthNames[i],\n        monthValue: i + 1,\n      }),\n    );\n    const rows: number = 12 / MONTHS_PER_ROW;\n    const monthArray: Month[][] = [];\n    for (let i: number = 0; i < rows; i++) {\n      monthArray.push(months.slice(MONTHS_PER_ROW * i, MONTHS_PER_ROW * (i + 1)));\n    }\n    this._months = monthArray;\n  }\n\n  /** Creates the rows for the year selection view. */\n  private _createYearRows(offset: number = 0): number[][] {\n    const startValueYearView: number = this._getStartValueYearView();\n    const allYears: number[] = new Array(YEARS_PER_PAGE)\n      .fill(0)\n      .map((_, i: number) => startValueYearView + offset + i);\n    const rows: number = YEARS_PER_PAGE / YEARS_PER_ROW;\n    const yearArray: number[][] = [];\n    for (let i: number = 0; i < rows; i++) {\n      yearArray.push(allYears.slice(YEARS_PER_ROW * i, YEARS_PER_ROW * (i + 1)));\n    }\n    return yearArray;\n  }\n\n  /**\n   * Calculates the first year that will be shown in the year selection panel.\n   * If `minDate` and `maxDate` are both null, the starting year is calculated as\n   * the multiple of YEARS_PER_PAGE closest to and less than activeDate,\n   * e.g., with `YEARS_PER_PAGE` = 24 and `activeDate` = 2020, the function will return 2016 (24 * 83),\n   * while with `activeDate` = 2000, the function will return 1992 (24 * 82).\n   * If `minDate` is not null, it returns the corresponding year; if `maxDate` is not null,\n   * it returns the corresponding year minus `YEARS_PER_PAGE`, so that the `maxDate` is the last rendered year.\n   * If both are not null, `maxDate` has priority over `minDate`.\n   */\n  private _getStartValueYearView(): number {\n    let startingYear = 0;\n    if (this.max) {\n      startingYear = this._dateAdapter.getYear(this.max) - YEARS_PER_PAGE + 1;\n    } else if (this.min) {\n      startingYear = this._dateAdapter.getYear(this.min);\n    }\n    const activeYear = this._dateAdapter.getYear(this._activeDate);\n    return (\n      activeYear -\n      ((((activeYear - startingYear) % YEARS_PER_PAGE) + YEARS_PER_PAGE) % YEARS_PER_PAGE)\n    );\n  }\n\n  /** Checks if date is within the min-max range. */\n  private _isDayInRange(date: string): boolean {\n    if (!this.min && !this.max) {\n      return true;\n    }\n    const isBeforeMin: boolean =\n      this._dateAdapter.isValid(this.min) &&\n      this._dateAdapter.compareDate(this.min!, this._dateAdapter.deserialize(date)!) > 0;\n    const isAfterMax: boolean =\n      this._dateAdapter.isValid(this.max) &&\n      this._dateAdapter.compareDate(this.max!, this._dateAdapter.deserialize(date)!) < 0;\n    return !(isBeforeMin || isAfterMax);\n  }\n\n  /** Checks if date is within the min-max range in month view. */\n  private _isMonthInRange(month: number, year: number): boolean {\n    if (!this.min && !this.max) {\n      return true;\n    }\n\n    const isBeforeMin: boolean =\n      this._dateAdapter.isValid(this.min) &&\n      (year < this._dateAdapter.getYear(this.min!) ||\n        (year === this._dateAdapter.getYear(this.min!) &&\n          month < this._dateAdapter.getMonth(this.min!)));\n\n    const isAfterMax: boolean =\n      this._dateAdapter.isValid(this.max) &&\n      (year > this._dateAdapter.getYear(this.max!) ||\n        (year === this._dateAdapter.getYear(this.max!) &&\n          month > this._dateAdapter.getMonth(this.max!)));\n\n    return !(isBeforeMin || isAfterMax);\n  }\n\n  /** Checks if date is within the min-max range in year view. */\n  private _isYearInRange(year: number): boolean {\n    if (!this.min && !this.max) {\n      return true;\n    }\n    const isBeforeMin: boolean =\n      this._dateAdapter.isValid(this.min) && this._dateAdapter.getYear(this.min!) > year;\n    const isAfterMax: boolean =\n      this._dateAdapter.isValid(this.max) && this._dateAdapter.getYear(this.max!) < year;\n    return !(isBeforeMin || isAfterMax);\n  }\n\n  // Implementation adapted from https://github.com/angular/components/blob/main/src/material/datepicker/year-view.ts#L366\n  private _isMonthFilteredOut(month: number, year: number): boolean {\n    if (!this.dateFilter) {\n      return true;\n    }\n\n    const firstOfMonth = this._dateAdapter.createDate(year, month, 1)!;\n    for (\n      let date: T = firstOfMonth;\n      this._dateAdapter.getMonth(date) == month;\n      date = this._dateAdapter.addCalendarDays(date, 1)\n    ) {\n      if (this.dateFilter(date)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  // Implementation adapted from https://github.com/angular/components/blob/main/src/material/datepicker/multi-year-view.ts#L351\n  private _isYearFilteredOut(year: number): boolean {\n    if (!this.dateFilter) {\n      return true;\n    }\n\n    const firstOfYear = this._dateAdapter.createDate(year, 1, 1)!;\n    for (\n      let date: T = firstOfYear;\n      this._dateAdapter.getYear(date) == year;\n      date = this._dateAdapter.addCalendarDays(date, 1)\n    ) {\n      if (this.dateFilter(date)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  /** Emits the selected date and sets it internally. */\n  private _selectDate(day: string): void {\n    this._chosenMonth = undefined;\n    this._setChosenYear();\n    if (this._selected !== day) {\n      this._selected = day;\n      this._dateSelected.emit(this._dateAdapter.deserialize(day)!);\n    }\n  }\n\n  private _setChosenYear(): void {\n    if (this.view === 'month') {\n      this._chosenYear = this._dateAdapter.getYear(\n        this._dateAdapter.deserialize(this._selected) ?? this.selected ?? this.now,\n      );\n    } else {\n      this._chosenYear = undefined;\n    }\n  }\n\n  private _assignActiveDate(date: T): void {\n    if (this.min && this._dateAdapter.compareDate(this.min, date) > 0) {\n      this._activeDate = this.min;\n      return;\n    }\n    if (this.max && this._dateAdapter.compareDate(this.max, date) < 0) {\n      this._activeDate = this.max;\n      return;\n    }\n    this._activeDate = date;\n  }\n\n  /** Goes to the month identified by the shift. */\n  private _goToDifferentMonth(months: number): void {\n    this._init(this._dateAdapter.addCalendarMonths(this._activeDate, months));\n  }\n\n  private _goToDifferentYear(years: number): void {\n    this._chosenYear! += years;\n    // Can't use `_assignActiveDate(...)` here, because it will set it to min/max value if argument is out of range\n    this._activeDate = this._dateAdapter.createDate(\n      this._chosenYear!,\n      this._dateAdapter.getMonth(this._activeDate),\n      this._dateAdapter.getDate(this._activeDate),\n    );\n    this._init();\n  }\n\n  private _goToDifferentYearRange(years: number): void {\n    this._init(this._dateAdapter.addCalendarYears(this._activeDate, years));\n  }\n\n  private _prevDisabled(prevDate: T): boolean {\n    if (!this.min) {\n      return false;\n    }\n    return this._dateAdapter.compareDate(prevDate, this.min) < 0;\n  }\n\n  private _nextDisabled(nextDate: T): boolean {\n    if (!this.max) {\n      return false;\n    }\n    return this._dateAdapter.compareDate(nextDate, this.max) > 0;\n  }\n\n  /** Checks if the \"previous month\" button should be disabled. */\n  private _previousMonthDisabled(): boolean {\n    const prevMonth = this._dateAdapter.addCalendarDays(\n      this._activeDate,\n      this._dateAdapter.getDate(this._activeDate) * -1,\n    );\n    return this._prevDisabled(prevMonth);\n  }\n\n  /** Checks if the \"next month\" button should be disabled. */\n  private _nextMonthDisabled(): boolean {\n    let nextMonth = this._dateAdapter.addCalendarMonths(this._activeDate, this._wide ? 2 : 1);\n    nextMonth = this._dateAdapter.createDate(\n      this._dateAdapter.getYear(nextMonth),\n      this._dateAdapter.getMonth(nextMonth),\n      1,\n    );\n    return this._nextDisabled(nextMonth);\n  }\n\n  /** Checks if the \"previous year\" button should be disabled. */\n  private _previousYearDisabled(): boolean {\n    const prevYear = this._dateAdapter.createDate(\n      this._dateAdapter.getYear(this._activeDate) - 1,\n      12,\n      31,\n    );\n    return this._prevDisabled(prevYear);\n  }\n\n  /** Checks if the \"next year\" button should be disabled. */\n  private _nextYearDisabled(): boolean {\n    const nextYear = this._dateAdapter.createDate(\n      this._dateAdapter.getYear(this._activeDate) + (this._wide ? 2 : 1),\n      1,\n      1,\n    );\n    return this._nextDisabled(nextYear);\n  }\n\n  /** Checks if the \"previous year\" button should be disabled in year view. */\n  private _previousYearRangeDisabled(): boolean {\n    const prevYear = this._dateAdapter.createDate(this._years[0][0] - 1, 12, 31);\n    return this._prevDisabled(prevYear);\n  }\n\n  /** Checks if the \"next year\" button should be disabled in year view. */\n  private _nextYearRangeDisabled(): boolean {\n    const years = this._wide ? this._nextMonthYears : this._years;\n    const lastYearRange = years[years.length - 1];\n    const lastYear = lastYearRange[lastYearRange.length - 1];\n    const nextYear = this._dateAdapter.createDate(lastYear + 1, 1, 1);\n    return this._nextDisabled(nextYear);\n  }\n\n  private _handleTableBlur(eventTarget: HTMLElement): void {\n    if (eventTarget?.localName !== 'button') {\n      this._setTabIndex();\n    }\n  }\n\n  private _setTabIndex(): void {\n    Array.from(\n      this.shadowRoot!.querySelectorAll('.sbb-calendar__cell[tabindex=\"0\"]') ?? [],\n    ).forEach((day) => ((day as HTMLElement).tabIndex = -1));\n    const firstFocusable = this._getFirstFocusable();\n    if (firstFocusable) {\n      firstFocusable.tabIndex = 0;\n    }\n  }\n\n  /** Get the element in the calendar to assign focus. */\n  private _getFirstFocusable(): HTMLButtonElement {\n    const active = this._selected ? this._dateAdapter.deserialize(this._selected)! : this.now;\n    let firstFocusable =\n      this.shadowRoot!.querySelector('.sbb-calendar__selected') ??\n      this.shadowRoot!.querySelector(`[value=\"${this._dateAdapter.toIso8601(active)}\"]`) ??\n      this.shadowRoot!.querySelector(`[data-month=\"${this._dateAdapter.getMonth(active)}\"]`) ??\n      this.shadowRoot!.querySelector(`[data-year=\"${this._dateAdapter.getYear(active)}\"]`);\n    if (!firstFocusable || (firstFocusable as HTMLButtonElement)?.disabled) {\n      firstFocusable =\n        this._calendarView === 'day'\n          ? this._getFirstFocusableDay()\n          : this.shadowRoot!.querySelector('.sbb-calendar__cell:not([disabled])');\n    }\n    return (firstFocusable as HTMLButtonElement) || null;\n  }\n\n  /**\n   * In `day` view in `vertical` orientation,\n   * if the first of the month is not a Monday, it is not the first rendered element in the table,\n   * so `this.shadowRoot!.querySelector('.sbb-calendar__cell:not([disabled])')` will return a wrong value.\n   *\n   * To solve this, the element with the lowest `value` is taken (ISO String are ordered).\n   */\n  private _getFirstFocusableDay(): HTMLButtonElement | null {\n    const daysInView: HTMLButtonElement[] = Array.from(\n      this.shadowRoot!.querySelectorAll('.sbb-calendar__cell:not([disabled])'),\n    );\n    if (!daysInView || daysInView.length === 0) {\n      return null;\n    } else {\n      const firstElement = daysInView.map((e: HTMLButtonElement): string => e.value).sort()[0];\n      return this.shadowRoot!.querySelector(`.sbb-calendar__cell[value=\"${firstElement}\"]`);\n    }\n  }\n\n  private _handleKeyboardEvent(event: KeyboardEvent, day?: Day<T>): void {\n    if (isArrowKeyOrPageKeysPressed(event)) {\n      event.preventDefault();\n    }\n    // Gets the currently rendered table's cell;\n    // they could be days, months or years based on the current selection view.\n    // If `wide` is true, years are doubled in number and days are (roughly) doubled too, affecting the `index` calculation.\n    const cells: HTMLButtonElement[] = this._cells;\n    const index: number = cells.findIndex((e: HTMLButtonElement) => e === event.target);\n    let nextEl: HTMLButtonElement;\n    if (day) {\n      nextEl = this._navigateByKeyboardDayView(event, index, cells, day);\n    } else {\n      nextEl = this._navigateByKeyboard(event, index, cells);\n    }\n    const activeEl: HTMLButtonElement = this.shadowRoot!.activeElement as HTMLButtonElement;\n    if (nextEl !== activeEl) {\n      (nextEl as HTMLButtonElement).tabIndex = 0;\n      nextEl?.focus();\n      (activeEl as HTMLButtonElement).tabIndex = -1;\n    }\n  }\n\n  private _navigateByKeyboardDayView(\n    evt: KeyboardEvent,\n    index: number,\n    cells: HTMLButtonElement[],\n    day: Day<T>,\n  ): HTMLButtonElement {\n    const arrowsOffset =\n      this.orientation === 'horizontal'\n        ? { leftRight: 1, upDown: DAYS_PER_ROW }\n        : { leftRight: DAYS_PER_ROW, upDown: 1 };\n    const offsetForVertical: number =\n      index < this._keyboardNavigationDayViewParameters.firstMonthLength\n        ? this._keyboardNavigationDayViewParameters.firstMonthOffset\n        : this._keyboardNavigationDayViewParameters.secondMonthOffset;\n\n    switch (evt.key) {\n      case 'ArrowUp':\n        return this._findDayArrows(cells, index, day.dateValue!, -arrowsOffset.upDown);\n      case 'ArrowDown':\n        return this._findDayArrows(cells, index, day.dateValue!, arrowsOffset.upDown);\n      case 'ArrowLeft':\n        return this._findDayArrows(cells, index, day.dateValue!, -arrowsOffset.leftRight);\n      case 'ArrowRight':\n        return this._findDayArrows(cells, index, day.dateValue!, arrowsOffset.leftRight);\n      case 'PageUp': {\n        if (this.orientation === 'horizontal') {\n          const firstOfWeek: number = +day.dayValue % DAYS_PER_ROW || DAYS_PER_ROW;\n          const delta: number = firstOfWeek - +day.dayValue;\n          return this._findDayPageUpDown(cells, index, day, delta, arrowsOffset.upDown);\n        } else {\n          const weekNumber: number = Math.ceil((+day.dayValue + offsetForVertical) / DAYS_PER_ROW);\n          const firstOfWeek: number = (weekNumber - 1) * DAYS_PER_ROW - offsetForVertical + 1;\n          const delta: number = firstOfWeek - +day.dayValue;\n          return this._findDayPageUpDown(cells, index, day, delta, arrowsOffset.upDown);\n        }\n      }\n      case 'PageDown': {\n        if (this.orientation === 'horizontal') {\n          const monthInBounds = +day.monthValue + 1 > 12 ? 1 : +day.monthValue + 1;\n          const yearInBounds = +day.monthValue + 1 > 12 ? +day.yearValue + 1 : +day.yearValue;\n          const firstNextMonth: T = this._dateAdapter.createDate(yearInBounds, monthInBounds, 1);\n          const lastOfMonth: number = this._dateAdapter.getDate(\n            this._dateAdapter.addCalendarDays(firstNextMonth, -1),\n          );\n          const delta: number =\n            Math.trunc((lastOfMonth - +day.dayValue!) / DAYS_PER_ROW) * DAYS_PER_ROW;\n          return this._findDayPageUpDown(cells, index, day, delta, -arrowsOffset.upDown);\n        } else {\n          const weekNumber: number = Math.ceil((+day.dayValue + offsetForVertical) / DAYS_PER_ROW);\n          const lastOfWeek: number = weekNumber * DAYS_PER_ROW - offsetForVertical;\n          const delta: number = lastOfWeek - +day.dayValue;\n          return this._findDayPageUpDown(cells, index, day, delta, -arrowsOffset.upDown);\n        }\n      }\n      case 'Home': {\n        return this._findDayFirst(cells, index, day, 1);\n      }\n      case 'End': {\n        const monthInBounds = +day.monthValue + 1 > 12 ? 1 : +day.monthValue + 1;\n        const yearInBounds = +day.monthValue + 1 > 12 ? +day.yearValue + 1 : +day.yearValue;\n        const firstNextMonth: T = this._dateAdapter.createDate(yearInBounds, monthInBounds, 1);\n        return this._findDayLast(cells, index, firstNextMonth);\n      }\n      default:\n        return cells[index];\n    }\n  }\n\n  private _isDayOutOfView(date: string): boolean {\n    return (\n      date < this._keyboardNavigationDayViewParameters.firstDayInView! ||\n      date > this._keyboardNavigationDayViewParameters.lastDayInView!\n    );\n  }\n\n  private _findDayArrows(\n    cells: HTMLButtonElement[],\n    index: number,\n    date: T,\n    delta: number,\n  ): HTMLButtonElement {\n    const newDateValue = this._dateAdapter.toIso8601(\n      this._dateAdapter.addCalendarDays(date, delta),\n    );\n    if (this._isDayOutOfView(newDateValue)) {\n      return cells[index];\n    }\n    const nextCell = cells.find((e) => e.value === newDateValue);\n    if (!nextCell || nextCell.disabled) {\n      return this._findDayArrows(cells, index, this._dateAdapter.deserialize(newDateValue)!, delta);\n    }\n    return nextCell;\n  }\n\n  private _findDayPageUpDown(\n    cells: HTMLButtonElement[],\n    index: number,\n    day: Day<T>,\n    delta: number,\n    deltaIfDisabled: number,\n  ): HTMLButtonElement {\n    const newDateValue = this._dateAdapter.toIso8601(\n      this._dateAdapter.addCalendarDays(day.dateValue!, delta),\n    );\n    if (this._isDayOutOfView(newDateValue)) {\n      return cells[index];\n    }\n    const nextCell = cells.find((e) => e.value === newDateValue);\n    if (!nextCell || nextCell.disabled) {\n      return this._findDayPageUpDown(cells, index, day, delta + deltaIfDisabled, deltaIfDisabled);\n    }\n    return nextCell;\n  }\n\n  private _findDayFirst(\n    cells: HTMLButtonElement[],\n    index: number,\n    day: Day<T>,\n    date: number,\n  ): HTMLButtonElement {\n    const newDateValue = this._dateAdapter.toIso8601(\n      this._dateAdapter.createDate(+day.yearValue, +day.monthValue, date),\n    );\n    if (this._isDayOutOfView(newDateValue)) {\n      return cells[index];\n    }\n    const nextCell = cells.find((e) => e.value === newDateValue);\n    if (!nextCell || nextCell.disabled) {\n      return this._findDayFirst(cells, index, day, date + 1);\n    }\n    return nextCell;\n  }\n\n  private _findDayLast(\n    cells: HTMLButtonElement[],\n    index: number,\n    firstNextMonth: T,\n  ): HTMLButtonElement {\n    const newDateValue = this._dateAdapter.toIso8601(\n      this._dateAdapter.addCalendarDays(firstNextMonth, -1),\n    );\n    if (this._isDayOutOfView(newDateValue)) {\n      return cells[index];\n    }\n    const nextCell = cells.find((e) => e.value === newDateValue);\n    if (!nextCell || nextCell.disabled) {\n      return this._findDayLast(cells, index, this._dateAdapter.deserialize(newDateValue)!);\n    }\n    return nextCell;\n  }\n\n  /**\n   * Gets the index of the element to move to, based on a list of elements (which can be potentially disabled),\n   * the keyboard input and the position of the current element in the list.\n   * In the day view, the `day?: Day` parameter is mandatory for calculation,\n   * while in month and year view it's not due to the fixed amount of rendered cells.\n   */\n  private _navigateByKeyboard(\n    evt: KeyboardEvent,\n    index: number,\n    cells: HTMLButtonElement[],\n  ): HTMLButtonElement {\n    const {\n      elementIndexForWideMode,\n      offsetForWideMode,\n      lastElementIndexForWideMode,\n      verticalOffset,\n    }: CalendarKeyboardNavigationMonthYearViewsParameters =\n      this._calculateParametersForKeyboardNavigation(index, this._calendarView === 'year');\n\n    switch (evt.key) {\n      case 'ArrowUp':\n        return this._findNext(cells, index, -verticalOffset);\n      case 'ArrowDown':\n        return this._findNext(cells, index, verticalOffset);\n      case 'ArrowLeft':\n        return this._findNext(cells, index, -1);\n      case 'ArrowRight':\n        return this._findNext(cells, index, 1);\n      case 'Home':\n        return this._findFirst(cells, offsetForWideMode);\n      case 'PageUp':\n        return this._findFirstOnColumn(\n          cells,\n          elementIndexForWideMode,\n          offsetForWideMode,\n          verticalOffset,\n        );\n      case 'PageDown':\n        return this._findLastOnColumn(cells, index, lastElementIndexForWideMode, verticalOffset);\n      case 'End':\n        return this._findLast(cells, lastElementIndexForWideMode - 1);\n      default:\n        return cells[index];\n    }\n  }\n\n  /**\n   * Calculates the parameters needed in keyboard navigation in year and month view.\n   * @param index The starting element's index in the cell array.\n   * @param isYearView Whether the displayed `view` is the year one.\n   */\n  private _calculateParametersForKeyboardNavigation(\n    index: number,\n    isYearView: boolean,\n  ): CalendarKeyboardNavigationMonthYearViewsParameters {\n    const elementsPerPage = isYearView ? YEARS_PER_PAGE : MONTHS_PER_PAGE;\n    const offset: number = Math.trunc(index / elementsPerPage) * elementsPerPage;\n    const indexInView: number = offset === 0 ? index : index - elementsPerPage;\n    return {\n      verticalOffset: isYearView ? YEARS_PER_ROW : MONTHS_PER_ROW,\n      elementIndexForWideMode: indexInView,\n      offsetForWideMode: index - indexInView,\n      lastElementIndexForWideMode: offset === 0 ? elementsPerPage : elementsPerPage * 2,\n    };\n  }\n\n  /**\n   * Gets the next element of the provided array starting from `index` by adding `delta`.\n   * If the found element is disabled, it continues adding `delta` until it finds an enabled one in the array bounds.\n   */\n  private _findNext(days: HTMLButtonElement[], index: number, delta: number): HTMLButtonElement {\n    let nextIndex = index + delta;\n    while (nextIndex < days.length && days[nextIndex]?.disabled) {\n      nextIndex += delta;\n    }\n    return days[nextIndex] ?? days[index];\n  }\n\n  /** Find the first enabled element in the provided array. */\n  private _findFirst(days: HTMLButtonElement[], firstOfCurrentMonth: number): HTMLButtonElement {\n    return !days[firstOfCurrentMonth].disabled\n      ? days[firstOfCurrentMonth]\n      : this._findNext(days, firstOfCurrentMonth, 1);\n  }\n\n  /** Find the last enabled element in the provided array. */\n  private _findLast(days: HTMLButtonElement[], lastOfCurrentMonth: number): HTMLButtonElement {\n    return !days[lastOfCurrentMonth].disabled\n      ? days[lastOfCurrentMonth]\n      : this._findNext(days, lastOfCurrentMonth, -1);\n  }\n\n  /** Find the first enabled element in the same column of the provided array. */\n  private _findFirstOnColumn(\n    days: HTMLButtonElement[],\n    index: number,\n    offset: number,\n    verticalOffset: number,\n  ): HTMLButtonElement {\n    const nextIndex = (index % verticalOffset) + offset;\n    return !days[nextIndex].disabled\n      ? days[nextIndex]\n      : this._findNext(days, nextIndex, verticalOffset);\n  }\n\n  /** Find the last enabled element in the same column of the provided array. */\n  private _findLastOnColumn(\n    days: HTMLButtonElement[],\n    index: number,\n    offset: number,\n    verticalOffset: number,\n  ): HTMLButtonElement {\n    const nextIndex = index + Math.trunc((offset - index - 1) / verticalOffset) * verticalOffset;\n    return !days[nextIndex].disabled\n      ? days[nextIndex]\n      : this._findNext(days, nextIndex, -verticalOffset);\n  }\n\n  private _resetCalendarView(initTransition = false): void {\n    this._resetFocus = true;\n    this._activeDate = this.selected ?? this.now;\n    this._setChosenYear();\n    this._chosenMonth = undefined;\n    this._nextCalendarView = this._calendarView = this.view;\n\n    if (initTransition) {\n      this._startTableTransition();\n    }\n  }\n\n  /** Render the view for the day selection. */\n  private _renderDayView(): TemplateResult {\n    const nextMonthActiveDate = this._wide\n      ? this._dateAdapter.addCalendarMonths(this._activeDate, 1)\n      : undefined;\n    return html`\n      <div class=\"sbb-calendar__controls\">\n        ${this._getArrow(\n          'left',\n          () => this._goToDifferentMonth(-1),\n          i18nPreviousMonth[this._language.current],\n          this._previousMonthDisabled(),\n        )}\n        <div class=\"sbb-calendar__controls-month\">\n          ${this._createLabelForDayView(this._activeDate)}\n          ${this._wide ? this._createLabelForDayView(nextMonthActiveDate!) : nothing}\n          <sbb-screen-reader-only role=\"status\">\n            ${this._createAriaLabelForDayView(this._activeDate, nextMonthActiveDate!)}\n          </sbb-screen-reader-only>\n        </div>\n        ${this._getArrow(\n          'right',\n          () => this._goToDifferentMonth(1),\n          i18nNextMonth[this._language.current],\n          this._nextMonthDisabled(),\n        )}\n      </div>\n      <div class=\"sbb-calendar__table-container sbb-calendar__table-day-view\">\n        ${this.orientation === 'horizontal'\n          ? html`\n              ${this._createDayTable(this._weeks)}\n              ${this._wide ? this._createDayTable(this._nextMonthWeeks) : nothing}\n            `\n          : html`\n              ${this._createDayTableVertical(this._weeks)}\n              ${this._wide\n                ? this._createDayTableVertical(this._nextMonthWeeks, nextMonthActiveDate)\n                : nothing}\n            `}\n      </div>\n    `;\n  }\n\n  /** Creates the label with the month for the daily view. */\n  private _createLabelForDayView(d: T): TemplateResult {\n    const monthLabel = `${\n      this._monthNames[this._dateAdapter.getMonth(d) - 1]\n    } ${this._dateAdapter.getYear(d)}`;\n    return html`\n      <button\n        type=\"button\"\n        class=\"sbb-calendar__date-selection sbb-calendar__controls-change-date\"\n        aria-label=\"${i18nYearMonthSelection[this._language.current]} ${monthLabel}\"\n        @click=${() => {\n          this._resetFocus = true;\n          this._nextCalendarView = 'year';\n          this._startTableTransition();\n        }}\n      >\n        ${monthLabel}\n        <sbb-icon name=\"chevron-small-down-small\"></sbb-icon>\n      </button>\n    `;\n  }\n\n  /** Creates the aria-label for the daily view. */\n  private _createAriaLabelForDayView(...dates: T[]): string {\n    let monthLabel = '';\n    for (const d of dates) {\n      if (d) {\n        monthLabel += `${\n          this._monthNames[this._dateAdapter.getMonth(d) - 1]\n        } ${this._dateAdapter.getYear(d)} `;\n      }\n    }\n    return monthLabel;\n  }\n\n  /** Creates the calendar table for the daily view. */\n  private _createDayTable(weeks: Day<T>[][]): TemplateResult {\n    const today: string = this._dateAdapter.toIso8601(this.now);\n    return html`\n      <table\n        class=\"sbb-calendar__table\"\n        @focusout=${(event: FocusEvent) =>\n          this._handleTableBlur(event.relatedTarget as HTMLElement)}\n        @animationend=${(e: AnimationEvent) => this._tableAnimationEnd(e)}\n      >\n        <thead class=\"sbb-calendar__table-header\">\n          <tr class=\"sbb-calendar__table-header-row\">\n            ${this._weekdays.map(\n              (day: Weekday) => html`\n                <th class=\"sbb-calendar__table-header\">\n                  <sbb-screen-reader-only>${day.long}</sbb-screen-reader-only>\n                  <span aria-hidden=\"true\">${day.narrow}</span>\n                </th>\n              `,\n            )}\n          </tr>\n        </thead>\n        <tbody class=\"sbb-calendar__table-body\">\n          ${weeks.map((week: Day<T>[], rowIndex: number) => {\n            const firstRowOffset: number = DAYS_PER_ROW - week.length;\n            if (rowIndex === 0 && firstRowOffset) {\n              return html`\n                <tr>\n                  ${[...Array(firstRowOffset).keys()].map(\n                    () => html`<td class=\"sbb-calendar__table-data\"></td>`,\n                  )}\n                  ${this._createDayCells(week, today)}\n                </tr>\n              `;\n            }\n            return html`<tr>\n              ${this._createDayCells(week, today)}\n            </tr>`;\n          })}\n        </tbody>\n      </table>\n    `;\n  }\n\n  /* Creates the table in orientation='vertical'. */\n  private _createDayTableVertical(weeks: Day<T>[][], nextMonthActiveDate?: T): TemplateResult {\n    const today: string = this._dateAdapter.toIso8601(this.now);\n    const weekOffset = this._dateAdapter.getFirstWeekOffset(\n      nextMonthActiveDate ?? this._activeDate,\n    );\n    return html`\n      <table\n        class=\"sbb-calendar__table\"\n        @focusout=${(event: FocusEvent) =>\n          this._handleTableBlur(event.relatedTarget as HTMLElement)}\n        @animationend=${(e: AnimationEvent) => this._tableAnimationEnd(e)}\n      >\n        <tbody class=\"sbb-calendar__table-body\">\n          ${weeks.map((week: Day<T>[], rowIndex: number) => {\n            const weekday = this._weekdays[rowIndex];\n            return html`\n              <tr>\n                ${!nextMonthActiveDate\n                  ? html` <td class=\"sbb-calendar__table-header\">\n                      <sbb-screen-reader-only>${weekday.long}</sbb-screen-reader-only>\n                      <span aria-hidden=\"true\">${weekday.narrow}</span>\n                    </td>`\n                  : nothing}\n                ${rowIndex < weekOffset\n                  ? html`<td class=\"sbb-calendar__table-data\"></td>`\n                  : nothing}\n                ${this._createDayCells(week, today)}\n              </tr>\n            `;\n          })}\n        </tbody>\n      </table>\n    `;\n  }\n\n  /** Creates the cells for the daily view. */\n  private _createDayCells(week: Day<T>[], today: string): TemplateResult[] {\n    return week.map((day: Day<T>) => {\n      const isOutOfRange = !this._isDayInRange(day.value);\n      const isFilteredOut = !this._dateFilter(this._dateAdapter.deserialize(day.value)!);\n      const selected: boolean = !!this._selected && day.value === this._selected;\n      const isToday = day.value === today;\n      return html`\n        <td\n          class=${classMap({\n            'sbb-calendar__table-data': true,\n            'sbb-calendar__table-data-selected': selected,\n          })}\n        >\n          <button\n            class=${classMap({\n              'sbb-calendar__cell': true,\n              'sbb-calendar__day': true,\n              'sbb-calendar__cell-current': isToday,\n              'sbb-calendar__selected': selected,\n              'sbb-calendar__crossed-out': !isOutOfRange && isFilteredOut,\n            })}\n            @click=${() => this._selectDate(day.value)}\n            ?disabled=${isOutOfRange || isFilteredOut}\n            value=${day.value}\n            type=\"button\"\n            aria-label=${this._dateAdapter.getAccessibilityFormatDate(day.value)}\n            aria-pressed=${selected}\n            aria-disabled=${isOutOfRange || isFilteredOut}\n            aria-current=${isToday ? 'date' : nothing}\n            tabindex=\"-1\"\n            @keydown=${(evt: KeyboardEvent) => this._handleKeyboardEvent(evt, day)}\n            sbb-popover-close\n          >\n            ${day.dayValue}\n          </button>\n        </td>\n      `;\n    });\n  }\n\n  /** Render the view for the month selection. */\n  private _renderMonthView(): TemplateResult {\n    return html`\n      <div class=\"sbb-calendar__controls\">\n        ${this._getArrow(\n          'left',\n          () => this._goToDifferentYear(-1),\n          i18nPreviousYear[this._language.current],\n          this._previousYearDisabled(),\n        )}\n        <div class=\"sbb-calendar__controls-month\">${this._createLabelForMonthView()}</div>\n        ${this._getArrow(\n          'right',\n          () => this._goToDifferentYear(1),\n          i18nNextYear[this._language.current],\n          this._nextYearDisabled(),\n        )}\n      </div>\n      <div class=\"sbb-calendar__table-container sbb-calendar__table-month-view\">\n        ${this._createMonthTable(this._months, this._chosenYear!)}\n        ${this._wide ? this._createMonthTable(this._months, this._chosenYear! + 1) : nothing}\n      </div>\n    `;\n  }\n\n  /** Creates the label with the year for the monthly view. */\n  private _createLabelForMonthView(): TemplateResult {\n    return html` <button\n        type=\"button\"\n        id=\"sbb-calendar__month-selection\"\n        class=\"sbb-calendar__controls-change-date\"\n        aria-label=${`${i18nCalendarDateSelection[this._language.current]} ${this._chosenYear}`}\n        @click=${() => this._resetCalendarView(true)}\n      >\n        ${this._chosenYear} ${this._wide ? ` - ${this._chosenYear! + 1}` : nothing}\n        <sbb-icon name=\"chevron-small-up-small\"></sbb-icon>\n      </button>\n      <sbb-screen-reader-only role=\"status\"> ${this._chosenYear} </sbb-screen-reader-only>`;\n  }\n\n  /** Creates the table for the month selection view. */\n  private _createMonthTable(months: Month[][], year: number): TemplateResult {\n    return html`\n      <table\n        class=\"sbb-calendar__table\"\n        @animationend=${(e: AnimationEvent) => this._tableAnimationEnd(e)}\n      >\n        ${this._wide\n          ? html`<thead class=\"sbb-calendar__table-header\" aria-hidden=\"true\">\n              <tr class=\"sbb-calendar__table-header-row\">\n                <th class=\"sbb-calendar__table-header\" colspan=${MONTHS_PER_ROW}>${year}</th>\n              </tr>\n            </thead>`\n          : nothing}\n        <tbody class=\"sbb-calendar__table-body\">\n          ${months.map(\n            (row: Month[]) => html`\n              <tr>\n                ${row.map((month: Month) => {\n                  const isOutOfRange = !this._isMonthInRange(month.monthValue, year);\n                  const isFilteredOut = !this._isMonthFilteredOut(month.monthValue, year);\n                  const selectedMonth = this._selected\n                    ? this._dateAdapter.getMonth(this._dateAdapter.deserialize(this._selected)!)\n                    : undefined;\n                  const selectedYear = this._selected\n                    ? this._dateAdapter.getYear(this._dateAdapter.deserialize(this._selected)!)\n                    : undefined;\n                  const selected: boolean =\n                    !!this._selected && year === selectedYear && month.monthValue === selectedMonth;\n\n                  const isCurrentMonth =\n                    year === this._dateAdapter.getYear(this.now) &&\n                    this._dateAdapter.getMonth(this.now) === month.monthValue;\n\n                  return html` <td\n                    class=${classMap({\n                      'sbb-calendar__table-data': true,\n                      'sbb-calendar__table-month': true,\n                    })}\n                  >\n                    <button\n                      class=${classMap({\n                        'sbb-calendar__cell': true,\n                        'sbb-calendar__pill': true,\n                        'sbb-calendar__cell-current': isCurrentMonth,\n                        'sbb-calendar__crossed-out': !isOutOfRange && isFilteredOut,\n                        'sbb-calendar__selected': selected,\n                      })}\n                      @click=${() => this._onMonthSelection(month.monthValue, year)}\n                      ?disabled=${isOutOfRange || isFilteredOut}\n                      aria-label=${`${month.longValue} ${year}`}\n                      aria-pressed=${selected}\n                      aria-disabled=${String(isOutOfRange || isFilteredOut)}\n                      tabindex=\"-1\"\n                      data-month=${month.monthValue || nothing}\n                      @keydown=${(evt: KeyboardEvent) => this._handleKeyboardEvent(evt)}\n                    >\n                      ${month.value}\n                    </button>\n                  </td>`;\n                })}\n              </tr>\n            `,\n          )}\n        </tbody>\n      </table>\n    `;\n  }\n\n  /** Select the month and change the view to day selection. */\n  private _onMonthSelection(month: number, year: number): void {\n    this._chosenMonth = month;\n    this._nextCalendarView = 'day';\n    this._init(\n      this._dateAdapter.createDate(\n        year,\n        this._chosenMonth,\n        this._dateAdapter.getDate(this._activeDate),\n      ),\n    );\n    this._startTableTransition();\n  }\n\n  /** Render the view for the year selection. */\n  private _renderYearView(): TemplateResult {\n    return html`\n      <div class=\"sbb-calendar__controls\">\n        ${this._getArrow(\n          'left',\n          () => this._goToDifferentYearRange(-YEARS_PER_PAGE),\n          i18nPreviousYearRange(YEARS_PER_PAGE)[this._language.current],\n          this._previousYearRangeDisabled(),\n        )}\n        <div class=\"sbb-calendar__controls-month\">${this._createLabelForYearView()}</div>\n        ${this._getArrow(\n          'right',\n          () => this._goToDifferentYearRange(YEARS_PER_PAGE),\n          i18nNextYearRange(YEARS_PER_PAGE)[this._language.current],\n          this._nextYearRangeDisabled(),\n        )}\n      </div>\n      <div class=\"sbb-calendar__table-container sbb-calendar__table-year-view\">\n        ${this._createYearTable(this._years)}\n        ${this._wide ? this._createYearTable(this._nextMonthYears, true) : nothing}\n      </div>\n    `;\n  }\n\n  /** Creates the button arrow for all the views. */\n  private _getArrow(\n    direction: 'left' | 'right',\n    click: () => void,\n    ariaLabel: string,\n    disabled: boolean,\n  ): TemplateResult {\n    return html`<sbb-secondary-button\n      size=\"m\"\n      icon-name=\"chevron-small-${direction}-small\"\n      aria-label=${ariaLabel}\n      @click=${click}\n      ?disabled=${disabled}\n      id=\"sbb-calendar__controls-${direction === 'left' ? 'previous' : 'next'}\"\n    ></sbb-secondary-button>`;\n  }\n\n  /** Creates the label with the year range for the yearly view. */\n  private _createLabelForYearView(): TemplateResult {\n    const firstYear: number = this._years.flat()[0];\n    const lastYearArray: number[] = (this._wide ? this._nextMonthYears : this._years).flat();\n    const lastYear: number = lastYearArray[lastYearArray.length - 1];\n    const yearLabel = `${firstYear} - ${lastYear}`;\n    return html`\n      <button\n        type=\"button\"\n        id=\"sbb-calendar__year-selection\"\n        class=\"sbb-calendar__controls-change-date\"\n        aria-label=\"${i18nCalendarDateSelection[this._language.current]} ${yearLabel}\"\n        @click=${() => this._resetCalendarView(true)}\n      >\n        ${yearLabel}\n        <sbb-icon name=\"chevron-small-up-small\"></sbb-icon>\n      </button>\n      <sbb-screen-reader-only role=\"status\"> ${yearLabel} </sbb-screen-reader-only>\n    `;\n  }\n\n  /** Creates the table for the year selection view. */\n  private _createYearTable(years: number[][], shiftRight = false): TemplateResult {\n    const now = this.now;\n    return html` <table\n      class=\"sbb-calendar__table\"\n      @animationend=${(e: AnimationEvent) => this._tableAnimationEnd(e)}\n    >\n      <tbody class=\"sbb-calendar__table-body\">\n        ${years.map(\n          (row: number[]) =>\n            html` <tr>\n              ${row.map((year: number) => {\n                const isOutOfRange = !this._isYearInRange(year);\n                const isFilteredOut = !this._isYearFilteredOut(year);\n                const selectedYear = this._selected\n                  ? this._dateAdapter.getYear(this._dateAdapter.deserialize(this._selected)!)\n                  : undefined;\n                const selected: boolean = !!this._selected && year === selectedYear;\n                const isCurrentYear = this._dateAdapter.getYear(now) === year;\n                return html` <td class=\"sbb-calendar__table-data sbb-calendar__table-year\">\n                  <button\n                    class=${classMap({\n                      'sbb-calendar__cell': true,\n                      'sbb-calendar__pill': true,\n                      'sbb-calendar__cell-current': isCurrentYear,\n                      'sbb-calendar__crossed-out': !isOutOfRange && isFilteredOut,\n                      'sbb-calendar__selected': selected,\n                    })}\n                    @click=${() => this._onYearSelection(year, shiftRight)}\n                    ?disabled=${isOutOfRange || isFilteredOut}\n                    aria-label=${year}\n                    aria-pressed=${selected}\n                    aria-disabled=${String(isOutOfRange || isFilteredOut)}\n                    tabindex=\"-1\"\n                    data-year=${year || nothing}\n                    @keydown=${(evt: KeyboardEvent) => this._handleKeyboardEvent(evt)}\n                  >\n                    ${year}\n                  </button>\n                </td>`;\n              })}\n            </tr>`,\n        )}\n      </tbody>\n    </table>`;\n  }\n\n  /** Select the year and change the view to month selection. */\n  private _onYearSelection(year: number, rightSide: boolean): void {\n    this._chosenYear = rightSide ? year - 1 : year;\n    this._nextCalendarView = 'month';\n    this._assignActiveDate(\n      this._dateAdapter.createDate(\n        this._chosenYear,\n        this._dateAdapter.getMonth(this._activeDate),\n        this._dateAdapter.getDate(this._activeDate),\n      ),\n    );\n    this._startTableTransition();\n  }\n\n  private _getView(): TemplateResult {\n    if (isServer || this.hydrationRequired) {\n      // TODO: We disable SSR for calendar for now. Figure our, if there is a way\n      // to enable it, while considering i18n and date information.\n      return html`${nothing}`;\n    }\n    switch (this._calendarView) {\n      case 'year':\n        return this._renderYearView();\n      case 'month':\n        return this._renderMonthView();\n      case 'day':\n      default:\n        return this._renderDayView();\n    }\n  }\n\n  private _tableAnimationEnd(event: AnimationEvent): void {\n    const table = event.target as HTMLElement;\n    if (event.animationName === 'hide') {\n      table.classList.remove('sbb-calendar__table-hide');\n      this._resetFocus = true;\n      this._calendarView = this._nextCalendarView;\n    } else if (event.animationName === 'show') {\n      this.removeAttribute('data-transition');\n    }\n  }\n\n  private _startTableTransition(): void {\n    this.toggleAttribute('data-transition', true);\n    this.shadowRoot\n      ?.querySelectorAll('table')\n      ?.forEach((e) => e.classList.toggle('sbb-calendar__table-hide'));\n  }\n\n  protected override render(): TemplateResult {\n    return html`<div class=\"sbb-calendar__wrapper\">${this._getView()}</div>`;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-calendar': SbbCalendarElement;\n  }\n}\n"],"names":["SbbCalendarElement","_a"],"mappings":"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"}