@sbb-esta/lyne-elements-experimental-dev 0.0.0 → 4.5.1-dev.1771849274

package/development/seat-reservation/seat-reservation/seat-reservation-base-element.js

@@ -0,0 +1,1171 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+import { __runInitializers, __esDecorate } from "tslib";
+import { isArrowKeyOrPageKeysPressed } from "@sbb-esta/lyne-elements/core/a11y.js";
+import { forceType } from "@sbb-esta/lyne-elements/core/decorators.js";
+import { LitElement, isServer } from "lit";
+import { property, state, eventOptions } from "lit/decorators.js";
+import { mapIconToSvg, mapPlaceInfosToPlaceSelection, mapPlaceAndCoachToSeatReservationPlaceSelection, mapCoachInfosToCoachSelection } from "../common/mapper.js";
+var ScrollDirection;
+(function(ScrollDirection2) {
+  ScrollDirection2["right"] = "right";
+  ScrollDirection2["left"] = "left";
+})(ScrollDirection || (ScrollDirection = {}));
+const MAX_SERVICE_PROPERTIES = 3;
+const ALLOWED_SERVICE_ICONS = [
+  "sa-vo",
+  "sa-rs",
+  "sa-abteilkinderwagen",
+  "sa-wr",
+  "sa-fa",
+  "sa-bz",
+  "sa-rz"
+];
+let SeatReservationBaseElement = (() => {
+  var _seatReservations_accessor_storage, _hasNavigation_accessor_storage, _alignVertical_accessor_storage, _baseGridSize_accessor_storage, _height_accessor_storage, _maxSeatReservations_accessor_storage, _maxBicycleReservations_accessor_storage, _preventPlaceClick_accessor_storage, _preselectCoachIndex_accessor_storage, _selectedCoachIndex_accessor_storage, _focusedCoachIndex_accessor_storage, _hoveredCoachIndex_accessor_storage, _a;
+  let _classSuper = LitElement;
+  let _instanceExtraInitializers = [];
+  let _seatReservations_decorators;
+  let _seatReservations_initializers = [];
+  let _seatReservations_extraInitializers = [];
+  let _hasNavigation_decorators;
+  let _hasNavigation_initializers = [];
+  let _hasNavigation_extraInitializers = [];
+  let _alignVertical_decorators;
+  let _alignVertical_initializers = [];
+  let _alignVertical_extraInitializers = [];
+  let _baseGridSize_decorators;
+  let _baseGridSize_initializers = [];
+  let _baseGridSize_extraInitializers = [];
+  let _height_decorators;
+  let _height_initializers = [];
+  let _height_extraInitializers = [];
+  let _maxSeatReservations_decorators;
+  let _maxSeatReservations_initializers = [];
+  let _maxSeatReservations_extraInitializers = [];
+  let _maxBicycleReservations_decorators;
+  let _maxBicycleReservations_initializers = [];
+  let _maxBicycleReservations_extraInitializers = [];
+  let _preventPlaceClick_decorators;
+  let _preventPlaceClick_initializers = [];
+  let _preventPlaceClick_extraInitializers = [];
+  let _preselectCoachIndex_decorators;
+  let _preselectCoachIndex_initializers = [];
+  let _preselectCoachIndex_extraInitializers = [];
+  let _selectedCoachIndex_decorators;
+  let _selectedCoachIndex_initializers = [];
+  let _selectedCoachIndex_extraInitializers = [];
+  let _focusedCoachIndex_decorators;
+  let _focusedCoachIndex_initializers = [];
+  let _focusedCoachIndex_extraInitializers = [];
+  let _hoveredCoachIndex_decorators;
+  let _hoveredCoachIndex_initializers = [];
+  let _hoveredCoachIndex_extraInitializers = [];
+  let _coachAreaScrollend_decorators;
+  return _a = class extends _classSuper {
+    constructor() {
+      super(...arguments);
+      __privateAdd(this, _seatReservations_accessor_storage);
+      __privateAdd(this, _hasNavigation_accessor_storage);
+      __privateAdd(this, _alignVertical_accessor_storage);
+      __privateAdd(this, _baseGridSize_accessor_storage);
+      __privateAdd(this, _height_accessor_storage);
+      __privateAdd(this, _maxSeatReservations_accessor_storage);
+      __privateAdd(this, _maxBicycleReservations_accessor_storage);
+      __privateAdd(this, _preventPlaceClick_accessor_storage);
+      __privateAdd(this, _preselectCoachIndex_accessor_storage);
+      __privateAdd(this, _selectedCoachIndex_accessor_storage);
+      __privateAdd(this, _focusedCoachIndex_accessor_storage);
+      __privateAdd(this, _hoveredCoachIndex_accessor_storage);
+      __privateSet(this, _seatReservations_accessor_storage, (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _seatReservations_initializers, null)));
+      __privateSet(this, _hasNavigation_accessor_storage, (__runInitializers(this, _seatReservations_extraInitializers), __runInitializers(this, _hasNavigation_initializers, true)));
+      __privateSet(this, _alignVertical_accessor_storage, (__runInitializers(this, _hasNavigation_extraInitializers), __runInitializers(this, _alignVertical_initializers, false)));
+      __privateSet(this, _baseGridSize_accessor_storage, (__runInitializers(this, _alignVertical_extraInitializers), __runInitializers(this, _baseGridSize_initializers, 16)));
+      __privateSet(this, _height_accessor_storage, (__runInitializers(this, _baseGridSize_extraInitializers), __runInitializers(this, _height_initializers, null)));
+      __privateSet(this, _maxSeatReservations_accessor_storage, (__runInitializers(this, _height_extraInitializers), __runInitializers(this, _maxSeatReservations_initializers, -1)));
+      __privateSet(this, _maxBicycleReservations_accessor_storage, (__runInitializers(this, _maxSeatReservations_extraInitializers), __runInitializers(this, _maxBicycleReservations_initializers, -1)));
+      __privateSet(this, _preventPlaceClick_accessor_storage, (__runInitializers(this, _maxBicycleReservations_extraInitializers), __runInitializers(this, _preventPlaceClick_initializers, false)));
+      __privateSet(this, _preselectCoachIndex_accessor_storage, (__runInitializers(this, _preventPlaceClick_extraInitializers), __runInitializers(this, _preselectCoachIndex_initializers, -1)));
+      __privateSet(this, _selectedCoachIndex_accessor_storage, (__runInitializers(this, _preselectCoachIndex_extraInitializers), __runInitializers(this, _selectedCoachIndex_initializers, -1)));
+      __privateSet(this, _focusedCoachIndex_accessor_storage, (__runInitializers(this, _selectedCoachIndex_extraInitializers), __runInitializers(this, _focusedCoachIndex_initializers, -1)));
+      __privateSet(this, _hoveredCoachIndex_accessor_storage, (__runInitializers(this, _focusedCoachIndex_extraInitializers), __runInitializers(this, _hoveredCoachIndex_initializers, -1)));
+      this.coachBorderPadding = (__runInitializers(this, _hoveredCoachIndex_extraInitializers), 6);
+      this.gapBetweenCoaches = 4;
+      this.coachBorderOffset = this.coachBorderPadding / this.baseGridSize;
+      this.gapBetweenCoachDecks = 48;
+      this.coachNavButtonDim = 0;
+      this.coachNavData = [];
+      this.currScrollDirection = ScrollDirection.right;
+      this.maxCalcCoachesWidth = 0;
+      this.scrollCoachesAreaWidth = 0;
+      this.scrollNavigationAreaDim = 0;
+      this.triggerCoachPositionsCollection = [];
+      this.navigationScrollArea = null;
+      this.coachScrollArea = null;
+      this.currSelectedPlace = null;
+      this.currSelectedPlaceElementId = null;
+      this.currSelectedCoachIndex = -1;
+      this.currSelectedDeckIndex = 0;
+      this.preventCoachScrollByPlaceClick = false;
+      this.selectedSeatReservationPlaces = {
+        seats: [],
+        bicycles: []
+      };
+      this.seatReservationWithoutNavigationHasFocus = false;
+      this.isCoachGridFocusable = false;
+      this.isAutoScrolling = false;
+      this.isKeyboardNavigation = false;
+      this.hasMultipleDecks = false;
+      this.hasSeatReservationNativeFocus = false;
+      this.keyboardNavigationEvents = {
+        ArrowLeft: "ArrowLeft",
+        ArrowRight: "ArrowRight",
+        ArrowUp: "ArrowUp",
+        ArrowDown: "ArrowDown",
+        Tab: "Tab",
+        Enter: "Enter"
+      };
+      this.notAreaElements = [
+        "DRIVER_AREA",
+        "COACH_PASSAGE",
+        "COACH_WALL_NO_PASSAGE",
+        "COMPARTMENT_PASSAGE",
+        "COMPARTMENT_PASSAGE_HIGH",
+        "COMPARTMENT_PASSAGE_MIDDLE",
+        "COMPARTMENT_PASSAGE_LOW"
+      ];
+      this.overHangingElementInformation = [];
+      this._isRunningInitPreselectCoachIndex = false;
+      this._lastStartScrollPos = -1;
+      this._prepareServiceIconsNavigation = (propertyIds) => {
+        if (!propertyIds) {
+          return [];
+        }
+        const shrunkPropertyIds = propertyIds?.map(function(propertyId) {
+          return {
+            pId: propertyId,
+            svgName: mapIconToSvg[propertyId]?.svgName ? mapIconToSvg[propertyId]?.svgName : ""
+          };
+        }).filter((propertyToSvg) => ALLOWED_SERVICE_ICONS.indexOf(propertyToSvg.svgName) !== -1).filter((value, index, self) => self.map((propSvg) => propSvg.svgName).indexOf(value.svgName) === index).map((propertyToSvg) => propertyToSvg.pId).slice(0, MAX_SERVICE_PROPERTIES);
+        return shrunkPropertyIds ? shrunkPropertyIds : [];
+      };
+    }
+    /** The seat reservations array contains all coaches and places */
+    get seatReservations() {
+      return __privateGet(this, _seatReservations_accessor_storage);
+    }
+    set seatReservations(value) {
+      __privateSet(this, _seatReservations_accessor_storage, value);
+    }
+    /** The seat reservation navigation can be toggled by this property */
+    get hasNavigation() {
+      return __privateGet(this, _hasNavigation_accessor_storage);
+    }
+    set hasNavigation(value) {
+      __privateSet(this, _hasNavigation_accessor_storage, value);
+    }
+    /** The seat reservation area is aligned vertically */
+    get alignVertical() {
+      return __privateGet(this, _alignVertical_accessor_storage);
+    }
+    set alignVertical(value) {
+      __privateSet(this, _alignVertical_accessor_storage, value);
+    }
+    /** The seat reservation area's base grid size */
+    get baseGridSize() {
+      return __privateGet(this, _baseGridSize_accessor_storage);
+    }
+    set baseGridSize(value) {
+      __privateSet(this, _baseGridSize_accessor_storage, value);
+    }
+    /** The seat reservation area's width */
+    get height() {
+      return __privateGet(this, _height_accessor_storage);
+    }
+    set height(value) {
+      __privateSet(this, _height_accessor_storage, value);
+    }
+    /** Maximal number of possible clickable seats */
+    get maxSeatReservations() {
+      return __privateGet(this, _maxSeatReservations_accessor_storage);
+    }
+    set maxSeatReservations(value) {
+      __privateSet(this, _maxSeatReservations_accessor_storage, value);
+    }
+    /** Maximal number of possible clickable bicycle places */
+    get maxBicycleReservations() {
+      return __privateGet(this, _maxBicycleReservations_accessor_storage);
+    }
+    set maxBicycleReservations(value) {
+      __privateSet(this, _maxBicycleReservations_accessor_storage, value);
+    }
+    /** Any click functionality is prevented */
+    get preventPlaceClick() {
+      return __privateGet(this, _preventPlaceClick_accessor_storage);
+    }
+    set preventPlaceClick(value) {
+      __privateSet(this, _preventPlaceClick_accessor_storage, value);
+    }
+    get preselectCoachIndex() {
+      return __privateGet(this, _preselectCoachIndex_accessor_storage);
+    }
+    set preselectCoachIndex(value) {
+      __privateSet(this, _preselectCoachIndex_accessor_storage, value);
+    }
+    get selectedCoachIndex() {
+      return __privateGet(this, _selectedCoachIndex_accessor_storage);
+    }
+    set selectedCoachIndex(value) {
+      __privateSet(this, _selectedCoachIndex_accessor_storage, value);
+    }
+    get focusedCoachIndex() {
+      return __privateGet(this, _focusedCoachIndex_accessor_storage);
+    }
+    set focusedCoachIndex(value) {
+      __privateSet(this, _focusedCoachIndex_accessor_storage, value);
+    }
+    get hoveredCoachIndex() {
+      return __privateGet(this, _hoveredCoachIndex_accessor_storage);
+    }
+    set hoveredCoachIndex(value) {
+      __privateSet(this, _hoveredCoachIndex_accessor_storage, value);
+    }
+    willUpdate(changedProperties) {
+      super.willUpdate(changedProperties);
+      if (changedProperties.has("seatReservations")) {
+        this.hasMultipleDecks = this.seatReservations?.length > 1;
+        this._initPrepareSeatReservationData();
+        this._prepareCoachWidthAndGapCalculations();
+        this._initSeatReservationPlaceSelection();
+        this.initNavigationSelectionByScrollEvent();
+      }
+      if (changedProperties.has("baseGridSize")) {
+        this.coachBorderOffset = this.coachBorderPadding / this.baseGridSize;
+        this.style?.setProperty("--sbb-seat-reservation-grid-size", `${this.baseGridSize}px`);
+        this.initNavigationSelectionByScrollEvent();
+      }
+      if (changedProperties.has("height") && !!this.height) {
+        const seatReservationLayer = this.seatReservations[this.currSelectedDeckIndex] || null;
+        if (seatReservationLayer?.coachItems.length) {
+          this.baseGridSize = this.height / seatReservationLayer.coachItems[0].dimension.h;
+          this.coachBorderOffset = this.coachBorderPadding / this.baseGridSize;
+          this.style?.setProperty("--sbb-seat-reservation-grid-size", `${this.baseGridSize}px`);
+          this.initNavigationSelectionByScrollEvent();
+        }
+      }
+      if (changedProperties.has("alignVertical") && this.alignVertical) {
+        this.initNavigationSelectionByScrollEvent();
+      }
+      if (changedProperties.has("preselectCoachIndex")) {
+        this._isRunningInitPreselectCoachIndex = true;
+        setTimeout(() => this.scrollToSelectedNavCoach(this.preselectCoachIndex), 1);
+      }
+    }
+    navigateByDirectionBtn(btnDirection) {
+      this.unfocusPlaceElement();
+      let navigateToCoachIndex = this.currSelectedCoachIndex;
+      if (btnDirection == "DIRECTION_LEFT" && navigateToCoachIndex > 0) {
+        navigateToCoachIndex = this.currSelectedCoachIndex != -1 ? this.currSelectedCoachIndex - 1 : 0;
+      } else if (btnDirection == "DIRECTION_RIGHT" && navigateToCoachIndex < this.seatReservations[this.currSelectedDeckIndex]?.coachItems.length - 1) {
+        navigateToCoachIndex = this.currSelectedCoachIndex != -1 ? this.currSelectedCoachIndex + 1 : 0;
+      }
+      this.scrollToSelectedNavCoach(navigateToCoachIndex);
+    }
+    /**
+     * Data can be prepared once for the entire component
+     * in order to avoid recurring iteration processes in rendering.
+     */
+    _initPrepareSeatReservationData() {
+      this._determineBaseFontSize();
+      if (this.hasMultipleDecks) {
+        this._initEmptyCoachDeckOffsets();
+      }
+      this._prepareNavigationCoachData();
+    }
+    /** Init scroll event handling for coach navigation */
+    initNavigationSelectionByScrollEvent() {
+      this.coachScrollArea = this.shadowRoot?.querySelector("#sbb-sr__wrapper-scrollarea");
+      this.navigationScrollArea = this.shadowRoot?.querySelector("#sbb-sr__navigation-list-coaches");
+      const seatReservationDeck = this.seatReservations ? this.seatReservations[this.currSelectedDeckIndex] : null;
+      if (seatReservationDeck && seatReservationDeck.coachItems.length > 0) {
+        const coachHeightWithBorderPadding = seatReservationDeck.coachItems[0].dimension.h * this.baseGridSize + this.coachBorderPadding;
+        const gapBetweenCoachDecks = (this.seatReservations.length - 1) * this.gapBetweenCoachDecks;
+        this.style?.setProperty("--sbb-seat-reservation-height", `${coachHeightWithBorderPadding * this.seatReservations.length + gapBetweenCoachDecks}`);
+        this.style?.setProperty("--sbb-seat-reservation-decks", `${this.seatReservations.length}`);
+      }
+      if (this.navigationScrollArea) {
+        this.scrollNavigationAreaDim = this.alignVertical ? this.navigationScrollArea.getBoundingClientRect().height : this.navigationScrollArea.getBoundingClientRect().width;
+        const navCoachesList = this.navigationScrollArea.querySelector("ul > li");
+        if (navCoachesList) {
+          const firstLiEleDimension = navCoachesList?.getBoundingClientRect();
+          this.coachNavButtonDim = this.alignVertical ? firstLiEleDimension.height : firstLiEleDimension.width;
+        }
+      }
+      if (this.coachScrollArea && seatReservationDeck) {
+        let currCalcTriggerPos = 0;
+        this.scrollCoachesAreaWidth = this.alignVertical ? this.coachScrollArea.getBoundingClientRect().height : this.coachScrollArea.getBoundingClientRect().width;
+        this.triggerCoachPositionsCollection = seatReservationDeck.coachItems.map((coach) => {
+          const startPosX = currCalcTriggerPos;
+          const coachWidth = this.getCalculatedDimension(coach.dimension).w;
+          const currentCoachOverhangingInfo = this.overHangingElementInformation.find((e) => e.coachId === coach.id);
+          const overhangingElementsPresent = currentCoachOverhangingInfo?.overhangingPlaces || currentCoachOverhangingInfo?.overhangingGraphicAreas;
+          currCalcTriggerPos += coachWidth + (!overhangingElementsPresent ? this.gapBetweenCoaches : 2 * this.gapBetweenCoaches);
+          return {
+            start: startPosX,
+            end: currCalcTriggerPos,
+            width: coachWidth
+          };
+        });
+        this.maxCalcCoachesWidth = currCalcTriggerPos;
+      }
+    }
+    /**
+     * Scroll event handler managed the end of scrolling inside the coach scroll area.
+     * Timeout event handling to check if the scrolling has been completed.
+     * It is required because the Safari browser does not handle scrollend event,
+     * and we therefore imitate this event -> scrollend.
+     */
+    coachAreaScrollend() {
+      if (this._scrollTimeout) {
+        clearTimeout(this._scrollTimeout);
+      }
+      this._scrollTimeout = setTimeout(() => this._handleCoachAreaScrollendEvent(), 150);
+    }
+    /**
+     * If no navigation exists (property setting -> hasNavigation) and a table coach gets the focus,
+     * the first place in the coach must be automatically preselected to control the place navigation via keyboard
+     *
+     * @param focusCoachIndex
+     */
+    onFocusTableCoachAndPreselectPlace(focusCoachIndex) {
+      if (!this.seatReservationWithoutNavigationHasFocus && !this.hasNavigation) {
+        this.seatReservationWithoutNavigationHasFocus = true;
+        this.currSelectedCoachIndex = focusCoachIndex === 0 ? this.getNextAvailableCoachIndex(-1) : this.getPrevAvailableCoachIndex(focusCoachIndex);
+        this.preselectPlaceInCoach();
+      }
+    }
+    /** Will be triggered by focus navigation direction */
+    onFocusNavDirectionButton() {
+      this.focusedCoachIndex = -1;
+    }
+    /** TAB Key Event handling for Coach Navigation */
+    onKeyNavigationNavCoachButton(event, currNavCoachButtonIndex) {
+      const pressedKey = event.key;
+      if (pressedKey === this.keyboardNavigationEvents.Tab) {
+        this._handleTabKeyNavigation(event, "navigation", currNavCoachButtonIndex);
+        return;
+      }
+      if (isArrowKeyOrPageKeysPressed(event)) {
+        this.keyboardSeatmapEventHandling(event);
+      }
+    }
+    /** General TAB Key Event handling for tab navigation inside the coach navigation area and the seatmap area */
+    _handleTabKeyNavigation(event, eventArea, currTabIndex) {
+      const pressedKey = event.key;
+      const pressedShiftTab = event.shiftKey;
+      if (pressedKey === this.keyboardNavigationEvents.Tab) {
+        if (eventArea == "navigation") {
+          if (currTabIndex == this.currSelectedCoachIndex) {
+            if (!this.currSelectedPlace || !pressedShiftTab || this.coachNavData[currTabIndex].isDriverArea || this.focusedCoachIndex == -1) {
+              this.focusedCoachIndex = currTabIndex;
+            } else if (pressedShiftTab && this.currSelectedPlace) {
+              this.focusedCoachIndex = -1;
+              this.focusPlaceElement(this.currSelectedPlace);
+            }
+          } else {
+            this.focusedCoachIndex = currTabIndex;
+          }
+          this._scrollToSelectedNavigationButton(currTabIndex);
+        } else if (eventArea == "seatmap") {
+          event.preventDefault();
+          if (pressedShiftTab) {
+            this._navigateCoachNavigationByKeyboard("PREV_TAB");
+          } else {
+            this._navigateCoachNavigationByKeyboard("NEXT_TAB");
+          }
+        }
+      }
+    }
+    /**
+     * Initialisation of Keyboard Seatmap event handling to navigation between each places inside a selected coach by using [arrow] keys.
+     * With the [TAB] key the user navigation goes to the next coach navigation element and the currently selected place is automatically reset.
+     */
+    keyboardSeatmapEventHandling(event) {
+      const pressedKey = event.key;
+      this.preventCoachScrollByPlaceClick = false;
+      if (!this.hasSeatReservationNativeFocus && (event.shiftKey && pressedKey === this.keyboardNavigationEvents.Tab || pressedKey === this.keyboardNavigationEvents.Tab)) {
+        this.hasSeatReservationNativeFocus = true;
+      }
+      if (pressedKey == this.keyboardNavigationEvents.Tab) {
+        this._handleTabKeyNavigation(event, "seatmap");
+        return;
+      }
+      if (this.currSelectedCoachIndex !== -1 && isArrowKeyOrPageKeysPressed(event)) {
+        event.preventDefault();
+        switch (pressedKey) {
+          case this.keyboardNavigationEvents.ArrowLeft:
+            {
+              const pressedLeftKeyMapping = this.alignVertical ? this.keyboardNavigationEvents.ArrowDown : pressedKey;
+              this._navigateToPlaceByKeyboard(pressedLeftKeyMapping);
+            }
+            break;
+          case this.keyboardNavigationEvents.ArrowRight:
+            {
+              const pressedRightKeyMapping = this.alignVertical ? this.keyboardNavigationEvents.ArrowUp : pressedKey;
+              this._navigateToPlaceByKeyboard(pressedRightKeyMapping);
+            }
+            break;
+          case this.keyboardNavigationEvents.ArrowUp:
+            {
+              const pressedUpKeyMapping = this.alignVertical ? this.keyboardNavigationEvents.ArrowLeft : pressedKey;
+              this._navigateToPlaceByKeyboard(pressedUpKeyMapping);
+            }
+            break;
+          case this.keyboardNavigationEvents.ArrowDown:
+            {
+              const pressedDownKeyMapping = this.alignVertical ? this.keyboardNavigationEvents.ArrowRight : pressedKey;
+              this._navigateToPlaceByKeyboard(pressedDownKeyMapping);
+            }
+            break;
+        }
+      }
+    }
+    /**
+     * Selects a place inside the coach if navigated via keyboard,
+     * otherwise the coach grid is selected (necessary for ScreenReader)
+     */
+    preselectPlaceInCoach() {
+      if (!this.isAutoScrolling)
+        return;
+      if (this._isRunningInitPreselectCoachIndex) {
+        this._isRunningInitPreselectCoachIndex = false;
+        return;
+      }
+      if (this.coachNavData[this.currSelectedCoachIndex] && this.coachNavData[this.currSelectedCoachIndex].isDriverArea) {
+        this._setFocusToSelectedCoachGrid();
+        return;
+      }
+      if (this.isKeyboardNavigation && this.isAutoScrolling) {
+        const closestPlace = this._getClosestPlaceByKeyDirection();
+        if (closestPlace) {
+          this.unfocusPlaceElement();
+          this.focusPlaceElement(closestPlace);
+          this.focusedCoachIndex = -1;
+        } else {
+          this._setFocusToSelectedCoachGrid();
+        }
+      } else {
+        this.unfocusPlaceElement();
+        this.isCoachGridFocusable = true;
+        this._setFocusToSelectedCoachGrid();
+      }
+    }
+    scrollToSelectedNavCoach(selectedNavCoachIndex) {
+      if (this._isValidCoachIndex(selectedNavCoachIndex) && selectedNavCoachIndex !== this.currSelectedCoachIndex) {
+        this.hoveredCoachIndex = selectedNavCoachIndex;
+        this.isAutoScrolling = true;
+        this.isCoachGridFocusable = true;
+        this.currSelectedCoachIndex = selectedNavCoachIndex;
+        this.currSelectedDeckIndex = this._getExistingCoachDeckIndex();
+        this._setScrollDirectionByCoachIndex();
+        const scrollToCoachPosX = this._getCoachScrollPositionX();
+        const isSelectedCoachIndexScrollable = this.selectedCoachIndex !== -1 || this.currSelectedCoachIndex > 0;
+        if (isSelectedCoachIndexScrollable && this._isScrollableToSelectedCoach()) {
+          this._lastStartScrollPos = this.coachScrollArea.scrollLeft;
+          this.coachScrollArea.scrollTo({
+            top: this.alignVertical ? scrollToCoachPosX : 0,
+            left: this.alignVertical ? 0 : scrollToCoachPosX,
+            behavior: "smooth"
+          });
+        } else {
+          this.updateCurrentSelectedCoach();
+        }
+        this._scrollToSelectedNavigationButton(selectedNavCoachIndex);
+      }
+    }
+    focusPlaceElement(place) {
+      this.unfocusPlaceElement();
+      if (place) {
+        this.currSelectedPlace = place;
+        this._setCurrSelectedPlaceElementId(place);
+        const selectedPlaceElement = this._getPlaceHtmlElement();
+        if (selectedPlaceElement) {
+          selectedPlaceElement.setAttribute("keyfocus", "focus");
+          const delayScrollInViewport = setTimeout(() => {
+            const placeId = this.getPlaceElementId(this.currSelectedDeckIndex, this.currSelectedCoachIndex, place.number);
+            this._scrollPlaceIntoNearestViewport(placeId);
+            clearTimeout(delayScrollInViewport);
+          }, 0);
+        }
+      }
+    }
+    unfocusPlaceElement() {
+      const selectedPlaceElement = this._getPlaceHtmlElement();
+      if (selectedPlaceElement) {
+        selectedPlaceElement.setAttribute("keyfocus", "unfocus");
+        this._setCurrSelectedPlaceElementId(null);
+        this.currSelectedPlace = null;
+      }
+    }
+    getCalculatedDimension(elementDimension, coachDimension, isOriginHeight, isStretchHeight) {
+      if (coachDimension && !isOriginHeight) {
+        elementDimension.h += this.coachBorderOffset * 2;
+      }
+      if (isStretchHeight) {
+        elementDimension.h += this.coachBorderOffset;
+      }
+      return {
+        w: this.baseGridSize * elementDimension.w,
+        h: this.baseGridSize * elementDimension.h
+      };
+    }
+    getCalculatedPosition(elementPosition, elementDimension, coachDimension, isOriginHeight) {
+      if (coachDimension && elementDimension) {
+        const endPosHeight = isOriginHeight ? coachDimension.h : coachDimension.h + this.coachBorderOffset;
+        if (elementPosition.y === 0) {
+          elementPosition.y -= this.coachBorderOffset;
+        } else if (elementPosition.y + elementDimension.h === endPosHeight) {
+          elementPosition.y += this.coachBorderOffset;
+        }
+      }
+      return {
+        x: this.baseGridSize * elementPosition.x,
+        y: this.baseGridSize * elementPosition.y,
+        z: elementPosition.z
+      };
+    }
+    /**
+     * detects if a (graphical) element is on the border with its position (upper or lower border).
+     * @param baseElement
+     * @param coachDimension
+     * @protected
+     */
+    isElementDirectlyOnBorder(baseElement, coachDimension) {
+      return baseElement.position.y === 0 || baseElement.position.y + baseElement.dimension.h === coachDimension.h;
+    }
+    /**
+     * Counts all available seats together depending on the seat type
+     *
+     * @param places
+     * @returns An Object with count of free seats and free bicycle places
+     */
+    getAvailableFreePlacesNumFromCoach(places) {
+      const accumulator = { seats: 0, bicycles: 0 };
+      const freePlaces = places?.reduce((accumulator2, currPlace) => {
+        if (currPlace.state !== "FREE") {
+          return accumulator2;
+        }
+        if (currPlace.type === "SEAT") {
+          accumulator2.seats++;
+        } else {
+          accumulator2.bicycles++;
+        }
+        return accumulator2;
+      }, accumulator);
+      return freePlaces ? freePlaces : accumulator;
+    }
+    /**
+     * At the end of a scroll Event from the coach scrollable area,
+     * the reached coach is marked as selected
+     */
+    _handleCoachAreaScrollendEvent() {
+      const findScrollCoachIndex = this.isAutoScrolling ? this.currSelectedCoachIndex : this._getCoachIndexByScrollTriggerPosition();
+      if (this.preventCoachScrollByPlaceClick) {
+        const isCoachScrolling = Math.abs(this._lastStartScrollPos - this.coachScrollArea.scrollLeft) > this.baseGridSize * 2;
+        if (isCoachScrolling) {
+          this.selectedCoachIndex = findScrollCoachIndex;
+        }
+        this.preventCoachScrollByPlaceClick = false;
+        return;
+      }
+      this._lastStartScrollPos = this.coachScrollArea.scrollLeft;
+      this.hoveredCoachIndex = -1;
+      if (this.currSelectedCoachIndex === -1) {
+        this.currSelectedCoachIndex = findScrollCoachIndex;
+      }
+      if (this._isScrollableToSelectedCoach()) {
+        this.currSelectedCoachIndex = findScrollCoachIndex;
+      } else {
+        this.currSelectedCoachIndex = findScrollCoachIndex < this.currSelectedCoachIndex ? this.currSelectedCoachIndex : findScrollCoachIndex;
+      }
+      if (!this.isAutoScrolling) {
+        this._scrollToSelectedNavigationButton(findScrollCoachIndex);
+      }
+      this.preventCoachScrollByPlaceClick = false;
+      this.updateCurrentSelectedCoach();
+      if (!this.hasNavigation) {
+        this.preselectPlaceInCoach();
+        this.isAutoScrolling = false;
+      }
+    }
+    /**
+     * Performs an automatic main navigation scroll to the specified selectedNavCoachIndex.
+     * Calculates the central scroll offset of the nav coach to be selected.
+     * @param selectedNavCoachIndex
+     */
+    _scrollToSelectedNavigationButton(selectedNavCoachIndex) {
+      setTimeout(() => {
+        if (this.hasNavigation && this.navigationScrollArea) {
+          const navigationAreaCenteredPosX = this.scrollNavigationAreaDim / 2;
+          const scrollButtonOffsetX = selectedNavCoachIndex * this.coachNavButtonDim;
+          const scrollOffsetX = scrollButtonOffsetX - navigationAreaCenteredPosX + this.coachNavButtonDim;
+          this.navigationScrollArea.scrollTo({
+            top: this.alignVertical ? scrollOffsetX : 0,
+            left: this.alignVertical ? 0 : scrollOffsetX,
+            behavior: "smooth"
+          });
+        }
+      }, 10);
+    }
+    /**
+     * Sets the new ScrollDirection by the new given target coach index.
+     */
+    _setScrollDirectionByCoachIndex() {
+      this.currScrollDirection = this.currSelectedCoachIndex > this.selectedCoachIndex ? ScrollDirection.right : ScrollDirection.left;
+    }
+    /**
+     * Returns the scroll start or end position X from the selected coach.
+     * In case the user is currently navigating through places by keyboard and goes to previous coach,
+     * then we return the end position of the coach to get the closest scroll position of the next focus place.
+     * @returns number
+     */
+    _getCoachScrollPositionX() {
+      const coachTriggerPoint = this.triggerCoachPositionsCollection[this.currSelectedCoachIndex];
+      const isFocusPlaceFromPreviousCoachPosition = this.isKeyboardNavigation && this.currScrollDirection === ScrollDirection.left && coachTriggerPoint.width > this.scrollCoachesAreaWidth;
+      return isFocusPlaceFromPreviousCoachPosition ? coachTriggerPoint.end - this.scrollCoachesAreaWidth : coachTriggerPoint.start;
+    }
+    /**
+     * Sets the focus on the HTML table (grid) caption element so that the heading is read out when using a ScreenReader.
+     */
+    _setFocusToSelectedCoachGrid() {
+      if (this.isCoachGridFocusable && this.hasSeatReservationNativeFocus) {
+        this.isCoachGridFocusable = false;
+        const coachTableCaptionElement = this.shadowRoot?.querySelector("#sbb-sr-coach-caption-" + this.currSelectedCoachIndex);
+        if (coachTableCaptionElement) {
+          coachTableCaptionElement.focus();
+        }
+      }
+    }
+    /**
+     * Returns whether the current scrolled position can be used to scroll to the selected wagon
+     * @returns boolean
+     */
+    _isScrollableToSelectedCoach() {
+      const currScrollPosX = this.alignVertical ? this.coachScrollArea.scrollTop : this.coachScrollArea.scrollLeft;
+      const coachScrollWindowWidth = this.alignVertical ? this.coachScrollArea.getBoundingClientRect().height : this.coachScrollArea.getBoundingClientRect().width;
+      const maxScrollWidthArea = this.maxCalcCoachesWidth - coachScrollWindowWidth;
+      const currCoachTrigger = this.triggerCoachPositionsCollection[this.currSelectedCoachIndex];
+      const isScrollPosSameToCurrCoachPos = currScrollPosX === this.triggerCoachPositionsCollection[this.currSelectedCoachIndex].start;
+      return (currScrollPosX < maxScrollWidthArea || currScrollPosX > currCoachTrigger.start) && !isScrollPosSameToCurrCoachPos;
+    }
+    /**
+     * Returns the coach index which is currently visible in the scroll area
+     * @returns number
+     */
+    _getCoachIndexByScrollTriggerPosition() {
+      const scrollPos = this.alignVertical ? this.coachScrollArea.scrollTop : this.coachScrollArea.scrollLeft;
+      const scrollOffsetX = scrollPos + this.scrollCoachesAreaWidth / 2;
+      return this.triggerCoachPositionsCollection.findIndex((coachTrigger) => scrollOffsetX >= coachTrigger.start && scrollOffsetX <= coachTrigger.end);
+    }
+    /**
+     * Get the first place of current selected coach by table cell coordinate 0-0 id.
+     * @returns Place or null
+     */
+    _getFirstPlaceInSelectedCoach() {
+      let firstPlace = null;
+      const coach = this.seatReservations[this.currSelectedDeckIndex].coachItems[this.currSelectedCoachIndex];
+      const firstCellId = "cell-" + this.currSelectedDeckIndex + "-" + this.currSelectedCoachIndex + "-0-0";
+      const placeNumber = this.shadowRoot?.querySelector("#" + firstCellId)?.querySelector("sbb-seat-reservation-place-control")?.getAttribute("text") || null;
+      if (coach && placeNumber) {
+        firstPlace = coach.places?.find((place) => place.number === placeNumber) || null;
+      }
+      return firstPlace;
+    }
+    _getSwitchedCoachDeckIndexByKeyNavigation(pressedKey, coach) {
+      if (!this.currSelectedPlace || pressedKey === this.keyboardNavigationEvents.ArrowRight || pressedKey === this.keyboardNavigationEvents.ArrowLeft)
+        return null;
+      if (pressedKey === this.keyboardNavigationEvents.ArrowDown && this.currSelectedPlace.position.y + 2 === coach.dimension.h && !!this.seatReservations[this.currSelectedDeckIndex + 1]) {
+        return this.currSelectedDeckIndex + 1;
+      } else if (pressedKey === this.keyboardNavigationEvents.ArrowUp && this.currSelectedPlace.position.y === 0 && !!this.seatReservations[this.currSelectedDeckIndex - 1]) {
+        return this.currSelectedDeckIndex - 1;
+      }
+      return null;
+    }
+    /**
+     * To get the correct closest place of current pressed key and the current selected place,
+     * we have to investigate the coordinates of each place to find the closest place of the currSelectedPlaceElementId.
+     * @param pressedKey
+     * @returns Place or null
+     */
+    _getClosestPlaceByKeyDirection(pressedKey) {
+      const coach = this.seatReservations[this.currSelectedDeckIndex].coachItems[this.currSelectedCoachIndex];
+      let closestPlace = null;
+      let coachPlaces = coach.places;
+      let switchedCoachDeckIndex = null;
+      if (coachPlaces) {
+        if (!this.currSelectedPlaceElementId) {
+          return this._getFirstPlaceInSelectedCoach();
+        } else {
+          if (this.currSelectedPlace) {
+            const currSelectedPlacePosition = { ...this.currSelectedPlace.position };
+            if (pressedKey) {
+              switchedCoachDeckIndex = this._getSwitchedCoachDeckIndexByKeyNavigation(pressedKey, coach);
+              if (switchedCoachDeckIndex !== null) {
+                coachPlaces = this.seatReservations[switchedCoachDeckIndex].coachItems[this.currSelectedCoachIndex].places || [];
+                currSelectedPlacePosition.y = switchedCoachDeckIndex < this.currSelectedDeckIndex ? coach.dimension.h : -1;
+              }
+            }
+            for (const place of coachPlaces) {
+              if (!pressedKey) {
+                if (this.currScrollDirection === ScrollDirection.right && place.position.y === currSelectedPlacePosition.y && (!closestPlace || place.position.x < closestPlace.position.x)) {
+                  closestPlace = place;
+                } else if (this.currScrollDirection === ScrollDirection.left && place.position.y === currSelectedPlacePosition.y && (!closestPlace || place.position.x > closestPlace.position.x)) {
+                  closestPlace = place;
+                }
+              } else {
+                if (place.number !== this.currSelectedPlace?.number) {
+                  if (pressedKey === this.keyboardNavigationEvents.ArrowRight && (place.position.y === currSelectedPlacePosition.y || place.position.y === currSelectedPlacePosition.y - 1) && place.position.x > currSelectedPlacePosition.x && (!closestPlace || place.position.x < closestPlace.position.x)) {
+                    closestPlace = place;
+                  } else if (pressedKey === this.keyboardNavigationEvents.ArrowDown && (place.position.x === currSelectedPlacePosition.x || place.position.x === currSelectedPlacePosition.x + 1) && place.position.y > currSelectedPlacePosition.y && (!closestPlace || place.position.y < closestPlace.position.y)) {
+                    closestPlace = place;
+                  } else if (pressedKey === this.keyboardNavigationEvents.ArrowLeft && (place.position.y === currSelectedPlacePosition.y || place.position.y === currSelectedPlacePosition.y + 1) && place.position.x < currSelectedPlacePosition.x && (!closestPlace || place.position.x > closestPlace.position.x)) {
+                    closestPlace = place;
+                  } else if (pressedKey === this.keyboardNavigationEvents.ArrowUp && (place.position.x === currSelectedPlacePosition.x || place.position.x === currSelectedPlacePosition.x - 1) && place.position.y < currSelectedPlacePosition.y && (!closestPlace || place.position.y > closestPlace.position.y)) {
+                    closestPlace = place;
+                  }
+                }
+              }
+            }
+            if (switchedCoachDeckIndex !== null && closestPlace) {
+              this.currSelectedDeckIndex = switchedCoachDeckIndex;
+            }
+          }
+        }
+      }
+      return closestPlace;
+    }
+    // Handling for Tab navigation if a place is selected inside the coach.
+    // This controls the focused coach from the current selected coach.
+    _navigateCoachNavigationByKeyboard(tabDirection) {
+      const currFocusIndex = this.focusedCoachIndex === -1 ? this.currSelectedCoachIndex === -1 ? 0 : this.currSelectedCoachIndex : this.focusedCoachIndex;
+      const newFocusableIndex = tabDirection === "NEXT_TAB" ? this.getNextAvailableCoachIndex(currFocusIndex) : this.getPrevAvailableCoachIndex(currFocusIndex);
+      if (this.hasNavigation) {
+        const selectedPlaceElement = this._getPlaceHtmlElement();
+        const placeInCoachHasFocus = selectedPlaceElement ? selectedPlaceElement.getAttribute("keyfocus") === "focus" : false;
+        if (tabDirection === "PREV_TAB" && this.selectedCoachIndex === currFocusIndex) {
+          if (placeInCoachHasFocus || this.currSelectedPlace !== null) {
+            this.focusedCoachIndex = currFocusIndex;
+            this.unfocusPlaceElement();
+            return;
+          } else if (currFocusIndex == 0) {
+            this.unfocusPlaceElement();
+            this.currSelectedPlace = null;
+            this.focusedCoachIndex = -1;
+            const btnLeftDirection = this.shadowRoot?.getElementById("sbb-sr-navigation__wrapper-button-direction--left");
+            btnLeftDirection.focus();
+          } else {
+            this.focusedCoachIndex = newFocusableIndex;
+          }
+        } else if (newFocusableIndex !== this.currSelectedCoachIndex) {
+          this.focusedCoachIndex = newFocusableIndex;
+        } else if (tabDirection === "NEXT_TAB" && newFocusableIndex === this.coachNavData.length - 1) {
+          this.unfocusPlaceElement();
+          this.focusedCoachIndex = -1;
+          const btnRightDirection = this.shadowRoot?.getElementById("sbb-sr-navigation__wrapper-button-direction--right");
+          btnRightDirection.focus();
+        } else {
+          this.focusedCoachIndex = -1;
+          this.selectedCoachIndex = newFocusableIndex;
+          if (placeInCoachHasFocus) {
+            this.focusPlaceElement(this.currSelectedPlace);
+          } else {
+            this.isCoachGridFocusable = true;
+            this._setFocusToSelectedCoachGrid();
+          }
+        }
+        this._scrollToSelectedNavigationButton(newFocusableIndex);
+      } else {
+        this.scrollToSelectedNavCoach(newFocusableIndex);
+      }
+    }
+    _navigateToPlaceByKeyboard(pressedKey) {
+      this.isKeyboardNavigation = true;
+      if (this.focusedCoachIndex !== -1) {
+        this.focusedCoachIndex = -1;
+      }
+      if (!this.preventPlaceClick) {
+        const findClosestPlace = this._getClosestPlaceByKeyDirection(pressedKey);
+        if (findClosestPlace) {
+          this.focusPlaceElement(findClosestPlace);
+        } else {
+          if (pressedKey === this.keyboardNavigationEvents.ArrowRight || pressedKey === this.keyboardNavigationEvents.ArrowLeft || this.alignVertical && (pressedKey === this.keyboardNavigationEvents.ArrowUp || pressedKey === this.keyboardNavigationEvents.ArrowDown)) {
+            const newSelectedCoachIndex = pressedKey === this.keyboardNavigationEvents.ArrowRight ? this.getNextAvailableCoachIndex() : this.getPrevAvailableCoachIndex();
+            this.scrollToSelectedNavCoach(newSelectedCoachIndex);
+          }
+        }
+      }
+    }
+    getNextAvailableCoachIndex(currentIndex) {
+      const startIndex = currentIndex ?? this.currSelectedCoachIndex;
+      return startIndex < this.seatReservations[this.currSelectedDeckIndex].coachItems.length - 1 ? startIndex + 1 : startIndex;
+    }
+    getPrevAvailableCoachIndex(currentIndex) {
+      const startIndex = currentIndex ?? this.currSelectedCoachIndex;
+      return startIndex > 0 ? startIndex - 1 : startIndex;
+    }
+    updateSelectedSeatReservationPlaces(placeSelection) {
+      const placeTypeProp = placeSelection.placeType === "SEAT" ? "seats" : "bicycles";
+      const maxReservations = placeSelection.placeType === "SEAT" ? this.maxSeatReservations : this.maxBicycleReservations;
+      const currSelectedPlaces = this.selectedSeatReservationPlaces[placeTypeProp];
+      this.selectedSeatReservationPlaces[placeTypeProp] = this._updateSelectedSeatReservationPlaces(currSelectedPlaces, maxReservations, placeSelection);
+      this.dispatchEvent(new CustomEvent("selectedplaces", {
+        bubbles: true,
+        composed: true,
+        detail: this.selectedSeatReservationPlaces
+      }));
+    }
+    _updateSelectedSeatReservationPlaces(selectedSeatReservationPlaces, maxReservations, placeSelection) {
+      if (placeSelection.state === "SELECTED") {
+        const selectedPlaceDeckIndex = this._getDeckIndexByPlaceId(placeSelection.id);
+        const seatReservationSelection = this._getSeatReservationPlaceSelection(placeSelection, selectedPlaceDeckIndex);
+        if (seatReservationSelection) {
+          selectedSeatReservationPlaces.push(seatReservationSelection);
+        }
+      } else {
+        selectedSeatReservationPlaces = selectedSeatReservationPlaces.filter((_selectedPlace) => _selectedPlace.id !== placeSelection.id);
+      }
+      if (maxReservations > -1 && selectedSeatReservationPlaces.length > maxReservations) {
+        const resetWithPlaceSelection = maxReservations > 0 ? placeSelection : void 0;
+        selectedSeatReservationPlaces = this._resetAllPlaceSelections(selectedSeatReservationPlaces, resetWithPlaceSelection);
+      }
+      return selectedSeatReservationPlaces;
+    }
+    updateCurrentSelectedPlaceInCoach(placeSelection) {
+      const placeDeckIndex = this._getDeckIndexByPlaceId(placeSelection.id);
+      const coachIndex = placeSelection.coachIndex;
+      if (placeDeckIndex === null)
+        return;
+      const place = this.seatReservations[placeDeckIndex].coachItems[coachIndex].places?.find((place2) => place2.number == placeSelection.number);
+      if (!place)
+        return;
+      this.currSelectedDeckIndex = placeDeckIndex;
+      this.currSelectedCoachIndex = coachIndex;
+      this.currSelectedPlace = place;
+      if (this.currSelectedCoachIndex !== this.selectedCoachIndex) {
+        this.updateCurrentSelectedCoach();
+      }
+      this._setCurrSelectedPlaceElementId(place);
+      const delayScrollInViewport = setTimeout(() => {
+        this._scrollPlaceIntoNearestViewport(placeSelection.id);
+        clearTimeout(delayScrollInViewport);
+      }, 0);
+    }
+    updateCurrentSelectedCoach() {
+      if (this.currSelectedCoachIndex == this.selectedCoachIndex)
+        return;
+      if (this.focusedCoachIndex != -1) {
+        this.focusedCoachIndex = this.currSelectedCoachIndex;
+      }
+      this.selectedCoachIndex = this.currSelectedCoachIndex;
+      const coachSelection = this._getSeatReservationSelectedCoach(this.selectedCoachIndex);
+      if (coachSelection) {
+        this.dispatchEvent(new CustomEvent("selectedcoach", {
+          bubbles: true,
+          composed: true,
+          detail: coachSelection
+        }));
+      }
+    }
+    getPlaceElementId(coachDeckIndex, coachIndex, placeNumber) {
+      return "seat-reservation__place-button-" + coachDeckIndex + "-" + coachIndex + "-" + placeNumber;
+    }
+    /**
+     * In the case of coach layouts with different decks,
+     * it is necessary to extend the offset with empty coaches
+     * in order to create a stable vehicle layout.
+     *
+     *             [ooo]-[ooo]-[ooo]
+     * [ooo]-[ooo]-[ooo]-[ooo]-[ooo]
+     */
+    _initEmptyCoachDeckOffsets() {
+      const coachOffsetIndexCounter = Array(this.seatReservations.length - 1).fill(0);
+      const lowerDeck = this.seatReservations[this.seatReservations.length - 1];
+      lowerDeck.coachItems.forEach((lowerCoachItem) => {
+        for (let i = 0; i < this.seatReservations.length - 1; i++) {
+          const deckCoachItem = this.seatReservations[i].coachItems[coachOffsetIndexCounter[i]];
+          if (lowerCoachItem.id != deckCoachItem?.id) {
+            const emptyOffsetCoach = {
+              ...lowerCoachItem,
+              places: void 0,
+              propertyIds: void 0,
+              graphicElements: void 0,
+              serviceElements: void 0,
+              travelClass: []
+            };
+            this.seatReservations[i].coachItems.splice(coachOffsetIndexCounter[i], 0, emptyOffsetCoach);
+          }
+          coachOffsetIndexCounter[i]++;
+        }
+      });
+    }
+    /**
+     * Initialization of SeatReservationPlaceSelection Array based on the transferred places
+     * that have the state SELECTED within the seatReservation object
+     */
+    _initSeatReservationPlaceSelection() {
+      this.selectedSeatReservationPlaces.seats = [];
+      this.selectedSeatReservationPlaces.bicycles = [];
+      this.seatReservations?.forEach((seatReservation, coachDeckIndex) => seatReservation.coachItems.map((coach, coachIndex) => {
+        coach.places?.filter((place) => place.state === "SELECTED")?.forEach((place) => {
+          const placeId = this.getPlaceElementId(coachDeckIndex, coachIndex, place.number);
+          const preselectedPlaceSelection = mapPlaceInfosToPlaceSelection(place, placeId, seatReservation.deckCoachIndex, coachIndex);
+          const seatReservationPlaceSelection = this._getSeatReservationPlaceSelection(preselectedPlaceSelection, coachDeckIndex);
+          if (seatReservationPlaceSelection) {
+            if (seatReservationPlaceSelection.placeType === "SEAT") {
+              this.selectedSeatReservationPlaces.seats.push(seatReservationPlaceSelection);
+            } else {
+              this.selectedSeatReservationPlaces.bicycles.push(seatReservationPlaceSelection);
+            }
+          }
+        });
+      }));
+    }
+    /**
+     * All selected places will be reset or the currentSelectedPlace was given, then we reset all except currentSelectedPlace
+     * @param reservationPlaceSelections
+     * @param currSelectedPlace
+     */
+    _resetAllPlaceSelections(reservationPlaceSelections, currSelectedPlace) {
+      for (const placeSelection of reservationPlaceSelections) {
+        if (!currSelectedPlace || currSelectedPlace.id !== placeSelection.id) {
+          const placeElement = this.shadowRoot?.getElementById(placeSelection.id);
+          if (placeElement) {
+            placeElement.setAttribute("state", "FREE");
+          }
+        }
+      }
+      if (currSelectedPlace) {
+        reservationPlaceSelections = reservationPlaceSelections.filter((_selectedPlace) => _selectedPlace.id === currSelectedPlace.id);
+      } else {
+        reservationPlaceSelections = [];
+      }
+      return reservationPlaceSelections;
+    }
+    _getSeatReservationPlaceSelection(currSelectedPlace, coachDeckIndex) {
+      if (coachDeckIndex === null)
+        return null;
+      const coach = this.seatReservations[coachDeckIndex].coachItems[currSelectedPlace.coachIndex];
+      const place = coach.places?.find((place2) => place2.number === currSelectedPlace.number);
+      return place ? mapPlaceAndCoachToSeatReservationPlaceSelection(place, coach, currSelectedPlace.id, currSelectedPlace.deckIndex, currSelectedPlace.coachIndex) : null;
+    }
+    _getSeatReservationSelectedCoach(coachIndex) {
+      if (!this.seatReservations[this.currSelectedDeckIndex].coachItems[coachIndex])
+        return null;
+      const coach = this.seatReservations[this.currSelectedDeckIndex].coachItems[coachIndex];
+      const coachNumberOfFreePlaces = this.getAvailableFreePlacesNumFromCoach(coach.places);
+      return mapCoachInfosToCoachSelection(coachIndex, coach, coachNumberOfFreePlaces);
+    }
+    _setCurrSelectedPlaceElementId(place) {
+      this.currSelectedPlaceElementId = place ? this.getPlaceElementId(this.currSelectedDeckIndex, this.currSelectedCoachIndex, place.number) : null;
+    }
+    /**
+     * Preparation of the used documents font-size which needs
+     * to be determined in order to correctly calculate CSS values with rem
+     * */
+    _determineBaseFontSize() {
+      if (!isServer) {
+        const baseFontSize = parseInt(window.getComputedStyle(document.body).fontSize, 10);
+        const onePixelInRem = 1 / baseFontSize;
+        this.style?.setProperty("--sbb-seat-reservation-one-px-rem", `${onePixelInRem + "rem"}`);
+      }
+    }
+    /**
+     * Prepares data for displaying navigation area.
+     * Calculates the values which are not going to change during use of a component:
+     *    - coach id
+     *    - list of service icons
+     *    - class (first, second, any)
+     *    - whether there is a driver area left or right
+     * */
+    _prepareNavigationCoachData() {
+      if (this.seatReservations) {
+        const lowerDeck = this.seatReservations[this.seatReservations.length - 1].coachItems;
+        this.coachNavData = [];
+        lowerDeck.forEach((coach, index) => {
+          const travelClasses = [];
+          const propertyIds = [];
+          const places = [];
+          this.seatReservations.map((sr) => {
+            return sr.coachItems[index];
+          }).forEach((coach2) => {
+            travelClasses.push(...coach2.travelClass);
+            propertyIds.push(...coach2.propertyIds ? coach2.propertyIds : []);
+            places.push(...coach2.places ? coach2.places : []);
+          });
+          this.coachNavData.push({
+            id: coach.id,
+            travelClass: this._prepareTravelClassNavigation(travelClasses),
+            propertyIds: this._prepareServiceIconsNavigation(propertyIds),
+            isDriverArea: coach.places ? coach.places.length === 0 : true,
+            driverAreaSide: this._prepareDriverAreaSideNavigation(coach),
+            freePlaces: this.getAvailableFreePlacesNumFromCoach(places)
+          });
+        });
+      }
+    }
+    _prepareTravelClassNavigation(travelClasses) {
+      if (travelClasses.indexOf("FIRST") !== -1)
+        return "FIRST";
+      if (travelClasses.indexOf("SECOND") !== -1)
+        return "SECOND";
+      return "ANY_CLASS";
+    }
+    _prepareDriverAreaSideNavigation(coachItem) {
+      const coachDriverAreas = coachItem.graphicElements?.filter((graphicalElements) => graphicalElements.icon === "DRIVER_AREA");
+      if (coachDriverAreas && coachDriverAreas.length > 0) {
+        const hasLeftDriverArea = coachDriverAreas.find((driverAreaElement) => driverAreaElement.position.x === 0) || false;
+        const hasRightDriverArea = coachDriverAreas.find((driverAreaElement) => driverAreaElement.position.x > 0) || false;
+        return {
+          left: !!hasLeftDriverArea,
+          right: !!hasRightDriverArea
+        };
+      }
+      return void 0;
+    }
+    _prepareCoachWidthAndGapCalculations() {
+      if (this.seatReservations) {
+        const coachItems = this.seatReservations[this.seatReservations.length - 1]?.coachItems;
+        coachItems?.forEach((coachItem) => {
+          const hasOverhangingPlaces = this._isOverhangingElementsPresent(coachItem.dimension.w, coachItem.places);
+          const filteredElements = coachItem.graphicElements?.filter((e) => e.icon && !this.notAreaElements.includes(e.icon));
+          const hasOverhangingGraphicAreas = this._isOverhangingElementsPresent(coachItem.dimension.w, filteredElements);
+          this.overHangingElementInformation.push({
+            coachId: coachItem.id,
+            overhangingPlaces: hasOverhangingPlaces,
+            overhangingGraphicAreas: hasOverhangingGraphicAreas
+          });
+        });
+      }
+    }
+    /**
+     * Returns the current selected place HTML element by currSelectedPlaceElementId.
+     * @returns HTMLElement or null
+     */
+    _getPlaceHtmlElement() {
+      return this.currSelectedPlaceElementId ? this.shadowRoot?.getElementById(this.currSelectedPlaceElementId) || null : null;
+    }
+    /**
+     * Returns the extracted coach deck index from place id
+     * @returns number
+     */
+    _getDeckIndexByPlaceId(placeId) {
+      const deckIndex = this.shadowRoot?.querySelector("#" + placeId)?.getAttribute("data-deck-index");
+      if (deckIndex && !isNaN(+deckIndex)) {
+        return +deckIndex;
+      }
+      return null;
+    }
+    _isValidCoachIndex(coachIndex) {
+      return coachIndex >= 0 && coachIndex <= this.seatReservations[this.seatReservations.length - 1].coachItems.length;
+    }
+    /**
+     * Returns existing coach deck index depending on the selected coach.
+     * This method is necessary to get an available coach deck index during keyboard navigation, which can vary between coaches with different decks.
+     * For example, when navigating from a coach with two decks to a coach with one deck.
+     *
+     *       [ooo]-[ooo]-[ooo]
+     * [ooo]-[ooo]-[ooo]-[ooo]-[ooo]
+     *
+     * @returns number
+     */
+    _getExistingCoachDeckIndex() {
+      if (this.seatReservations[this.currSelectedDeckIndex].coachItems[this.currSelectedCoachIndex].places !== void 0) {
+        return this.currSelectedDeckIndex;
+      }
+      const nextAvailableDeckCoachIndex = this.seatReservations.findIndex((seatReservation) => seatReservation.coachItems[this.currSelectedCoachIndex].places !== void 0);
+      return this.currSelectedDeckIndex >= nextAvailableDeckCoachIndex ? this.currSelectedDeckIndex : nextAvailableDeckCoachIndex;
+    }
+    /**
+     * If a selected place is slightly hidden by the overflow scroll content and is still clicked,
+     * the method tries to scroll the selected place into the nearest viewport, so that it is completely visible.
+     *
+     * @param placeId
+     */
+    _scrollPlaceIntoNearestViewport(placeId) {
+      this.shadowRoot?.getElementById(placeId)?.scrollIntoView({ behavior: "smooth", block: "nearest", inline: "nearest" });
+    }
+    /**
+     * checks if any places or graphical elements (e.g. toilet area, etc.) are overhanging the coach borders
+     * @param coachItemWidth
+     * @param elements
+     */
+    _isOverhangingElementsPresent(coachItemWidth, elements) {
+      return elements?.some((element) => element.position.x === 0 || element.position.x + element.dimension.w >= coachItemWidth) ?? false;
+    }
+  }, _seatReservations_accessor_storage = new WeakMap(), _hasNavigation_accessor_storage = new WeakMap(), _alignVertical_accessor_storage = new WeakMap(), _baseGridSize_accessor_storage = new WeakMap(), _height_accessor_storage = new WeakMap(), _maxSeatReservations_accessor_storage = new WeakMap(), _maxBicycleReservations_accessor_storage = new WeakMap(), _preventPlaceClick_accessor_storage = new WeakMap(), _preselectCoachIndex_accessor_storage = new WeakMap(), _selectedCoachIndex_accessor_storage = new WeakMap(), _focusedCoachIndex_accessor_storage = new WeakMap(), _hoveredCoachIndex_accessor_storage = new WeakMap(), (() => {
+    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+    _seatReservations_decorators = [property({ attribute: "seat-reservations", type: Array })];
+    _hasNavigation_decorators = [forceType(), property({ attribute: "has-navigation", type: Boolean })];
+    _alignVertical_decorators = [forceType(), property({ attribute: "align-vertical", type: Boolean, reflect: true, useDefault: true })];
+    _baseGridSize_decorators = [forceType(), property({ attribute: "base-grid-size", type: Number })];
+    _height_decorators = [forceType(), property({ attribute: "height", type: Number })];
+    _maxSeatReservations_decorators = [forceType(), property({ attribute: "max-seat-reservations", type: Number })];
+    _maxBicycleReservations_decorators = [forceType(), property({ attribute: "max-bicycle-reservations", type: Number })];
+    _preventPlaceClick_decorators = [forceType(), property({ attribute: "prevent-place-click", type: Boolean })];
+    _preselectCoachIndex_decorators = [forceType(), property({ attribute: "preselect-coach-index", type: Number })];
+    _selectedCoachIndex_decorators = [state()];
+    _focusedCoachIndex_decorators = [state()];
+    _hoveredCoachIndex_decorators = [state()];
+    _coachAreaScrollend_decorators = [eventOptions({ passive: true })];
+    __esDecorate(_a, null, _seatReservations_decorators, { kind: "accessor", name: "seatReservations", static: false, private: false, access: { has: (obj) => "seatReservations" in obj, get: (obj) => obj.seatReservations, set: (obj, value) => {
+      obj.seatReservations = value;
+    } }, metadata: _metadata }, _seatReservations_initializers, _seatReservations_extraInitializers);
+    __esDecorate(_a, null, _hasNavigation_decorators, { kind: "accessor", name: "hasNavigation", static: false, private: false, access: { has: (obj) => "hasNavigation" in obj, get: (obj) => obj.hasNavigation, set: (obj, value) => {
+      obj.hasNavigation = value;
+    } }, metadata: _metadata }, _hasNavigation_initializers, _hasNavigation_extraInitializers);
+    __esDecorate(_a, null, _alignVertical_decorators, { kind: "accessor", name: "alignVertical", static: false, private: false, access: { has: (obj) => "alignVertical" in obj, get: (obj) => obj.alignVertical, set: (obj, value) => {
+      obj.alignVertical = value;
+    } }, metadata: _metadata }, _alignVertical_initializers, _alignVertical_extraInitializers);
+    __esDecorate(_a, null, _baseGridSize_decorators, { kind: "accessor", name: "baseGridSize", static: false, private: false, access: { has: (obj) => "baseGridSize" in obj, get: (obj) => obj.baseGridSize, set: (obj, value) => {
+      obj.baseGridSize = value;
+    } }, metadata: _metadata }, _baseGridSize_initializers, _baseGridSize_extraInitializers);
+    __esDecorate(_a, null, _height_decorators, { kind: "accessor", name: "height", static: false, private: false, access: { has: (obj) => "height" in obj, get: (obj) => obj.height, set: (obj, value) => {
+      obj.height = value;
+    } }, metadata: _metadata }, _height_initializers, _height_extraInitializers);
+    __esDecorate(_a, null, _maxSeatReservations_decorators, { kind: "accessor", name: "maxSeatReservations", static: false, private: false, access: { has: (obj) => "maxSeatReservations" in obj, get: (obj) => obj.maxSeatReservations, set: (obj, value) => {
+      obj.maxSeatReservations = value;
+    } }, metadata: _metadata }, _maxSeatReservations_initializers, _maxSeatReservations_extraInitializers);
+    __esDecorate(_a, null, _maxBicycleReservations_decorators, { kind: "accessor", name: "maxBicycleReservations", static: false, private: false, access: { has: (obj) => "maxBicycleReservations" in obj, get: (obj) => obj.maxBicycleReservations, set: (obj, value) => {
+      obj.maxBicycleReservations = value;
+    } }, metadata: _metadata }, _maxBicycleReservations_initializers, _maxBicycleReservations_extraInitializers);
+    __esDecorate(_a, null, _preventPlaceClick_decorators, { kind: "accessor", name: "preventPlaceClick", static: false, private: false, access: { has: (obj) => "preventPlaceClick" in obj, get: (obj) => obj.preventPlaceClick, set: (obj, value) => {
+      obj.preventPlaceClick = value;
+    } }, metadata: _metadata }, _preventPlaceClick_initializers, _preventPlaceClick_extraInitializers);
+    __esDecorate(_a, null, _preselectCoachIndex_decorators, { kind: "accessor", name: "preselectCoachIndex", static: false, private: false, access: { has: (obj) => "preselectCoachIndex" in obj, get: (obj) => obj.preselectCoachIndex, set: (obj, value) => {
+      obj.preselectCoachIndex = value;
+    } }, metadata: _metadata }, _preselectCoachIndex_initializers, _preselectCoachIndex_extraInitializers);
+    __esDecorate(_a, null, _selectedCoachIndex_decorators, { kind: "accessor", name: "selectedCoachIndex", static: false, private: false, access: { has: (obj) => "selectedCoachIndex" in obj, get: (obj) => obj.selectedCoachIndex, set: (obj, value) => {
+      obj.selectedCoachIndex = value;
+    } }, metadata: _metadata }, _selectedCoachIndex_initializers, _selectedCoachIndex_extraInitializers);
+    __esDecorate(_a, null, _focusedCoachIndex_decorators, { kind: "accessor", name: "focusedCoachIndex", static: false, private: false, access: { has: (obj) => "focusedCoachIndex" in obj, get: (obj) => obj.focusedCoachIndex, set: (obj, value) => {
+      obj.focusedCoachIndex = value;
+    } }, metadata: _metadata }, _focusedCoachIndex_initializers, _focusedCoachIndex_extraInitializers);
+    __esDecorate(_a, null, _hoveredCoachIndex_decorators, { kind: "accessor", name: "hoveredCoachIndex", static: false, private: false, access: { has: (obj) => "hoveredCoachIndex" in obj, get: (obj) => obj.hoveredCoachIndex, set: (obj, value) => {
+      obj.hoveredCoachIndex = value;
+    } }, metadata: _metadata }, _hoveredCoachIndex_initializers, _hoveredCoachIndex_extraInitializers);
+    __esDecorate(_a, null, _coachAreaScrollend_decorators, { kind: "method", name: "coachAreaScrollend", static: false, private: false, access: { has: (obj) => "coachAreaScrollend" in obj, get: (obj) => obj.coachAreaScrollend }, metadata: _metadata }, null, _instanceExtraInitializers);
+    if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+  })(), _a.events = {
+    selectedplaces: "selectedplaces",
+    selectedcoach: "selectedcoach"
+  }, _a;
+})();
+export {
+  SeatReservationBaseElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"seat-reservation-base-element.js","sources":["../../../../../src/elements-experimental/seat-reservation/seat-reservation/seat-reservation-base-element.ts"],"sourcesContent":["import { isArrowKeyOrPageKeysPressed } from '@sbb-esta/lyne-elements/core/a11y.js';\nimport { forceType } from '@sbb-esta/lyne-elements/core/decorators.js';\nimport { isServer, LitElement, type PropertyValues } from 'lit';\nimport { eventOptions, property, state } from 'lit/decorators.js';\n\nimport {\n  mapCoachInfosToCoachSelection,\n  mapIconToSvg,\n  mapPlaceAndCoachToSeatReservationPlaceSelection,\n  mapPlaceInfosToPlaceSelection,\n} from '../common/mapper.ts';\nimport type {\n  BaseElement,\n  CoachItem,\n  CoachNumberOfFreePlaces,\n  ElementDimension,\n  ElementPosition,\n  NavigationCoachItem,\n  Place,\n  PlaceSelection,\n  PlaceTravelClass,\n  SeatReservation,\n  SeatReservationPlaceSelection,\n  SeatReservationSelectedCoach,\n  SeatReservationSelectedPlaces,\n} from '../common.ts';\nimport type { SbbSeatReservationPlaceControlElement } from '../seat-reservation-place-control/seat-reservation-place-control.component.ts';\n\nenum ScrollDirection {\n  right = 'right',\n  left = 'left',\n}\n\ninterface CoachScrollTriggerPoint {\n  start: number;\n  end: number;\n  width: number;\n}\n\nconst MAX_SERVICE_PROPERTIES = 3;\nconst ALLOWED_SERVICE_ICONS: string[] = [\n  'sa-vo',\n  'sa-rs',\n  'sa-abteilkinderwagen',\n  'sa-wr',\n  'sa-fa',\n  'sa-bz',\n  'sa-rz',\n];\n\nexport class SeatReservationBaseElement extends LitElement {\n  public static readonly events = {\n    selectedplaces: 'selectedplaces',\n    selectedcoach: 'selectedcoach',\n  } as const;\n\n  /** The seat reservations array contains all coaches and places */\n  @property({ attribute: 'seat-reservations', type: Array })\n  public accessor seatReservations: SeatReservation[] = null!;\n\n  /** The seat reservation navigation can be toggled by this property */\n  @forceType()\n  @property({ attribute: 'has-navigation', type: Boolean })\n  public accessor hasNavigation: boolean = true;\n\n  /** The seat reservation area is aligned vertically */\n  @forceType()\n  @property({ attribute: 'align-vertical', type: Boolean, reflect: true, useDefault: true })\n  public accessor alignVertical: boolean = false;\n\n  /** The seat reservation area's base grid size */\n  @forceType()\n  @property({ attribute: 'base-grid-size', type: Number })\n  public accessor baseGridSize: number = 16;\n\n  /** The seat reservation area's width */\n  @forceType()\n  @property({ attribute: 'height', type: Number })\n  public accessor height: number = null!;\n\n  /** Maximal number of possible clickable seats */\n  @forceType()\n  @property({ attribute: 'max-seat-reservations', type: Number })\n  public accessor maxSeatReservations: number = -1;\n\n  /** Maximal number of possible clickable bicycle places */\n  @forceType()\n  @property({ attribute: 'max-bicycle-reservations', type: Number })\n  public accessor maxBicycleReservations: number = -1;\n\n  /** Any click functionality is prevented */\n  @forceType()\n  @property({ attribute: 'prevent-place-click', type: Boolean })\n  public accessor preventPlaceClick: boolean = false;\n\n  @forceType()\n  @property({ attribute: 'preselect-coach-index', type: Number })\n  public accessor preselectCoachIndex: number = -1;\n\n  @state() protected accessor selectedCoachIndex: number = -1;\n  @state() protected accessor focusedCoachIndex: number = -1;\n  @state() protected accessor hoveredCoachIndex: number = -1;\n\n  // Describes the distance between the border of the coach and the places in pixels\n  protected coachBorderPadding = 6;\n  // Describes the gap between the coaches in pixels\n  protected gapBetweenCoaches = 4;\n  // The calculated coachBorderOffset is used to calculate the width and height of coach border graphic,\n  // but also to position other graphics that are aligned directly to the coach border.\n  protected coachBorderOffset = this.coachBorderPadding / this.baseGridSize;\n  // Describes the gap between the coaches decks by multiple deck visualization\n  protected gapBetweenCoachDecks = 48;\n  // Describes the fix width of coach navigation button\n  protected coachNavButtonDim: number = 0;\n  protected coachNavData: NavigationCoachItem[] = [];\n  protected currScrollDirection: ScrollDirection = ScrollDirection.right;\n  protected maxCalcCoachesWidth: number = 0;\n  protected scrollCoachesAreaWidth: number = 0;\n  protected scrollNavigationAreaDim: number = 0;\n  protected triggerCoachPositionsCollection: CoachScrollTriggerPoint[] = [];\n  protected navigationScrollArea: HTMLElement = null!;\n  protected coachScrollArea: HTMLElement = null!;\n  protected currSelectedPlace: Place | null = null;\n  protected currSelectedPlaceElementId: string | null = null;\n  protected currSelectedCoachIndex: number = -1;\n  protected currSelectedDeckIndex: number = 0;\n  protected preventCoachScrollByPlaceClick: boolean = false;\n  protected selectedSeatReservationPlaces: SeatReservationSelectedPlaces = {\n    seats: [],\n    bicycles: [],\n  };\n  protected seatReservationWithoutNavigationHasFocus = false;\n  protected isCoachGridFocusable = false;\n  protected isAutoScrolling = false;\n  protected isKeyboardNavigation = false;\n  protected hasMultipleDecks = false;\n  protected hasSeatReservationNativeFocus = false;\n  protected keyboardNavigationEvents = {\n    ArrowLeft: 'ArrowLeft',\n    ArrowRight: 'ArrowRight',\n    ArrowUp: 'ArrowUp',\n    ArrowDown: 'ArrowDown',\n    Tab: 'Tab',\n    Enter: 'Enter',\n  } as const;\n\n  // Graphics that should not be rendered with an area\n  protected notAreaElements = [\n    'DRIVER_AREA',\n    'COACH_PASSAGE',\n    'COACH_WALL_NO_PASSAGE',\n    'COMPARTMENT_PASSAGE',\n    'COMPARTMENT_PASSAGE_HIGH',\n    'COMPARTMENT_PASSAGE_MIDDLE',\n    'COMPARTMENT_PASSAGE_LOW',\n  ];\n\n  protected overHangingElementInformation: {\n    coachId: string;\n    overhangingPlaces: boolean;\n    overhangingGraphicAreas: boolean;\n  }[] = [];\n\n  private _isRunningInitPreselectCoachIndex = false;\n  private _scrollTimeout: ReturnType<typeof setTimeout> | undefined;\n  private _lastStartScrollPos = -1;\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('seatReservations')) {\n      this.hasMultipleDecks = this.seatReservations?.length > 1;\n\n      this._initPrepareSeatReservationData();\n      this._prepareCoachWidthAndGapCalculations();\n      this._initSeatReservationPlaceSelection();\n      this.initNavigationSelectionByScrollEvent();\n    }\n\n    if (changedProperties.has('baseGridSize')) {\n      this.coachBorderOffset = this.coachBorderPadding / this.baseGridSize;\n      this.style?.setProperty('--sbb-seat-reservation-grid-size', `${this.baseGridSize}px`);\n\n      this.initNavigationSelectionByScrollEvent();\n    }\n\n    // If the height is used, the baseGridSize must be recalculated\n    if (changedProperties.has('height') && !!this.height) {\n      const seatReservationLayer = this.seatReservations[this.currSelectedDeckIndex] || null;\n      if (seatReservationLayer?.coachItems.length) {\n        this.baseGridSize = this.height / seatReservationLayer.coachItems[0].dimension.h;\n        this.coachBorderOffset = this.coachBorderPadding / this.baseGridSize;\n        this.style?.setProperty('--sbb-seat-reservation-grid-size', `${this.baseGridSize}px`);\n\n        this.initNavigationSelectionByScrollEvent();\n      }\n    }\n\n    if (changedProperties.has('alignVertical') && this.alignVertical) {\n      this.initNavigationSelectionByScrollEvent();\n    }\n\n    if (changedProperties.has('preselectCoachIndex')) {\n      // setTimeout is necessary because without, _getCoachScrollPositionX() would fail with NPE because\n      // the coachScrollArea is not yet initialized\n      this._isRunningInitPreselectCoachIndex = true;\n      setTimeout(() => this.scrollToSelectedNavCoach(this.preselectCoachIndex), 1);\n    }\n  }\n\n  protected navigateByDirectionBtn(btnDirection: string): void {\n    this.unfocusPlaceElement();\n    let navigateToCoachIndex = this.currSelectedCoachIndex;\n    if (btnDirection == 'DIRECTION_LEFT' && navigateToCoachIndex > 0) {\n      navigateToCoachIndex =\n        this.currSelectedCoachIndex != -1 ? this.currSelectedCoachIndex - 1 : 0;\n    } else if (\n      btnDirection == 'DIRECTION_RIGHT' &&\n      navigateToCoachIndex <\n        this.seatReservations[this.currSelectedDeckIndex]?.coachItems.length - 1\n    ) {\n      navigateToCoachIndex =\n        this.currSelectedCoachIndex != -1 ? this.currSelectedCoachIndex + 1 : 0;\n    }\n\n    this.scrollToSelectedNavCoach(navigateToCoachIndex);\n  }\n\n  /**\n   * Data can be prepared once for the entire component\n   * in order to avoid recurring iteration processes in rendering.\n   */\n  private _initPrepareSeatReservationData(): void {\n    this._determineBaseFontSize();\n\n    if (this.hasMultipleDecks) {\n      // If there are multiple decks, we need to check\n      // whether empty coaches need to be added on different deck levels\n      this._initEmptyCoachDeckOffsets();\n    }\n\n    this._prepareNavigationCoachData();\n  }\n\n  /** Init scroll event handling for coach navigation */\n  protected initNavigationSelectionByScrollEvent(): void {\n    this.coachScrollArea = this.shadowRoot?.querySelector(\n      '#sbb-sr__wrapper-scrollarea',\n    ) as HTMLElement;\n    this.navigationScrollArea = this.shadowRoot?.querySelector(\n      '#sbb-sr__navigation-list-coaches',\n    ) as HTMLElement;\n\n    const seatReservationDeck = this.seatReservations\n      ? this.seatReservations[this.currSelectedDeckIndex]\n      : null;\n    if (seatReservationDeck && seatReservationDeck.coachItems.length > 0) {\n      // Calculates the absolute height of one coach including border padding\n      const coachHeightWithBorderPadding =\n        seatReservationDeck.coachItems[0].dimension.h * this.baseGridSize + this.coachBorderPadding;\n\n      // Calculate each gap between multiple coach the decks.\n      // No gap exist if just one coach deck exist.\n      const gapBetweenCoachDecks = (this.seatReservations.length - 1) * this.gapBetweenCoachDecks;\n\n      this.style?.setProperty(\n        '--sbb-seat-reservation-height',\n        `${coachHeightWithBorderPadding * this.seatReservations.length + gapBetweenCoachDecks}`,\n      );\n      this.style?.setProperty('--sbb-seat-reservation-decks', `${this.seatReservations.length}`);\n    }\n\n    if (this.navigationScrollArea) {\n      this.scrollNavigationAreaDim = this.alignVertical\n        ? this.navigationScrollArea.getBoundingClientRect().height\n        : this.navigationScrollArea.getBoundingClientRect().width;\n\n      // Init the coachNavButtonDim dimension, which is needed to calculate the correct scroll navigation later\n      const navCoachesList = this.navigationScrollArea.querySelector('ul > li') as HTMLUListElement;\n      if (navCoachesList) {\n        const firstLiEleDimension = navCoachesList?.getBoundingClientRect();\n        this.coachNavButtonDim = this.alignVertical\n          ? firstLiEleDimension.height\n          : firstLiEleDimension.width;\n      }\n    }\n\n    if (this.coachScrollArea && seatReservationDeck) {\n      // Init the start offset for the calculation of the coach scroll trigger positions\n      let currCalcTriggerPos = 0;\n      this.scrollCoachesAreaWidth = this.alignVertical\n        ? this.coachScrollArea.getBoundingClientRect().height\n        : this.coachScrollArea.getBoundingClientRect().width;\n\n      // Precalculate trigger scroll position array depends on coach width\n      this.triggerCoachPositionsCollection = seatReservationDeck.coachItems.map((coach) => {\n        const startPosX = currCalcTriggerPos;\n        const coachWidth = this.getCalculatedDimension(coach.dimension).w;\n\n        // Calculation of the end scroll trigger position of a coach, including the gap between the coaches\n        // The gap is maybe adjusted if overhanging places or graphics exist\n        const currentCoachOverhangingInfo = this.overHangingElementInformation.find(\n          (e) => e.coachId === coach.id,\n        );\n        const overhangingElementsPresent =\n          currentCoachOverhangingInfo?.overhangingPlaces ||\n          currentCoachOverhangingInfo?.overhangingGraphicAreas;\n        currCalcTriggerPos +=\n          coachWidth +\n          (!overhangingElementsPresent ? this.gapBetweenCoaches : 2 * this.gapBetweenCoaches);\n\n        return {\n          start: startPosX,\n          end: currCalcTriggerPos,\n          width: coachWidth,\n        } as CoachScrollTriggerPoint;\n      });\n\n      // Set maximum calculated coach width\n      this.maxCalcCoachesWidth = currCalcTriggerPos;\n    }\n  }\n\n  /**\n   * Scroll event handler managed the end of scrolling inside the coach scroll area.\n   * Timeout event handling to check if the scrolling has been completed.\n   * It is required because the Safari browser does not handle scrollend event,\n   * and we therefore imitate this event -> scrollend.\n   */\n  @eventOptions({ passive: true })\n  protected coachAreaScrollend(): void {\n    if (this._scrollTimeout) {\n      // First, we cleared the registered timeout, as the scrolling is still running\n      // and thus we prevent the execution of the _handleCoachAreaScrollendEvent function\n      clearTimeout(this._scrollTimeout);\n    }\n    // If no further scroll event is fired, the next timeout can execute the inner function _handleCoachAreaScrollendEvent without clearing\n    this._scrollTimeout = setTimeout(() => this._handleCoachAreaScrollendEvent(), 150);\n  }\n\n  /**\n   * If no navigation exists (property setting -> hasNavigation) and a table coach gets the focus,\n   * the first place in the coach must be automatically preselected to control the place navigation via keyboard\n   *\n   * @param focusCoachIndex\n   */\n  protected onFocusTableCoachAndPreselectPlace(focusCoachIndex: number): void {\n    if (!this.seatReservationWithoutNavigationHasFocus && !this.hasNavigation) {\n      this.seatReservationWithoutNavigationHasFocus = true;\n      this.currSelectedCoachIndex =\n        focusCoachIndex === 0\n          ? this.getNextAvailableCoachIndex(-1)\n          : this.getPrevAvailableCoachIndex(focusCoachIndex);\n      this.preselectPlaceInCoach();\n    }\n  }\n\n  /** Will be triggered by focus navigation direction */\n  protected onFocusNavDirectionButton(): void {\n    // If any navigation direction button (right|left) get the focus, so we have manual reset the previous focusCoachIndex.\n    this.focusedCoachIndex = -1;\n  }\n\n  /** TAB Key Event handling for Coach Navigation */\n  protected onKeyNavigationNavCoachButton(\n    event: KeyboardEvent,\n    currNavCoachButtonIndex: number,\n  ): void {\n    const pressedKey = event.key;\n\n    if (pressedKey === this.keyboardNavigationEvents.Tab) {\n      this._handleTabKeyNavigation(event, 'navigation', currNavCoachButtonIndex);\n      return;\n    }\n\n    // By using any other key (no TAB) inside the Navigation area, so we can handle this by using the logic from keyboardSeatmapEventHandling\n    if (isArrowKeyOrPageKeysPressed(event)) {\n      this.keyboardSeatmapEventHandling(event);\n    }\n  }\n\n  /** General TAB Key Event handling for tab navigation inside the coach navigation area and the seatmap area */\n  private _handleTabKeyNavigation(\n    event: KeyboardEvent,\n    eventArea: string,\n    currTabIndex?: number,\n  ): void {\n    const pressedKey = event.key;\n    const pressedShiftTab = event.shiftKey;\n\n    if (pressedKey === this.keyboardNavigationEvents.Tab) {\n      // Handle TAB key event navigation for coach navigation area.\n      // Fpr coach navigation we just control the focus index to visualize focus style for nav coach button\n      if (eventArea == 'navigation') {\n        if (currTabIndex == this.currSelectedCoachIndex) {\n          if (\n            !this.currSelectedPlace ||\n            !pressedShiftTab ||\n            this.coachNavData[currTabIndex].isDriverArea ||\n            this.focusedCoachIndex == -1\n          ) {\n            this.focusedCoachIndex = currTabIndex;\n          } else if (pressedShiftTab && this.currSelectedPlace) {\n            //If the For back tabbing, we jump\n            this.focusedCoachIndex = -1;\n            this.focusPlaceElement(this.currSelectedPlace);\n          }\n        } else {\n          this.focusedCoachIndex = currTabIndex!;\n        }\n\n        this._scrollToSelectedNavigationButton(currTabIndex!);\n      }\n      // Handle TAB key event navigation for seatmap area\n      else if (eventArea == 'seatmap') {\n        event.preventDefault();\n        if (pressedShiftTab) {\n          this._navigateCoachNavigationByKeyboard('PREV_TAB');\n        } else {\n          this._navigateCoachNavigationByKeyboard('NEXT_TAB');\n        }\n      }\n    }\n  }\n\n  /**\n   * Initialisation of Keyboard Seatmap event handling to navigation between each places inside a selected coach by using [arrow] keys.\n   * With the [TAB] key the user navigation goes to the next coach navigation element and the currently selected place is automatically reset.\n   */\n  protected keyboardSeatmapEventHandling(event: KeyboardEvent): void {\n    const pressedKey = event.key;\n    this.preventCoachScrollByPlaceClick = false;\n\n    // Check any keyboard event was triggered inside the seat reservation component,\n    // so we can say the native browser focus lies on the component\n    if (\n      !this.hasSeatReservationNativeFocus &&\n      ((event.shiftKey && pressedKey === this.keyboardNavigationEvents.Tab) ||\n        pressedKey === this.keyboardNavigationEvents.Tab)\n    ) {\n      this.hasSeatReservationNativeFocus = true;\n    }\n\n    // If any place is selected and TAB Key combination ist pressed,\n    // then we handle the next or previous coach selection\n    if (pressedKey == this.keyboardNavigationEvents.Tab) {\n      this._handleTabKeyNavigation(event, 'seatmap');\n      return;\n    }\n\n    // Arrow Keyboard navigation to control places inside the seatmap\n    if (this.currSelectedCoachIndex !== -1 && isArrowKeyOrPageKeysPressed(event)) {\n      event.preventDefault();\n\n      switch (pressedKey) {\n        case this.keyboardNavigationEvents.ArrowLeft:\n          {\n            const pressedLeftKeyMapping: string = this.alignVertical\n              ? this.keyboardNavigationEvents.ArrowDown\n              : pressedKey;\n            this._navigateToPlaceByKeyboard(pressedLeftKeyMapping);\n          }\n          break;\n        case this.keyboardNavigationEvents.ArrowRight:\n          {\n            const pressedRightKeyMapping: string = this.alignVertical\n              ? this.keyboardNavigationEvents.ArrowUp\n              : pressedKey;\n            this._navigateToPlaceByKeyboard(pressedRightKeyMapping);\n          }\n          break;\n        case this.keyboardNavigationEvents.ArrowUp:\n          {\n            const pressedUpKeyMapping: string = this.alignVertical\n              ? this.keyboardNavigationEvents.ArrowLeft\n              : pressedKey;\n            this._navigateToPlaceByKeyboard(pressedUpKeyMapping);\n          }\n          break;\n        case this.keyboardNavigationEvents.ArrowDown:\n          {\n            const pressedDownKeyMapping: string = this.alignVertical\n              ? this.keyboardNavigationEvents.ArrowRight\n              : pressedKey;\n            this._navigateToPlaceByKeyboard(pressedDownKeyMapping);\n          }\n          break;\n        default:\n          break;\n      }\n    }\n  }\n\n  /**\n   * Selects a place inside the coach if navigated via keyboard,\n   * otherwise the coach grid is selected (necessary for ScreenReader)\n   */\n  protected preselectPlaceInCoach(): void {\n    // No preselect place by manual seatmap scrolling\n    if (!this.isAutoScrolling) return;\n\n    // No auto place preselection by running the preselect coach index\n    if (this._isRunningInitPreselectCoachIndex) {\n      this._isRunningInitPreselectCoachIndex = false;\n      return;\n    }\n\n    // For DriverArea or Empty coach (no places), no place is selectable, so we return directly\n    if (\n      this.coachNavData[this.currSelectedCoachIndex] &&\n      this.coachNavData[this.currSelectedCoachIndex].isDriverArea\n    ) {\n      this._setFocusToSelectedCoachGrid();\n      return;\n    }\n\n    // Only when keyboard navigation is used and coaches are scrolled by auto scrolling,\n    // then we can set the focus on the first place in the coach.\n    if (this.isKeyboardNavigation && this.isAutoScrolling) {\n      const closestPlace = this._getClosestPlaceByKeyDirection();\n      //If closestPlace exist, we have to unfocus previous focused place\n      if (closestPlace) {\n        this.unfocusPlaceElement();\n        this.focusPlaceElement(closestPlace);\n        this.focusedCoachIndex = -1;\n      } else {\n        // If a coach was selected with no places, then we have to focus the coachGrid\n        this._setFocusToSelectedCoachGrid();\n      }\n    }\n    // In cases where the preselection function is triggered by normal clicking or via screen reader via tab,\n    // we only focus the table without directly focusing the place.\n    else {\n      this.unfocusPlaceElement();\n\n      this.isCoachGridFocusable = true;\n      this._setFocusToSelectedCoachGrid();\n    }\n  }\n\n  protected scrollToSelectedNavCoach(selectedNavCoachIndex: number): void {\n    if (\n      this._isValidCoachIndex(selectedNavCoachIndex) &&\n      selectedNavCoachIndex !== this.currSelectedCoachIndex\n    ) {\n      this.hoveredCoachIndex = selectedNavCoachIndex;\n      this.isAutoScrolling = true;\n      this.isCoachGridFocusable = true;\n      this.currSelectedCoachIndex = selectedNavCoachIndex;\n      this.currSelectedDeckIndex = this._getExistingCoachDeckIndex();\n      this._setScrollDirectionByCoachIndex();\n\n      const scrollToCoachPosX = this._getCoachScrollPositionX();\n      const isSelectedCoachIndexScrollable =\n        this.selectedCoachIndex !== -1 || this.currSelectedCoachIndex > 0;\n\n      // Checks whether the current scroll position allows scrolling to the next wagon or not\n      if (isSelectedCoachIndexScrollable && this._isScrollableToSelectedCoach()) {\n        this._lastStartScrollPos = this.coachScrollArea.scrollLeft;\n        this.coachScrollArea.scrollTo({\n          top: this.alignVertical ? scrollToCoachPosX : 0,\n          left: this.alignVertical ? 0 : scrollToCoachPosX,\n          behavior: 'smooth',\n        });\n      } else {\n        this.updateCurrentSelectedCoach();\n      }\n\n      // Automatic scrolling to the selected coach in the main navigation\n      this._scrollToSelectedNavigationButton(selectedNavCoachIndex);\n    }\n  }\n\n  protected focusPlaceElement(place: Place | null): void {\n    this.unfocusPlaceElement();\n    if (place) {\n      this.currSelectedPlace = place;\n      this._setCurrSelectedPlaceElementId(place);\n\n      const selectedPlaceElement = this._getPlaceHtmlElement();\n      if (selectedPlaceElement) {\n        selectedPlaceElement.setAttribute('keyfocus', 'focus');\n\n        //Try to scroll focused place into the viewport\n        const delayScrollInViewport = setTimeout(() => {\n          const placeId = this.getPlaceElementId(\n            this.currSelectedDeckIndex,\n            this.currSelectedCoachIndex,\n            place.number,\n          );\n          this._scrollPlaceIntoNearestViewport(placeId);\n          clearTimeout(delayScrollInViewport);\n        }, 0);\n      }\n    }\n  }\n\n  protected unfocusPlaceElement(): void {\n    const selectedPlaceElement = this._getPlaceHtmlElement();\n    if (selectedPlaceElement) {\n      selectedPlaceElement.setAttribute('keyfocus', 'unfocus');\n      this._setCurrSelectedPlaceElementId(null);\n      this.currSelectedPlace = null;\n    }\n  }\n\n  protected getCalculatedDimension(\n    elementDimension: ElementDimension,\n    coachDimension?: ElementDimension,\n    isOriginHeight?: boolean,\n    isStretchHeight?: boolean,\n  ): ElementDimension {\n    if (coachDimension && !isOriginHeight) {\n      // Since the height of the coach has been visually expanded to maintain a distance between the border of the coach and the places,\n      // some graphics must also be adapted to the height, which end with the borders of the coach\n      elementDimension.h += this.coachBorderOffset * 2;\n    }\n\n    if (isStretchHeight) {\n      // In the case of graphics are assigned directly at the border of the coach,\n      // these graphics must be expanded in height by a coachBorderOffset in order to reach their original visual position\n      elementDimension.h += this.coachBorderOffset;\n    }\n\n    return {\n      w: this.baseGridSize * elementDimension.w,\n      h: this.baseGridSize * elementDimension.h,\n    };\n  }\n\n  protected getCalculatedPosition(\n    elementPosition: ElementPosition,\n    elementDimension?: ElementDimension,\n    coachDimension?: ElementDimension,\n    isOriginHeight?: boolean,\n  ): ElementPosition {\n    if (coachDimension && elementDimension) {\n      const endPosHeight = isOriginHeight\n        ? coachDimension.h\n        : coachDimension.h + this.coachBorderOffset;\n      // If the original element is positioned at the top or bottom of the coach, we need to recalculate the Y coordinate with the additional border padding\n      if (elementPosition.y === 0) {\n        elementPosition.y -= this.coachBorderOffset;\n      } else if (elementPosition.y + elementDimension.h === endPosHeight) {\n        elementPosition.y += this.coachBorderOffset;\n      }\n    }\n\n    return {\n      x: this.baseGridSize * elementPosition.x,\n      y: this.baseGridSize * elementPosition.y,\n      z: elementPosition.z,\n    };\n  }\n\n  /**\n   * detects if a (graphical) element is on the border with its position (upper or lower border).\n   * @param baseElement\n   * @param coachDimension\n   * @protected\n   */\n  protected isElementDirectlyOnBorder(\n    baseElement: BaseElement,\n    coachDimension: ElementDimension,\n  ): boolean {\n    return (\n      baseElement.position.y === 0 ||\n      baseElement.position.y + baseElement.dimension.h === coachDimension.h\n    );\n  }\n\n  /**\n   * Counts all available seats together depending on the seat type\n   *\n   * @param places\n   * @returns An Object with count of free seats and free bicycle places\n   */\n  protected getAvailableFreePlacesNumFromCoach(\n    places: Place[] | undefined,\n  ): CoachNumberOfFreePlaces {\n    const accumulator: CoachNumberOfFreePlaces = { seats: 0, bicycles: 0 };\n    const freePlaces = places?.reduce((accumulator, currPlace: Place) => {\n      if (currPlace.state !== 'FREE') {\n        return accumulator;\n      }\n      // Count up depending on seat type\n      if (currPlace.type === 'SEAT') {\n        accumulator.seats++;\n      } else {\n        accumulator.bicycles++;\n      }\n      return accumulator;\n    }, accumulator);\n    return freePlaces ? freePlaces : accumulator;\n  }\n\n  /**\n   * At the end of a scroll Event from the coach scrollable area,\n   * the reached coach is marked as selected\n   */\n  private _handleCoachAreaScrollendEvent(): void {\n    const findScrollCoachIndex = this.isAutoScrolling\n      ? this.currSelectedCoachIndex\n      : this._getCoachIndexByScrollTriggerPosition();\n\n    // TIMO-43705\n    // If a place was selected by mouse click (preventCoachScrollByPlaceClick) before triggering this scrollend method,\n    // then this scrolling was triggered by the method _scrollPlaceIntoNearestViewport, and it is only a place adjustment scroll (scrollIntoView),\n    // where a less visible place has been scrolled into the viewport. In case of a place adjustment by click, we can return here.\n    if (this.preventCoachScrollByPlaceClick) {\n      // Check whether the endscrolling is just a place adjustment scrolling (place has 2 grid size units)\n      const isCoachScrolling =\n        Math.abs(this._lastStartScrollPos - this.coachScrollArea.scrollLeft) >\n        this.baseGridSize * 2;\n      if (isCoachScrolling) {\n        this.selectedCoachIndex = findScrollCoachIndex;\n      }\n\n      this.preventCoachScrollByPlaceClick = false;\n      return;\n    }\n\n    this._lastStartScrollPos = this.coachScrollArea.scrollLeft;\n\n    // After coach scrollend event we can reset the hovered coach index\n    this.hoveredCoachIndex = -1;\n\n    // In case the user uses the scrollbar without interacting with the seat reservation,\n    // the currently selected index is -1, and we have to set this value with findScrollCoachIndex.\n    if (this.currSelectedCoachIndex === -1) {\n      this.currSelectedCoachIndex = findScrollCoachIndex;\n    }\n\n    if (this._isScrollableToSelectedCoach()) {\n      this.currSelectedCoachIndex = findScrollCoachIndex;\n    } else {\n      this.currSelectedCoachIndex =\n        findScrollCoachIndex < this.currSelectedCoachIndex\n          ? this.currSelectedCoachIndex\n          : findScrollCoachIndex;\n    }\n\n    if (!this.isAutoScrolling) {\n      //When user is scrolling via scrollbar, it automatically scrolls to the focused coach in the main navigation\n      this._scrollToSelectedNavigationButton(findScrollCoachIndex);\n    }\n    this.preventCoachScrollByPlaceClick = false;\n    this.updateCurrentSelectedCoach();\n\n    if (!this.hasNavigation) {\n      this.preselectPlaceInCoach();\n      this.isAutoScrolling = false;\n    }\n  }\n\n  /**\n   * Performs an automatic main navigation scroll to the specified selectedNavCoachIndex.\n   * Calculates the central scroll offset of the nav coach to be selected.\n   * @param selectedNavCoachIndex\n   */\n  private _scrollToSelectedNavigationButton(selectedNavCoachIndex: number): void {\n    //Time delay to not interfere with other executing calling scrollTo functions (coaches scrolling)\n    setTimeout(() => {\n      if (this.hasNavigation && this.navigationScrollArea) {\n        const navigationAreaCenteredPosX = this.scrollNavigationAreaDim / 2;\n        const scrollButtonOffsetX = selectedNavCoachIndex * this.coachNavButtonDim;\n        const scrollOffsetX =\n          scrollButtonOffsetX - navigationAreaCenteredPosX + this.coachNavButtonDim;\n        this.navigationScrollArea.scrollTo({\n          top: this.alignVertical ? scrollOffsetX : 0,\n          left: this.alignVertical ? 0 : scrollOffsetX,\n          behavior: 'smooth',\n        });\n      }\n    }, 10);\n  }\n\n  /**\n   * Sets the new ScrollDirection by the new given target coach index.\n   */\n  private _setScrollDirectionByCoachIndex(): void {\n    this.currScrollDirection =\n      this.currSelectedCoachIndex > this.selectedCoachIndex\n        ? ScrollDirection.right\n        : ScrollDirection.left;\n  }\n\n  /**\n   * Returns the scroll start or end position X from the selected coach.\n   * In case the user is currently navigating through places by keyboard and goes to previous coach,\n   * then we return the end position of the coach to get the closest scroll position of the next focus place.\n   * @returns number\n   */\n  private _getCoachScrollPositionX(): number {\n    const coachTriggerPoint = this.triggerCoachPositionsCollection[this.currSelectedCoachIndex];\n    const isFocusPlaceFromPreviousCoachPosition =\n      this.isKeyboardNavigation &&\n      this.currScrollDirection === ScrollDirection.left &&\n      coachTriggerPoint.width > this.scrollCoachesAreaWidth;\n\n    return isFocusPlaceFromPreviousCoachPosition\n      ? coachTriggerPoint.end - this.scrollCoachesAreaWidth\n      : coachTriggerPoint.start;\n  }\n\n  /**\n   * Sets the focus on the HTML table (grid) caption element so that the heading is read out when using a ScreenReader.\n   */\n  private _setFocusToSelectedCoachGrid(): void {\n    // When the user performs an action that affects the coach navigation, then the navigated table is focusable.\n    if (this.isCoachGridFocusable && this.hasSeatReservationNativeFocus) {\n      this.isCoachGridFocusable = false;\n      const coachTableCaptionElement = this.shadowRoot?.querySelector(\n        '#sbb-sr-coach-caption-' + this.currSelectedCoachIndex,\n      ) as HTMLTableCaptionElement;\n      if (coachTableCaptionElement) {\n        coachTableCaptionElement.focus();\n      }\n    }\n  }\n\n  /**\n   * Returns whether the current scrolled position can be used to scroll to the selected wagon\n   * @returns boolean\n   */\n  private _isScrollableToSelectedCoach(): boolean {\n    const currScrollPosX = this.alignVertical\n      ? this.coachScrollArea.scrollTop\n      : this.coachScrollArea.scrollLeft;\n    const coachScrollWindowWidth = this.alignVertical\n      ? this.coachScrollArea.getBoundingClientRect().height\n      : this.coachScrollArea.getBoundingClientRect().width;\n    const maxScrollWidthArea = this.maxCalcCoachesWidth - coachScrollWindowWidth;\n    const currCoachTrigger = this.triggerCoachPositionsCollection[this.currSelectedCoachIndex];\n    const isScrollPosSameToCurrCoachPos =\n      currScrollPosX === this.triggerCoachPositionsCollection[this.currSelectedCoachIndex].start;\n\n    return (\n      (currScrollPosX < maxScrollWidthArea || currScrollPosX > currCoachTrigger.start) &&\n      !isScrollPosSameToCurrCoachPos\n    );\n  }\n\n  /**\n   * Returns the coach index which is currently visible in the scroll area\n   * @returns number\n   */\n  private _getCoachIndexByScrollTriggerPosition(): number {\n    const scrollPos = this.alignVertical\n      ? this.coachScrollArea.scrollTop\n      : this.coachScrollArea.scrollLeft;\n    const scrollOffsetX = scrollPos + this.scrollCoachesAreaWidth / 2;\n    return this.triggerCoachPositionsCollection.findIndex(\n      (coachTrigger) => scrollOffsetX >= coachTrigger.start && scrollOffsetX <= coachTrigger.end,\n    );\n  }\n\n  /**\n   * Get the first place of current selected coach by table cell coordinate 0-0 id.\n   * @returns Place or null\n   */\n  private _getFirstPlaceInSelectedCoach(): Place | null {\n    let firstPlace: Place | null = null;\n    const coach =\n      this.seatReservations[this.currSelectedDeckIndex].coachItems[this.currSelectedCoachIndex];\n    const firstCellId =\n      'cell-' + this.currSelectedDeckIndex + '-' + this.currSelectedCoachIndex + '-0-0';\n    const placeNumber =\n      this.shadowRoot\n        ?.querySelector<HTMLTableCellElement>('#' + firstCellId)\n        ?.querySelector<SbbSeatReservationPlaceControlElement>('sbb-seat-reservation-place-control')\n        ?.getAttribute('text') || null;\n\n    if (coach && placeNumber) {\n      firstPlace = coach.places?.find((place) => place.number === placeNumber) || null;\n    }\n    return firstPlace;\n  }\n\n  private _getSwitchedCoachDeckIndexByKeyNavigation(\n    pressedKey: string,\n    coach: CoachItem,\n  ): number | null {\n    if (\n      !this.currSelectedPlace ||\n      pressedKey === this.keyboardNavigationEvents.ArrowRight ||\n      pressedKey === this.keyboardNavigationEvents.ArrowLeft\n    )\n      return null;\n\n    //CHECK DECK SWITCH DOWN\n    if (\n      pressedKey === this.keyboardNavigationEvents.ArrowDown &&\n      this.currSelectedPlace.position.y + 2 === coach.dimension.h &&\n      !!this.seatReservations[this.currSelectedDeckIndex + 1]\n    ) {\n      return this.currSelectedDeckIndex + 1;\n    }\n    //CHECK DECK SWITCH UP\n    else if (\n      pressedKey === this.keyboardNavigationEvents.ArrowUp &&\n      this.currSelectedPlace.position.y === 0 &&\n      !!this.seatReservations[this.currSelectedDeckIndex - 1]\n    ) {\n      return this.currSelectedDeckIndex - 1;\n    }\n    return null;\n  }\n  /**\n   * To get the correct closest place of current pressed key and the current selected place,\n   * we have to investigate the coordinates of each place to find the closest place of the currSelectedPlaceElementId.\n   * @param pressedKey\n   * @returns Place or null\n   */\n  private _getClosestPlaceByKeyDirection(pressedKey?: string): Place | null {\n    const coach =\n      this.seatReservations[this.currSelectedDeckIndex].coachItems[this.currSelectedCoachIndex];\n    let closestPlace = null;\n    let coachPlaces = coach.places;\n    let switchedCoachDeckIndex = null;\n\n    if (coachPlaces) {\n      // If no place set, then we use initial the left-top place on the coach\n      if (!this.currSelectedPlaceElementId) {\n        return this._getFirstPlaceInSelectedCoach();\n      } else {\n        if (this.currSelectedPlace) {\n          const currSelectedPlacePosition = { ...this.currSelectedPlace.position };\n\n          if (pressedKey) {\n            // Check whether the keyboard navigation is used to switch to another coach deck (Up -> Down | Down -> Up).\n            // In this case, we take the coach places we have to checked from the target deck now.\n            switchedCoachDeckIndex = this._getSwitchedCoachDeckIndexByKeyNavigation(\n              pressedKey,\n              coach,\n            );\n            if (switchedCoachDeckIndex !== null) {\n              // Assign check places from the target switch deck\n              coachPlaces =\n                this.seatReservations[switchedCoachDeckIndex].coachItems[\n                  this.currSelectedCoachIndex\n                ].places || [];\n              // We have to update y coordinate\n              currSelectedPlacePosition.y =\n                switchedCoachDeckIndex < this.currSelectedDeckIndex ? coach.dimension.h : -1;\n            }\n          }\n\n          for (const place of coachPlaces) {\n            // If no key pressed, then we try to find the place of the current currScrollDirection\n            if (!pressedKey) {\n              // Find place from the left side of coach by y coordinate. Current currScrollDirection is RIGHT\n              if (\n                this.currScrollDirection === ScrollDirection.right &&\n                place.position.y === currSelectedPlacePosition.y &&\n                (!closestPlace || place.position.x < closestPlace.position.x)\n              ) {\n                closestPlace = place;\n              }\n              //Find place from the right side of coach by y coordinate. Current currScrollDirection is LEFT\n              else if (\n                this.currScrollDirection === ScrollDirection.left &&\n                place.position.y === currSelectedPlacePosition.y &&\n                (!closestPlace || place.position.x > closestPlace.position.x)\n              ) {\n                closestPlace = place;\n              }\n            } else {\n              if (place.number !== this.currSelectedPlace?.number) {\n                //Key [Right] navigation, we check the place coordinates of the x-axis to get the smallest larger x place coordinate of the currently selected place\n                if (\n                  pressedKey === this.keyboardNavigationEvents.ArrowRight &&\n                  (place.position.y === currSelectedPlacePosition.y ||\n                    place.position.y === currSelectedPlacePosition.y - 1) &&\n                  place.position.x > currSelectedPlacePosition.x &&\n                  (!closestPlace || place.position.x < closestPlace.position.x)\n                ) {\n                  closestPlace = place;\n                }\n                //Key [Down] navigation, we check the place coordinates of the y-axis to get the smallest larger y place coordinate of the currently selected place\n                else if (\n                  pressedKey === this.keyboardNavigationEvents.ArrowDown &&\n                  (place.position.x === currSelectedPlacePosition.x ||\n                    place.position.x === currSelectedPlacePosition.x + 1) &&\n                  place.position.y > currSelectedPlacePosition.y &&\n                  (!closestPlace || place.position.y < closestPlace.position.y)\n                ) {\n                  closestPlace = place;\n                }\n                //Key [Left] navigation, we check the place coordinates of the x-axis to get the greatest smaller x place coordinate of the currently selected place\n                else if (\n                  pressedKey === this.keyboardNavigationEvents.ArrowLeft &&\n                  (place.position.y === currSelectedPlacePosition.y ||\n                    place.position.y === currSelectedPlacePosition.y + 1) &&\n                  place.position.x < currSelectedPlacePosition.x &&\n                  (!closestPlace || place.position.x > closestPlace.position.x)\n                ) {\n                  closestPlace = place;\n                }\n                //Key [Up] navigation, we check the place coordinates of the y-axis to get the greatest smaller y place coordinate of the currently selected place\n                else if (\n                  pressedKey === this.keyboardNavigationEvents.ArrowUp &&\n                  (place.position.x === currSelectedPlacePosition.x ||\n                    place.position.x === currSelectedPlacePosition.x - 1) &&\n                  place.position.y < currSelectedPlacePosition.y &&\n                  (!closestPlace || place.position.y > closestPlace.position.y)\n                ) {\n                  closestPlace = place;\n                }\n              }\n            }\n          }\n\n          // If a place has been found in the changing switch coach,\n          // we can update the currSelectedDeckIndex\n          if (switchedCoachDeckIndex !== null && closestPlace) {\n            this.currSelectedDeckIndex = switchedCoachDeckIndex;\n          }\n        }\n      }\n    }\n    return closestPlace;\n  }\n\n  // Handling for Tab navigation if a place is selected inside the coach.\n  // This controls the focused coach from the current selected coach.\n  private _navigateCoachNavigationByKeyboard(tabDirection: string): void {\n    const currFocusIndex =\n      this.focusedCoachIndex === -1\n        ? this.currSelectedCoachIndex === -1\n          ? 0\n          : this.currSelectedCoachIndex\n        : this.focusedCoachIndex;\n\n    // Check next or prev tab is pressed, then we need to find the next available coach index that should receive the focus\n    const newFocusableIndex: number =\n      tabDirection === 'NEXT_TAB'\n        ? this.getNextAvailableCoachIndex(currFocusIndex)\n        : this.getPrevAvailableCoachIndex(currFocusIndex);\n\n    if (this.hasNavigation) {\n      const selectedPlaceElement = this._getPlaceHtmlElement();\n      const placeInCoachHasFocus = selectedPlaceElement\n        ? selectedPlaceElement.getAttribute('keyfocus') === 'focus'\n        : false;\n\n      // If we tab back (PREV_TAB) and the focus is currently on place,\n      // we remove the selected state from the currently selected navigation coach and only set the focus status to it\n      if (tabDirection === 'PREV_TAB' && this.selectedCoachIndex === currFocusIndex) {\n        // If we TAB back and have a selected places inside the current coach, then we move out from the seatmap and set the focus to the current selected coach\n        if (placeInCoachHasFocus || this.currSelectedPlace !== null) {\n          this.focusedCoachIndex = currFocusIndex;\n          this.unfocusPlaceElement();\n          return;\n        }\n        // If we tab back and the current selected nav coach is the first element, so we have to focus (jump) directly to the left nav direction button\n        else if (currFocusIndex == 0) {\n          this.unfocusPlaceElement();\n          this.currSelectedPlace = null;\n          this.focusedCoachIndex = -1;\n          const btnLeftDirection = this.shadowRoot?.getElementById(\n            'sbb-sr-navigation__wrapper-button-direction--left',\n          ) as HTMLElement;\n          btnLeftDirection.focus();\n        } else {\n          this.focusedCoachIndex = newFocusableIndex;\n        }\n      }\n      // Only sets the focus on the new navigation coach\n      else if (newFocusableIndex !== this.currSelectedCoachIndex) {\n        this.focusedCoachIndex = newFocusableIndex;\n      }\n      // If we tab next and the current selected nav coach is the last element, so we have to focus (jump) directly to the right nav direction button\n      else if (tabDirection === 'NEXT_TAB' && newFocusableIndex === this.coachNavData.length - 1) {\n        this.unfocusPlaceElement();\n        this.focusedCoachIndex = -1;\n        const btnRightDirection = this.shadowRoot?.getElementById(\n          'sbb-sr-navigation__wrapper-button-direction--right',\n        ) as HTMLElement;\n        btnRightDirection.focus();\n      } else {\n        this.focusedCoachIndex = -1;\n        this.selectedCoachIndex = newFocusableIndex;\n        // If any place was focused in coach, so we set focused again\n        if (placeInCoachHasFocus) {\n          this.focusPlaceElement(this.currSelectedPlace);\n        }\n        // If no place was selected, then we select the coach grid\n        else {\n          this.isCoachGridFocusable = true;\n          this._setFocusToSelectedCoachGrid();\n        }\n      }\n\n      // By Tab Navigation, perform automatic scrolling to the focused wagon\n      this._scrollToSelectedNavigationButton(newFocusableIndex);\n    }\n    // If no navigation exist, we scroll directly to the next tabable coach\n    else {\n      this.scrollToSelectedNavCoach(newFocusableIndex);\n    }\n  }\n\n  private _navigateToPlaceByKeyboard(pressedKey: string): void {\n    this.isKeyboardNavigation = true;\n\n    if (this.focusedCoachIndex !== -1) {\n      this.focusedCoachIndex = -1;\n    }\n\n    if (!this.preventPlaceClick) {\n      const findClosestPlace = this._getClosestPlaceByKeyDirection(pressedKey);\n\n      if (findClosestPlace) {\n        this.focusPlaceElement(findClosestPlace);\n      }\n      // No closest place found by key navigation\n      else {\n        if (\n          pressedKey === this.keyboardNavigationEvents.ArrowRight ||\n          pressedKey === this.keyboardNavigationEvents.ArrowLeft ||\n          (this.alignVertical &&\n            (pressedKey === this.keyboardNavigationEvents.ArrowUp ||\n              pressedKey === this.keyboardNavigationEvents.ArrowDown))\n        ) {\n          // Check the current pressed key to get the next available coach index\n          const newSelectedCoachIndex =\n            pressedKey === this.keyboardNavigationEvents.ArrowRight\n              ? this.getNextAvailableCoachIndex()\n              : this.getPrevAvailableCoachIndex();\n\n          this.scrollToSelectedNavCoach(newSelectedCoachIndex);\n        }\n      }\n    }\n  }\n\n  protected getNextAvailableCoachIndex(currentIndex?: number): number {\n    const startIndex = currentIndex ?? this.currSelectedCoachIndex;\n    return startIndex < this.seatReservations[this.currSelectedDeckIndex].coachItems.length - 1\n      ? startIndex + 1\n      : startIndex;\n  }\n\n  protected getPrevAvailableCoachIndex(currentIndex?: number): number {\n    const startIndex = currentIndex ?? this.currSelectedCoachIndex;\n    return startIndex > 0 ? startIndex - 1 : startIndex;\n  }\n\n  protected updateSelectedSeatReservationPlaces(placeSelection: PlaceSelection): void {\n    const placeTypeProp = placeSelection.placeType === 'SEAT' ? 'seats' : 'bicycles';\n    const maxReservations =\n      placeSelection.placeType === 'SEAT' ? this.maxSeatReservations : this.maxBicycleReservations;\n    const currSelectedPlaces = this.selectedSeatReservationPlaces[placeTypeProp];\n\n    this.selectedSeatReservationPlaces[placeTypeProp] = this._updateSelectedSeatReservationPlaces(\n      currSelectedPlaces,\n      maxReservations,\n      placeSelection,\n    );\n    /**\n     * @type {CustomEvent<SeatReservationSelectedPlaces>}\n     * Emits when a place was selected and returns a Place array with all selected places.\n     */\n    this.dispatchEvent(\n      new CustomEvent<SeatReservationSelectedPlaces>('selectedplaces', {\n        bubbles: true,\n        composed: true,\n        detail: this.selectedSeatReservationPlaces,\n      }),\n    );\n  }\n\n  private _updateSelectedSeatReservationPlaces(\n    selectedSeatReservationPlaces: SeatReservationPlaceSelection[],\n    maxReservations: number,\n    placeSelection: PlaceSelection,\n  ): SeatReservationPlaceSelection[] {\n    // Add selected place to selectedSeatReservationPlaces\n    if (placeSelection.state === 'SELECTED') {\n      const selectedPlaceDeckIndex = this._getDeckIndexByPlaceId(placeSelection.id);\n      const seatReservationSelection = this._getSeatReservationPlaceSelection(\n        placeSelection,\n        selectedPlaceDeckIndex,\n      );\n      if (seatReservationSelection) {\n        selectedSeatReservationPlaces.push(seatReservationSelection);\n      }\n    }\n    // Remove selected place from selectedSeatReservationPlaces\n    else {\n      selectedSeatReservationPlaces = selectedSeatReservationPlaces.filter(\n        (_selectedPlace) => _selectedPlace.id !== placeSelection.id,\n      );\n    }\n    // Checks whether maxReservation is activated and the maximum number of selected places is reached\n    if (maxReservations > -1 && selectedSeatReservationPlaces.length > maxReservations) {\n      const resetWithPlaceSelection = maxReservations > 0 ? placeSelection : undefined;\n\n      selectedSeatReservationPlaces = this._resetAllPlaceSelections(\n        selectedSeatReservationPlaces,\n        resetWithPlaceSelection,\n      );\n    }\n    return selectedSeatReservationPlaces;\n  }\n\n  protected updateCurrentSelectedPlaceInCoach(placeSelection: PlaceSelection): void {\n    const placeDeckIndex = this._getDeckIndexByPlaceId(placeSelection.id);\n    const coachIndex = placeSelection.coachIndex;\n\n    if (placeDeckIndex === null) return;\n\n    const place = this.seatReservations[placeDeckIndex].coachItems[coachIndex].places?.find(\n      (place) => place.number == placeSelection.number,\n    );\n\n    if (!place) return;\n\n    this.currSelectedDeckIndex = placeDeckIndex;\n    this.currSelectedCoachIndex = coachIndex;\n    this.currSelectedPlace = place;\n\n    if (this.currSelectedCoachIndex !== this.selectedCoachIndex) {\n      this.updateCurrentSelectedCoach();\n    }\n\n    this._setCurrSelectedPlaceElementId(place);\n\n    // Time delay to wait for status update process at clicked place\n    const delayScrollInViewport = setTimeout(() => {\n      this._scrollPlaceIntoNearestViewport(placeSelection.id);\n      clearTimeout(delayScrollInViewport);\n    }, 0);\n  }\n\n  protected updateCurrentSelectedCoach(): void {\n    //Only if the selectedCoachIndex has changed, an update needs to be carried out\n    if (this.currSelectedCoachIndex == this.selectedCoachIndex) return;\n\n    // If a focusindex has been set (!= -1), it can be updated with the current selectedCoachIndex\n    if (this.focusedCoachIndex != -1) {\n      this.focusedCoachIndex = this.currSelectedCoachIndex;\n    }\n    this.selectedCoachIndex = this.currSelectedCoachIndex;\n\n    const coachSelection = this._getSeatReservationSelectedCoach(this.selectedCoachIndex);\n    if (coachSelection) {\n      /**\n       * @type {CustomEvent<SeatReservationSelectedCoach>}\n       * Emits when a coach was selected and returns a CoachSelection\n       */\n      this.dispatchEvent(\n        new CustomEvent<SeatReservationSelectedCoach>('selectedcoach', {\n          bubbles: true,\n          composed: true,\n          detail: coachSelection,\n        }),\n      );\n    }\n  }\n\n  protected getPlaceElementId(\n    coachDeckIndex: number,\n    coachIndex: number,\n    placeNumber: string,\n  ): string {\n    return (\n      'seat-reservation__place-button-' + coachDeckIndex + '-' + coachIndex + '-' + placeNumber\n    );\n  }\n\n  /**\n   * In the case of coach layouts with different decks,\n   * it is necessary to extend the offset with empty coaches\n   * in order to create a stable vehicle layout.\n   *\n   *             [ooo]-[ooo]-[ooo]\n   * [ooo]-[ooo]-[ooo]-[ooo]-[ooo]\n   */\n  private _initEmptyCoachDeckOffsets(): void {\n    // Prefill offset counters with 0 start index\n    const coachOffsetIndexCounter = Array(this.seatReservations.length - 1).fill(0);\n    // Takes the lower deck which contains the max numbers of coaches\n    const lowerDeck = this.seatReservations[this.seatReservations.length - 1];\n\n    lowerDeck.coachItems.forEach((lowerCoachItem: CoachItem) => {\n      for (let i = 0; i < this.seatReservations.length - 1; i++) {\n        const deckCoachItem = this.seatReservations[i].coachItems[coachOffsetIndexCounter[i]];\n        if (lowerCoachItem.id != deckCoachItem?.id) {\n          // Add Empty offset coach to specified index position\n          const emptyOffsetCoach = {\n            ...lowerCoachItem,\n            places: undefined,\n            propertyIds: undefined,\n            graphicElements: undefined,\n            serviceElements: undefined,\n            travelClass: [],\n          };\n          this.seatReservations[i].coachItems.splice(\n            coachOffsetIndexCounter[i],\n            0,\n            emptyOffsetCoach,\n          );\n        }\n\n        coachOffsetIndexCounter[i]++;\n      }\n    });\n  }\n\n  /**\n   * Initialization of SeatReservationPlaceSelection Array based on the transferred places\n   * that have the state SELECTED within the seatReservation object\n   */\n  private _initSeatReservationPlaceSelection(): void {\n    // Reset place selections\n    this.selectedSeatReservationPlaces.seats = [];\n    this.selectedSeatReservationPlaces.bicycles = [];\n\n    this.seatReservations?.forEach((seatReservation: SeatReservation, coachDeckIndex: number) =>\n      seatReservation.coachItems.map((coach: CoachItem, coachIndex: number) => {\n        coach.places\n          ?.filter((place) => place.state === 'SELECTED')\n          ?.forEach((place) => {\n            const placeId = this.getPlaceElementId(coachDeckIndex, coachIndex, place.number);\n            const preselectedPlaceSelection: PlaceSelection = mapPlaceInfosToPlaceSelection(\n              place,\n              placeId,\n              seatReservation.deckCoachIndex,\n              coachIndex,\n            );\n\n            const seatReservationPlaceSelection: SeatReservationPlaceSelection | null =\n              this._getSeatReservationPlaceSelection(preselectedPlaceSelection, coachDeckIndex);\n\n            if (seatReservationPlaceSelection) {\n              if (seatReservationPlaceSelection.placeType === 'SEAT') {\n                this.selectedSeatReservationPlaces.seats.push(seatReservationPlaceSelection);\n              } else {\n                this.selectedSeatReservationPlaces.bicycles.push(seatReservationPlaceSelection);\n              }\n            }\n          });\n      }),\n    );\n  }\n  /**\n   * All selected places will be reset or the currentSelectedPlace was given, then we reset all except currentSelectedPlace\n   * @param reservationPlaceSelections\n   * @param currSelectedPlace\n   */\n  private _resetAllPlaceSelections(\n    reservationPlaceSelections: SeatReservationPlaceSelection[],\n    currSelectedPlace?: PlaceSelection,\n  ): SeatReservationPlaceSelection[] {\n    //Find all places to be needed unselect\n    for (const placeSelection of reservationPlaceSelections) {\n      if (!currSelectedPlace || currSelectedPlace.id !== placeSelection.id) {\n        const placeElement = this.shadowRoot?.getElementById(placeSelection.id) as HTMLElement;\n        if (placeElement) {\n          placeElement.setAttribute('state', 'FREE');\n        }\n      }\n    }\n    //Removes all selected places except the currently selected place\n    if (currSelectedPlace) {\n      reservationPlaceSelections = reservationPlaceSelections.filter(\n        (_selectedPlace) => _selectedPlace.id === currSelectedPlace.id,\n      );\n    } else {\n      reservationPlaceSelections = [];\n    }\n    return reservationPlaceSelections;\n  }\n\n  private _getSeatReservationPlaceSelection(\n    currSelectedPlace: PlaceSelection,\n    coachDeckIndex: number | null,\n  ): SeatReservationPlaceSelection | null {\n    if (coachDeckIndex === null) return null;\n\n    const coach = this.seatReservations[coachDeckIndex].coachItems[currSelectedPlace.coachIndex];\n    const place = coach.places?.find((place) => place.number === currSelectedPlace.number);\n\n    return place\n      ? mapPlaceAndCoachToSeatReservationPlaceSelection(\n          place,\n          coach,\n          currSelectedPlace.id,\n          currSelectedPlace.deckIndex,\n          currSelectedPlace.coachIndex,\n        )\n      : null;\n  }\n\n  private _getSeatReservationSelectedCoach(\n    coachIndex: number,\n  ): SeatReservationSelectedCoach | null {\n    if (!this.seatReservations[this.currSelectedDeckIndex].coachItems[coachIndex]) return null;\n\n    const coach = this.seatReservations[this.currSelectedDeckIndex].coachItems[coachIndex];\n    const coachNumberOfFreePlaces = this.getAvailableFreePlacesNumFromCoach(coach.places);\n    return mapCoachInfosToCoachSelection(coachIndex, coach, coachNumberOfFreePlaces);\n  }\n\n  private _setCurrSelectedPlaceElementId(place: Place | null): void {\n    this.currSelectedPlaceElementId = place\n      ? this.getPlaceElementId(\n          this.currSelectedDeckIndex,\n          this.currSelectedCoachIndex,\n          place.number,\n        )\n      : null;\n  }\n\n  /**\n   * Preparation of the used documents font-size which needs\n   * to be determined in order to correctly calculate CSS values with rem\n   * */\n  private _determineBaseFontSize(): void {\n    if (!isServer) {\n      const baseFontSize = parseInt(window.getComputedStyle(document.body).fontSize, 10);\n      //calculate rem of 1px\n      const onePixelInRem = 1 / baseFontSize;\n      this.style?.setProperty('--sbb-seat-reservation-one-px-rem', `${onePixelInRem + 'rem'}`);\n    }\n  }\n\n  /**\n   * Prepares data for displaying navigation area.\n   * Calculates the values which are not going to change during use of a component:\n   *    - coach id\n   *    - list of service icons\n   *    - class (first, second, any)\n   *    - whether there is a driver area left or right\n   * */\n  private _prepareNavigationCoachData(): void {\n    if (this.seatReservations) {\n      const lowerDeck: CoachItem[] =\n        this.seatReservations[this.seatReservations.length - 1].coachItems;\n\n      this.coachNavData = [];\n\n      lowerDeck.forEach((coach, index) => {\n        const travelClasses: PlaceTravelClass[] = [];\n        const propertyIds: string[] = [];\n        const places: Place[] = [];\n\n        // Collect all important navigation data to be rendered\n        this.seatReservations\n          .map((sr) => {\n            return sr.coachItems[index];\n          })\n          .forEach((coach: CoachItem) => {\n            travelClasses.push(...coach.travelClass);\n            propertyIds.push(...(coach.propertyIds ? coach.propertyIds : []));\n            places.push(...(coach.places ? coach.places : []));\n          });\n\n        this.coachNavData.push({\n          id: coach.id,\n          travelClass: this._prepareTravelClassNavigation(travelClasses),\n          propertyIds: this._prepareServiceIconsNavigation(propertyIds),\n          isDriverArea: coach.places ? coach.places.length === 0 : true,\n          driverAreaSide: this._prepareDriverAreaSideNavigation(coach),\n          freePlaces: this.getAvailableFreePlacesNumFromCoach(places),\n        });\n      });\n    }\n  }\n\n  private _prepareTravelClassNavigation(travelClasses: PlaceTravelClass[]): PlaceTravelClass {\n    if (travelClasses.indexOf('FIRST') !== -1) return 'FIRST';\n    if (travelClasses.indexOf('SECOND') !== -1) return 'SECOND';\n    return 'ANY_CLASS';\n  }\n\n  private _prepareDriverAreaSideNavigation(\n    coachItem: CoachItem,\n  ): Record<string, boolean> | undefined {\n    const coachDriverAreas = coachItem.graphicElements?.filter(\n      (graphicalElements) => graphicalElements.icon === 'DRIVER_AREA',\n    );\n\n    if (coachDriverAreas && coachDriverAreas.length > 0) {\n      // Checking the driver area position whether it is present on the left or right side in a coach\n      const hasLeftDriverArea =\n        coachDriverAreas.find((driverAreaElement) => driverAreaElement.position.x === 0) || false;\n      const hasRightDriverArea =\n        coachDriverAreas.find((driverAreaElement) => driverAreaElement.position.x > 0) || false;\n\n      return {\n        left: !!hasLeftDriverArea,\n        right: !!hasRightDriverArea,\n      };\n    }\n    return undefined;\n  }\n\n  private _prepareServiceIconsNavigation = (propertyIds: string[]): string[] => {\n    if (!propertyIds) {\n      return [];\n    }\n\n    const shrunkPropertyIds = propertyIds\n      ?.map(function (propertyId: string): {\n        pId: string;\n        svgName: string;\n      } {\n        // prepare temporary object mapping property id to it's svgName so that we can compare it to the list of allowed icons\n        return {\n          pId: propertyId,\n          svgName: mapIconToSvg[propertyId]?.svgName ? mapIconToSvg[propertyId]?.svgName : '',\n        };\n      })\n      //filter out objects service icons which are not in ALLOWED_SERVICE_ICONS\n      .filter((propertyToSvg) => ALLOWED_SERVICE_ICONS.indexOf(propertyToSvg.svgName) !== -1)\n      //make it distinct by svgName\n      .filter(\n        (value, index, self) =>\n          self.map((propSvg) => propSvg.svgName).indexOf(value.svgName) === index,\n      )\n      // go back to propertyId string from temporary object\n      .map((propertyToSvg) => propertyToSvg.pId)\n      // take first MAX_SERVICE_PROPERTIES regardless of the input from Backend, otherwise the layout could be destroyed\n      .slice(0, MAX_SERVICE_PROPERTIES);\n    return shrunkPropertyIds ? shrunkPropertyIds : [];\n  };\n\n  private _prepareCoachWidthAndGapCalculations(): void {\n    if (this.seatReservations) {\n      const coachItems: CoachItem[] =\n        this.seatReservations[this.seatReservations.length - 1]?.coachItems;\n\n      coachItems?.forEach((coachItem: CoachItem) => {\n        const hasOverhangingPlaces = this._isOverhangingElementsPresent(\n          coachItem.dimension.w,\n          coachItem.places,\n        );\n\n        //Must  be done also for graphical elements, as they can also protrude the coach border\n        // Check only graphical elements that are not area elements\n        const filteredElements = coachItem.graphicElements?.filter(\n          (e) => e.icon && !this.notAreaElements.includes(e.icon),\n        );\n\n        const hasOverhangingGraphicAreas = this._isOverhangingElementsPresent(\n          coachItem.dimension.w,\n          filteredElements,\n        );\n\n        this.overHangingElementInformation.push({\n          coachId: coachItem.id,\n          overhangingPlaces: hasOverhangingPlaces,\n          overhangingGraphicAreas: hasOverhangingGraphicAreas,\n        });\n      });\n    }\n  }\n\n  /**\n   * Returns the current selected place HTML element by currSelectedPlaceElementId.\n   * @returns HTMLElement or null\n   */\n  private _getPlaceHtmlElement(): HTMLElement | null {\n    return this.currSelectedPlaceElementId\n      ? this.shadowRoot?.getElementById(this.currSelectedPlaceElementId) || null\n      : null;\n  }\n\n  /**\n   * Returns the extracted coach deck index from place id\n   * @returns number\n   */\n  private _getDeckIndexByPlaceId(placeId: string): number | null {\n    const deckIndex = this.shadowRoot\n      ?.querySelector('#' + placeId)\n      ?.getAttribute('data-deck-index');\n    if (deckIndex && !isNaN(+deckIndex)) {\n      return +deckIndex;\n    }\n    return null;\n  }\n\n  private _isValidCoachIndex(coachIndex: number): boolean {\n    return (\n      coachIndex >= 0 &&\n      coachIndex <= this.seatReservations[this.seatReservations.length - 1].coachItems.length\n    );\n  }\n\n  /**\n   * Returns existing coach deck index depending on the selected coach.\n   * This method is necessary to get an available coach deck index during keyboard navigation, which can vary between coaches with different decks.\n   * For example, when navigating from a coach with two decks to a coach with one deck.\n   *\n   *       [ooo]-[ooo]-[ooo]\n   * [ooo]-[ooo]-[ooo]-[ooo]-[ooo]\n   *\n   * @returns number\n   */\n  private _getExistingCoachDeckIndex(): number {\n    if (\n      this.seatReservations[this.currSelectedDeckIndex].coachItems[this.currSelectedCoachIndex]\n        .places !== undefined\n    ) {\n      return this.currSelectedDeckIndex;\n    }\n\n    // Find next possible coach deck index where places exist\n    const nextAvailableDeckCoachIndex = this.seatReservations.findIndex(\n      (seatReservation) =>\n        seatReservation.coachItems[this.currSelectedCoachIndex].places !== undefined,\n    );\n    return this.currSelectedDeckIndex >= nextAvailableDeckCoachIndex\n      ? this.currSelectedDeckIndex\n      : nextAvailableDeckCoachIndex;\n  }\n\n  /**\n   * If a selected place is slightly hidden by the overflow scroll content and is still clicked,\n   * the method tries to scroll the selected place into the nearest viewport, so that it is completely visible.\n   *\n   * @param placeId\n   */\n  private _scrollPlaceIntoNearestViewport(placeId: string): void {\n    this.shadowRoot\n      ?.getElementById(placeId)\n      ?.scrollIntoView({ behavior: 'smooth', block: 'nearest', inline: 'nearest' });\n  }\n\n  /**\n   * checks if any places or graphical elements (e.g. toilet area, etc.) are overhanging the coach borders\n   * @param coachItemWidth\n   * @param elements\n   */\n  private _isOverhangingElementsPresent(\n    coachItemWidth: number,\n    elements: (Place | BaseElement)[] | undefined,\n  ): boolean {\n    return (\n      elements?.some(\n        (element) =>\n          element.position.x === 0 || element.position.x + element.dimension.w >= coachItemWidth,\n      ) ?? false\n    );\n  }\n}\n"],"names":["ScrollDirection","accumulator","place","coach"],"mappings":"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"}